mirror of
https://github.com/bevyengine/bevy
synced 2024-11-22 12:43:34 +00:00
11b41206eb
This updates the `pipelined-rendering` branch to use the latest `bevy_ecs` from `main`. This accomplishes a couple of goals: 1. prepares for upcoming `custom-shaders` branch changes, which were what drove many of the recent bevy_ecs changes on `main` 2. prepares for the soon-to-happen merge of `pipelined-rendering` into `main`. By including bevy_ecs changes now, we make that merge simpler / easier to review. I split this up into 3 commits: 1. **add upstream bevy_ecs**: please don't bother reviewing this content. it has already received thorough review on `main` and is a literal copy/paste of the relevant folders (the old folders were deleted so the directories are literally exactly the same as `main`). 2. **support manual buffer application in stages**: this is used to enable the Extract step. we've already reviewed this once on the `pipelined-rendering` branch, but its worth looking at one more time in the new context of (1). 3. **support manual archetype updates in QueryState**: same situation as (2).
92 lines
2.9 KiB
Rust
92 lines
2.9 KiB
Rust
use bevy::{prelude::*, scene::InstanceId};
|
|
|
|
fn main() {
|
|
App::new()
|
|
.insert_resource(Msaa { samples: 4 })
|
|
.add_plugins(DefaultPlugins)
|
|
.init_resource::<SceneInstance>()
|
|
.add_startup_system(setup)
|
|
.add_system(scene_update)
|
|
.add_system(move_scene_entities)
|
|
.run();
|
|
}
|
|
|
|
// Resource to hold the scene `instance_id` until it is loaded
|
|
#[derive(Default)]
|
|
struct SceneInstance(Option<InstanceId>);
|
|
|
|
// Component that will be used to tag entities in the scene
|
|
struct EntityInMyScene;
|
|
|
|
fn setup(
|
|
mut commands: Commands,
|
|
asset_server: Res<AssetServer>,
|
|
mut scene_spawner: ResMut<SceneSpawner>,
|
|
mut scene_instance: ResMut<SceneInstance>,
|
|
) {
|
|
commands.spawn_bundle(PointLightBundle {
|
|
transform: Transform::from_xyz(4.0, 5.0, 4.0),
|
|
..Default::default()
|
|
});
|
|
commands.spawn_bundle(PerspectiveCameraBundle {
|
|
transform: Transform::from_xyz(1.05, 0.9, 1.5)
|
|
.looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y),
|
|
..Default::default()
|
|
});
|
|
|
|
// Spawn the scene as a child of another entity. This first scene will be translated backward
|
|
// with its parent
|
|
commands
|
|
.spawn_bundle((
|
|
Transform::from_xyz(0.0, 0.0, -1.0),
|
|
GlobalTransform::identity(),
|
|
))
|
|
.with_children(|parent| {
|
|
parent.spawn_scene(asset_server.load("models/FlightHelmet/FlightHelmet.gltf#Scene0"));
|
|
});
|
|
|
|
// Spawn a second scene, and keep its `instance_id`
|
|
let instance_id =
|
|
scene_spawner.spawn(asset_server.load("models/FlightHelmet/FlightHelmet.gltf#Scene0"));
|
|
scene_instance.0 = Some(instance_id);
|
|
}
|
|
|
|
// This system will wait for the scene to be ready, and then tag entities from
|
|
// the scene with `EntityInMyScene`. All entities from the second scene will be
|
|
// tagged
|
|
fn scene_update(
|
|
mut commands: Commands,
|
|
scene_spawner: Res<SceneSpawner>,
|
|
scene_instance: Res<SceneInstance>,
|
|
mut done: Local<bool>,
|
|
) {
|
|
if !*done {
|
|
if let Some(instance_id) = scene_instance.0 {
|
|
if let Some(entity_iter) = scene_spawner.iter_instance_entities(instance_id) {
|
|
entity_iter.for_each(|entity| {
|
|
commands.entity(entity).insert(EntityInMyScene);
|
|
});
|
|
*done = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This system will move all entities with component `EntityInMyScene`, so all
|
|
// entities from the second scene
|
|
fn move_scene_entities(
|
|
time: Res<Time>,
|
|
mut scene_entities: Query<&mut Transform, With<EntityInMyScene>>,
|
|
) {
|
|
let mut direction = 1.;
|
|
let mut scale = 1.;
|
|
for mut transform in scene_entities.iter_mut() {
|
|
transform.translation = Vec3::new(
|
|
scale * direction * time.seconds_since_startup().sin() as f32 / 20.,
|
|
0.,
|
|
time.seconds_since_startup().cos() as f32 / 20.,
|
|
);
|
|
direction *= -1.;
|
|
scale += 0.5;
|
|
}
|
|
}
|