├── assets
    ├── 9_1.scr.ron
    ├── X.png
    ├── Y.png
    ├── Z.png
    ├── bevy.png
    ├── arrow.png
    ├── Raleway-Bold.ttf
    ├── 9_2.scr.ron
    ├── 9_0.scr.ron
    ├── 9_3.scr.ron
    ├── 8.scr.ron
    ├── gltf.gltf
    ├── part_scene.scn.ron
    └── scene.scn.ron
├── examples
    ├── transform.rs
    ├── visibility.rs
    └── rotation.rs
├── Cargo.toml
├── src
    ├── user_input
    │   ├── touch.rs
    │   ├── mouse.rs
    │   ├── keyboard.rs
    │   └── gamepad.rs
    ├── lib.rs
    ├── common.rs
    ├── local.rs
    ├── ecs.rs
    ├── events.rs
    ├── visibility.rs
    ├── main.rs
    ├── user_input.rs
    ├── systems.rs
    ├── components.rs
    ├── query.rs
    ├── transform.rs
    ├── resources.rs
    ├── reflect.rs
    ├── scenes.rs
    └── entitys.rs
├── test_scene.scn.ron
└── scene.scn.ron


/assets/9_1.scr.ron:
--------------------------------------------------------------------------------
1 | (
2 |     entities: {
3 |         
4 |     }
5 | )


--------------------------------------------------------------------------------
/assets/X.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PhaestusFox/BevyBasics/HEAD/assets/X.png


--------------------------------------------------------------------------------
/assets/Y.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PhaestusFox/BevyBasics/HEAD/assets/Y.png


--------------------------------------------------------------------------------
/assets/Z.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PhaestusFox/BevyBasics/HEAD/assets/Z.png


--------------------------------------------------------------------------------
/assets/bevy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PhaestusFox/BevyBasics/HEAD/assets/bevy.png


--------------------------------------------------------------------------------
/assets/arrow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PhaestusFox/BevyBasics/HEAD/assets/arrow.png


--------------------------------------------------------------------------------
/assets/Raleway-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PhaestusFox/BevyBasics/HEAD/assets/Raleway-Bold.ttf


--------------------------------------------------------------------------------
/examples/transform.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy_basics::prelude::*;
 3 | 
 4 | fn main() {
 5 |     App::new()
 6 |         .add_plugins(DefaultPlugins)
 7 |         .add_plugin(CommonPlugin)
 8 |         .add_plugin(TransformExample)
 9 |         .add_startup_system(spawn_cam)
10 |         .run()
11 | }
12 | 


--------------------------------------------------------------------------------
/assets/9_2.scr.ron:
--------------------------------------------------------------------------------
 1 | (
 2 |     entities: {
 3 |         0: (
 4 |             components: {
 5 |                 "type_name": (
 6 |                     translation: (
 7 |                         x: 0.0,
 8 |                         y: 0.0,
 9 |                         z: 0.0
10 |                     ),
11 |                 ),
12 |             },
13 |         ),
14 |     }
15 | )


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "bevy_basics"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | resolver = "2"
 6 | 
 7 | 
 8 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 9 | 
10 | [dependencies]
11 | bevy = {version = "0.9.1"}
12 | bevy-inspector-egui = "0.14.0"
13 | bevy_editor_pls = {git = "https://github.com/PhaestusFox/bevy_editor_pls"}
14 | ron = "0.8.0"
15 | rand = "0.8.5"
16 | serde = "1.0.144"


--------------------------------------------------------------------------------
/assets/9_0.scr.ron:
--------------------------------------------------------------------------------
 1 | (
 2 |   entities: {
 3 |     0: (
 4 |       components: {
 5 |         "bevy_transform::components::transform::Transform": (
 6 |           translation: (
 7 |             x: 0.0,
 8 |             y: 0.0,
 9 |             z: 0.0
10 |           ),
11 |           rotation: (0.0, 0.0, 0.0, 1.0),
12 |           scale: (
13 |             x: 1.0,
14 |             y: 1.0,
15 |             z: 1.0
16 |           ),
17 |         ),
18 |         "scene::ComponentB": (
19 |           value: "hello",
20 |         ),
21 |         "scene::ComponentA": (
22 |           x: 1.0,
23 |           y: 2.0,
24 |         ),
25 |       },
26 |     ),
27 |     1: (
28 |       components: {
29 |         "scene::ComponentA": (
30 |           x: 3.0,
31 |           y: 4.0,
32 |         ),
33 |       },
34 |     ),
35 |   }
36 | )


--------------------------------------------------------------------------------
/src/user_input/touch.rs:
--------------------------------------------------------------------------------
 1 | use super::InputExample;
 2 | use bevy::prelude::*;
 3 | 
 4 | pub struct TouchExample;
 5 | impl Plugin for TouchExample {
 6 |     fn build(&self, app: &mut App) {
 7 |         app.add_system_set(SystemSet::on_update(InputExample::TouchEvent).with_system(touch_event))
 8 |             .add_system_set(
 9 |                 SystemSet::on_update(InputExample::TouchInput).with_system(touch_input),
10 |             );
11 |     }
12 | }
13 | 
14 | fn touch_event(mut touchs: EventReader<TouchInput>) {
15 |     for touch in touchs.iter() {
16 |         if touch.phase == bevy::input::touch::TouchPhase::Started {
17 |             println!("touch: {:?}", touch);
18 |         }
19 |     }
20 | }
21 | 
22 | fn touch_input(touchs: Res<Touches>) {
23 |     for touch in touchs.iter() {
24 |         println!("touch: {:?}", touch);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | mod common;
 4 | pub use prelude::*;
 5 | pub mod prelude {
 6 |     pub use super::{
 7 |         common::*, components::ComponentPlugin, ecs::ECSExample, entitys::EntityPlugin,
 8 |         reflect::ReflectExample, resources::ResourcePlugin, scenes::ScenesExample, spawn_cam,
 9 |         systems::SystemPlugin, transform::TransformExample, user_input::InputExample,
10 |         visibility::VisibilityExample,
11 |     };
12 | }
13 | 
14 | mod components;
15 | mod ecs;
16 | mod entitys;
17 | #[allow(dead_code)]
18 | mod events;
19 | #[allow(dead_code)]
20 | mod local;
21 | #[allow(dead_code)]
22 | mod query;
23 | #[allow(dead_code)]
24 | mod reflect;
25 | mod resources;
26 | mod scenes;
27 | mod systems;
28 | mod transform;
29 | #[allow(dead_code)]
30 | mod user_input;
31 | mod visibility;
32 | pub fn spawn_cam(mut commands: Commands) {
33 |     let trans = Transform::from_xyz(5., 5., 5.);
34 |     commands
35 |         .spawn(Camera3dBundle {
36 |             transform: trans.looking_at(Vec3::ZERO, Vec3::Y),
37 |             ..Default::default()
38 |         })
39 |         .insert(common::MainCamera);
40 |     commands.spawn(SpotLightBundle {
41 |         transform: trans.looking_at(Vec3::ZERO, Vec3::Y),
42 |         ..Default::default()
43 |     });
44 | }
45 | 


--------------------------------------------------------------------------------
/src/common.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | pub use crate::components::{BBDirection, ComponentExample as BoxBall, Speed, WorldSize};
 4 | pub use crate::resources::{ColorSet, ColorWheel, DefaultFont};
 5 | 
 6 | #[derive(Component)]
 7 | pub struct MainCamera;
 8 | 
 9 | #[derive(Component)]
10 | pub struct UiCamera;
11 | 
12 | pub struct CommonPlugin;
13 | 
14 | impl Plugin for CommonPlugin {
15 |     fn build(&self, app: &mut App) {
16 |         app.insert_resource(SpamTime(Timer::from_seconds(2., TimerMode::Repeating)));
17 |         app.add_system_to_stage(CoreStage::First, timer_updata);
18 |         app.register_type::<super::components::Speed>();
19 |         app.register_type::<super::components::BBDirection>();
20 |         app.add_event::<Events>();
21 |         app.add_system(reset_system);
22 |     }
23 | }
24 | 
25 | fn reset_system(mut events: EventWriter<Events>, input: Res<Input<KeyCode>>) {
26 |     if input.just_pressed(KeyCode::Space) {
27 |         println!("send reset");
28 |         events.send(Events::Reset);
29 |     }
30 | }
31 | 
32 | #[derive(Resource)]
33 | pub struct SpamTime(Timer);
34 | 
35 | impl SpamTime {
36 |     pub fn finished(&self) -> bool {
37 |         self.0.finished()
38 |     }
39 | }
40 | 
41 | fn timer_updata(time: Res<Time>, mut timer: ResMut<SpamTime>) {
42 |     timer.0.tick(time.delta());
43 | }
44 | 
45 | pub enum Events {
46 |     Reset,
47 | }
48 | 


--------------------------------------------------------------------------------
/assets/9_3.scr.ron:
--------------------------------------------------------------------------------
 1 | (
 2 |     entities: {
 3 |         0: (
 4 |             components: {
 5 |                 ///////////////////////
 6 |                 {
 7 |                     "type": "bevy_transform::components::transform::Transform",
 8 |                     "struct": {
 9 |                     "translation": {
10 |                         "type": "glam::vec3::Vec3",
11 |                         "value": (0.0, 0.0, 0.0),
12 |                     },
13 |                     "rotation": {
14 |                         "type": "glam::quat::Quat",
15 |                         "value": (0.0, 0.0, 0.0, 1.0),
16 |                     },
17 |                     "scale": {
18 |                         "type": "glam::vec3::Vec3",
19 |                         "value": (1.0, 1.0, 1.0),
20 |                     },
21 |                     },
22 |                 },
23 |                 ////////////////////
24 |                 "bevy_transform::components::transform::Transform": (
25 |                     translation: (
26 |                         x: 0.0,
27 |                         y: 0.0,
28 |                         z: 0.0
29 |                     ),
30 |                     rotation: (0.0, 0.0, 0.0, 1.0),
31 |                     scale: (
32 |                         x: 1.0,
33 |                         y: 1.0,
34 |                         z: 1.0
35 |                     ),
36 |                 ),
37 |             },
38 |         ),
39 |     }
40 | )


--------------------------------------------------------------------------------
/assets/8.scr.ron:
--------------------------------------------------------------------------------
 1 | 
 2 | [
 3 |   (
 4 |     entity: 0,
 5 |     components: [
 6 |       {
 7 |         "type": "bevy_transform::components::transform::Transform",
 8 |         "struct": {
 9 |           "translation": {
10 |             "type": "glam::vec3::Vec3",
11 |             "value": (0.0, 0.0, 0.0),
12 |           },
13 |           "rotation": {
14 |             "type": "glam::quat::Quat",
15 |             "value": (0.0, 0.0, 0.0, 1.0),
16 |           },
17 |           "scale": {
18 |             "type": "glam::vec3::Vec3",
19 |             "value": (1.0, 1.0, 1.0),
20 |           },
21 |         },
22 |       },
23 |       {
24 |         "type": "scene::ComponentB",
25 |         "struct": {
26 |           "value": {
27 |             "type": "alloc::string::String",
28 |             "value": "hello",
29 |           },
30 |         },
31 |       },
32 |       {
33 |         "type": "scene::ComponentA",
34 |         "struct": {
35 |           "x": {
36 |             "type": "f32",
37 |             "value": 1.0,
38 |           },
39 |           "y": {
40 |             "type": "f32",
41 |             "value": 2.0,
42 |           },
43 |         },
44 |       },
45 |     ],
46 |   ),
47 |   (
48 |     entity: 1,
49 |     components: [
50 |       {
51 |         "type": "scene::ComponentA",
52 |         "struct": {
53 |           "x": {
54 |             "type": "f32",
55 |             "value": 3.0,
56 |           },
57 |           "y": {
58 |             "type": "f32",
59 |             "value": 4.0,
60 |           },
61 |         },
62 |       },
63 |     ],
64 |   ),
65 | ]


--------------------------------------------------------------------------------
/src/local.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | fn test(mut id: u8) -> impl FnMut(Res<Input<KeyCode>>) {
 4 |     move |input| {
 5 |         println!("test system {:?}", id);
 6 |         if input.just_pressed(KeyCode::Space) {
 7 |             id += 1;
 8 |         }
 9 |     }
10 | }
11 | 
12 | #[derive(Resource)]
13 | pub struct Slave(u8);
14 | 
15 | pub fn hello(is_slave: Local<Slave>) {
16 |     if is_slave.0 != 0 {
17 |         println!("Hello from slave {}", is_slave.0);
18 |     } else {
19 |         println!("Hello from master");
20 |     }
21 | }
22 | 
23 | pub fn hello2(is_slave1: Local<Slave>, is_slave2: Local<Slave>) {
24 |     if is_slave1.0 != 0 {
25 |         println!("Hello from slave {}", is_slave1.0);
26 |     } else {
27 |         println!("Hello from master");
28 |     }
29 |     println!("Slaver {} is here too", is_slave2.0);
30 | }
31 | 
32 | impl FromWorld for Slave {
33 |     fn from_world(world: &mut World) -> Self {
34 |         if let Some(mut is_slave) = world.get_resource_mut::<Slave>() {
35 |             is_slave.0 += 1;
36 |             Slave(is_slave.0)
37 |         } else {
38 |             world.insert_resource(Slave(0));
39 |             Slave(0)
40 |         }
41 |     }
42 | }
43 | 
44 | fn edit_loacl(mut slave: Local<Slave>) {
45 |     *slave = Slave(slave.0 + 1);
46 | }
47 | 
48 | fn first_run_example(mut not_first: Local<bool>) {
49 |     if !(*not_first) {
50 |         //first time the system runs
51 |         *not_first = true;
52 |     } else {
53 |         //all other tiemes the system runs
54 |     }
55 |     //runs every time
56 | }
57 | 
58 | #[derive(Default, Resource)]
59 | struct LastState(u64);
60 | 
61 | fn change_example(mut last_state: Local<LastState>, this_state: Res<LastState>) {
62 |     if this_state.0 == last_state.0 {
63 |         return;
64 |     }
65 |     last_state.0 = this_state.0;
66 |     //code that only runs of state change
67 | }
68 | 


--------------------------------------------------------------------------------
/src/user_input/mouse.rs:
--------------------------------------------------------------------------------
 1 | use super::InputExample;
 2 | use bevy::prelude::*;
 3 | 
 4 | pub struct MouseExample;
 5 | impl Plugin for MouseExample {
 6 |     fn build(&self, app: &mut App) {
 7 |         app.add_system_set(
 8 |             SystemSet::on_update(InputExample::MouseClick)
 9 |                 .with_system(mouse_button)
10 |                 .with_system(mouse_button_raw),
11 |         );
12 |         app.add_system_set(
13 |             SystemSet::on_update(InputExample::MouseMove).with_system(mouse_move_raw),
14 |         );
15 |         app.add_system_set(
16 |             SystemSet::on_update(InputExample::MouseScroll).with_system(mouse_scroll),
17 |         );
18 |         app.add_system_set(
19 |             SystemSet::on_update(InputExample::Cursor)
20 |                 .with_system(mouse_move)
21 |                 .with_system(cursor_click),
22 |         );
23 |     }
24 | }
25 | 
26 | fn mouse_button(input: Res<Input<MouseButton>>) {
27 |     for key in input.get_just_pressed() {
28 |         println!("you have clicked: {:?}", key);
29 |     }
30 | }
31 | 
32 | use bevy::input::mouse::MouseButtonInput;
33 | fn mouse_button_raw(mut input: EventReader<MouseButtonInput>) {
34 |     for key in input.iter() {
35 |         println!("you have clicked: {:?}", key);
36 |     }
37 | }
38 | 
39 | use bevy::input::mouse::MouseMotion;
40 | fn mouse_move_raw(mut events: EventReader<MouseMotion>) {
41 |     for e in events.iter() {
42 |         println!("Mouse Move: {:?}", e)
43 |     }
44 | }
45 | 
46 | use bevy::input::mouse::MouseWheel;
47 | fn mouse_scroll(mut events: EventReader<MouseWheel>) {
48 |     for e in events.iter() {
49 |         println!("Scroll is: {:?}", e);
50 |     }
51 | }
52 | 
53 | fn mouse_move(mut events: EventReader<CursorMoved>) {
54 |     for e in events.iter() {
55 |         println!("Cursor is at: {:?}", e);
56 |     }
57 | }
58 | 
59 | fn cursor_click(mut events: EventReader<CursorEntered>) {
60 |     for e in events.iter() {
61 |         println!("Enter window: {:?}", e);
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/ecs.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | pub struct ECSExample;
 4 | 
 5 | impl Plugin for ECSExample {
 6 |     fn build(&self, app: &mut App) {
 7 |         app.add_startup_system(my_system)
 8 |             .add_system(my_logic)
 9 |             .add_system(my_other_logic);
10 |     }
11 | }
12 | 
13 | #[derive(Component)]
14 | struct MyCompontentUnit;
15 | 
16 | #[derive(Debug, Component)]
17 | struct MyCompontentWithData(String);
18 | 
19 | #[derive(Debug, Component)]
20 | struct MyCompontentWithName {
21 |     name: String,
22 | }
23 | 
24 | #[derive(Resource)]
25 | struct Target(Entity);
26 | 
27 | fn my_system(mut commands: Commands) {
28 |     println!(
29 |         "spawned entity {:?}",
30 |         commands.spawn(MyCompontentUnit).id()
31 |     );
32 |     let entity = commands
33 |         .spawn(MyCompontentWithName {
34 |             name: "target".to_string(),
35 |         })
36 |         .id();
37 |     println!(
38 |         "spawned entity {:?}",
39 |         commands
40 |             .spawn(MyCompontentWithData("Hello".to_string()))
41 |             .id()
42 |     );
43 |     println!(
44 |         "spawned entity {:?}",
45 |         commands
46 |             .spawn(MyCompontentWithData("World".to_string()))
47 |             .id()
48 |     );
49 |     commands.insert_resource(Target(entity));
50 | }
51 | 
52 | fn my_logic(
53 |     input: Res<Input<KeyCode>>,
54 |     data: Query<&MyCompontentWithData>,
55 |     targets: Query<&MyCompontentWithName>,
56 |     target: Res<Target>,
57 | ) {
58 |     if input.just_pressed(KeyCode::P) {
59 |         for data in data.iter() {
60 |             println!("Data:{}", data.0);
61 |         }
62 |     }
63 |     if input.just_pressed(KeyCode::T) {
64 |         println!(
65 |             "the target is {:?}:{}",
66 |             target.0,
67 |             targets.get(target.0).unwrap().name
68 |         );
69 |     }
70 | }
71 | 
72 | fn my_other_logic(input: Res<Input<KeyCode>>, unit: Query<&MyCompontentUnit>) {
73 |     if input.just_pressed(KeyCode::P) {
74 |         for _ in unit.iter() {
75 |             println!("Unit");
76 |         }
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/events.rs:
--------------------------------------------------------------------------------
 1 | use bevy::{ecs::event::Events, prelude::*};
 2 | 
 3 | fn event_update_every_x_frames<T: 'static + Send + Sync>(
 4 |     frames: usize,
 5 | ) -> impl FnMut(ResMut<Events<T>>, Local<usize>) {
 6 |     move |mut events: ResMut<Events<T>>, mut frame: Local<usize>| {
 7 |         *frame += 1;
 8 |         if frames >= *frame {
 9 |             events.update();
10 |             *frame = 0;
11 |         }
12 |     }
13 | }
14 | 
15 | fn update_every_other_frame<T: 'static + Send + Sync>(
16 |     mut events: ResMut<Events<T>>,
17 |     mut update: Local<bool>,
18 | ) {
19 |     *update = !*update;
20 |     if *update {
21 |         events.update();
22 |     }
23 | }
24 | 
25 | fn update_every_sec<T: 'static + Send + Sync>(
26 |     mut events: ResMut<Events<T>>,
27 |     time: Res<Time>,
28 |     mut last: Local<f32>,
29 | ) {
30 |     *last += time.delta_seconds();
31 |     if *last > 1.0 {
32 |         events.update();
33 |         *last %= 1.0;
34 |     }
35 | }
36 | 
37 | struct Popup {
38 |     tital: String,
39 |     icon: String,
40 |     message: String,
41 | }
42 | 
43 | fn some_system(mut popup: EventWriter<Popup>, input: Res<Input<KeyCode>>) {
44 |     if input.just_pressed(KeyCode::Space) {
45 |         popup.send(Popup {
46 |             tital: "KeyPress".to_string(),
47 |             icon: "keys/space.png".to_string(),
48 |             message: "Space was pressed".to_string(),
49 |         })
50 |     }
51 |     if input.just_pressed(KeyCode::PageUp) {
52 |         popup.send(Popup {
53 |             tital: "KeyPress".to_string(),
54 |             icon: "keys/PUp.png".to_string(),
55 |             message: "Page Up was pressed".to_string(),
56 |         })
57 |     }
58 |     if input.just_pressed(KeyCode::PageDown) {
59 |         popup.send(Popup {
60 |             tital: "KeyPress".to_string(),
61 |             icon: "keys/PDown.png".to_string(),
62 |             message: "Page Down was pressed".to_string(),
63 |         })
64 |     }
65 | }
66 | 
67 | fn pupup_system(mut commands: Commands, mut events: EventReader<Popup>) {
68 |     for popup in events.iter() {
69 |         spawn_popup(&mut commands, popup);
70 |     }
71 | }
72 | 
73 | fn spawn_popup(_commands: &mut Commands, _popup: &Popup) {
74 |     todo!()
75 | }
76 | 


--------------------------------------------------------------------------------
/src/user_input/keyboard.rs:
--------------------------------------------------------------------------------
 1 | use super::InputExample;
 2 | use bevy::prelude::*;
 3 | 
 4 | pub struct KeyboardExample;
 5 | impl Plugin for KeyboardExample {
 6 |     fn build(&self, app: &mut App) {
 7 |         app.add_system_set(SystemSet::on_update(InputExample::Keyboard).with_system(keycode_test));
 8 |     }
 9 | }
10 | 
11 | fn key_press(input: Res<Input<KeyCode>>) {
12 |     if input.just_pressed(KeyCode::Space) {
13 |         //Jump
14 |     }
15 | }
16 | 
17 | fn input(input: Res<Input<KeyCode>>) {
18 |     for key in input.get_pressed() {
19 |         match key {
20 |             KeyCode::A => {
21 |                 //left
22 |             }
23 |             KeyCode::W => {
24 |                 //forward
25 |             }
26 |             KeyCode::S => {
27 |                 //back
28 |             }
29 |             KeyCode::D => {
30 |                 //right
31 |             }
32 |             _ => {}
33 |         }
34 |     }
35 | }
36 | 
37 | fn multi_key(input: Res<Input<KeyCode>>) {
38 |     if input.just_pressed(KeyCode::Space)
39 |         && input.any_pressed([KeyCode::A, KeyCode::D, KeyCode::W, KeyCode::S])
40 |     {
41 |         //moving jump
42 |     }
43 | }
44 | 
45 | use bevy::input::keyboard::KeyboardInput;
46 | fn order_keys(mut keys: EventReader<KeyboardInput>) {
47 |     for key in keys.iter() {
48 |         if let Some(keycode) = key.key_code {
49 |             //has a standard keycode
50 |             let _ = keycode;
51 |         } else {
52 |             //no keycode use scan code here
53 |         }
54 |     }
55 | }
56 | 
57 | fn keycode_test(input: Res<Input<KeyCode>>, mut events: EventReader<KeyboardInput>) {
58 |     for key in input.get_pressed() {
59 |         println!("{:?}", key);
60 |     }
61 |     for event in events.iter() {
62 |         println!("{:?}", event);
63 |     }
64 | }
65 | 
66 | #[derive(Debug, Component)]
67 | struct Player;
68 | fn player_controler(mut player: Query<&mut Transform, With<Player>>, input: Res<Input<KeyCode>>) {
69 |     let mut player = player.single_mut();
70 |     if input.any_pressed([KeyCode::W, KeyCode::Up, KeyCode::Numpad8]) {
71 |         player.translation.y += 1.
72 |     }
73 |     if input.any_pressed([KeyCode::S, KeyCode::Down, KeyCode::Numpad2]) {
74 |         player.translation.y -= 1.
75 |     }
76 |     if input.any_pressed([KeyCode::A, KeyCode::Left, KeyCode::Numpad4]) {
77 |         player.translation.x -= 1.
78 |     }
79 |     if input.any_pressed([KeyCode::D, KeyCode::Right, KeyCode::Numpad6]) {
80 |         player.translation.x += 1.
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/visibility.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | fn toggle_visibility(
 4 |     mut visibility: Query<(&mut Visibility, &VisibilityExample)>,
 5 |     input: Res<Input<KeyCode>>,
 6 | ) {
 7 |     let mut set: std::collections::HashSet<u8> = std::collections::HashSet::default();
 8 |     for key in input.get_just_pressed() {
 9 |         match key {
10 |             KeyCode::Numpad0 => {
11 |                 set.insert(0);
12 |             }
13 |             KeyCode::Numpad1 => {
14 |                 set.insert(1);
15 |             }
16 |             KeyCode::Numpad2 => {
17 |                 set.insert(2);
18 |             }
19 |             KeyCode::Numpad3 => {
20 |                 set.insert(3);
21 |             }
22 |             KeyCode::Numpad4 => {
23 |                 set.insert(4);
24 |             }
25 |             KeyCode::Numpad5 => {
26 |                 set.insert(5);
27 |             }
28 |             KeyCode::Numpad6 => {
29 |                 set.insert(6);
30 |             }
31 |             KeyCode::Numpad7 => {
32 |                 set.insert(7);
33 |             }
34 |             KeyCode::Numpad8 => {
35 |                 set.insert(8);
36 |             }
37 |             KeyCode::Numpad9 => {
38 |                 set.insert(9);
39 |             }
40 |             _ => {}
41 |         }
42 |     }
43 |     for (mut vis, id) in visibility.iter_mut() {
44 |         if set.contains(&id.0) {
45 |             vis.is_visible = !vis.is_visible;
46 |         }
47 |     }
48 | }
49 | 
50 | //setup///////////////////////////////
51 | #[derive(Component, Reflect)]
52 | pub struct VisibilityExample(pub u8);
53 | 
54 | impl Plugin for VisibilityExample {
55 |     fn build(&self, app: &mut App) {
56 |         app.add_startup_system(spawn_cube)
57 |             .add_system(toggle_visibility);
58 |     }
59 | }
60 | 
61 | const CUBE_COLORS: [Color; 10] = [
62 |     Color::RED,
63 |     Color::GREEN,
64 |     Color::BLUE,
65 |     Color::BLACK,
66 |     Color::CRIMSON,
67 |     Color::CYAN,
68 |     Color::GOLD,
69 |     Color::VIOLET,
70 |     Color::WHITE,
71 |     Color::ORANGE,
72 | ];
73 | 
74 | fn spawn_cube(
75 |     mut commands: Commands,
76 |     mut meshs: ResMut<Assets<Mesh>>,
77 |     mut materials: ResMut<Assets<StandardMaterial>>,
78 | ) {
79 |     let mut last = Entity::from_raw(0);
80 |     for i in 0..10 {
81 |         let e = commands
82 |             .spawn(PbrBundle {
83 |                 transform: Transform::from_xyz(0., if i == 0 { -2.5 } else { 0.5 }, 0.),
84 |                 mesh: meshs.add(shape::Cube { size: 0.5 }.into()),
85 |                 material: materials.add(CUBE_COLORS[i].into()),
86 |                 ..Default::default()
87 |             })
88 |             .insert(VisibilityExample(i as u8))
89 |             .id();
90 |         if i == 0 {
91 |             last = e;
92 |             continue;
93 |         }
94 |         commands.entity(last).add_child(e);
95 |         last = e;
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy_basics::prelude::*;
 3 | use bevy_editor_pls::*;
 4 | 
 5 | fn main() {
 6 |     App::new()
 7 |         // default stuff //
 8 |         .add_plugins(DefaultPlugins)
 9 |         .add_plugin(EditorPlugin)
10 |         .add_plugin(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
11 |         .add_plugin(bevy::diagnostic::EntityCountDiagnosticsPlugin)
12 |         .add_plugin(CommonPlugin)
13 |         .add_startup_system(spawn_cam)
14 |         // end default stuff //
15 |         // comment in the examples you want //
16 |         .add_system(cube_move)
17 |         .add_startup_system(startup_system)
18 |         // .add_plugin(ECSExample)
19 |         // .add_plugin(SystemPlugin)
20 |         // .add_plugin(ComponentPlugin)
21 |         // .add_plugin(EntityPlugin)
22 |         // .add_plugin(ResourcePlugin)
23 |         // .add_plugin(InputExample::TouchEvent)
24 |         // .add_plugin(TransformExample)
25 |         // .add_plugin(VisibilityExample(0))
26 |         // .add_plugin(ReflectExample)
27 |         .add_plugin(ScenesExample)
28 |         .run();
29 | }
30 | 
31 | #[derive(Component)]
32 | struct Cube;
33 | 
34 | pub fn spawn_cam(mut commands: Commands) {
35 |     let trans = Transform::from_xyz(5., 5., 5.);
36 |     commands
37 |         .spawn(Camera3dBundle {
38 |             transform: trans.looking_at(Vec3::ZERO, Vec3::Y),
39 |             ..Default::default()
40 |         })
41 |         .insert(MainCamera);
42 |     commands.spawn(SpotLightBundle {
43 |         transform: trans.looking_at(Vec3::ZERO, Vec3::Y),
44 |         ..Default::default()
45 |     });
46 | }
47 | 
48 | #[allow(dead_code)]
49 | fn startup_system(
50 |     mut commands: Commands,
51 |     mut mesh_assets: ResMut<Assets<Mesh>>,
52 |     mut materials_asstes: ResMut<Assets<StandardMaterial>>,
53 | ) {
54 |     commands
55 |         .spawn(PbrBundle {
56 |             mesh: mesh_assets.add(Mesh::from(shape::Cube { size: 1.0 })),
57 |             material: materials_asstes.add(StandardMaterial {
58 |                 base_color: Color::rgb(1.0, 0.5, 0.5),
59 |                 ..Default::default()
60 |             }),
61 |             ..Default::default()
62 |         })
63 |         .insert(Cube);
64 | }
65 | 
66 | #[allow(dead_code)]
67 | fn cube_move(input: Res<Input<KeyCode>>, mut cubes: Query<&mut Transform, With<Cube>>) {
68 |     let mut change = Vec3::ZERO;
69 |     if input.just_pressed(KeyCode::W) {
70 |         change.z -= 1.0;
71 |     }
72 |     if input.just_pressed(KeyCode::S) {
73 |         change.z += 1.0;
74 |     }
75 |     if input.just_pressed(KeyCode::A) {
76 |         change.x -= 1.0;
77 |     }
78 |     if input.just_pressed(KeyCode::D) {
79 |         change.x += 1.0;
80 |     }
81 |     if input.just_pressed(KeyCode::PageDown) {
82 |         change.y -= 1.0;
83 |     }
84 |     if input.just_pressed(KeyCode::PageUp) {
85 |         change.y += 1.0;
86 |     }
87 |     for mut cube in cubes.iter_mut() {
88 |         cube.translation += change;
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/user_input/gamepad.rs:
--------------------------------------------------------------------------------
 1 | use super::InputExample;
 2 | use bevy::{input::gamepad::GamepadEventRaw, prelude::*};
 3 | 
 4 | pub struct GamepadExample;
 5 | impl Plugin for GamepadExample {
 6 |     fn build(&self, app: &mut App) {
 7 |         app.add_system_set(
 8 |             SystemSet::on_update(InputExample::GamepadButton)
 9 |                 .with_system(gamepad_button)
10 |                 .with_system(gamepad_button_axis),
11 |         )
12 |         .add_system_set(
13 |             SystemSet::on_update(InputExample::GamepadEvent)
14 |                 .with_system(gamepad_event)
15 |                 .with_system(gamepad_event_raw),
16 |         )
17 |         .add_system_set(SystemSet::on_update(InputExample::GamepadAxis).with_system(gamepad_axis));
18 |     }
19 | }
20 | 
21 | fn gamepad_button(input: Res<Input<GamepadButton>>) {
22 |     for button in input.get_just_pressed() {
23 |         println!("You pressed : {:?}", button);
24 |     }
25 | }
26 | 
27 | fn gamepad_button_axis(input: Res<Axis<GamepadButton>>) {
28 |     for button in [
29 |         GamepadButtonType::LeftTrigger2,
30 |         GamepadButtonType::RightTrigger2,
31 |     ] {
32 |         if let Some(val) = input.get(GamepadButton {
33 |             gamepad: Gamepad { id: 0 },
34 |             button_type: button,
35 |         }) {
36 |             if val > DEADZONE && val < 1.0 {
37 |                 println!("you have trigger at: {}", val);
38 |             }
39 |         }
40 |     }
41 | }
42 | 
43 | const DEADZONE: f32 = 0.1;
44 | const AXISTYPES: [GamepadAxisType; 6] = [
45 |     GamepadAxisType::LeftStickX,
46 |     GamepadAxisType::LeftStickY,
47 |     GamepadAxisType::LeftZ,
48 |     GamepadAxisType::RightStickX,
49 |     GamepadAxisType::RightStickY,
50 |     GamepadAxisType::RightZ,
51 | ];
52 | 
53 | fn gamepad_axis(input: Res<Axis<GamepadAxis>>) {
54 |     for axis in AXISTYPES.iter() {
55 |         if let Some(x) = input.get(GamepadAxis {
56 |             gamepad: Gamepad { id: 0 },
57 |             axis_type: *axis,
58 |         }) {
59 |             if x.abs() > DEADZONE {
60 |                 println!("gamepad axis {:?}: {}", axis, x)
61 |             }
62 |         }
63 |     }
64 | }
65 | 
66 | fn gamepad_event(mut events: EventReader<GamepadEvent>) {
67 |     for e in events.iter() {
68 |         println!("gamepad event: {:?}", e);
69 |     }
70 | }
71 | 
72 | fn gamepad_event_raw(mut events: EventReader<GamepadEventRaw>) {
73 |     for e in events.iter() {
74 |         println!("Raw Event: {:?}", e);
75 |     }
76 | }
77 | 
78 | fn list_gamepads(gamepads: Res<Gamepads>, time: Res<Time>, mut delta: Local<f32>) {
79 |     *delta += time.delta_seconds();
80 |     if *delta < 1.0 {
81 |         return;
82 |     }
83 |     let gamepads: Vec<Gamepad> = gamepads.iter().collect();
84 |     if gamepads.len() == 0 {
85 |         println!("there are no gamepads connected");
86 |         return;
87 |     }
88 |     println!(
89 |         "there are {} controlers connected\n they are:",
90 |         gamepads.len()
91 |     );
92 |     for gamepad in gamepads {
93 |         println!("{:?}", gamepad);
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/user_input.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | 
  3 | mod gamepad;
  4 | mod keyboard;
  5 | mod mouse;
  6 | mod touch;
  7 | 
  8 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  9 | pub enum InputExample {
 10 |     Keyboard,
 11 |     MouseClick,
 12 |     MouseMove,
 13 |     MouseScroll,
 14 |     Cursor,
 15 |     GamepadButton,
 16 |     GamepadEvent,
 17 |     GamepadAxis,
 18 |     TouchEvent,
 19 |     TouchInput,
 20 | }
 21 | 
 22 | impl Plugin for InputExample {
 23 |     fn build(&self, app: &mut App) {
 24 |         app.add_state(*self)
 25 |             .add_system(change_mode)
 26 |             .add_plugin(keyboard::KeyboardExample)
 27 |             .add_plugin(mouse::MouseExample)
 28 |             .add_plugin(gamepad::GamepadExample)
 29 |             .add_plugin(touch::TouchExample);
 30 |     }
 31 | }
 32 | 
 33 | fn change_mode(input: Res<Input<KeyCode>>, mut state: ResMut<State<InputExample>>) {
 34 |     use InputExample::*;
 35 |     let up = if input.just_pressed(KeyCode::PageUp) {
 36 |         true
 37 |     } else if input.just_pressed(KeyCode::PageDown) {
 38 |         false
 39 |     } else {
 40 |         return;
 41 |     };
 42 |     let set = match state.current() {
 43 |         Keyboard => {
 44 |             if up {
 45 |                 TouchEvent
 46 |             } else {
 47 |                 MouseClick
 48 |             }
 49 |         }
 50 |         MouseClick => {
 51 |             if up {
 52 |                 Keyboard
 53 |             } else {
 54 |                 MouseMove
 55 |             }
 56 |         }
 57 |         MouseMove => {
 58 |             if up {
 59 |                 MouseClick
 60 |             } else {
 61 |                 MouseScroll
 62 |             }
 63 |         }
 64 |         MouseScroll => {
 65 |             if up {
 66 |                 MouseMove
 67 |             } else {
 68 |                 Cursor
 69 |             }
 70 |         }
 71 |         Cursor => {
 72 |             if up {
 73 |                 MouseScroll
 74 |             } else {
 75 |                 GamepadButton
 76 |             }
 77 |         }
 78 |         GamepadButton => {
 79 |             if up {
 80 |                 Cursor
 81 |             } else {
 82 |                 GamepadEvent
 83 |             }
 84 |         }
 85 |         GamepadEvent => {
 86 |             if up {
 87 |                 GamepadButton
 88 |             } else {
 89 |                 GamepadAxis
 90 |             }
 91 |         }
 92 |         GamepadAxis => {
 93 |             if up {
 94 |                 GamepadEvent
 95 |             } else {
 96 |                 TouchEvent
 97 |             }
 98 |         }
 99 |         TouchEvent => {
100 |             if up {
101 |                 GamepadAxis
102 |             } else {
103 |                 TouchInput
104 |             }
105 |         }
106 |         TouchInput => {
107 |             if up {
108 |                 TouchEvent
109 |             } else {
110 |                 Keyboard
111 |             }
112 |         }
113 |     };
114 |     println!("Set mode to {:?}", set);
115 |     state.set(set).unwrap();
116 | }
117 | 


--------------------------------------------------------------------------------
/src/systems.rs:
--------------------------------------------------------------------------------
  1 | use super::common::*;
  2 | use bevy::prelude::*;
  3 | 
  4 | pub struct SystemPlugin;
  5 | 
  6 | impl Plugin for SystemPlugin {
  7 |     fn build(&self, app: &mut App) {
  8 |         app.add_system(basic_system);
  9 |         app.add_startup_system(startup_system);
 10 |         app.add_system(exclusive_system);
 11 |         app.add_system_to_stage(CoreStage::First, first_system);
 12 |         app.add_system_to_stage(CoreStage::Last, last_system);
 13 |         app.add_system(system_chain_one.pipe(system_chain_two));
 14 |         app.add_startup_system(test_system);
 15 |     }
 16 | }
 17 | 
 18 | fn startup_system() {
 19 |     println!("running startup system once");
 20 | }
 21 | 
 22 | fn basic_system(input: Res<Input<KeyCode>>) {
 23 |     if input.just_pressed(KeyCode::Space) {
 24 |         println!("Space was pressed");
 25 |     }
 26 | }
 27 | 
 28 | fn exclusive_system(world: &mut World) {
 29 |     let input = world.get_resource::<Input<KeyCode>>().unwrap();
 30 |     if input.just_pressed(KeyCode::Space) {
 31 |         println!("got input directily from world");
 32 |     }
 33 | }
 34 | 
 35 | fn first_system(timer: Res<SpamTime>) {
 36 |     if timer.finished() {
 37 |         println!("running first system");
 38 |     }
 39 | }
 40 | 
 41 | fn last_system(timer: Res<SpamTime>) {
 42 |     if timer.finished() {
 43 |         println!("running last system");
 44 |     }
 45 | }
 46 | 
 47 | fn system_chain_one(mut loacl: Local<f32>, input: Res<Input<KeyCode>>) -> f32 {
 48 |     let mut change = 0.0;
 49 |     for key in input.get_just_pressed() {
 50 |         match key {
 51 |             KeyCode::Numpad1 => change += 1.0,
 52 |             KeyCode::Numpad2 => change += 2.0,
 53 |             KeyCode::Numpad3 => change += 3.0,
 54 |             KeyCode::Numpad4 => change += 4.0,
 55 |             KeyCode::Numpad5 => change += 5.0,
 56 |             KeyCode::Numpad6 => change += 6.0,
 57 |             KeyCode::Numpad7 => change += 7.0,
 58 |             KeyCode::Numpad8 => change += 8.0,
 59 |             KeyCode::Numpad9 => change += 9.0,
 60 |             _ => {}
 61 |         }
 62 |     }
 63 |     if input.pressed(KeyCode::NumpadSubtract) {
 64 |         change = -change;
 65 |     }
 66 |     *loacl += change;
 67 |     *loacl
 68 | }
 69 | 
 70 | fn system_chain_two(input: In<f32>, time: Res<Time>, mut loacl: Local<f32>) {
 71 |     if input.0 == *loacl {
 72 |         return;
 73 |     }
 74 |     println!(
 75 |         "time: {} with input {}",
 76 |         time.elapsed_seconds(),
 77 |         input.0
 78 |     );
 79 |     *loacl = input.0;
 80 | }
 81 | 
 82 | fn test_system(
 83 |     mut commands: Commands,
 84 |     res: Res<Time>,
 85 |     res_mut: ResMut<Assets<Mesh>>,
 86 |     op_res: Option<Res<AssetServer>>,
 87 |     query: Query<&mut Transform, Changed<Interaction>>,
 88 |     mut event_r: EventReader<AssetEvent<StandardMaterial>>,
 89 |     event_w: EventWriter<GamepadEvent>,
 90 | ) {
 91 |     commands.spawn_empty().despawn();
 92 |     let _ = res;
 93 |     let _ = res_mut;
 94 |     let _ = op_res;
 95 |     let _ = query;
 96 |     let _ = event_w;
 97 |     for event in event_r.iter() {
 98 |         println!("got event {:?}", event);
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/examples/visibility.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | use bevy_basics::prelude::*;
  3 | use bevy_inspector_egui::prelude::*;
  4 | 
  5 | fn main() {
  6 |     App::new()
  7 |         .add_plugins(DefaultPlugins)
  8 |         .add_plugin(VisibilityExample(0))
  9 |         .add_startup_system(spawn_cam)
 10 |         .add_plugin(WorldInspectorPlugin::default())
 11 |         .run()
 12 | }
 13 | 
 14 | fn toggle_visibility(
 15 |     mut visibility: Query<(&mut Visibility, &VisibilityExample)>,
 16 |     input: Res<Input<KeyCode>>,
 17 | ) {
 18 |     let mut set: std::collections::HashSet<u8> = std::collections::HashSet::default();
 19 |     for key in input.get_just_pressed() {
 20 |         match key {
 21 |             KeyCode::Numpad0 => {
 22 |                 set.insert(0);
 23 |             }
 24 |             KeyCode::Numpad1 => {
 25 |                 set.insert(1);
 26 |             }
 27 |             KeyCode::Numpad2 => {
 28 |                 set.insert(2);
 29 |             }
 30 |             KeyCode::Numpad3 => {
 31 |                 set.insert(3);
 32 |             }
 33 |             KeyCode::Numpad4 => {
 34 |                 set.insert(4);
 35 |             }
 36 |             KeyCode::Numpad5 => {
 37 |                 set.insert(5);
 38 |             }
 39 |             KeyCode::Numpad6 => {
 40 |                 set.insert(6);
 41 |             }
 42 |             KeyCode::Numpad7 => {
 43 |                 set.insert(7);
 44 |             }
 45 |             KeyCode::Numpad8 => {
 46 |                 set.insert(8);
 47 |             }
 48 |             KeyCode::Numpad9 => {
 49 |                 set.insert(9);
 50 |             }
 51 |             _ => {}
 52 |         }
 53 |     }
 54 |     for (mut vis, id) in visibility.iter_mut() {
 55 |         if set.contains(&id.0) {
 56 |             vis.is_visible = !vis.is_visible;
 57 |         }
 58 |     }
 59 | }
 60 | 
 61 | //setup///////////////////////////////
 62 | #[derive(Component, Reflect)]
 63 | pub struct VisibilityExample(pub u8);
 64 | 
 65 | impl Plugin for VisibilityExample {
 66 |     fn build(&self, app: &mut App) {
 67 |         app.add_startup_system(spawn_cube)
 68 |             .add_system(toggle_visibility);
 69 |     }
 70 | }
 71 | 
 72 | const CUBE_COLORS: [Color; 10] = [
 73 |     Color::RED,
 74 |     Color::GREEN,
 75 |     Color::BLUE,
 76 |     Color::BLACK,
 77 |     Color::CRIMSON,
 78 |     Color::CYAN,
 79 |     Color::GOLD,
 80 |     Color::VIOLET,
 81 |     Color::WHITE,
 82 |     Color::ORANGE,
 83 | ];
 84 | 
 85 | fn spawn_cube(
 86 |     mut commands: Commands,
 87 |     mut meshs: ResMut<Assets<Mesh>>,
 88 |     mut materials: ResMut<Assets<StandardMaterial>>,
 89 | ) {
 90 |     let mut last = Entity::from_raw(0);
 91 |     for i in 0..10 {
 92 |         let e = commands
 93 |             .spawn(PbrBundle {
 94 |                 transform: Transform::from_xyz(0., if i == 0 { -2.5 } else { 0.5 }, 0.),
 95 |                 mesh: meshs.add(shape::Cube { size: 0.5 }.into()),
 96 |                 material: materials.add(CUBE_COLORS[i].into()),
 97 |                 ..Default::default()
 98 |             })
 99 |             .insert(VisibilityExample(i as u8))
100 |             .id();
101 |         if i == 0 {
102 |             last = e;
103 |             continue;
104 |         }
105 |         commands.entity(last).add_child(e);
106 |         last = e;
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/src/components.rs:
--------------------------------------------------------------------------------
  1 | use super::common::*;
  2 | use bevy::prelude::*;
  3 | use rand::Rng;
  4 | 
  5 | pub struct ComponentPlugin;
  6 | 
  7 | impl Plugin for ComponentPlugin {
  8 |     fn build(&self, app: &mut App) {
  9 |         app.insert_resource(WorldSize(Vec3::ONE * 10.));
 10 |         app.add_startup_system(spawn_balls)
 11 |             .add_system(move_balls)
 12 |             .add_system(speed_switch);
 13 |     }
 14 | }
 15 | 
 16 | #[derive(Component)]
 17 | #[component(storage = "SparseSet")]
 18 | pub struct ComponentExample;
 19 | 
 20 | #[derive(Component, Default, Reflect)]
 21 | #[reflect(Component)]
 22 | pub struct Speed(pub f32);
 23 | 
 24 | #[derive(Component, Default, Reflect)]
 25 | #[reflect(Component)]
 26 | pub struct BBDirection(pub Vec3);
 27 | 
 28 | fn spawn_balls(
 29 |     mut commands: Commands,
 30 |     mut materials: ResMut<Assets<StandardMaterial>>,
 31 |     mut meshes: ResMut<Assets<Mesh>>,
 32 |     world_size: Res<WorldSize>,
 33 | ) {
 34 |     let mut rng = rand::thread_rng();
 35 |     let mesh = meshes.add(Mesh::from(shape::Icosphere {
 36 |         radius: 1.,
 37 |         subdivisions: 2,
 38 |     }));
 39 |     for _ in 0..10 {
 40 |         let speed = rng.gen_range(5.0..=50.0);
 41 |         let direction = Vec3::new(
 42 |             rng.gen_range(-1.0..1.),
 43 |             rng.gen_range(-1.0..1.),
 44 |             rng.gen_range(-1.0..1.),
 45 |         );
 46 |         let size = rng.gen_range(0.5..=1.5);
 47 |         let material = materials.add(StandardMaterial {
 48 |             base_color: Color::rgb(speed / 50., size - 0.5, rng.gen_range(0.0..=1.0)),
 49 |             ..Default::default()
 50 |         });
 51 |         commands
 52 |             .spawn((PbrBundle {
 53 |                 mesh: mesh.clone(),
 54 |                 material,
 55 |                 transform: Transform::from_translation(Vec3::new(
 56 |                     rng.gen_range(-world_size.0.x..world_size.0.x),
 57 |                     rng.gen_range(-world_size.0.y..world_size.0.y),
 58 |                     rng.gen_range(-world_size.0.z..world_size.0.z),
 59 |                 ))
 60 |                 .with_scale(Vec3::ONE * size),
 61 |                 ..Default::default()
 62 |             },
 63 |             Speed(speed),
 64 |             BBDirection(direction),
 65 |             ComponentExample,
 66 |             ));
 67 |     }
 68 | }
 69 | 
 70 | fn move_balls(
 71 |     mut balls: Query<(&mut Transform, &Speed, &mut BBDirection), With<ComponentExample>>,
 72 |     time: Res<Time>,
 73 |     world_size: Res<WorldSize>,
 74 | ) {
 75 |     let dt = time.delta_seconds();
 76 |     for (mut transform, speed, mut direction) in balls.iter_mut() {
 77 |         transform.translation += direction.0 * speed.0 * dt;
 78 |         if transform.translation.x.abs() >= world_size.0.x {
 79 |             direction.0.x = -direction.0.x;
 80 |         }
 81 |         if transform.translation.y.abs() >= world_size.0.y {
 82 |             direction.0.y = -direction.0.y;
 83 |         }
 84 |         if transform.translation.z.abs() >= world_size.0.z {
 85 |             direction.0.z = -direction.0.z;
 86 |         }
 87 |         transform.translation = transform
 88 |             .translation
 89 |             .clamp(-world_size.0 * 0.99, world_size.0 * 0.99);
 90 |     }
 91 | }
 92 | 
 93 | fn speed_switch(
 94 |     switch: Res<SpamTime>,
 95 |     mut balls: Query<&mut Speed, With<ComponentExample>>,
 96 |     mut fast: Local<bool>,
 97 | ) {
 98 |     if !switch.finished() {
 99 |         return;
100 |     }
101 |     for mut ball in balls.iter_mut() {
102 |         if *fast {
103 |             ball.0 /= 2.;
104 |         } else {
105 |             ball.0 *= 2.;
106 |         }
107 |     }
108 |     *fast = !*fast;
109 | }
110 | 
111 | //End///////////////////////////////////////////////
112 | #[derive(Resource)]
113 | pub struct WorldSize(pub Vec3);
114 | 


--------------------------------------------------------------------------------
/src/query.rs:
--------------------------------------------------------------------------------
  1 | use crate::common::*;
  2 | use bevy::prelude::*;
  3 | 
  4 | fn query_init(mut commands: Commands) {
  5 |     commands
  6 |         .spawn((Speed(0.),BBDirection(Vec3::ZERO),Name::new("Bob")));
  7 | }
  8 | 
  9 | fn single(_query: Query<&SomeComponent>) {}
 10 | 
 11 | fn multiple(_query: Query<(&SomeComponent, &SomeOtherComponent)>) {}
 12 | 
 13 | fn query(query: Query<&Name, Or<(With<Speed>, With<Transform>)>>) {
 14 |     for name in query.iter() {
 15 |         println!("{} has A Speed and A BBDirection", name.as_str());
 16 |     }
 17 | }
 18 | 
 19 | fn no_conflic(_query: Query<&Name, Or<(With<Speed>, With<Transform>)>>) {}
 20 | 
 21 | fn conflic(mut _query: Query<&mut Name, Or<(With<Speed>, With<Transform>)>>) {}
 22 | 
 23 | fn some_query(_query: Query<(&Transform, Option<&Name>)>) {}
 24 | #[derive(Component)]
 25 | struct SomeComponent;
 26 | 
 27 | #[derive(Component)]
 28 | struct SomeOtherComponent;
 29 | 
 30 | fn entity_ref(_query: Query<(Entity, &SomeComponent)>) {}
 31 | 
 32 | #[derive(Component)]
 33 | struct Player;
 34 | 
 35 | #[derive(Component)]
 36 | struct Size(f32);
 37 | 
 38 | fn query_filter(
 39 |     mut player_query: Query<(&mut Transform, &Size), With<Player>>,
 40 |     obj_query: Query<(&Transform, &Size), Without<Player>>,
 41 | ) {
 42 |     let (mut player_tran, player_size) = player_query.single_mut();
 43 | 
 44 |     for (tran, size) in obj_query.iter() {
 45 |         if check_colision(&player_tran, player_size, tran, size) {
 46 |             move_player(&mut player_tran, player_size, tran, size);
 47 |         }
 48 |     }
 49 | }
 50 | 
 51 | fn check_colision(
 52 |     player_tran: &Transform,
 53 |     player_size: &Size,
 54 |     obj_tran: &Transform,
 55 |     obj_size: &Size,
 56 | ) -> bool {
 57 |     let player_center = player_tran.translation;
 58 |     let player_half_size = player_size.0 * 0.5;
 59 |     let obj_center = obj_tran.translation;
 60 |     let obj_half_size = obj_size.0 * 0.5;
 61 |     if player_center.x + player_half_size < obj_center.x - obj_half_size {
 62 |         return false;
 63 |     }
 64 |     if player_center.x - player_half_size > obj_center.x + obj_half_size {
 65 |         return false;
 66 |     }
 67 |     if player_center.y + player_half_size < obj_center.y - obj_half_size {
 68 |         return false;
 69 |     }
 70 |     if player_center.y - player_half_size > obj_center.y + obj_half_size {
 71 |         return false;
 72 |     }
 73 |     if player_center.z + player_half_size < obj_center.z - obj_half_size {
 74 |         return false;
 75 |     }
 76 |     if player_center.z - player_half_size > obj_center.z + obj_half_size {
 77 |         return false;
 78 |     }
 79 |     true
 80 | }
 81 | 
 82 | fn move_player(
 83 |     player_tran: &mut Transform,
 84 |     player_size: &Size,
 85 |     obj_tran: &Transform,
 86 |     obj_size: &Size,
 87 | ) {
 88 |     let player_center = player_tran.translation;
 89 |     let player_half_size = player_size.0 * 0.5;
 90 |     let obj_center = obj_tran.translation;
 91 |     let obj_half_size = obj_size.0 * 0.5;
 92 |     if player_center.x + player_half_size < obj_center.x - obj_half_size {
 93 |         player_tran.translation.x += obj_half_size + player_half_size;
 94 |     }
 95 |     if player_center.x - player_half_size > obj_center.x + obj_half_size {
 96 |         player_tran.translation.x -= obj_half_size + player_half_size;
 97 |     }
 98 |     if player_center.y + player_half_size < obj_center.y - obj_half_size {
 99 |         player_tran.translation.y += obj_half_size + player_half_size;
100 |     }
101 |     if player_center.y - player_half_size > obj_center.y + obj_half_size {
102 |         player_tran.translation.y -= obj_half_size + player_half_size;
103 |     }
104 |     if player_center.z + player_half_size < obj_center.z - obj_half_size {
105 |         player_tran.translation.z += obj_half_size + player_half_size;
106 |     }
107 |     if player_center.z - player_half_size > obj_center.z + obj_half_size {
108 |         player_tran.translation.z -= obj_half_size + player_half_size;
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/src/transform.rs:
--------------------------------------------------------------------------------
  1 | use crate::common::Events;
  2 | use bevy::prelude::*;
  3 | fn entity_move(
  4 |     mut cubes: Query<&mut Transform, With<TransformExample>>,
  5 |     input: Res<Input<KeyCode>>,
  6 |     time: Res<Time>,
  7 |     mut rot: Local<Vec3>,
  8 |     mut events: EventReader<Events>,
  9 | ) {
 10 |     let mut reset = false;
 11 |     for event in events.iter() {
 12 |         match event {
 13 |             Events::Reset => {
 14 |                 reset = true;
 15 |             }
 16 |         }
 17 |     }
 18 |     let mut delta = Vec3::ZERO;
 19 |     let mut scail = Vec3::ZERO;
 20 |     for key in input.get_pressed() {
 21 |         match key {
 22 |             KeyCode::A => {
 23 |                 if input.pressed(KeyCode::R) {
 24 |                     rot.x -= 1.0 * time.delta_seconds();
 25 |                 } else if input.pressed(KeyCode::T) {
 26 |                     scail.x -= 1.;
 27 |                 } else {
 28 |                     delta.x -= 1.;
 29 |                 }
 30 |             }
 31 |             KeyCode::D => {
 32 |                 if input.pressed(KeyCode::R) {
 33 |                     rot.x += 1.0 * time.delta_seconds();
 34 |                 } else if input.pressed(KeyCode::T) {
 35 |                     scail.x += 1.;
 36 |                 } else {
 37 |                     delta.x += 1.;
 38 |                 }
 39 |             }
 40 |             KeyCode::W => {
 41 |                 if input.pressed(KeyCode::R) {
 42 |                     rot.y += 1.0 * time.delta_seconds();
 43 |                 } else if input.pressed(KeyCode::T) {
 44 |                     scail.y += 1.;
 45 |                 } else {
 46 |                     delta.y += 1.;
 47 |                 }
 48 |             }
 49 |             KeyCode::S => {
 50 |                 if input.pressed(KeyCode::R) {
 51 |                     rot.y -= 1.0 * time.delta_seconds();
 52 |                 } else if input.pressed(KeyCode::T) {
 53 |                     scail.y -= 1.;
 54 |                 } else {
 55 |                     delta.y -= 1.;
 56 |                 }
 57 |             }
 58 |             KeyCode::Q => {
 59 |                 if input.pressed(KeyCode::R) {
 60 |                     rot.z -= 1.0 * time.delta_seconds();
 61 |                 } else if input.pressed(KeyCode::T) {
 62 |                     scail.z -= 1.;
 63 |                 } else {
 64 |                     delta.z -= 1.;
 65 |                 }
 66 |             }
 67 |             KeyCode::E => {
 68 |                 if input.pressed(KeyCode::R) {
 69 |                     rot.z += 1.0 * time.delta_seconds();
 70 |                 } else if input.pressed(KeyCode::T) {
 71 |                     scail.z += 1.;
 72 |                 } else {
 73 |                     delta.z += 1.;
 74 |                 }
 75 |             }
 76 |             _ => {}
 77 |         }
 78 |     }
 79 |     for mut cube in cubes.iter_mut() {
 80 |         if reset {
 81 |             *cube = Transform::from_translation(Vec3::Y);
 82 |             *rot = Vec3::ZERO;
 83 |             continue;
 84 |         }
 85 |         cube.translation += delta * time.delta_seconds();
 86 |         cube.scale += scail * time.delta_seconds();
 87 |         cube.rotation = Quat::from_euler(EulerRot::XYZ, rot.x, rot.y, rot.z);
 88 |     }
 89 | }
 90 | 
 91 | fn spawn_cube(
 92 |     mut commands: Commands,
 93 |     mut meshs: ResMut<Assets<Mesh>>,
 94 |     mut materials: ResMut<Assets<StandardMaterial>>,
 95 | ) {
 96 |     commands
 97 |         .spawn(PbrBundle {
 98 |             mesh: meshs.add(shape::Cube { size: 1. }.into()),
 99 |             material: materials.add(Color::ORANGE_RED.into()),
100 |             transform: Transform::from_xyz(0., 1., 0.),
101 |             ..Default::default()
102 |         })
103 |         .insert(TransformExample)
104 |         .with_children(|p| {
105 |             p.spawn(PbrBundle {
106 |                 mesh: meshs.add(shape::Cube { size: 1. }.into()),
107 |                 material: materials.add(Color::ALICE_BLUE.into()),
108 |                 transform: Transform::from_xyz(0., 1., 0.),
109 |                 ..Default::default()
110 |             })
111 |             .insert(TransformExample);
112 |         });
113 | }
114 | 
115 | //setup /////////////////////////////////////////////////
116 | #[derive(Component)]
117 | pub struct TransformExample;
118 | 
119 | impl Plugin for TransformExample {
120 |     fn build(&self, app: &mut App) {
121 |         app.add_startup_system(spawn_cube).add_system(entity_move);
122 |     }
123 | }
124 | 
125 | #[allow(dead_code, unused)]
126 | fn crate_transforms() {
127 |     let matrix = Transform::IDENTITY.compute_matrix();
128 | 
129 |     let transform = Transform::from_matrix(matrix);
130 |     let transform = Transform::from_scale(Vec3::ONE);
131 |     let transform = Transform::from_rotation(Quat::IDENTITY);
132 |     let mut transform = Transform::from_translation(Vec3::ZERO);
133 | 
134 |     transform.with_rotation(Quat::IDENTITY);
135 |     transform.with_scale(Vec3::ONE);
136 |     transform.with_translation(Vec3::ZERO);
137 | 
138 |     fn get_transforms(transforms: Query<&Transform>) {
139 |         //do stuff
140 |     }
141 |     let global_transform = GlobalTransform::IDENTITY;
142 | 
143 |     transform.rotate(Quat::IDENTITY);
144 |     let x = transform.local_x();
145 |     let up = transform.up();
146 |     transform.look_at(Vec3::ZERO, Vec3::Y);
147 |     let matrix = transform.compute_matrix();
148 |     let affine = transform.compute_affine();
149 | 
150 |     let t = global_transform.translation();
151 |     let up = global_transform.up();
152 |     let left = global_transform.left();
153 |     let (s, r, t) = global_transform.to_scale_rotation_translation();
154 | }
155 | 


--------------------------------------------------------------------------------
/src/resources.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | 
  3 | pub struct ResourcePlugin;
  4 | 
  5 | impl Plugin for ResourcePlugin {
  6 |     fn build(&self, app: &mut App) {
  7 |         app.init_resource::<DefaultFont>();
  8 | 
  9 |         app.insert_resource(CustomColors([
 10 |             Color::GOLD,
 11 |             Color::INDIGO,
 12 |             Color::LIME_GREEN,
 13 |             Color::BISQUE,
 14 |             Color::AQUAMARINE,
 15 |             Color::MAROON,
 16 |             Color::SEA_GREEN,
 17 |             Color::SALMON,
 18 |             Color::YELLOW_GREEN,
 19 |             Color::ALICE_BLUE,
 20 |         ]));
 21 | 
 22 |         app.init_resource::<ColorWheel>();
 23 | 
 24 |         app.add_system(add_new_custom);
 25 |     }
 26 | }
 27 | 
 28 | #[derive(Resource)]
 29 | pub struct CustomColors([Color; 10]);
 30 | 
 31 | #[derive(Resource)]
 32 | pub struct ColorWheel(Vec<Handle<StandardMaterial>>);
 33 | 
 34 | #[derive(Resource)]
 35 | pub struct DefaultFont(pub Handle<Font>);
 36 | 
 37 | #[allow(dead_code)]
 38 | pub struct FancyFont(pub Handle<Font>);
 39 | 
 40 | impl FromWorld for DefaultFont {
 41 |     fn from_world(world: &mut World) -> Self {
 42 |         DefaultFont(
 43 |             world
 44 |                 .get_resource::<AssetServer>()
 45 |                 .unwrap()
 46 |                 .load("./Raleway-Bold.ttf"),
 47 |         )
 48 |     }
 49 | }
 50 | 
 51 | impl FromWorld for ColorWheel {
 52 |     fn from_world(world: &mut World) -> Self {
 53 |         let mut matts = Vec::with_capacity(29);
 54 |         let custom_colors = world.remove_resource::<CustomColors>();
 55 |         let mut materials = world
 56 |             .get_resource_mut::<Assets<StandardMaterial>>()
 57 |             .unwrap();
 58 | 
 59 |         matts.push(materials.add(StandardMaterial {
 60 |             base_color: Color::rgb(0., 0., 0.),
 61 |             ..Default::default()
 62 |         }));
 63 |         matts.push(materials.add(StandardMaterial {
 64 |             base_color: Color::rgb(0.5, 0.5, 0.5),
 65 |             ..Default::default()
 66 |         }));
 67 |         matts.push(materials.add(StandardMaterial {
 68 |             base_color: Color::rgb(1., 1., 1.),
 69 |             ..Default::default()
 70 |         }));
 71 |         for i in 0..4 {
 72 |             matts.push(materials.add(StandardMaterial {
 73 |                 base_color: Color::rgb(1. - (i as f32 * 0.25), 0., 0.),
 74 |                 ..Default::default()
 75 |             }));
 76 |             matts.push(materials.add(StandardMaterial {
 77 |                 base_color: Color::rgb(0., 1. - (i as f32 * 0.25), 0.),
 78 |                 ..Default::default()
 79 |             }));
 80 |             matts.push(materials.add(StandardMaterial {
 81 |                 base_color: Color::rgb(0., 0., 1. - (i as f32 * 0.25)),
 82 |                 ..Default::default()
 83 |             }));
 84 |             matts.push(materials.add(StandardMaterial {
 85 |                 base_color: Color::rgb(1., 1. - (i as f32 * 0.25), 0.),
 86 |                 ..Default::default()
 87 |             }));
 88 |             matts.push(materials.add(StandardMaterial {
 89 |                 base_color: Color::rgb(1. - (i as f32 * 0.25), 1., 0.),
 90 |                 ..Default::default()
 91 |             }));
 92 |             matts.push(materials.add(StandardMaterial {
 93 |                 base_color: Color::rgb(1. - (i as f32 * 0.25), 0., 1.),
 94 |                 ..Default::default()
 95 |             }));
 96 |             matts.push(materials.add(StandardMaterial {
 97 |                 base_color: Color::rgb(1., 0., 1. - (i as f32 * 0.25)),
 98 |                 ..Default::default()
 99 |             }));
100 |             matts.push(materials.add(StandardMaterial {
101 |                 base_color: Color::rgb(0., 1., 1. - (i as f32 * 0.25)),
102 |                 ..Default::default()
103 |             }));
104 |             matts.push(materials.add(StandardMaterial {
105 |                 base_color: Color::rgb(0., 1. - (i as f32 * 0.25), 1.),
106 |                 ..Default::default()
107 |             }));
108 |         }
109 | 
110 |         if let Some(colors) = custom_colors {
111 |             for i in 0..colors.0.len() {
112 |                 matts.push(materials.add(StandardMaterial {
113 |                     base_color: colors.0[i],
114 |                     ..Default::default()
115 |                 }));
116 |             }
117 |             world.remove_resource::<CustomColors>();
118 |         }
119 | 
120 |         ColorWheel(matts)
121 |     }
122 | }
123 | 
124 | impl ColorWheel {
125 |     pub fn get_color<'a>(&self, set: ColorSet, input: usize) -> Handle<StandardMaterial> {
126 |         use rand::Rng;
127 |         let index = match set {
128 |             ColorSet::Red => input * 3,
129 |             ColorSet::Green => input * 3 + 1,
130 |             ColorSet::Blue => input * 3 + 2,
131 |             ColorSet::Custom(set) => 39 + input + set as usize * 10,
132 |             ColorSet::Random => rand::thread_rng().gen_range(0..self.0.len()),
133 |         };
134 |         let index = if index >= self.0.len() { 0 } else { index };
135 |         self.0[index].clone()
136 |     }
137 | }
138 | 
139 | pub enum ColorSet {
140 |     Red,
141 |     Green,
142 |     Blue,
143 |     Custom(u8),
144 |     Random,
145 | }
146 | 
147 | fn add_new_custom(
148 |     mut commands: Commands,
149 |     mut color_weel: ResMut<ColorWheel>,
150 |     new_custom: Option<Res<CustomColors>>,
151 |     mut matts: ResMut<Assets<StandardMaterial>>,
152 | ) {
153 |     if new_custom.is_none() {
154 |         return;
155 |     }
156 |     for color in new_custom.unwrap().0.iter() {
157 |         color_weel.0.push(matts.add(StandardMaterial {
158 |             base_color: *color,
159 |             ..Default::default()
160 |         }));
161 |     }
162 | 
163 |     commands.remove_resource::<CustomColors>();
164 | }
165 | 


--------------------------------------------------------------------------------
/assets/gltf.gltf:
--------------------------------------------------------------------------------
  1 | {
  2 |     "asset" : {
  3 |         "generator" : "Khronos glTF Blender I/O v3.3.32",
  4 |         "version" : "2.0"
  5 |     },
  6 |     "scene" : 1,
  7 |     "scenes" : [
  8 |         {
  9 |             "name" : "Scene0",
 10 |             "nodes" : [
 11 |                 0
 12 |             ]
 13 |         },
 14 |         {
 15 |             "name" : "Scene1",
 16 |             "nodes" : [
 17 |                 1
 18 |             ]
 19 |         }
 20 |     ],
 21 |     "nodes" : [
 22 |         {
 23 |             "mesh" : 0,
 24 |             "name" : "Cube"
 25 |         },
 26 |         {
 27 |             "mesh" : 1,
 28 |             "name" : "Cube.001",
 29 |             "translation" : [
 30 |                 0,
 31 |                 0,
 32 |                 2.750795841217041
 33 |             ]
 34 |         }
 35 |     ],
 36 |     "materials" : [
 37 |         {
 38 |             "doubleSided" : true,
 39 |             "name" : "Material",
 40 |             "pbrMetallicRoughness" : {
 41 |                 "baseColorFactor" : [
 42 |                     0.8000000715255737,
 43 |                     0,
 44 |                     0.3334742784500122,
 45 |                     1
 46 |                 ],
 47 |                 "metallicFactor" : 0,
 48 |                 "roughnessFactor" : 0.5
 49 |             }
 50 |         },
 51 |         {
 52 |             "doubleSided" : true,
 53 |             "name" : "Material.001",
 54 |             "pbrMetallicRoughness" : {
 55 |                 "baseColorFactor" : [
 56 |                     0.8000000715255737,
 57 |                     0.6565112471580505,
 58 |                     0,
 59 |                     1
 60 |                 ],
 61 |                 "metallicFactor" : 0,
 62 |                 "roughnessFactor" : 0.5
 63 |             }
 64 |         }
 65 |     ],
 66 |     "meshes" : [
 67 |         {
 68 |             "name" : "Cube",
 69 |             "primitives" : [
 70 |                 {
 71 |                     "attributes" : {
 72 |                         "POSITION" : 0,
 73 |                         "NORMAL" : 1,
 74 |                         "TEXCOORD_0" : 2
 75 |                     },
 76 |                     "indices" : 3,
 77 |                     "material" : 0
 78 |                 }
 79 |             ]
 80 |         },
 81 |         {
 82 |             "name" : "Cube.001",
 83 |             "primitives" : [
 84 |                 {
 85 |                     "attributes" : {
 86 |                         "POSITION" : 4,
 87 |                         "NORMAL" : 5,
 88 |                         "TEXCOORD_0" : 6
 89 |                     },
 90 |                     "indices" : 7,
 91 |                     "material" : 1
 92 |                 }
 93 |             ]
 94 |         }
 95 |     ],
 96 |     "accessors" : [
 97 |         {
 98 |             "bufferView" : 0,
 99 |             "componentType" : 5126,
100 |             "count" : 24,
101 |             "max" : [
102 |                 1,
103 |                 1,
104 |                 1
105 |             ],
106 |             "min" : [
107 |                 -1,
108 |                 -1,
109 |                 -1
110 |             ],
111 |             "type" : "VEC3"
112 |         },
113 |         {
114 |             "bufferView" : 1,
115 |             "componentType" : 5126,
116 |             "count" : 24,
117 |             "type" : "VEC3"
118 |         },
119 |         {
120 |             "bufferView" : 2,
121 |             "componentType" : 5126,
122 |             "count" : 24,
123 |             "type" : "VEC2"
124 |         },
125 |         {
126 |             "bufferView" : 3,
127 |             "componentType" : 5123,
128 |             "count" : 36,
129 |             "type" : "SCALAR"
130 |         },
131 |         {
132 |             "bufferView" : 4,
133 |             "componentType" : 5126,
134 |             "count" : 24,
135 |             "max" : [
136 |                 1,
137 |                 1,
138 |                 1
139 |             ],
140 |             "min" : [
141 |                 -1,
142 |                 -1,
143 |                 -1
144 |             ],
145 |             "type" : "VEC3"
146 |         },
147 |         {
148 |             "bufferView" : 5,
149 |             "componentType" : 5126,
150 |             "count" : 24,
151 |             "type" : "VEC3"
152 |         },
153 |         {
154 |             "bufferView" : 6,
155 |             "componentType" : 5126,
156 |             "count" : 24,
157 |             "type" : "VEC2"
158 |         },
159 |         {
160 |             "bufferView" : 7,
161 |             "componentType" : 5123,
162 |             "count" : 36,
163 |             "type" : "SCALAR"
164 |         }
165 |     ],
166 |     "bufferViews" : [
167 |         {
168 |             "buffer" : 0,
169 |             "byteLength" : 288,
170 |             "byteOffset" : 0,
171 |             "target" : 34962
172 |         },
173 |         {
174 |             "buffer" : 0,
175 |             "byteLength" : 288,
176 |             "byteOffset" : 288,
177 |             "target" : 34962
178 |         },
179 |         {
180 |             "buffer" : 0,
181 |             "byteLength" : 192,
182 |             "byteOffset" : 576,
183 |             "target" : 34962
184 |         },
185 |         {
186 |             "buffer" : 0,
187 |             "byteLength" : 72,
188 |             "byteOffset" : 768,
189 |             "target" : 34963
190 |         },
191 |         {
192 |             "buffer" : 0,
193 |             "byteLength" : 288,
194 |             "byteOffset" : 840,
195 |             "target" : 34962
196 |         },
197 |         {
198 |             "buffer" : 0,
199 |             "byteLength" : 288,
200 |             "byteOffset" : 1128,
201 |             "target" : 34962
202 |         },
203 |         {
204 |             "buffer" : 0,
205 |             "byteLength" : 192,
206 |             "byteOffset" : 1416,
207 |             "target" : 34962
208 |         },
209 |         {
210 |             "buffer" : 0,
211 |             "byteLength" : 72,
212 |             "byteOffset" : 1608,
213 |             "target" : 34963
214 |         }
215 |     ],
216 |     "buffers" : [
217 |         {
218 |             "byteLength" : 1680,
219 |             "uri" : "data:application/octet-stream;base64,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"
220 |         }
221 |     ]
222 | }
223 | 


--------------------------------------------------------------------------------
/src/reflect.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     prelude::*,
  3 |     reflect::{GetPath, TypeRegistry},
  4 | };
  5 | 
  6 | pub struct ReflectExample;
  7 | 
  8 | impl Plugin for ReflectExample {
  9 |     fn build(&self, app: &mut App) {
 10 |         app.register_type::<ReflectStruct>();
 11 |         app.register_type::<ReflectEnum>();
 12 |         app.add_startup_system(your_system);
 13 |     }
 14 | }
 15 | 
 16 | #[derive(Debug, Clone, Reflect, serde::Serialize, serde::Deserialize)]
 17 | #[reflect(Serialize, Deserialize, DoThing)]
 18 | struct ReflectStruct {
 19 |     filed_0: usize,
 20 |     filed_1: usize,
 21 |     filed_2: ReflectEnum,
 22 | }
 23 | 
 24 | #[derive(Debug, Clone, Reflect, serde::Serialize, serde::Deserialize)]
 25 | #[reflect(Serialize, Deserialize)]
 26 | struct ReflectStructPath {
 27 |     filed_0: ReflectStruct,
 28 |     filed_1: ReflectStruct,
 29 |     filed_2: ReflectStruct,
 30 | }
 31 | 
 32 | #[derive(Debug, Clone, Reflect, serde::Serialize, serde::Deserialize)]
 33 | #[reflect(Serialize, Deserialize)]
 34 | enum ReflectEnum {
 35 |     Variant0,
 36 |     Variant1(String),
 37 |     Variant2(usize),
 38 | }
 39 | 
 40 | #[derive(Debug, Reflect, Clone, bevy::reflect::FromReflect)]
 41 | #[reflect_value()]
 42 | enum ReflectEnum2 {
 43 |     Value0,
 44 |     Value1,
 45 |     Value2,
 46 | }
 47 | 
 48 | fn get_field_by_name() {
 49 |     use bevy::reflect::ReflectRef;
 50 |     let hard_type = ReflectStruct {
 51 |         filed_0: 0,
 52 |         filed_1: 1,
 53 |         filed_2: ReflectEnum::Variant0,
 54 |     };
 55 |     let obj = hard_type.as_reflect();
 56 |     let name = "filed_0";
 57 |     let _filed = if let ReflectRef::Struct(data) = obj.reflect_ref() {
 58 |         //Some(&T) if it has field with this name
 59 |         //None if field is not of type T
 60 |         data.get_field::<usize>(name)
 61 |     } else {
 62 |         //do something if the field is not there
 63 |         todo!()
 64 |     };
 65 |     //or
 66 |     let name = "filed_1";
 67 |     let _filed = if let ReflectRef::Struct(data) = obj.reflect_ref() {
 68 |         //Some(&T) if it has field with this name
 69 |         //None if field is not of type T
 70 |         data.get_field::<usize>(name)
 71 |     } else {
 72 |         //do something if the field is not there
 73 |         todo!()
 74 |     };
 75 | }
 76 | 
 77 | fn patch_struct() {
 78 |     use bevy::reflect::DynamicStruct;
 79 |     let mut hard_type = ReflectStruct {
 80 |         filed_0: 0,
 81 |         filed_1: 1,
 82 |         filed_2: ReflectEnum::Variant0,
 83 |     };
 84 |     let mut dynamic_struct = DynamicStruct::default();
 85 |     dynamic_struct.insert::<usize>("filed_0", 1);
 86 |     hard_type.apply(dynamic_struct.as_reflect());
 87 |     assert_eq!(hard_type.filed_0, 1);
 88 | }
 89 | 
 90 | fn path_get() {
 91 |     let top = ReflectStructPath {
 92 |         filed_0: ReflectStruct {
 93 |             filed_0: 0,
 94 |             filed_1: 1,
 95 |             filed_2: ReflectEnum::Variant0,
 96 |         },
 97 |         filed_1: ReflectStruct {
 98 |             filed_0: 2,
 99 |             filed_1: 3,
100 |             filed_2: ReflectEnum::Variant1("One".into()),
101 |         },
102 |         filed_2: ReflectStruct {
103 |             filed_0: 4,
104 |             filed_1: 5,
105 |             filed_2: ReflectEnum::Variant2(2),
106 |         },
107 |     };
108 |     if let Ok(val) = top.get_path::<usize>("filed_0.filed_1") {
109 |         assert_eq!(*val, 1);
110 |     };
111 |     if let Ok(val) = top.get_path::<usize>("filed_2.filed_0") {
112 |         assert_eq!(*val, 4);
113 |     };
114 | }
115 | 
116 | fn iterator() {
117 |     use bevy::reflect::DynamicStruct;
118 |     let mut zero = 0usize;
119 |     let mut dynamic = DynamicStruct::default();
120 |     dynamic.insert("num", 0usize);
121 |     let mut hard_type = ReflectStruct {
122 |         filed_0: 0,
123 |         filed_1: 1,
124 |         filed_2: ReflectEnum::Variant0,
125 |     };
126 |     fn add_one(to: &mut dyn Reflect) {
127 |         use bevy::reflect::ReflectMut;
128 |         match to.reflect_mut() {
129 |             ReflectMut::Value(val) => {
130 |                 if val.is::<usize>() {
131 |                     *val.downcast_mut::<usize>().unwrap() += 1;
132 |                 }
133 |             }
134 |             ReflectMut::Struct(struct_data) => {
135 |                 for field in 0..struct_data.field_len() {
136 |                     let field = struct_data.field_at_mut(field).unwrap();
137 |                     if field.is::<usize>() {
138 |                         *field.downcast_mut::<usize>().unwrap() += 1;
139 |                     }
140 |                 }
141 |             }
142 |             _ => todo!(),
143 |         }
144 |     }
145 |     add_one(zero.as_reflect_mut());
146 |     add_one(dynamic.as_reflect_mut());
147 |     add_one(hard_type.as_reflect_mut());
148 |     assert_eq!(zero, 1);
149 |     assert_eq!(dynamic.get_field("num"), Some(&1usize));
150 |     assert_eq!(hard_type.filed_0, 1);
151 |     assert_eq!(hard_type.filed_1, 2);
152 | }
153 | 
154 | fn reflect_trait() {
155 |     let type_registure = TypeRegistry::default();
156 |     let mut type_registure = type_registure.write();
157 |     type_registure.register::<ReflectStruct>();
158 |     let hard_type = ReflectStruct {
159 |         filed_0: 0,
160 |         filed_1: 0,
161 |         filed_2: ReflectEnum::Variant0,
162 |     };
163 |     let obj = hard_type.as_reflect();
164 |     let info = type_registure.get(obj.type_id()).unwrap();
165 |     if let Some(do_thing) = info.data::<ReflectDoThing>() {
166 |         let obj = do_thing.get(obj).unwrap();
167 |         println!("{}", obj.do_thing())
168 |     }
169 | }
170 | 
171 | #[test]
172 | fn serialize() {
173 |     let mut world = World::default();
174 |     world.spawn(Transform::default());
175 |     let type_registry = AppTypeRegistry::default();
176 |     {
177 |         let mut type_registry = type_registry.write();
178 |         type_registry.register::<Transform>();
179 |         type_registry.register::<Vec3>();
180 |         type_registry.register::<Quat>();
181 |     }
182 |     let scene = bevy::scene::DynamicScene::from_world(&world, &type_registry);
183 |     let res = scene.serialize_ron(&type_registry);
184 |     if let Ok(str) = res {
185 |         println!("{}", str);
186 |     }
187 | }
188 | 
189 | fn scripting() {
190 |     let mut data = ReflectStructPath {
191 |         filed_0: ReflectStruct {
192 |             filed_0: 0,
193 |             filed_1: 1,
194 |             filed_2: ReflectEnum::Variant0,
195 |         },
196 |         filed_1: ReflectStruct {
197 |             filed_0: 2,
198 |             filed_1: 3,
199 |             filed_2: ReflectEnum::Variant1("One".into()),
200 |         },
201 |         filed_2: ReflectStruct {
202 |             filed_0: 4,
203 |             filed_1: 5,
204 |             filed_2: ReflectEnum::Variant2(2),
205 |         },
206 |     };
207 |     let user_script = "filed_0.filed_1 = 0";
208 |     let mut word = user_script.split(' ');
209 |     let filed = word.next();
210 |     let op = word.next();
211 |     let val = word.next();
212 |     if let (Some(path), Some(op), Some(val)) = (filed, op, val) {
213 |         let val: usize = val.parse().unwrap();
214 |         if let Ok(old) = data.get_path_mut::<usize>(path) {
215 |             match op {
216 |                 "=" => {
217 |                     *old = val;
218 |                 }
219 |                 "+" => {
220 |                     *old += val;
221 |                 }
222 |                 _ => todo!(),
223 |             }
224 |         }
225 |     }
226 | }
227 | 
228 | #[reflect_trait]
229 | pub trait DoThing {
230 |     fn do_thing(&self) -> String;
231 | }
232 | impl DoThing for ReflectStruct {
233 |     fn do_thing(&self) -> String {
234 |         "Hi I Reflect".to_string()
235 |     }
236 | }
237 | 
238 | // seems to be named AppTypeRegistry on the main branch
239 | fn your_system(registry: Res<AppTypeRegistry>) {
240 |     use std::any::TypeId;
241 |     let registry = registry.read();
242 |     if let Some(info) = registry.get(TypeId::of::<ReflectStruct>()) {
243 |         println!("name: {}", info.short_name());
244 |         println!("type info: {:?}", info.type_info());
245 |         println!("type data: {:?}", info.data::<ReflectSerialize>().is_some());
246 |         let array = [
247 |             ReflectEnum2::Value0,
248 |             ReflectEnum2::Value1,
249 |             ReflectEnum2::Value2,
250 |         ];
251 |         let _array = array.as_reflect();
252 |         let list = vec![
253 |             ReflectEnum2::Value0,
254 |             ReflectEnum2::Value1,
255 |             ReflectEnum2::Value2,
256 |         ];
257 |         let _list = list.as_reflect();
258 |         let _d_struct = bevy::reflect::DynamicStruct::default();
259 |         let data = info.data::<ReflectSerialize>();
260 |         let d = if let Some(data) = data {
261 |             let reflect: Box<dyn Reflect> = Box::new(ReflectStruct {
262 |                 filed_0: 10,
263 |                 filed_1: 0,
264 |                 filed_2: ReflectEnum::Variant1("Test".to_string()),
265 |             });
266 |             let s = data.get_serializable(&*reflect);
267 |             if let Ok(val) =
268 |                 ron::ser::to_string_pretty(s.borrow(), ron::ser::PrettyConfig::default())
269 |             {
270 |                 println!("serialzie: {}", val);
271 |                 val
272 |             } else {
273 |                 return;
274 |             }
275 |         } else {
276 |             return;
277 |         };
278 |         let de = if let Some(de) = info.data::<ReflectDeserialize>() {
279 |             de
280 |         } else {
281 |             println!("no deserialize");
282 |             return;
283 |         };
284 |         let mut d = if let Ok(d) = ron::de::Deserializer::from_str(&d) {
285 |             d
286 |         } else {
287 |             println!("ron deserializer failed");
288 |             return;
289 |         };
290 |         let val = if let Ok(val) = de.deserialize(&mut d) {
291 |             val
292 |         } else {
293 |             println!("deserialize failed");
294 |             return;
295 |         };
296 |         match val.reflect_ref() {
297 |             bevy::reflect::ReflectRef::Struct(info) => {
298 |                 for (i, v) in info.iter_fields().enumerate() {
299 |                     println!("{:?}:{:?}", info.name_at(i), v);
300 |                 }
301 |             }
302 |             bevy::reflect::ReflectRef::TupleStruct(_) => todo!(),
303 |             bevy::reflect::ReflectRef::Tuple(_) => todo!(),
304 |             bevy::reflect::ReflectRef::List(_) => todo!(),
305 |             bevy::reflect::ReflectRef::Array(_) => todo!(),
306 |             bevy::reflect::ReflectRef::Map(_) => todo!(),
307 |             bevy::reflect::ReflectRef::Value(_) => todo!(),
308 |             bevy::reflect::ReflectRef::Enum(_) => todo!(),
309 |         }
310 |         let name = val.get_path::<ReflectEnum>("filed_2");
311 |         println!("{:?}", name);
312 |         let val: ReflectStruct = if let Ok(val) = val.take() {
313 |             val
314 |         } else {
315 |             println!("downcast failed");
316 |             return;
317 |         };
318 |         println!("{:?}", val)
319 |     }
320 | }
321 | 


--------------------------------------------------------------------------------
/src/scenes.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     prelude::*,
  3 |     scene::{InstanceId, SceneInstance},
  4 | };
  5 | 
  6 | pub struct ScenesExample;
  7 | 
  8 | impl Plugin for ScenesExample {
  9 |     fn build(&self, app: &mut App) {
 10 |         app.add_system(spawn_scene);
 11 |         app.init_resource::<SceneData>();
 12 |         app.init_resource::<DynamicSceneData>();
 13 |         app.add_system(spawn_scene_bundle);
 14 |         app.add_startup_system(load_gltf);
 15 |         app.add_system(gltf_scene);
 16 |         app.add_system(save_scene);
 17 |         app.add_startup_system(load_scene);
 18 |         app.add_system(simple_save_scene)
 19 |             .add_system(advanced_save_scene);
 20 |         app.add_system(spawn_scene_cube)
 21 |         .add_system(move_scene_cube);
 22 |     }
 23 | }
 24 | 
 25 | #[derive(Resource)]
 26 | struct SceneData([Handle<Scene>; 10]);
 27 | #[derive(Resource)]
 28 | struct DynamicSceneData(Handle<DynamicScene>);
 29 | #[derive(Resource)]
 30 | struct GltfHandle(Handle<bevy::gltf::Gltf>);
 31 | 
 32 | impl FromWorld for SceneData {
 33 |     fn from_world(world: &mut World) -> Self {
 34 |         let mesh_handle = world
 35 |             .resource_mut::<Assets<Mesh>>()
 36 |             .add(shape::Box::new(1., 1., 1.).into());
 37 |         let mut assets = world.resource_mut::<Assets<Scene>>();
 38 |         let mut data = SceneData(Default::default());
 39 |         for i in 0..10 {
 40 |             let mut new_world = World::new();
 41 |             new_world.spawn(PbrBundle {
 42 |                 mesh: mesh_handle.clone(),
 43 |                 transform: Transform::from_translation(Vec3 {
 44 |                     x: (i / 2) as f32,
 45 |                     y: (i % 3) as f32,
 46 |                     z: ((i * 2) % 5) as f32,
 47 |                 }),
 48 |                 ..Default::default()
 49 |             });
 50 |             let s = Scene { world: new_world };
 51 |             let sh = assets.add(s);
 52 |             data.0[i] = sh;
 53 |         }
 54 |         data
 55 |     }
 56 | }
 57 | 
 58 | impl FromWorld for DynamicSceneData {
 59 |     fn from_world(world: &mut World) -> Self {
 60 |         let scene_handle = world.resource::<SceneData>();
 61 |         let scenes = world.resource::<Assets<Scene>>();
 62 |         let scene = scenes.get(&scene_handle.0[0]).unwrap();
 63 |         let type_registry = world.resource::<bevy::prelude::AppTypeRegistry>();
 64 |         let from_scene = DynamicScene::from_scene(scene, type_registry);
 65 |         let dyn_scene_handle = world.resource_mut::<Assets<DynamicScene>>().add(from_scene);
 66 |         DynamicSceneData(dyn_scene_handle)
 67 |     }
 68 | }
 69 | 
 70 | fn save_scene(
 71 |     input: Res<Input<KeyCode>>,
 72 |     scene: Res<DynamicSceneData>,
 73 |     scenes: Res<Assets<DynamicScene>>,
 74 |     type_registry: Res<AppTypeRegistry>,
 75 | ) {
 76 |     if !input.just_pressed(KeyCode::PageDown) {
 77 |         return;
 78 |     }
 79 |     info!("saving scene");
 80 |     let string = if let Some(scene) = scenes.get(&scene.0) {
 81 |         scene.serialize_ron(&type_registry).unwrap()
 82 |     } else {
 83 |         error!("failed to get scene");
 84 |         return;
 85 |     };
 86 |     std::fs::write("./assets/scene.scn.ron", string).unwrap();
 87 | }
 88 | 
 89 | fn load_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 90 |     let id = commands
 91 |         .spawn(DynamicSceneBundle {
 92 |             scene: asset_server.load("part_scene.scn.ron"),
 93 |             ..Default::default()
 94 |         })
 95 |         .id();
 96 |     info!("loading scene on {:?}", id);
 97 | }
 98 | 
 99 | fn spawn_scene(
100 |     input: Res<Input<KeyCode>>,
101 |     mut scene_spawner: ResMut<SceneSpawner>,
102 |     scenes: Res<SceneData>,
103 |     mut instance: Local<[Vec<InstanceId>; 10]>,
104 | ) {
105 |     for key in input.get_just_pressed() {
106 |         let pressed = match key {
107 |             KeyCode::Numpad0 => 0,
108 |             KeyCode::Numpad1 => 1,
109 |             KeyCode::Numpad2 => 2,
110 |             KeyCode::Numpad3 => 3,
111 |             KeyCode::Numpad4 => 4,
112 |             KeyCode::Numpad5 => 5,
113 |             KeyCode::Numpad6 => 6,
114 |             KeyCode::Numpad7 => 7,
115 |             KeyCode::Numpad8 => 8,
116 |             KeyCode::Numpad9 => 9,
117 |             _ => 10,
118 |         };
119 |         if pressed < 10 {
120 |             if input.pressed(KeyCode::S) {
121 |                 instance[pressed].push(scene_spawner.spawn(scenes.0[pressed].clone()));
122 |             } else if input.pressed(KeyCode::R) {
123 |                 for id in instance[pressed].iter() {
124 |                     scene_spawner.despawn_instance(*id);
125 |                 }
126 |                 instance[pressed].clear();
127 |             }
128 |         }
129 |     }
130 | }
131 | 
132 | fn spawn_scene_bundle(
133 |     mut commands: Commands,
134 |     input: Res<Input<KeyCode>>,
135 |     loaded: Query<Entity, With<SceneInstance>>,
136 |     scenes: Res<SceneData>,
137 | ) {
138 |     if input.just_pressed(KeyCode::C) {
139 |         for scene in loaded.iter() {
140 |             commands.entity(scene).despawn_recursive();
141 |         }
142 |         return;
143 |     }
144 |     for key in input.get_just_pressed() {
145 |         let pressed = match key {
146 |             KeyCode::Numpad0 => 0,
147 |             KeyCode::Numpad1 => 1,
148 |             KeyCode::Numpad2 => 2,
149 |             KeyCode::Numpad3 => 3,
150 |             KeyCode::Numpad4 => 4,
151 |             KeyCode::Numpad5 => 5,
152 |             KeyCode::Numpad6 => 6,
153 |             KeyCode::Numpad7 => 7,
154 |             KeyCode::Numpad8 => 8,
155 |             KeyCode::Numpad9 => 9,
156 |             _ => 10,
157 |         };
158 |         if pressed < 10 {
159 |             if input.pressed(KeyCode::A) {
160 |                 commands.spawn(SceneBundle {
161 |                     scene: scenes.0[pressed].clone(),
162 |                     ..Default::default()
163 |                 });
164 |             } else if input.pressed(KeyCode::D) {
165 |                 commands
166 |                     .spawn(SpatialBundle::default())
167 |                     .insert(scenes.0[pressed].clone());
168 |             }
169 |         }
170 |     }
171 | }
172 | 
173 | fn load_gltf(mut commands: Commands, asset_server: Res<AssetServer>) {
174 |     commands.insert_resource(GltfHandle(asset_server.load("gltf.gltf")));
175 | }
176 | 
177 | fn gltf_scene(
178 |     asset_server: Res<AssetServer>,
179 |     input: Res<Input<KeyCode>>,
180 |     mut scene_spawner: ResMut<SceneSpawner>,
181 |     mut instance: Local<Option<[InstanceId; 2]>>,
182 |     gltf_assets: Res<Assets<bevy::gltf::Gltf>>,
183 |     gltf_handle: Res<GltfHandle>,
184 | ) {
185 |     if input.just_pressed(KeyCode::NumpadMultiply) {
186 |         if instance.is_some() {
187 |             return;
188 |         }
189 |         if let Some(gltf) = gltf_assets.get(&gltf_handle.0) {
190 |             *instance = Some([
191 |                 scene_spawner.spawn(gltf.scenes[0].clone()),
192 |                 scene_spawner.spawn(asset_server.load("gltf.gltf#Scene1")),
193 |             ]);
194 |         }
195 |     } else if input.just_pressed(KeyCode::NumpadDivide) {
196 |         if let Some(v) = *instance {
197 |             scene_spawner.despawn_instance(v[0]);
198 |             scene_spawner.despawn_instance(v[1]);
199 |             *instance = None;
200 |         }
201 |     }
202 | }
203 | 
204 | //Video 2///////////////////////////////////////////////////////////////////////////
205 | use serde::{Deserialize, Serialize};
206 | #[derive(Component, Reflect, Serialize, Deserialize, Default)]
207 | #[reflect(Component, Serialize, Deserialize)]
208 | struct SceneItem;
209 | 
210 | #[derive(Component)]
211 | struct SceneCube;
212 | 
213 | fn spawn_scene_cube(
214 |     input: Res<Input<KeyCode>>,
215 |     mut commands: Commands,
216 |     asset_server: Res<AssetServer>,
217 |     query: Query<Entity, With<SceneCube>>,
218 | ) {
219 |     if !input.just_pressed(KeyCode::Key0) {
220 |         return;
221 |     }
222 |     commands
223 |         .spawn(PbrBundle {
224 |             mesh: asset_server.load("gltf.gltf#Mesh0/Primitive0"),
225 |             ..Default::default()
226 |         })
227 |         .insert(SceneItem)
228 |         .insert(SceneCube);
229 |     for cube in query.iter() {
230 |         commands.entity(cube).remove::<SceneCube>();
231 |     }
232 | }
233 | 
234 | fn move_scene_cube(
235 |     mut transforms: Query<&mut Transform, With<SceneCube>>,
236 |     input: Res<Input<KeyCode>>,
237 |     time: Res<Time>,
238 | ) {
239 |     let mut delta = Vec3::ZERO;
240 |     let dt = time.delta_seconds();
241 |     for key in input.get_pressed() {
242 |         match key {
243 |             KeyCode::A | KeyCode::Left => {delta.x -= 1.0},
244 |             KeyCode::D | KeyCode::Right => {delta.x += 1.0},
245 |             KeyCode::Z => {delta.y -= 1.0},
246 |             KeyCode::Q => {delta.y += 1.0},
247 |             KeyCode::W | KeyCode::Up => {delta.z -= 1.0},
248 |             KeyCode::S | KeyCode::Down => {delta.z += 1.0},
249 |             _ => {},
250 |         }
251 |     }
252 |     if delta.is_finite() {
253 |         for mut transform in transforms.iter_mut() {
254 |             transform.translation += delta * dt * 10.;
255 |         }
256 |     }
257 | }
258 | 
259 | fn advanced_save_scene(input: Res<Input<KeyCode>>, world: &World, query: Query<Entity, With<SceneItem>>,
260 |     type_registry: Res<AppTypeRegistry>) {
261 |     // return if the user did not just press PageUp
262 |     if !input.just_pressed(KeyCode::PageUp) {
263 |         return;
264 |     }
265 |     info!("saving advanced scene");
266 |     let mut scene = DynamicSceneBuilder::from_world(world);
267 |     scene.extract_entities(query.iter());
268 |     // save the scene to disk
269 |     let string = scene.build().serialize_ron(&type_registry).unwrap();
270 |     let _ = std::fs::write("./assets/advanced_scene.scn.ron", string).unwrap();
271 | }
272 | 
273 | fn simple_save_scene(
274 |     input: Res<Input<KeyCode>>,
275 |     world: &World,
276 |     type_registry: Res<AppTypeRegistry>,
277 | ) {
278 |     // return if the user did not just press PageUp
279 |     if !input.just_pressed(KeyCode::End) {
280 |         return;
281 |     }
282 |     info!("saving simple scene");
283 |     // crate scene from world
284 |     let dynamic_scene = DynamicScene::from_world(world, &type_registry);
285 |     // save the scene to disk
286 |     let string = dynamic_scene.serialize_ron(&type_registry).unwrap();
287 |     let _ = std::fs::write("./assets/simple_scene.scn.ron", string).unwrap();
288 | }
289 | 
290 | /// Create a new dynamic scene from a given world and etity set;
291 | fn from_world(
292 |     world: &World,
293 |     entitys: impl Iterator<Item = Entity>,
294 | ) -> DynamicScene {
295 |     let mut scene = DynamicSceneBuilder::from_world(world);
296 |     scene.extract_entities(entitys);
297 |     scene.build()
298 | }
299 | 
300 | // fn spawn_scene(
301 | //     asset_server: Res<AssetServer>,
302 | //     mut commands: Commands,
303 | // ) {
304 | //     commands.spawn_bundle(DynamicSceneBundle{
305 | //         scene: asset_server.load("scene.scn.ron"),
306 | //         ..Default::default()
307 | //     });
308 | // }


--------------------------------------------------------------------------------
/src/entitys.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | 
  3 | use crate::common::*;
  4 | 
  5 | pub struct EntityPlugin;
  6 | 
  7 | impl Plugin for EntityPlugin {
  8 |     fn build(&self, app: &mut App) {
  9 |         app.add_startup_system(ball_resource_init)
 10 |             .add_startup_system(spawn_ball_ui)
 11 |             .add_system(spawn_ball)
 12 |             .add_system(homing_ball_move)
 13 |             .add_system(inside_world_check)
 14 |             .add_system(change_speed)
 15 |             .add_system(change_color)
 16 |             .add_system(change_shape)
 17 |             .add_system(ball_ui_update)
 18 |             .add_system(move_cam);
 19 |     }
 20 | }
 21 | #[derive(Component)]
 22 | struct HomingBall;
 23 | 
 24 | #[derive(Resource)]
 25 | pub struct CurrentBall(Entity);
 26 | 
 27 | #[derive(Resource)]
 28 | pub struct CurrentBallUI {
 29 |     color: Entity,
 30 |     speed: Entity,
 31 | }
 32 | 
 33 | fn spawn_ball(
 34 |     mut commands: Commands,
 35 |     input: Res<Input<MouseButton>>,
 36 |     camera: Query<&Transform, With<MainCamera>>,
 37 |     mesh: Res<BallMesh>,
 38 |     matt: Res<ColorWheel>,
 39 | ) {
 40 |     if !input.just_pressed(MouseButton::Left) {
 41 |         return;
 42 |     }
 43 |     let start = camera.single().clone();
 44 |     let direction = start.looking_at(Vec3::ZERO, Vec3::Y).forward();
 45 |     let ball = commands
 46 |         .spawn(PbrBundle {
 47 |             mesh: mesh.0[0].clone(),
 48 |             material: matt.get_color(ColorSet::Random, 0),
 49 |             transform: start,
 50 |             ..Default::default()
 51 |         })
 52 |         .insert(BBDirection(direction))
 53 |         .insert(Speed(1.))
 54 |         .insert(HomingBall)
 55 |         .id();
 56 |     commands.insert_resource(CurrentBall(ball));
 57 | }
 58 | 
 59 | fn homing_ball_move(
 60 |     mut homing_balls: Query<(&mut Transform, &Speed, &BBDirection), With<HomingBall>>,
 61 |     time: Res<Time>,
 62 | ) {
 63 |     for (mut transform, speed, direction) in &mut homing_balls.iter_mut() {
 64 |         transform.translation += direction.0 * speed.0 * time.delta_seconds();
 65 |     }
 66 | }
 67 | 
 68 | fn inside_world_check(
 69 |     mut commands: Commands,
 70 |     homing_balls: Query<(Entity, &Transform), With<HomingBall>>,
 71 |     world_size: Res<WorldSize>,
 72 | ) {
 73 |     for (ball, transform) in homing_balls.iter() {
 74 |         if transform.translation.x < world_size.0.x
 75 |             && transform.translation.x > -world_size.0.x
 76 |             && transform.translation.y < world_size.0.y
 77 |             && transform.translation.y > -world_size.0.y
 78 |             && transform.translation.z < world_size.0.z
 79 |             && transform.translation.z > -world_size.0.z
 80 |         {
 81 |             commands.entity(ball).remove::<HomingBall>().insert(BoxBall);
 82 |         }
 83 |     }
 84 | }
 85 | 
 86 | fn change_speed(
 87 |     mut speed: Query<&mut Speed>,
 88 |     current_ball: Option<Res<CurrentBall>>,
 89 |     input: Res<Input<KeyCode>>,
 90 | ) {
 91 |     if current_ball.is_none() {
 92 |         return;
 93 |     }
 94 |     let ball = current_ball.unwrap().0;
 95 |     let mut speed = speed.get_mut(ball).expect("Current ball has Speed");
 96 |     if input.just_pressed(KeyCode::NumpadAdd) {
 97 |         speed.0 += 1.0;
 98 |     }
 99 |     if input.just_pressed(KeyCode::NumpadSubtract) {
100 |         speed.0 -= 1.0;
101 |     }
102 |     speed.0 = speed.0.clamp(-1.0, 100.0);
103 | }
104 | 
105 | fn change_color(
106 |     mut color: Query<&mut Handle<StandardMaterial>>,
107 |     current_ball: Option<Res<CurrentBall>>,
108 |     input: Res<Input<KeyCode>>,
109 |     colors: Res<ColorWheel>,
110 | ) {
111 |     if current_ball.is_none() {
112 |         return;
113 |     }
114 |     let ball = current_ball.unwrap().0;
115 |     let mut set_color = None;
116 |     if input.just_pressed(KeyCode::R) {
117 |         set_color = Some(get_color_index(&colors, ColorSet::Red, input.get_pressed()));
118 |     } else if input.just_pressed(KeyCode::G) {
119 |         set_color = Some(get_color_index(
120 |             &colors,
121 |             ColorSet::Blue,
122 |             input.get_pressed(),
123 |         ));
124 |     } else if input.just_pressed(KeyCode::B) {
125 |         set_color = Some(get_color_index(
126 |             &colors,
127 |             ColorSet::Green,
128 |             input.get_pressed(),
129 |         ));
130 |     } else if input.just_pressed(KeyCode::C) {
131 |         set_color = Some(get_color_index(
132 |             &colors,
133 |             ColorSet::Custom(0),
134 |             input.get_pressed(),
135 |         ));
136 |     } else if input.just_pressed(KeyCode::NumpadDecimal) {
137 |         set_color = Some(colors.get_color(ColorSet::Random, 0));
138 |     }
139 |     if let Some(set_color) = set_color {
140 |         *color.get_mut(ball).expect("Current ball has Color") = set_color;
141 |     }
142 | }
143 | 
144 | fn change_shape(
145 |     mut next_shape: Local<usize>,
146 |     current_ball: Option<Res<CurrentBall>>,
147 |     input: Res<Input<KeyCode>>,
148 |     shapes: Res<BallMesh>,
149 |     mut shape: Query<&mut Handle<Mesh>>,
150 | ) {
151 |     if current_ball.is_none() {
152 |         return;
153 |     }
154 |     let ball = current_ball.unwrap().0;
155 |     if input.just_pressed(KeyCode::NumpadMultiply) {
156 |         *shape.get_mut(ball).expect("Current ball has Mesh") = shapes.0[*next_shape].clone();
157 |         *next_shape = (*next_shape + 1) % shapes.0.len();
158 |     }
159 | }
160 | 
161 | fn spawn_ball_ui(mut commands: Commands, font: Res<DefaultFont>) {
162 |     let mut color = Entity::from_raw(0);
163 |     let mut speed = Entity::from_raw(0);
164 |     commands
165 |         .spawn(NodeBundle {
166 |             style: Style {
167 |                 size: Size::new(Val::Px(300.), Val::Px(100.)),
168 |                 ..Default::default()
169 |             },
170 |             background_color: Color::WHITE.into(),
171 |             ..Default::default()
172 |         })
173 |         .with_children(|p| {
174 |             color = p
175 |                 .spawn(TextBundle {
176 |                     style: Style {
177 |                         size: Size::new(Val::Px(300.), Val::Px(30.)),
178 |                         ..Default::default()
179 |                     },
180 |                     text: Text {
181 |                         sections: vec![
182 |                             TextSection {
183 |                                 style: TextStyle {
184 |                                     font: font.0.clone(),
185 |                                     font_size: 24.,
186 |                                     color: Color::BLACK,
187 |                                 },
188 |                                 value: "Color: ".to_string(),
189 |                             },
190 |                             TextSection {
191 |                                 style: TextStyle {
192 |                                     font: font.0.clone(),
193 |                                     font_size: 24.,
194 |                                     color: Color::BLACK,
195 |                                 },
196 |                                 value: "@".to_string(),
197 |                             },
198 |                         ],
199 |                         alignment: TextAlignment {
200 |                             vertical: VerticalAlign::Top,
201 |                             horizontal: HorizontalAlign::Left,
202 |                         },
203 |                     },
204 |                     ..Default::default()
205 |                 })
206 |                 .id();
207 |             speed = p
208 |                 .spawn(TextBundle {
209 |                     style: Style {
210 |                         size: Size::new(Val::Px(300.), Val::Px(30.)),
211 |                         ..Default::default()
212 |                     },
213 |                     text: Text {
214 |                         sections: vec![
215 |                             TextSection {
216 |                                 style: TextStyle {
217 |                                     font: font.0.clone(),
218 |                                     font_size: 24.,
219 |                                     color: Color::BLACK,
220 |                                 },
221 |                                 value: "Speed: ".to_string(),
222 |                             },
223 |                             TextSection {
224 |                                 style: TextStyle {
225 |                                     font: font.0.clone(),
226 |                                     font_size: 24.,
227 |                                     color: Color::BLACK,
228 |                                 },
229 |                                 value: "0".to_string(),
230 |                             },
231 |                         ],
232 |                         alignment: TextAlignment {
233 |                             vertical: VerticalAlign::Top,
234 |                             horizontal: HorizontalAlign::Left,
235 |                         },
236 |                     },
237 |                     ..Default::default()
238 |                 })
239 |                 .id();
240 |         });
241 |     commands.insert_resource(CurrentBallUI { speed, color });
242 | }
243 | 
244 | fn ball_ui_update(
245 |     ui: Res<CurrentBallUI>,
246 |     mut text: Query<&mut Text>,
247 |     current_ball: Option<Res<CurrentBall>>,
248 |     colors: Query<&Handle<StandardMaterial>>,
249 |     matts: Res<Assets<StandardMaterial>>,
250 |     speeds: Query<&Speed>,
251 | ) {
252 |     if current_ball.is_none() {
253 |         return;
254 |     }
255 |     let ball = current_ball.unwrap().0;
256 |     let mut color = text.get_mut(ui.color).unwrap();
257 |     let c_handel = colors.get(ball).unwrap();
258 |     color.sections[1].style.color = matts.get(c_handel).unwrap().base_color;
259 |     let mut speed = text.get_mut(ui.speed).unwrap();
260 |     speed.sections[1].value = format!("{}", speeds.get(ball).unwrap().0);
261 | }
262 | 
263 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
264 | #[derive(Resource)]
265 | struct BallMesh(Vec<Handle<Mesh>>);
266 | 
267 | fn ball_resource_init(mut commands: Commands, mut mesh: ResMut<Assets<Mesh>>) {
268 |     let mut prism = Mesh::new(bevy::render::render_resource::PrimitiveTopology::TriangleStrip);
269 |     prism.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 1.0, 0.0]; 4]);
270 |     prism.insert_attribute(
271 |         Mesh::ATTRIBUTE_POSITION,
272 |         vec![
273 |             [0.0, 0.5, 0.0],
274 |             [0.0, -0.5, 0.5],
275 |             [-0.5, -0.5, -0.5],
276 |             [0.5, -0.5, -0.5],
277 |         ],
278 |     );
279 |     prism.insert_attribute(Mesh::ATTRIBUTE_UV_0, vec![[0.0, 0.0]; 4]);
280 |     prism.set_indices(Some(bevy::render::mesh::Indices::U32(vec![
281 |         0, 1, 2, 3, 0, 1,
282 |     ])));
283 |     commands.insert_resource(BallMesh(vec![
284 |         mesh.add(
285 |             shape::Icosphere {
286 |                 radius: 1.,
287 |                 subdivisions: 2,
288 |             }
289 |             .into(),
290 |         ),
291 |         mesh.add(shape::Cube { size: 1. }.into()),
292 |         mesh.add(prism),
293 |     ]));
294 | }
295 | 
296 | fn get_color_index<'a>(
297 |     wheel: &ColorWheel,
298 |     set: ColorSet,
299 |     input: impl ExactSizeIterator<Item = &'a KeyCode>,
300 | ) -> Handle<StandardMaterial> {
301 |     let mut index = 0;
302 |     for key in input {
303 |         match key {
304 |             KeyCode::Numpad0 => {
305 |                 index = 0;
306 |             }
307 |             KeyCode::Numpad1 => {
308 |                 index = 1;
309 |             }
310 |             KeyCode::Numpad2 => {
311 |                 index = 2;
312 |             }
313 |             KeyCode::Numpad3 => {
314 |                 index = 3;
315 |             }
316 |             KeyCode::Numpad4 => {
317 |                 index = 4;
318 |             }
319 |             KeyCode::Numpad5 => {
320 |                 index = 5;
321 |             }
322 |             KeyCode::Numpad6 => {
323 |                 index = 6;
324 |             }
325 |             KeyCode::Numpad7 => {
326 |                 index = 7;
327 |             }
328 |             KeyCode::Numpad8 => {
329 |                 index = 8;
330 |             }
331 |             KeyCode::Numpad9 => {
332 |                 index = 9;
333 |             }
334 |             _ => {}
335 |         }
336 |     }
337 |     wheel.get_color(set, index)
338 | }
339 | 
340 | fn move_cam(
341 |     mut place: Local<i8>,
342 |     input: Res<Input<KeyCode>>,
343 |     mut cam: Query<&mut Transform, With<MainCamera>>,
344 | ) {
345 |     if input.just_pressed(KeyCode::Q) {
346 |         *place += 1;
347 |     } else if input.just_pressed(KeyCode::Z) {
348 |         *place -= 1;
349 |     } else {
350 |         return;
351 |     }
352 |     if *place < 0 {
353 |         *place += 18;
354 |     }
355 |     *place %= 18;
356 |     cam.single_mut().translation = cam_offset(*place);
357 |     cam.single_mut().look_at(Vec3::ZERO, Vec3::Y);
358 | }
359 | 
360 | fn cam_offset(place: i8) -> Vec3 {
361 |     match place {
362 |         0 => Vec3::X * 51. + Vec3::Y,
363 |         1 => Vec3::X * 57. + Vec3::Z * -25.,
364 |         2 => Vec3::Z * 62.4 + Vec3::Y,
365 |         3 => Vec3::X * -55. + Vec3::Y,
366 |         4 => Vec3::Z * -52. + Vec3::X * 25.,
367 |         5 => Vec3::Z * -50. + Vec3::Y,
368 |         6 => Vec3::X * 50.25 + Vec3::Z * 40.,
369 |         7 => Vec3::X * 50.1 + Vec3::Z * -20.,
370 |         8 => Vec3::X * 53. + Vec3::Z * 55.,
371 |         9 => Vec3::X * 52. + Vec3::Z * -51.,
372 |         10 => Vec3::X * 25. + Vec3::Z * 52.,
373 |         11 => Vec3::X * -25. + Vec3::Z * -50.3,
374 |         12 => Vec3::X * -50.5 + Vec3::Z * 30.2,
375 |         13 => Vec3::X * -52. + Vec3::Z * -20.1,
376 |         14 => Vec3::X * -51. + Vec3::Z * 50.3,
377 |         15 => Vec3::X * -56. + Vec3::Z * -50.9,
378 |         16 => Vec3::X * -54. + Vec3::Z * 35.1,
379 |         17 => Vec3::X * -58. + Vec3::Z * -42.,
380 |         _ => Vec3::ZERO,
381 |     }
382 | }
383 | 


--------------------------------------------------------------------------------
/examples/rotation.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | use bevy_basics::prelude::*;
  3 | 
  4 | fn main() {
  5 |     App::new()
  6 |         .add_plugins(DefaultPlugins)
  7 |         .add_plugin(bevy_inspector_egui::prelude::WorldInspectorPlugin::default())
  8 |         .add_startup_system(spawn_cam)
  9 |         .add_startup_system(spawn_world)
 10 |         .add_system(change_state)
 11 |         .add_system(add_move)
 12 |         .add_system(update_ui)
 13 |         .add_system(set_ui_arrow.after(update_ui))
 14 |         .add_system(set_ui_letter.after(update_ui))
 15 |         .add_system(update_select)
 16 |         .add_system(run)
 17 |         .run()
 18 | }
 19 | 
 20 | #[derive(Debug, Component)]
 21 | struct Cube;
 22 | 
 23 | const MOVES: usize = 3;
 24 | 
 25 | #[derive(Resource)]
 26 | struct Directions {
 27 |     z: UiImage,
 28 |     y: UiImage,
 29 |     x: UiImage,
 30 | }
 31 | 
 32 | const COLORS: [Color; 6] = [
 33 |     Color::RED,
 34 |     Color::BLUE,
 35 |     Color::WHITE,
 36 |     Color::GREEN,
 37 |     Color::ORANGE,
 38 |     Color::YELLOW,
 39 | ];
 40 | 
 41 | fn spawn_world(
 42 |     mut commands: Commands,
 43 |     mut colors: ResMut<Assets<StandardMaterial>>,
 44 |     mut mesh: ResMut<Assets<Mesh>>,
 45 |     asset_server: Res<AssetServer>,
 46 | ) {
 47 |     let mesh = mesh.add(
 48 |         shape::Quad {
 49 |             size: Vec2::ONE * 2.0,
 50 |             flip: false,
 51 |         }
 52 |         .into(),
 53 |     );
 54 |     let top = commands
 55 |         .spawn(PbrBundle {
 56 |             transform: Transform::from_translation(Vec3::Y).with_rotation(Quat::from_euler(
 57 |                 EulerRot::XYZ,
 58 |                 -90f32.to_radians(),
 59 |                 0.,
 60 |                 0.,
 61 |             )),
 62 |             material: colors.add(COLORS[5].into()),
 63 |             mesh: mesh.clone(),
 64 |             ..Default::default()
 65 |         })
 66 |         .id();
 67 |     let bottom = commands
 68 |         .spawn(PbrBundle {
 69 |             transform: Transform::from_translation(-Vec3::Y).with_rotation(Quat::from_euler(
 70 |                 EulerRot::XYZ,
 71 |                 90f32.to_radians(),
 72 |                 0.,
 73 |                 0.,
 74 |             )),
 75 |             material: colors.add(COLORS[2].into()),
 76 |             mesh: mesh.clone(),
 77 |             ..Default::default()
 78 |         })
 79 |         .id();
 80 |     let left = commands
 81 |         .spawn(PbrBundle {
 82 |             transform: Transform::from_translation(-Vec3::X).with_rotation(Quat::from_euler(
 83 |                 EulerRot::YXZ,
 84 |                 -90f32.to_radians(),
 85 |                 0.,
 86 |                 0.,
 87 |             )),
 88 |             material: colors.add(COLORS[0].into()),
 89 |             mesh: mesh.clone(),
 90 |             ..Default::default()
 91 |         })
 92 |         .id();
 93 |     let right = commands
 94 |         .spawn(PbrBundle {
 95 |             transform: Transform::from_translation(Vec3::X).with_rotation(Quat::from_euler(
 96 |                 EulerRot::YXZ,
 97 |                 90f32.to_radians(),
 98 |                 0.,
 99 |                 0.,
100 |             )),
101 |             material: colors.add(COLORS[4].into()),
102 |             mesh: mesh.clone(),
103 |             ..Default::default()
104 |         })
105 |         .id();
106 |     let back = commands
107 |         .spawn(PbrBundle {
108 |             transform: Transform::from_translation(-Vec3::Z).with_rotation(Quat::from_euler(
109 |                 EulerRot::YXZ,
110 |                 -180f32.to_radians(),
111 |                 0.,
112 |                 0.,
113 |             )),
114 |             material: colors.add(COLORS[1].into()),
115 |             mesh: mesh.clone(),
116 |             ..Default::default()
117 |         })
118 |         .id();
119 |     let frunt = commands
120 |         .spawn(PbrBundle {
121 |             transform: Transform::from_translation(Vec3::Z).with_rotation(Quat::from_euler(
122 |                 EulerRot::ZXY,
123 |                 90f32.to_radians(),
124 |                 0.,
125 |                 0.,
126 |             )),
127 |             material: colors.add(COLORS[3].into()),
128 |             mesh: mesh.clone(),
129 |             ..Default::default()
130 |         })
131 |         .id();
132 |     commands
133 |         .spawn(SpatialBundle::default())
134 |         .insert(Cube)
135 |         .push_children(&[top, bottom, left, right, frunt, back]);
136 |     let arrow_image: UiImage = asset_server.load("arrow.png").into();
137 |     let directions = Directions {
138 |         x: asset_server.load("X.png").into(),
139 |         y: asset_server.load("Y.png").into(),
140 |         z: asset_server.load("Z.png").into(),
141 |     };
142 |     let ui = commands
143 |         .spawn(NodeBundle {
144 |             style: Style {
145 |                 size: Size {
146 |                     width: Val::Px((77 * MOVES) as f32),
147 |                     height: Val::Px(52.0),
148 |                 },
149 |                 margin: UiRect {
150 |                     left: Val::Auto,
151 |                     right: Val::Auto,
152 |                     bottom: Val::Px(10.),
153 |                     top: Val::Undefined,
154 |                 },
155 |                 ..Default::default()
156 |             },
157 |             ..Default::default()
158 |         })
159 |         .insert(Name::new("UI Bar"))
160 |         .add_children(|p| {
161 |             let mut ui = UIElements([Entity::from_bits(u64::MAX); MOVES]);
162 |             for i in 0..ui.0.len() {
163 |                 ui.0[i] = p
164 |                     .spawn(NodeBundle {
165 |                         style: Style {
166 |                             size: Size {
167 |                                 width: Val::Px(75.0),
168 |                                 height: Val::Px(50.),
169 |                             },
170 |                             padding: UiRect::all(Val::Px(1.0)),
171 |                             ..Default::default()
172 |                         },
173 |                         ..Default::default()
174 |                     })
175 |                     .insert(Name::new(format!("Slot {}", i)))
176 |                     .with_children(|p| {
177 |                         p.spawn(ImageBundle {
178 |                             image: arrow_image.clone(),
179 |                             style: Style {
180 |                                 size: Size {
181 |                                     width: Val::Px(25.),
182 |                                     height: Val::Px(50.),
183 |                                 },
184 |                                 ..Default::default()
185 |                             },
186 |                             ..Default::default()
187 |                         });
188 |                         p.spawn(ImageBundle {
189 |                             image: arrow_image.clone(),
190 |                             style: Style {
191 |                                 size: Size {
192 |                                     width: Val::Px(50.),
193 |                                     height: Val::Px(50.),
194 |                                 },
195 |                                 ..Default::default()
196 |                             },
197 |                             ..Default::default()
198 |                         });
199 |                     })
200 |                     .id();
201 |             }
202 |             ui
203 |         });
204 |     commands.insert_resource(Order::default());
205 |     commands.insert_resource(ui);
206 |     commands.insert_resource(directions);
207 |     commands.insert_resource(Selected(0));
208 | }
209 | 
210 | fn change_state(
211 |     input: Res<Input<KeyCode>>,
212 |     mut transforms: Query<&mut Transform, With<Cube>>,
213 |     mut commands: Commands,
214 | ) {
215 |     if input.just_pressed(KeyCode::Space) {
216 |         for mut transform in transforms.iter_mut() {
217 |             *transform = Transform::IDENTITY;
218 |         }
219 |         commands.remove_resource::<Run>();
220 |         return;
221 |     }
222 |     if input.just_pressed(KeyCode::Return) {
223 |         commands.insert_resource(Run);
224 |     }
225 | }
226 | #[derive(Component, Clone, Copy)]
227 | enum Axis {
228 |     X,
229 |     Y,
230 |     Z,
231 | }
232 | #[derive(Component, Clone, Copy)]
233 | struct Arrow(bool);
234 | 
235 | #[derive(Resource)]
236 | struct Order([(Axis, Arrow); MOVES]);
237 | impl Order {
238 |     fn as_vec3(&self, index: usize) -> Vec3 {
239 |         match self.0[index].0 {
240 |             Axis::X => {
241 |                 if self.0[index].1 .0 {
242 |                     Vec3::NEG_X
243 |                 } else {
244 |                     Vec3::X
245 |                 }
246 |             }
247 |             Axis::Y => {
248 |                 if self.0[index].1 .0 {
249 |                     Vec3::NEG_Y
250 |                 } else {
251 |                     Vec3::Y
252 |                 }
253 |             }
254 |             Axis::Z => {
255 |                 if self.0[index].1 .0 {
256 |                     Vec3::NEG_Z
257 |                 } else {
258 |                     Vec3::Z
259 |                 }
260 |             }
261 |         }
262 |     }
263 | }
264 | impl Default for Order {
265 |     fn default() -> Self {
266 |         Order([(Axis::X, Arrow(true)); MOVES])
267 |     }
268 | }
269 | #[derive(Resource)]
270 | struct Run;
271 | 
272 | fn add_move(
273 |     mut selected: ResMut<Selected>,
274 |     mut order: ResMut<Order>,
275 |     input: Res<Input<KeyCode>>,
276 |     runing: Option<Res<Run>>,
277 | ) {
278 |     if runing.is_some() {
279 |         return;
280 |     }
281 |     for key in input.get_just_pressed() {
282 |         match key {
283 |             KeyCode::A | KeyCode::Left => {
284 |                 if selected.0 == 0 {
285 |                     selected.0 = MOVES - 1;
286 |                 } else {
287 |                     selected.0 -= 1;
288 |                 }
289 |             }
290 |             KeyCode::D | KeyCode::Right => {
291 |                 selected.0 = (selected.0 + 1) % MOVES;
292 |             }
293 |             KeyCode::W | KeyCode::Up => {
294 |                 set_arrow(selected.0, &mut order, true);
295 |             }
296 |             KeyCode::S | KeyCode::Down => {
297 |                 set_arrow(selected.0, &mut order, false);
298 |             }
299 |             KeyCode::Z => {
300 |                 set_axis(selected.0, &mut order, Axis::Z);
301 |             }
302 |             KeyCode::X => {
303 |                 set_axis(selected.0, &mut order, Axis::X);
304 |             }
305 |             KeyCode::Y | KeyCode::C => {
306 |                 set_axis(selected.0, &mut order, Axis::Y);
307 |             }
308 |             _ => {}
309 |         }
310 |     }
311 | }
312 | 
313 | #[inline]
314 | fn set_axis(index: usize, order: &mut Order, to: Axis) {
315 |     order.0[index].0 = to;
316 | }
317 | 
318 | #[inline]
319 | fn set_arrow(index: usize, order: &mut Order, to: bool) {
320 |     order.0[index].1 .0 = to;
321 | }
322 | 
323 | #[derive(Clone, Copy, Resource)]
324 | struct UIElements([Entity; MOVES]);
325 | 
326 | fn update_ui(elements: Res<UIElements>, order: Res<Order>, mut commands: Commands) {
327 |     if !order.is_changed() {
328 |         return;
329 |     }
330 |     for i in 0..MOVES {
331 |         commands.entity(elements.0[i]).insert(order.0[i]);
332 |     }
333 | }
334 | 
335 | fn set_ui_arrow(
336 |     query: Query<(&Arrow, &Children), Changed<Arrow>>,
337 |     mut transforms: Query<&mut Transform>,
338 | ) {
339 |     for (state, c) in query.iter() {
340 |         if state.0 {
341 |             if let Ok(mut trans) = transforms.get_mut(c[0]) {
342 |                 trans.rotation = Quat::IDENTITY;
343 |             }
344 |         } else {
345 |             if let Ok(mut trans) = transforms.get_mut(c[0]) {
346 |                 trans.rotation = Quat::from_rotation_z(std::f32::consts::PI);
347 |             }
348 |         }
349 |     }
350 | }
351 | 
352 | fn set_ui_letter(
353 |     query: Query<(&Axis, &Children), Changed<Axis>>,
354 |     mut ui_images: Query<&mut UiImage>,
355 |     directions: Res<Directions>,
356 | ) {
357 |     for (state, c) in query.iter() {
358 |         match state {
359 |             Axis::X => {
360 |                 if let Ok(mut image) = ui_images.get_mut(c[1]) {
361 |                     *image = directions.x.clone();
362 |                 }
363 |             }
364 |             Axis::Y => {
365 |                 if let Ok(mut image) = ui_images.get_mut(c[1]) {
366 |                     *image = directions.y.clone();
367 |                 }
368 |             }
369 |             Axis::Z => {
370 |                 if let Ok(mut image) = ui_images.get_mut(c[1]) {
371 |                     *image = directions.z.clone();
372 |                 }
373 |             }
374 |         }
375 |     }
376 | }
377 | 
378 | #[derive(Debug, DerefMut, Deref, Resource)]
379 | struct Selected(usize);
380 | 
381 | #[derive(Component)]
382 | struct Select;
383 | 
384 | fn update_select(
385 |     selected: Res<Selected>,
386 |     ui: Res<UIElements>,
387 |     mut query: Query<&mut BackgroundColor>,
388 |     mut old: Local<usize>,
389 | ) {
390 |     if selected.is_changed() {
391 |         if let Ok(mut color) = query.get_mut(ui.0[*old]) {
392 |             color.0 = Color::WHITE;
393 |         }
394 |         if let Ok(mut color) = query.get_mut(ui.0[selected.0]) {
395 |             color.0 = Color::GREEN;
396 |         }
397 |         *old = selected.0;
398 |     }
399 | }
400 | 
401 | fn run(
402 |     mut query: Query<&mut Transform, With<Cube>>,
403 |     order: Res<Order>,
404 |     mut progress: Local<f32>,
405 |     mut step: Local<usize>,
406 |     run: Option<Res<Run>>,
407 |     time: Res<Time>,
408 |     mut commands: Commands,
409 | ) {
410 |     if run.is_none() {
411 |         return;
412 |     }
413 |     let run = run.unwrap();
414 |     if run.is_added() {
415 |         *progress = 0.0;
416 |         *step = 0;
417 |     }
418 |     if *step == MOVES {
419 |         commands.remove_resource::<Run>();
420 |         return;
421 |     }
422 |     let mut trans = query.single_mut();
423 |     if *progress + time.delta_seconds() > 1.0 {
424 |         let max = *progress + time.delta_seconds();
425 |         let over = max - 1.;
426 |         let under = time.delta_seconds() - over;
427 |         trans.rotate_axis(order.as_vec3(*step), under * std::f32::consts::PI / 2.);
428 |         *step += 1;
429 |         if *step == MOVES {
430 |             return;
431 |         };
432 |         trans.rotate_axis(order.as_vec3(*step), over * std::f32::consts::PI / 2.);
433 |         *progress = over;
434 |     } else {
435 |         trans.rotate_axis(
436 |             order.as_vec3(*step),
437 |             time.delta_seconds() * std::f32::consts::PI / 2.,
438 |         );
439 |         *progress += time.delta_seconds();
440 |     }
441 | }
442 | 


--------------------------------------------------------------------------------
/test_scene.scn.ron:
--------------------------------------------------------------------------------
  1 | [
  2 |   (
  3 |     entity: 0,
  4 |     components: [
  5 |       {
  6 |         "type": "bevy_render::view::visibility::Visibility",
  7 |         "struct": {
  8 |           "is_visible": {
  9 |             "type": "bool",
 10 |             "value": true,
 11 |           },
 12 |         },
 13 |       },
 14 |       {
 15 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 16 |         "struct": {
 17 |           "is_visible_in_hierarchy": {
 18 |             "type": "bool",
 19 |             "value": false,
 20 |           },
 21 |           "is_visible_in_view": {
 22 |             "type": "bool",
 23 |             "value": false,
 24 |           },
 25 |         },
 26 |       },
 27 |       {
 28 |         "type": "bevy_transform::components::transform::Transform",
 29 |         "struct": {
 30 |           "translation": {
 31 |             "type": "glam::f32::vec3::Vec3",
 32 |             "struct": {
 33 |               "x": {
 34 |                 "type": "f32",
 35 |                 "value": 0.0,
 36 |               },
 37 |               "y": {
 38 |                 "type": "f32",
 39 |                 "value": 0.0,
 40 |               },
 41 |               "z": {
 42 |                 "type": "f32",
 43 |                 "value": 0.0,
 44 |               },
 45 |             },
 46 |           },
 47 |           "rotation": {
 48 |             "type": "glam::f32::sse2::quat::Quat",
 49 |             "value": (0.0, 0.0, 0.0, 1.0),
 50 |           },
 51 |           "scale": {
 52 |             "type": "glam::f32::vec3::Vec3",
 53 |             "struct": {
 54 |               "x": {
 55 |                 "type": "f32",
 56 |                 "value": 1.0,
 57 |               },
 58 |               "y": {
 59 |                 "type": "f32",
 60 |                 "value": 1.0,
 61 |               },
 62 |               "z": {
 63 |                 "type": "f32",
 64 |                 "value": 1.0,
 65 |               },
 66 |             },
 67 |           },
 68 |         },
 69 |       },
 70 |       {
 71 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 72 |         "tuple_struct": [
 73 |           {
 74 |             "type": "glam::f32::affine3a::Affine3A",
 75 |             "struct": {
 76 |               "matrix3": {
 77 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 78 |                 "struct": {
 79 |                   "x_axis": {
 80 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 81 |                     "struct": {
 82 |                       "x": {
 83 |                         "type": "f32",
 84 |                         "value": 1.0,
 85 |                       },
 86 |                       "y": {
 87 |                         "type": "f32",
 88 |                         "value": 0.0,
 89 |                       },
 90 |                       "z": {
 91 |                         "type": "f32",
 92 |                         "value": 0.0,
 93 |                       },
 94 |                     },
 95 |                   },
 96 |                   "y_axis": {
 97 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 98 |                     "struct": {
 99 |                       "x": {
100 |                         "type": "f32",
101 |                         "value": 0.0,
102 |                       },
103 |                       "y": {
104 |                         "type": "f32",
105 |                         "value": 1.0,
106 |                       },
107 |                       "z": {
108 |                         "type": "f32",
109 |                         "value": 0.0,
110 |                       },
111 |                     },
112 |                   },
113 |                   "z_axis": {
114 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
115 |                     "struct": {
116 |                       "x": {
117 |                         "type": "f32",
118 |                         "value": 0.0,
119 |                       },
120 |                       "y": {
121 |                         "type": "f32",
122 |                         "value": 0.0,
123 |                       },
124 |                       "z": {
125 |                         "type": "f32",
126 |                         "value": 1.0,
127 |                       },
128 |                     },
129 |                   },
130 |                 },
131 |               },
132 |               "translation": {
133 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
134 |                 "struct": {
135 |                   "x": {
136 |                     "type": "f32",
137 |                     "value": 0.0,
138 |                   },
139 |                   "y": {
140 |                     "type": "f32",
141 |                     "value": 0.0,
142 |                   },
143 |                   "z": {
144 |                     "type": "f32",
145 |                     "value": 0.0,
146 |                   },
147 |                 },
148 |               },
149 |             },
150 |           },
151 |         ],
152 |       },
153 |       {
154 |         "type": "bevy_hierarchy::components::parent::Parent",
155 |         "tuple_struct": [
156 |           {
157 |             "type": "bevy_ecs::entity::Entity",
158 |             "value": 2,
159 |           },
160 |         ],
161 |       },
162 |     ],
163 |   ),
164 |   (
165 |     entity: 1,
166 |     components: [
167 |       {
168 |         "type": "bevy_render::view::visibility::Visibility",
169 |         "struct": {
170 |           "is_visible": {
171 |             "type": "bool",
172 |             "value": true,
173 |           },
174 |         },
175 |       },
176 |       {
177 |         "type": "bevy_render::view::visibility::ComputedVisibility",
178 |         "struct": {
179 |           "is_visible_in_hierarchy": {
180 |             "type": "bool",
181 |             "value": false,
182 |           },
183 |           "is_visible_in_view": {
184 |             "type": "bool",
185 |             "value": false,
186 |           },
187 |         },
188 |       },
189 |       {
190 |         "type": "bevy_transform::components::transform::Transform",
191 |         "struct": {
192 |           "translation": {
193 |             "type": "glam::f32::vec3::Vec3",
194 |             "struct": {
195 |               "x": {
196 |                 "type": "f32",
197 |                 "value": 0.0,
198 |               },
199 |               "y": {
200 |                 "type": "f32",
201 |                 "value": 0.0,
202 |               },
203 |               "z": {
204 |                 "type": "f32",
205 |                 "value": 0.0,
206 |               },
207 |             },
208 |           },
209 |           "rotation": {
210 |             "type": "glam::f32::sse2::quat::Quat",
211 |             "value": (0.0, 0.0, 0.0, 1.0),
212 |           },
213 |           "scale": {
214 |             "type": "glam::f32::vec3::Vec3",
215 |             "struct": {
216 |               "x": {
217 |                 "type": "f32",
218 |                 "value": 1.0,
219 |               },
220 |               "y": {
221 |                 "type": "f32",
222 |                 "value": 1.0,
223 |               },
224 |               "z": {
225 |                 "type": "f32",
226 |                 "value": 1.0,
227 |               },
228 |             },
229 |           },
230 |         },
231 |       },
232 |       {
233 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
234 |         "tuple_struct": [
235 |           {
236 |             "type": "glam::f32::affine3a::Affine3A",
237 |             "struct": {
238 |               "matrix3": {
239 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
240 |                 "struct": {
241 |                   "x_axis": {
242 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
243 |                     "struct": {
244 |                       "x": {
245 |                         "type": "f32",
246 |                         "value": 1.0,
247 |                       },
248 |                       "y": {
249 |                         "type": "f32",
250 |                         "value": 0.0,
251 |                       },
252 |                       "z": {
253 |                         "type": "f32",
254 |                         "value": 0.0,
255 |                       },
256 |                     },
257 |                   },
258 |                   "y_axis": {
259 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
260 |                     "struct": {
261 |                       "x": {
262 |                         "type": "f32",
263 |                         "value": 0.0,
264 |                       },
265 |                       "y": {
266 |                         "type": "f32",
267 |                         "value": 1.0,
268 |                       },
269 |                       "z": {
270 |                         "type": "f32",
271 |                         "value": 0.0,
272 |                       },
273 |                     },
274 |                   },
275 |                   "z_axis": {
276 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
277 |                     "struct": {
278 |                       "x": {
279 |                         "type": "f32",
280 |                         "value": 0.0,
281 |                       },
282 |                       "y": {
283 |                         "type": "f32",
284 |                         "value": 0.0,
285 |                       },
286 |                       "z": {
287 |                         "type": "f32",
288 |                         "value": 1.0,
289 |                       },
290 |                     },
291 |                   },
292 |                 },
293 |               },
294 |               "translation": {
295 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
296 |                 "struct": {
297 |                   "x": {
298 |                     "type": "f32",
299 |                     "value": 0.0,
300 |                   },
301 |                   "y": {
302 |                     "type": "f32",
303 |                     "value": 0.0,
304 |                   },
305 |                   "z": {
306 |                     "type": "f32",
307 |                     "value": 0.0,
308 |                   },
309 |                 },
310 |               },
311 |             },
312 |           },
313 |         ],
314 |       },
315 |       {
316 |         "type": "bevy_hierarchy::components::parent::Parent",
317 |         "tuple_struct": [
318 |           {
319 |             "type": "bevy_ecs::entity::Entity",
320 |             "value": 2,
321 |           },
322 |         ],
323 |       },
324 |     ],
325 |   ),
326 |   (
327 |     entity: 2,
328 |     components: [
329 |       {
330 |         "type": "bevy_render::view::visibility::Visibility",
331 |         "struct": {
332 |           "is_visible": {
333 |             "type": "bool",
334 |             "value": true,
335 |           },
336 |         },
337 |       },
338 |       {
339 |         "type": "bevy_render::view::visibility::ComputedVisibility",
340 |         "struct": {
341 |           "is_visible_in_hierarchy": {
342 |             "type": "bool",
343 |             "value": false,
344 |           },
345 |           "is_visible_in_view": {
346 |             "type": "bool",
347 |             "value": false,
348 |           },
349 |         },
350 |       },
351 |       {
352 |         "type": "bevy_transform::components::transform::Transform",
353 |         "struct": {
354 |           "translation": {
355 |             "type": "glam::f32::vec3::Vec3",
356 |             "struct": {
357 |               "x": {
358 |                 "type": "f32",
359 |                 "value": 0.0,
360 |               },
361 |               "y": {
362 |                 "type": "f32",
363 |                 "value": 0.0,
364 |               },
365 |               "z": {
366 |                 "type": "f32",
367 |                 "value": 0.0,
368 |               },
369 |             },
370 |           },
371 |           "rotation": {
372 |             "type": "glam::f32::sse2::quat::Quat",
373 |             "value": (0.0, 0.0, 0.0, 1.0),
374 |           },
375 |           "scale": {
376 |             "type": "glam::f32::vec3::Vec3",
377 |             "struct": {
378 |               "x": {
379 |                 "type": "f32",
380 |                 "value": 1.0,
381 |               },
382 |               "y": {
383 |                 "type": "f32",
384 |                 "value": 1.0,
385 |               },
386 |               "z": {
387 |                 "type": "f32",
388 |                 "value": 1.0,
389 |               },
390 |             },
391 |           },
392 |         },
393 |       },
394 |       {
395 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
396 |         "tuple_struct": [
397 |           {
398 |             "type": "glam::f32::affine3a::Affine3A",
399 |             "struct": {
400 |               "matrix3": {
401 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
402 |                 "struct": {
403 |                   "x_axis": {
404 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
405 |                     "struct": {
406 |                       "x": {
407 |                         "type": "f32",
408 |                         "value": 1.0,
409 |                       },
410 |                       "y": {
411 |                         "type": "f32",
412 |                         "value": 0.0,
413 |                       },
414 |                       "z": {
415 |                         "type": "f32",
416 |                         "value": 0.0,
417 |                       },
418 |                     },
419 |                   },
420 |                   "y_axis": {
421 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
422 |                     "struct": {
423 |                       "x": {
424 |                         "type": "f32",
425 |                         "value": 0.0,
426 |                       },
427 |                       "y": {
428 |                         "type": "f32",
429 |                         "value": 1.0,
430 |                       },
431 |                       "z": {
432 |                         "type": "f32",
433 |                         "value": 0.0,
434 |                       },
435 |                     },
436 |                   },
437 |                   "z_axis": {
438 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
439 |                     "struct": {
440 |                       "x": {
441 |                         "type": "f32",
442 |                         "value": 0.0,
443 |                       },
444 |                       "y": {
445 |                         "type": "f32",
446 |                         "value": 0.0,
447 |                       },
448 |                       "z": {
449 |                         "type": "f32",
450 |                         "value": 1.0,
451 |                       },
452 |                     },
453 |                   },
454 |                 },
455 |               },
456 |               "translation": {
457 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
458 |                 "struct": {
459 |                   "x": {
460 |                     "type": "f32",
461 |                     "value": 0.0,
462 |                   },
463 |                   "y": {
464 |                     "type": "f32",
465 |                     "value": 0.0,
466 |                   },
467 |                   "z": {
468 |                     "type": "f32",
469 |                     "value": 0.0,
470 |                   },
471 |                 },
472 |               },
473 |             },
474 |           },
475 |         ],
476 |       },
477 |       {
478 |         "type": "bevy_hierarchy::components::children::Children",
479 |         "tuple_struct": [
480 |           {
481 |             "type": "smallvec::SmallVec<[bevy_ecs::entity::Entity; 8]>",
482 |             "list": [
483 |               {
484 |                 "type": "bevy_ecs::entity::Entity",
485 |                 "value": 0,
486 |               },
487 |               {
488 |                 "type": "bevy_ecs::entity::Entity",
489 |                 "value": 1,
490 |               },
491 |             ],
492 |           },
493 |         ],
494 |       },
495 |     ],
496 |   ),
497 | ]


--------------------------------------------------------------------------------
/assets/part_scene.scn.ron:
--------------------------------------------------------------------------------
  1 | [
  2 |   (
  3 |     entity: 0,
  4 |     components: [
  5 |       {
  6 |         "type": "bevy_render::view::visibility::Visibility",
  7 |         "struct": {
  8 |           "is_visible": {
  9 |             "type": "bool",
 10 |             "value": true,
 11 |           },
 12 |         },
 13 |       },
 14 |       {
 15 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 16 |         "struct": {
 17 |           "is_visible_in_hierarchy": {
 18 |             "type": "bool",
 19 |             "value": false,
 20 |           },
 21 |           "is_visible_in_view": {
 22 |             "type": "bool",
 23 |             "value": false,
 24 |           },
 25 |         },
 26 |       },
 27 |       {
 28 |         "type": "bevy_transform::components::transform::Transform",
 29 |         "struct": {
 30 |           "translation": {
 31 |             "type": "glam::f32::vec3::Vec3",
 32 |             "struct": {
 33 |               "x": {
 34 |                 "type": "f32",
 35 |                 "value": 0.0,
 36 |               },
 37 |               "y": {
 38 |                 "type": "f32",
 39 |                 "value": 0.0,
 40 |               },
 41 |               "z": {
 42 |                 "type": "f32",
 43 |                 "value": 0.0,
 44 |               },
 45 |             },
 46 |           },
 47 |           "rotation": {
 48 |             "type": "glam::f32::sse2::quat::Quat",
 49 |             "value": (0.0, 0.0, 0.0, 1.0),
 50 |           },
 51 |           "scale": {
 52 |             "type": "glam::f32::vec3::Vec3",
 53 |             "struct": {
 54 |               "x": {
 55 |                 "type": "f32",
 56 |                 "value": 1.0,
 57 |               },
 58 |               "y": {
 59 |                 "type": "f32",
 60 |                 "value": 1.0,
 61 |               },
 62 |               "z": {
 63 |                 "type": "f32",
 64 |                 "value": 1.0,
 65 |               },
 66 |             },
 67 |           },
 68 |         },
 69 |       },
 70 |       {
 71 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 72 |         "tuple_struct": [
 73 |           {
 74 |             "type": "glam::f32::affine3a::Affine3A",
 75 |             "struct": {
 76 |               "matrix3": {
 77 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 78 |                 "struct": {
 79 |                   "x_axis": {
 80 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 81 |                     "struct": {
 82 |                       "x": {
 83 |                         "type": "f32",
 84 |                         "value": 1.0,
 85 |                       },
 86 |                       "y": {
 87 |                         "type": "f32",
 88 |                         "value": 0.0,
 89 |                       },
 90 |                       "z": {
 91 |                         "type": "f32",
 92 |                         "value": 0.0,
 93 |                       },
 94 |                     },
 95 |                   },
 96 |                   "y_axis": {
 97 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 98 |                     "struct": {
 99 |                       "x": {
100 |                         "type": "f32",
101 |                         "value": 0.0,
102 |                       },
103 |                       "y": {
104 |                         "type": "f32",
105 |                         "value": 1.0,
106 |                       },
107 |                       "z": {
108 |                         "type": "f32",
109 |                         "value": 0.0,
110 |                       },
111 |                     },
112 |                   },
113 |                   "z_axis": {
114 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
115 |                     "struct": {
116 |                       "x": {
117 |                         "type": "f32",
118 |                         "value": 0.0,
119 |                       },
120 |                       "y": {
121 |                         "type": "f32",
122 |                         "value": 0.0,
123 |                       },
124 |                       "z": {
125 |                         "type": "f32",
126 |                         "value": 1.0,
127 |                       },
128 |                     },
129 |                   },
130 |                 },
131 |               },
132 |               "translation": {
133 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
134 |                 "struct": {
135 |                   "x": {
136 |                     "type": "f32",
137 |                     "value": 0.0,
138 |                   },
139 |                   "y": {
140 |                     "type": "f32",
141 |                     "value": 0.0,
142 |                   },
143 |                   "z": {
144 |                     "type": "f32",
145 |                     "value": 0.0,
146 |                   },
147 |                 },
148 |               },
149 |             },
150 |           },
151 |         ],
152 |       },
153 |       {
154 |         "type": "bevy_hierarchy::components::parent::Parent",
155 |         "tuple_struct": [
156 |           {
157 |             "type": "bevy_ecs::entity::Entity",
158 |             "value": 2,
159 |           },
160 |         ],
161 |       },
162 |     ],
163 |   ),
164 |   (
165 |     entity: 1,
166 |     components: [
167 |       {
168 |         "type": "bevy_render::view::visibility::Visibility",
169 |         "struct": {
170 |           "is_visible": {
171 |             "type": "bool",
172 |             "value": true,
173 |           },
174 |         },
175 |       },
176 |       {
177 |         "type": "bevy_render::view::visibility::ComputedVisibility",
178 |         "struct": {
179 |           "is_visible_in_hierarchy": {
180 |             "type": "bool",
181 |             "value": false,
182 |           },
183 |           "is_visible_in_view": {
184 |             "type": "bool",
185 |             "value": false,
186 |           },
187 |         },
188 |       },
189 |       {
190 |         "type": "bevy_transform::components::transform::Transform",
191 |         "struct": {
192 |           "translation": {
193 |             "type": "glam::f32::vec3::Vec3",
194 |             "struct": {
195 |               "x": {
196 |                 "type": "f32",
197 |                 "value": 0.0,
198 |               },
199 |               "y": {
200 |                 "type": "f32",
201 |                 "value": 0.0,
202 |               },
203 |               "z": {
204 |                 "type": "f32",
205 |                 "value": 0.0,
206 |               },
207 |             },
208 |           },
209 |           "rotation": {
210 |             "type": "glam::f32::sse2::quat::Quat",
211 |             "value": (0.0, 0.0, 0.0, 1.0),
212 |           },
213 |           "scale": {
214 |             "type": "glam::f32::vec3::Vec3",
215 |             "struct": {
216 |               "x": {
217 |                 "type": "f32",
218 |                 "value": 1.0,
219 |               },
220 |               "y": {
221 |                 "type": "f32",
222 |                 "value": 1.0,
223 |               },
224 |               "z": {
225 |                 "type": "f32",
226 |                 "value": 1.0,
227 |               },
228 |             },
229 |           },
230 |         },
231 |       },
232 |       {
233 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
234 |         "tuple_struct": [
235 |           {
236 |             "type": "glam::f32::affine3a::Affine3A",
237 |             "struct": {
238 |               "matrix3": {
239 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
240 |                 "struct": {
241 |                   "x_axis": {
242 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
243 |                     "struct": {
244 |                       "x": {
245 |                         "type": "f32",
246 |                         "value": 1.0,
247 |                       },
248 |                       "y": {
249 |                         "type": "f32",
250 |                         "value": 0.0,
251 |                       },
252 |                       "z": {
253 |                         "type": "f32",
254 |                         "value": 0.0,
255 |                       },
256 |                     },
257 |                   },
258 |                   "y_axis": {
259 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
260 |                     "struct": {
261 |                       "x": {
262 |                         "type": "f32",
263 |                         "value": 0.0,
264 |                       },
265 |                       "y": {
266 |                         "type": "f32",
267 |                         "value": 1.0,
268 |                       },
269 |                       "z": {
270 |                         "type": "f32",
271 |                         "value": 0.0,
272 |                       },
273 |                     },
274 |                   },
275 |                   "z_axis": {
276 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
277 |                     "struct": {
278 |                       "x": {
279 |                         "type": "f32",
280 |                         "value": 0.0,
281 |                       },
282 |                       "y": {
283 |                         "type": "f32",
284 |                         "value": 0.0,
285 |                       },
286 |                       "z": {
287 |                         "type": "f32",
288 |                         "value": 1.0,
289 |                       },
290 |                     },
291 |                   },
292 |                 },
293 |               },
294 |               "translation": {
295 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
296 |                 "struct": {
297 |                   "x": {
298 |                     "type": "f32",
299 |                     "value": 0.0,
300 |                   },
301 |                   "y": {
302 |                     "type": "f32",
303 |                     "value": 0.0,
304 |                   },
305 |                   "z": {
306 |                     "type": "f32",
307 |                     "value": 0.0,
308 |                   },
309 |                 },
310 |               },
311 |             },
312 |           },
313 |         ],
314 |       },
315 |       {
316 |         "type": "bevy_hierarchy::components::parent::Parent",
317 |         "tuple_struct": [
318 |           {
319 |             "type": "bevy_ecs::entity::Entity",
320 |             "value": 2,
321 |           },
322 |         ],
323 |       },
324 |     ],
325 |   ),
326 |   (
327 |     entity: 2,
328 |     components: [
329 |       {
330 |         "type": "bevy_render::view::visibility::Visibility",
331 |         "struct": {
332 |           "is_visible": {
333 |             "type": "bool",
334 |             "value": true,
335 |           },
336 |         },
337 |       },
338 |       {
339 |         "type": "bevy_render::view::visibility::ComputedVisibility",
340 |         "struct": {
341 |           "is_visible_in_hierarchy": {
342 |             "type": "bool",
343 |             "value": false,
344 |           },
345 |           "is_visible_in_view": {
346 |             "type": "bool",
347 |             "value": false,
348 |           },
349 |         },
350 |       },
351 |       {
352 |         "type": "bevy_transform::components::transform::Transform",
353 |         "struct": {
354 |           "translation": {
355 |             "type": "glam::f32::vec3::Vec3",
356 |             "struct": {
357 |               "x": {
358 |                 "type": "f32",
359 |                 "value": 0.0,
360 |               },
361 |               "y": {
362 |                 "type": "f32",
363 |                 "value": 0.0,
364 |               },
365 |               "z": {
366 |                 "type": "f32",
367 |                 "value": 0.0,
368 |               },
369 |             },
370 |           },
371 |           "rotation": {
372 |             "type": "glam::f32::sse2::quat::Quat",
373 |             "value": (0.0, 0.0, 0.0, 1.0),
374 |           },
375 |           "scale": {
376 |             "type": "glam::f32::vec3::Vec3",
377 |             "struct": {
378 |               "x": {
379 |                 "type": "f32",
380 |                 "value": 1.0,
381 |               },
382 |               "y": {
383 |                 "type": "f32",
384 |                 "value": 1.0,
385 |               },
386 |               "z": {
387 |                 "type": "f32",
388 |                 "value": 1.0,
389 |               },
390 |             },
391 |           },
392 |         },
393 |       },
394 |       {
395 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
396 |         "tuple_struct": [
397 |           {
398 |             "type": "glam::f32::affine3a::Affine3A",
399 |             "struct": {
400 |               "matrix3": {
401 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
402 |                 "struct": {
403 |                   "x_axis": {
404 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
405 |                     "struct": {
406 |                       "x": {
407 |                         "type": "f32",
408 |                         "value": 1.0,
409 |                       },
410 |                       "y": {
411 |                         "type": "f32",
412 |                         "value": 0.0,
413 |                       },
414 |                       "z": {
415 |                         "type": "f32",
416 |                         "value": 0.0,
417 |                       },
418 |                     },
419 |                   },
420 |                   "y_axis": {
421 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
422 |                     "struct": {
423 |                       "x": {
424 |                         "type": "f32",
425 |                         "value": 0.0,
426 |                       },
427 |                       "y": {
428 |                         "type": "f32",
429 |                         "value": 1.0,
430 |                       },
431 |                       "z": {
432 |                         "type": "f32",
433 |                         "value": 0.0,
434 |                       },
435 |                     },
436 |                   },
437 |                   "z_axis": {
438 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
439 |                     "struct": {
440 |                       "x": {
441 |                         "type": "f32",
442 |                         "value": 0.0,
443 |                       },
444 |                       "y": {
445 |                         "type": "f32",
446 |                         "value": 0.0,
447 |                       },
448 |                       "z": {
449 |                         "type": "f32",
450 |                         "value": 1.0,
451 |                       },
452 |                     },
453 |                   },
454 |                 },
455 |               },
456 |               "translation": {
457 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
458 |                 "struct": {
459 |                   "x": {
460 |                     "type": "f32",
461 |                     "value": 0.0,
462 |                   },
463 |                   "y": {
464 |                     "type": "f32",
465 |                     "value": 0.0,
466 |                   },
467 |                   "z": {
468 |                     "type": "f32",
469 |                     "value": 0.0,
470 |                   },
471 |                 },
472 |               },
473 |             },
474 |           },
475 |         ],
476 |       },
477 |       {
478 |         "type": "bevy_hierarchy::components::children::Children",
479 |         "tuple_struct": [
480 |           {
481 |             "type": "smallvec::SmallVec<[bevy_ecs::entity::Entity; 8]>",
482 |             "list": [
483 |               {
484 |                 "type": "bevy_ecs::entity::Entity",
485 |                 "value": 0,
486 |               },
487 |               {
488 |                 "type": "bevy_ecs::entity::Entity",
489 |                 "value": 1,
490 |               },
491 |             ],
492 |           },
493 |         ],
494 |       },
495 |     ],
496 |   ),
497 | ]


--------------------------------------------------------------------------------
/assets/scene.scn.ron:
--------------------------------------------------------------------------------
  1 | [
  2 |   (
  3 |     entity: 0,
  4 |     components: [
  5 |       {
  6 |         "type": "bevy_render::view::visibility::Visibility",
  7 |         "struct": {
  8 |           "is_visible": {
  9 |             "type": "bool",
 10 |             "value": true,
 11 |           },
 12 |         },
 13 |       },
 14 |       {
 15 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 16 |         "struct": {
 17 |           "is_visible_in_hierarchy": {
 18 |             "type": "bool",
 19 |             "value": false,
 20 |           },
 21 |           "is_visible_in_view": {
 22 |             "type": "bool",
 23 |             "value": false,
 24 |           },
 25 |         },
 26 |       },
 27 |       {
 28 |         "type": "bevy_transform::components::transform::Transform",
 29 |         "struct": {
 30 |           "translation": {
 31 |             "type": "glam::f32::vec3::Vec3",
 32 |             "struct": {
 33 |               "x": {
 34 |                 "type": "f32",
 35 |                 "value": 0.0,
 36 |               },
 37 |               "y": {
 38 |                 "type": "f32",
 39 |                 "value": 0.0,
 40 |               },
 41 |               "z": {
 42 |                 "type": "f32",
 43 |                 "value": 0.0,
 44 |               },
 45 |             },
 46 |           },
 47 |           "rotation": {
 48 |             "type": "glam::f32::sse2::quat::Quat",
 49 |             "value": (0.0, 0.0, 0.0, 1.0),
 50 |           },
 51 |           "scale": {
 52 |             "type": "glam::f32::vec3::Vec3",
 53 |             "struct": {
 54 |               "x": {
 55 |                 "type": "f32",
 56 |                 "value": 1.0,
 57 |               },
 58 |               "y": {
 59 |                 "type": "f32",
 60 |                 "value": 1.0,
 61 |               },
 62 |               "z": {
 63 |                 "type": "f32",
 64 |                 "value": 1.0,
 65 |               },
 66 |             },
 67 |           },
 68 |         },
 69 |       },
 70 |       {
 71 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 72 |         "tuple_struct": [
 73 |           {
 74 |             "type": "glam::f32::affine3a::Affine3A",
 75 |             "struct": {
 76 |               "matrix3": {
 77 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 78 |                 "struct": {
 79 |                   "x_axis": {
 80 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 81 |                     "struct": {
 82 |                       "x": {
 83 |                         "type": "f32",
 84 |                         "value": 1.0,
 85 |                       },
 86 |                       "y": {
 87 |                         "type": "f32",
 88 |                         "value": 0.0,
 89 |                       },
 90 |                       "z": {
 91 |                         "type": "f32",
 92 |                         "value": 0.0,
 93 |                       },
 94 |                     },
 95 |                   },
 96 |                   "y_axis": {
 97 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 98 |                     "struct": {
 99 |                       "x": {
100 |                         "type": "f32",
101 |                         "value": 0.0,
102 |                       },
103 |                       "y": {
104 |                         "type": "f32",
105 |                         "value": 1.0,
106 |                       },
107 |                       "z": {
108 |                         "type": "f32",
109 |                         "value": 0.0,
110 |                       },
111 |                     },
112 |                   },
113 |                   "z_axis": {
114 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
115 |                     "struct": {
116 |                       "x": {
117 |                         "type": "f32",
118 |                         "value": 0.0,
119 |                       },
120 |                       "y": {
121 |                         "type": "f32",
122 |                         "value": 0.0,
123 |                       },
124 |                       "z": {
125 |                         "type": "f32",
126 |                         "value": 1.0,
127 |                       },
128 |                     },
129 |                   },
130 |                 },
131 |               },
132 |               "translation": {
133 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
134 |                 "struct": {
135 |                   "x": {
136 |                     "type": "f32",
137 |                     "value": 0.0,
138 |                   },
139 |                   "y": {
140 |                     "type": "f32",
141 |                     "value": 0.0,
142 |                   },
143 |                   "z": {
144 |                     "type": "f32",
145 |                     "value": 0.0,
146 |                   },
147 |                 },
148 |               },
149 |             },
150 |           },
151 |         ],
152 |       },
153 |       {
154 |         "type": "bevy_hierarchy::components::parent::Parent",
155 |         "tuple_struct": [
156 |           {
157 |             "type": "bevy_ecs::entity::Entity",
158 |             "value": 2,
159 |           },
160 |         ],
161 |       },
162 |     ],
163 |   ),
164 |   (
165 |     entity: 1,
166 |     components: [
167 |       {
168 |         "type": "bevy_render::view::visibility::Visibility",
169 |         "struct": {
170 |           "is_visible": {
171 |             "type": "bool",
172 |             "value": true,
173 |           },
174 |         },
175 |       },
176 |       {
177 |         "type": "bevy_render::view::visibility::ComputedVisibility",
178 |         "struct": {
179 |           "is_visible_in_hierarchy": {
180 |             "type": "bool",
181 |             "value": false,
182 |           },
183 |           "is_visible_in_view": {
184 |             "type": "bool",
185 |             "value": false,
186 |           },
187 |         },
188 |       },
189 |       {
190 |         "type": "bevy_transform::components::transform::Transform",
191 |         "struct": {
192 |           "translation": {
193 |             "type": "glam::f32::vec3::Vec3",
194 |             "struct": {
195 |               "x": {
196 |                 "type": "f32",
197 |                 "value": 0.0,
198 |               },
199 |               "y": {
200 |                 "type": "f32",
201 |                 "value": 0.0,
202 |               },
203 |               "z": {
204 |                 "type": "f32",
205 |                 "value": 0.0,
206 |               },
207 |             },
208 |           },
209 |           "rotation": {
210 |             "type": "glam::f32::sse2::quat::Quat",
211 |             "value": (0.0, 0.0, 0.0, 1.0),
212 |           },
213 |           "scale": {
214 |             "type": "glam::f32::vec3::Vec3",
215 |             "struct": {
216 |               "x": {
217 |                 "type": "f32",
218 |                 "value": 1.0,
219 |               },
220 |               "y": {
221 |                 "type": "f32",
222 |                 "value": 1.0,
223 |               },
224 |               "z": {
225 |                 "type": "f32",
226 |                 "value": 1.0,
227 |               },
228 |             },
229 |           },
230 |         },
231 |       },
232 |       {
233 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
234 |         "tuple_struct": [
235 |           {
236 |             "type": "glam::f32::affine3a::Affine3A",
237 |             "struct": {
238 |               "matrix3": {
239 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
240 |                 "struct": {
241 |                   "x_axis": {
242 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
243 |                     "struct": {
244 |                       "x": {
245 |                         "type": "f32",
246 |                         "value": 1.0,
247 |                       },
248 |                       "y": {
249 |                         "type": "f32",
250 |                         "value": 0.0,
251 |                       },
252 |                       "z": {
253 |                         "type": "f32",
254 |                         "value": 0.0,
255 |                       },
256 |                     },
257 |                   },
258 |                   "y_axis": {
259 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
260 |                     "struct": {
261 |                       "x": {
262 |                         "type": "f32",
263 |                         "value": 0.0,
264 |                       },
265 |                       "y": {
266 |                         "type": "f32",
267 |                         "value": 1.0,
268 |                       },
269 |                       "z": {
270 |                         "type": "f32",
271 |                         "value": 0.0,
272 |                       },
273 |                     },
274 |                   },
275 |                   "z_axis": {
276 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
277 |                     "struct": {
278 |                       "x": {
279 |                         "type": "f32",
280 |                         "value": 0.0,
281 |                       },
282 |                       "y": {
283 |                         "type": "f32",
284 |                         "value": 0.0,
285 |                       },
286 |                       "z": {
287 |                         "type": "f32",
288 |                         "value": 1.0,
289 |                       },
290 |                     },
291 |                   },
292 |                 },
293 |               },
294 |               "translation": {
295 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
296 |                 "struct": {
297 |                   "x": {
298 |                     "type": "f32",
299 |                     "value": 0.0,
300 |                   },
301 |                   "y": {
302 |                     "type": "f32",
303 |                     "value": 0.0,
304 |                   },
305 |                   "z": {
306 |                     "type": "f32",
307 |                     "value": 0.0,
308 |                   },
309 |                 },
310 |               },
311 |             },
312 |           },
313 |         ],
314 |       },
315 |       {
316 |         "type": "bevy_hierarchy::components::parent::Parent",
317 |         "tuple_struct": [
318 |           {
319 |             "type": "bevy_ecs::entity::Entity",
320 |             "value": 2,
321 |           },
322 |         ],
323 |       },
324 |     ],
325 |   ),
326 |   (
327 |     entity: 2,
328 |     components: [
329 |       {
330 |         "type": "bevy_render::view::visibility::Visibility",
331 |         "struct": {
332 |           "is_visible": {
333 |             "type": "bool",
334 |             "value": true,
335 |           },
336 |         },
337 |       },
338 |       {
339 |         "type": "bevy_render::view::visibility::ComputedVisibility",
340 |         "struct": {
341 |           "is_visible_in_hierarchy": {
342 |             "type": "bool",
343 |             "value": false,
344 |           },
345 |           "is_visible_in_view": {
346 |             "type": "bool",
347 |             "value": false,
348 |           },
349 |         },
350 |       },
351 |       {
352 |         "type": "bevy_transform::components::transform::Transform",
353 |         "struct": {
354 |           "translation": {
355 |             "type": "glam::f32::vec3::Vec3",
356 |             "struct": {
357 |               "x": {
358 |                 "type": "f32",
359 |                 "value": 0.0,
360 |               },
361 |               "y": {
362 |                 "type": "f32",
363 |                 "value": 0.0,
364 |               },
365 |               "z": {
366 |                 "type": "f32",
367 |                 "value": 0.0,
368 |               },
369 |             },
370 |           },
371 |           "rotation": {
372 |             "type": "glam::f32::sse2::quat::Quat",
373 |             "value": (0.0, 0.0, 0.0, 1.0),
374 |           },
375 |           "scale": {
376 |             "type": "glam::f32::vec3::Vec3",
377 |             "struct": {
378 |               "x": {
379 |                 "type": "f32",
380 |                 "value": 1.0,
381 |               },
382 |               "y": {
383 |                 "type": "f32",
384 |                 "value": 1.0,
385 |               },
386 |               "z": {
387 |                 "type": "f32",
388 |                 "value": 1.0,
389 |               },
390 |             },
391 |           },
392 |         },
393 |       },
394 |       {
395 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
396 |         "tuple_struct": [
397 |           {
398 |             "type": "glam::f32::affine3a::Affine3A",
399 |             "struct": {
400 |               "matrix3": {
401 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
402 |                 "struct": {
403 |                   "x_axis": {
404 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
405 |                     "struct": {
406 |                       "x": {
407 |                         "type": "f32",
408 |                         "value": 1.0,
409 |                       },
410 |                       "y": {
411 |                         "type": "f32",
412 |                         "value": 0.0,
413 |                       },
414 |                       "z": {
415 |                         "type": "f32",
416 |                         "value": 0.0,
417 |                       },
418 |                     },
419 |                   },
420 |                   "y_axis": {
421 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
422 |                     "struct": {
423 |                       "x": {
424 |                         "type": "f32",
425 |                         "value": 0.0,
426 |                       },
427 |                       "y": {
428 |                         "type": "f32",
429 |                         "value": 1.0,
430 |                       },
431 |                       "z": {
432 |                         "type": "f32",
433 |                         "value": 0.0,
434 |                       },
435 |                     },
436 |                   },
437 |                   "z_axis": {
438 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
439 |                     "struct": {
440 |                       "x": {
441 |                         "type": "f32",
442 |                         "value": 0.0,
443 |                       },
444 |                       "y": {
445 |                         "type": "f32",
446 |                         "value": 0.0,
447 |                       },
448 |                       "z": {
449 |                         "type": "f32",
450 |                         "value": 1.0,
451 |                       },
452 |                     },
453 |                   },
454 |                 },
455 |               },
456 |               "translation": {
457 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
458 |                 "struct": {
459 |                   "x": {
460 |                     "type": "f32",
461 |                     "value": 0.0,
462 |                   },
463 |                   "y": {
464 |                     "type": "f32",
465 |                     "value": 0.0,
466 |                   },
467 |                   "z": {
468 |                     "type": "f32",
469 |                     "value": 0.0,
470 |                   },
471 |                 },
472 |               },
473 |             },
474 |           },
475 |         ],
476 |       },
477 |       {
478 |         "type": "bevy_hierarchy::components::children::Children",
479 |         "tuple_struct": [
480 |           {
481 |             "type": "smallvec::SmallVec<[bevy_ecs::entity::Entity; 8]>",
482 |             "list": [
483 |               {
484 |                 "type": "bevy_ecs::entity::Entity",
485 |                 "value": 0,
486 |               },
487 |               {
488 |                 "type": "bevy_ecs::entity::Entity",
489 |                 "value": 1,
490 |               },
491 |             ],
492 |           },
493 |         ],
494 |       },
495 |     ],
496 |   ),
497 | ]
498 | 
499 | [
500 |   (
501 |     entity: 0,
502 |     components: [
503 |       {
504 |         "type": "bevy_asset::handle::Handle<bevy_render::mesh::mesh::Mesh>",
505 |         "struct": {
506 |           "id": {
507 |             "type": "bevy_asset::handle::HandleId",
508 |             "value": Id("8ecbac0f-f545-4473-ad43-e1f4243af51e", 42069),
509 |           },
510 |         },
511 |       },
512 |     ],
513 |   ),
514 | ]


--------------------------------------------------------------------------------
/scene.scn.ron:
--------------------------------------------------------------------------------
   1 | [
   2 |   (
   3 |     entity: 5,
   4 |     components: [
   5 |       {
   6 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
   7 |         "tuple_struct": [
   8 |           {
   9 |             "type": "glam::f32::affine3a::Affine3A",
  10 |             "struct": {
  11 |               "matrix3": {
  12 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
  13 |                 "struct": {
  14 |                   "x_axis": {
  15 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
  16 |                     "struct": {
  17 |                       "x": {
  18 |                         "type": "f32",
  19 |                         "value": 0.7071068,
  20 |                       },
  21 |                       "y": {
  22 |                         "type": "f32",
  23 |                         "value": 0.0,
  24 |                       },
  25 |                       "z": {
  26 |                         "type": "f32",
  27 |                         "value": -0.70710677,
  28 |                       },
  29 |                     },
  30 |                   },
  31 |                   "y_axis": {
  32 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
  33 |                     "struct": {
  34 |                       "x": {
  35 |                         "type": "f32",
  36 |                         "value": -0.40824828,
  37 |                       },
  38 |                       "y": {
  39 |                         "type": "f32",
  40 |                         "value": 0.8164966,
  41 |                       },
  42 |                       "z": {
  43 |                         "type": "f32",
  44 |                         "value": -0.40824825,
  45 |                       },
  46 |                     },
  47 |                   },
  48 |                   "z_axis": {
  49 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
  50 |                     "struct": {
  51 |                       "x": {
  52 |                         "type": "f32",
  53 |                         "value": 0.5773503,
  54 |                       },
  55 |                       "y": {
  56 |                         "type": "f32",
  57 |                         "value": 0.57735026,
  58 |                       },
  59 |                       "z": {
  60 |                         "type": "f32",
  61 |                         "value": 0.57735026,
  62 |                       },
  63 |                     },
  64 |                   },
  65 |                 },
  66 |               },
  67 |               "translation": {
  68 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
  69 |                 "struct": {
  70 |                   "x": {
  71 |                     "type": "f32",
  72 |                     "value": 5.0,
  73 |                   },
  74 |                   "y": {
  75 |                     "type": "f32",
  76 |                     "value": 5.0,
  77 |                   },
  78 |                   "z": {
  79 |                     "type": "f32",
  80 |                     "value": 5.0,
  81 |                   },
  82 |                 },
  83 |               },
  84 |             },
  85 |           },
  86 |         ],
  87 |       },
  88 |       {
  89 |         "type": "bevy_render::view::visibility::Visibility",
  90 |         "struct": {
  91 |           "is_visible": {
  92 |             "type": "bool",
  93 |             "value": true,
  94 |           },
  95 |         },
  96 |       },
  97 |       {
  98 |         "type": "bevy_render::view::visibility::ComputedVisibility",
  99 |         "struct": {
 100 |           "is_visible_in_hierarchy": {
 101 |             "type": "bool",
 102 |             "value": true,
 103 |           },
 104 |           "is_visible_in_view": {
 105 |             "type": "bool",
 106 |             "value": true,
 107 |           },
 108 |         },
 109 |       },
 110 |       {
 111 |         "type": "bevy_transform::components::transform::Transform",
 112 |         "struct": {
 113 |           "translation": {
 114 |             "type": "glam::f32::vec3::Vec3",
 115 |             "struct": {
 116 |               "x": {
 117 |                 "type": "f32",
 118 |                 "value": 5.0,
 119 |               },
 120 |               "y": {
 121 |                 "type": "f32",
 122 |                 "value": 5.0,
 123 |               },
 124 |               "z": {
 125 |                 "type": "f32",
 126 |                 "value": 5.0,
 127 |               },
 128 |             },
 129 |           },
 130 |           "rotation": {
 131 |             "type": "glam::f32::sse2::quat::Quat",
 132 |             "value": (-0.27984813, 0.3647052, 0.11591689, 0.88047624),
 133 |           },
 134 |           "scale": {
 135 |             "type": "glam::f32::vec3::Vec3",
 136 |             "struct": {
 137 |               "x": {
 138 |                 "type": "f32",
 139 |                 "value": 1.0,
 140 |               },
 141 |               "y": {
 142 |                 "type": "f32",
 143 |                 "value": 1.0,
 144 |               },
 145 |               "z": {
 146 |                 "type": "f32",
 147 |                 "value": 1.0,
 148 |               },
 149 |             },
 150 |           },
 151 |         },
 152 |       },
 153 |       {
 154 |         "type": "bevy_render::view::visibility::VisibleEntities",
 155 |         "struct": {},
 156 |       },
 157 |       {
 158 |         "type": "bevy_render::primitives::Frustum",
 159 |         "struct": {},
 160 |       },
 161 |       {
 162 |         "type": "bevy_pbr::light::SpotLight",
 163 |         "struct": {
 164 |           "color": {
 165 |             "type": "bevy_render::color::Color",
 166 |             "value": Rgba(
 167 |               red: 1.0,
 168 |               green: 1.0,
 169 |               blue: 1.0,
 170 |               alpha: 1.0,
 171 |             ),
 172 |           },
 173 |           "intensity": {
 174 |             "type": "f32",
 175 |             "value": 800.0,
 176 |           },
 177 |           "range": {
 178 |             "type": "f32",
 179 |             "value": 20.0,
 180 |           },
 181 |           "radius": {
 182 |             "type": "f32",
 183 |             "value": 0.0,
 184 |           },
 185 |           "shadows_enabled": {
 186 |             "type": "bool",
 187 |             "value": false,
 188 |           },
 189 |           "shadow_depth_bias": {
 190 |             "type": "f32",
 191 |             "value": 0.02,
 192 |           },
 193 |           "shadow_normal_bias": {
 194 |             "type": "f32",
 195 |             "value": 0.6,
 196 |           },
 197 |           "outer_angle": {
 198 |             "type": "f32",
 199 |             "value": 0.7853982,
 200 |           },
 201 |           "inner_angle": {
 202 |             "type": "f32",
 203 |             "value": 0.0,
 204 |           },
 205 |         },
 206 |       },
 207 |     ],
 208 |   ),
 209 |   (
 210 |     entity: 6,
 211 |     components: [
 212 |       {
 213 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 214 |         "tuple_struct": [
 215 |           {
 216 |             "type": "glam::f32::affine3a::Affine3A",
 217 |             "struct": {
 218 |               "matrix3": {
 219 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 220 |                 "struct": {
 221 |                   "x_axis": {
 222 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 223 |                     "struct": {
 224 |                       "x": {
 225 |                         "type": "f32",
 226 |                         "value": 1.0,
 227 |                       },
 228 |                       "y": {
 229 |                         "type": "f32",
 230 |                         "value": 0.0,
 231 |                       },
 232 |                       "z": {
 233 |                         "type": "f32",
 234 |                         "value": 0.0,
 235 |                       },
 236 |                     },
 237 |                   },
 238 |                   "y_axis": {
 239 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 240 |                     "struct": {
 241 |                       "x": {
 242 |                         "type": "f32",
 243 |                         "value": 0.0,
 244 |                       },
 245 |                       "y": {
 246 |                         "type": "f32",
 247 |                         "value": 1.0,
 248 |                       },
 249 |                       "z": {
 250 |                         "type": "f32",
 251 |                         "value": 0.0,
 252 |                       },
 253 |                     },
 254 |                   },
 255 |                   "z_axis": {
 256 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 257 |                     "struct": {
 258 |                       "x": {
 259 |                         "type": "f32",
 260 |                         "value": 0.0,
 261 |                       },
 262 |                       "y": {
 263 |                         "type": "f32",
 264 |                         "value": 0.0,
 265 |                       },
 266 |                       "z": {
 267 |                         "type": "f32",
 268 |                         "value": 1.0,
 269 |                       },
 270 |                     },
 271 |                   },
 272 |                 },
 273 |               },
 274 |               "translation": {
 275 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
 276 |                 "struct": {
 277 |                   "x": {
 278 |                     "type": "f32",
 279 |                     "value": 0.0,
 280 |                   },
 281 |                   "y": {
 282 |                     "type": "f32",
 283 |                     "value": 0.0,
 284 |                   },
 285 |                   "z": {
 286 |                     "type": "f32",
 287 |                     "value": 0.0,
 288 |                   },
 289 |                 },
 290 |               },
 291 |             },
 292 |           },
 293 |         ],
 294 |       },
 295 |       {
 296 |         "type": "bevy_render::view::visibility::Visibility",
 297 |         "struct": {
 298 |           "is_visible": {
 299 |             "type": "bool",
 300 |             "value": true,
 301 |           },
 302 |         },
 303 |       },
 304 |       {
 305 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 306 |         "struct": {
 307 |           "is_visible_in_hierarchy": {
 308 |             "type": "bool",
 309 |             "value": true,
 310 |           },
 311 |           "is_visible_in_view": {
 312 |             "type": "bool",
 313 |             "value": true,
 314 |           },
 315 |         },
 316 |       },
 317 |       {
 318 |         "type": "bevy_transform::components::transform::Transform",
 319 |         "struct": {
 320 |           "translation": {
 321 |             "type": "glam::f32::vec3::Vec3",
 322 |             "struct": {
 323 |               "x": {
 324 |                 "type": "f32",
 325 |                 "value": 0.0,
 326 |               },
 327 |               "y": {
 328 |                 "type": "f32",
 329 |                 "value": 0.0,
 330 |               },
 331 |               "z": {
 332 |                 "type": "f32",
 333 |                 "value": 0.0,
 334 |               },
 335 |             },
 336 |           },
 337 |           "rotation": {
 338 |             "type": "glam::f32::sse2::quat::Quat",
 339 |             "value": (0.0, 0.0, 0.0, 1.0),
 340 |           },
 341 |           "scale": {
 342 |             "type": "glam::f32::vec3::Vec3",
 343 |             "struct": {
 344 |               "x": {
 345 |                 "type": "f32",
 346 |                 "value": 1.0,
 347 |               },
 348 |               "y": {
 349 |                 "type": "f32",
 350 |                 "value": 1.0,
 351 |               },
 352 |               "z": {
 353 |                 "type": "f32",
 354 |                 "value": 1.0,
 355 |               },
 356 |             },
 357 |           },
 358 |         },
 359 |       },
 360 |       {
 361 |         "type": "bevy_asset::handle::Handle<bevy_scene::dynamic_scene::DynamicScene>",
 362 |         "struct": {
 363 |           "id": {
 364 |             "type": "bevy_asset::handle::HandleId",
 365 |             "value": AssetPathId(((5248169831536229617), (6298619649789039366))),
 366 |           },
 367 |         },
 368 |       },
 369 |       {
 370 |         "type": "bevy_hierarchy::components::children::Children",
 371 |         "tuple_struct": [
 372 |           {
 373 |             "type": "smallvec::SmallVec<[bevy_ecs::entity::Entity; 8]>",
 374 |             "list": [
 375 |               {
 376 |                 "type": "bevy_ecs::entity::Entity",
 377 |                 "value": 7,
 378 |               },
 379 |               {
 380 |                 "type": "bevy_ecs::entity::Entity",
 381 |                 "value": 8,
 382 |               },
 383 |             ],
 384 |           },
 385 |         ],
 386 |       },
 387 |     ],
 388 |   ),
 389 |   (
 390 |     entity: 4,
 391 |     components: [
 392 |       {
 393 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 394 |         "tuple_struct": [
 395 |           {
 396 |             "type": "glam::f32::affine3a::Affine3A",
 397 |             "struct": {
 398 |               "matrix3": {
 399 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 400 |                 "struct": {
 401 |                   "x_axis": {
 402 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 403 |                     "struct": {
 404 |                       "x": {
 405 |                         "type": "f32",
 406 |                         "value": 1.0,
 407 |                       },
 408 |                       "y": {
 409 |                         "type": "f32",
 410 |                         "value": 0.0,
 411 |                       },
 412 |                       "z": {
 413 |                         "type": "f32",
 414 |                         "value": 0.0,
 415 |                       },
 416 |                     },
 417 |                   },
 418 |                   "y_axis": {
 419 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 420 |                     "struct": {
 421 |                       "x": {
 422 |                         "type": "f32",
 423 |                         "value": 0.0,
 424 |                       },
 425 |                       "y": {
 426 |                         "type": "f32",
 427 |                         "value": 1.0,
 428 |                       },
 429 |                       "z": {
 430 |                         "type": "f32",
 431 |                         "value": 0.0,
 432 |                       },
 433 |                     },
 434 |                   },
 435 |                   "z_axis": {
 436 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 437 |                     "struct": {
 438 |                       "x": {
 439 |                         "type": "f32",
 440 |                         "value": 0.0,
 441 |                       },
 442 |                       "y": {
 443 |                         "type": "f32",
 444 |                         "value": 0.0,
 445 |                       },
 446 |                       "z": {
 447 |                         "type": "f32",
 448 |                         "value": 1.0,
 449 |                       },
 450 |                     },
 451 |                   },
 452 |                 },
 453 |               },
 454 |               "translation": {
 455 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
 456 |                 "struct": {
 457 |                   "x": {
 458 |                     "type": "f32",
 459 |                     "value": 0.0,
 460 |                   },
 461 |                   "y": {
 462 |                     "type": "f32",
 463 |                     "value": 0.0,
 464 |                   },
 465 |                   "z": {
 466 |                     "type": "f32",
 467 |                     "value": 0.0,
 468 |                   },
 469 |                 },
 470 |               },
 471 |             },
 472 |           },
 473 |         ],
 474 |       },
 475 |       {
 476 |         "type": "bevy_render::view::visibility::Visibility",
 477 |         "struct": {
 478 |           "is_visible": {
 479 |             "type": "bool",
 480 |             "value": true,
 481 |           },
 482 |         },
 483 |       },
 484 |       {
 485 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 486 |         "struct": {
 487 |           "is_visible_in_hierarchy": {
 488 |             "type": "bool",
 489 |             "value": true,
 490 |           },
 491 |           "is_visible_in_view": {
 492 |             "type": "bool",
 493 |             "value": true,
 494 |           },
 495 |         },
 496 |       },
 497 |       {
 498 |         "type": "bevy_render::primitives::Aabb",
 499 |         "struct": {
 500 |           "center": {
 501 |             "type": "glam::f32::sse2::vec3a::Vec3A",
 502 |             "struct": {
 503 |               "x": {
 504 |                 "type": "f32",
 505 |                 "value": 0.0,
 506 |               },
 507 |               "y": {
 508 |                 "type": "f32",
 509 |                 "value": 0.0,
 510 |               },
 511 |               "z": {
 512 |                 "type": "f32",
 513 |                 "value": 0.0,
 514 |               },
 515 |             },
 516 |           },
 517 |           "half_extents": {
 518 |             "type": "glam::f32::sse2::vec3a::Vec3A",
 519 |             "struct": {
 520 |               "x": {
 521 |                 "type": "f32",
 522 |                 "value": 0.5,
 523 |               },
 524 |               "y": {
 525 |                 "type": "f32",
 526 |                 "value": 0.5,
 527 |               },
 528 |               "z": {
 529 |                 "type": "f32",
 530 |                 "value": 0.5,
 531 |               },
 532 |             },
 533 |           },
 534 |         },
 535 |       },
 536 |       {
 537 |         "type": "bevy_asset::handle::Handle<bevy_render::mesh::mesh::Mesh>",
 538 |         "struct": {
 539 |           "id": {
 540 |             "type": "bevy_asset::handle::HandleId",
 541 |             "value": Id("8ecbac0f-f545-4473-ad43-e1f4243af51e", 3260597288407341397),
 542 |           },
 543 |         },
 544 |       },
 545 |       {
 546 |         "type": "bevy_transform::components::transform::Transform",
 547 |         "struct": {
 548 |           "translation": {
 549 |             "type": "glam::f32::vec3::Vec3",
 550 |             "struct": {
 551 |               "x": {
 552 |                 "type": "f32",
 553 |                 "value": 0.0,
 554 |               },
 555 |               "y": {
 556 |                 "type": "f32",
 557 |                 "value": 0.0,
 558 |               },
 559 |               "z": {
 560 |                 "type": "f32",
 561 |                 "value": 0.0,
 562 |               },
 563 |             },
 564 |           },
 565 |           "rotation": {
 566 |             "type": "glam::f32::sse2::quat::Quat",
 567 |             "value": (0.0, 0.0, 0.0, 1.0),
 568 |           },
 569 |           "scale": {
 570 |             "type": "glam::f32::vec3::Vec3",
 571 |             "struct": {
 572 |               "x": {
 573 |                 "type": "f32",
 574 |                 "value": 1.0,
 575 |               },
 576 |               "y": {
 577 |                 "type": "f32",
 578 |                 "value": 1.0,
 579 |               },
 580 |               "z": {
 581 |                 "type": "f32",
 582 |                 "value": 1.0,
 583 |               },
 584 |             },
 585 |           },
 586 |         },
 587 |       },
 588 |       {
 589 |         "type": "bevy_asset::handle::Handle<bevy_pbr::pbr_material::StandardMaterial>",
 590 |         "struct": {
 591 |           "id": {
 592 |             "type": "bevy_asset::handle::HandleId",
 593 |             "value": Id("7494888b-c082-457b-aacf-517228cc0c22", 278277310944224104),
 594 |           },
 595 |         },
 596 |       },
 597 |     ],
 598 |   ),
 599 |   (
 600 |     entity: 7,
 601 |     components: [
 602 |       {
 603 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 604 |         "tuple_struct": [
 605 |           {
 606 |             "type": "glam::f32::affine3a::Affine3A",
 607 |             "struct": {
 608 |               "matrix3": {
 609 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 610 |                 "struct": {
 611 |                   "x_axis": {
 612 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 613 |                     "struct": {
 614 |                       "x": {
 615 |                         "type": "f32",
 616 |                         "value": 1.0,
 617 |                       },
 618 |                       "y": {
 619 |                         "type": "f32",
 620 |                         "value": 0.0,
 621 |                       },
 622 |                       "z": {
 623 |                         "type": "f32",
 624 |                         "value": 0.0,
 625 |                       },
 626 |                     },
 627 |                   },
 628 |                   "y_axis": {
 629 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 630 |                     "struct": {
 631 |                       "x": {
 632 |                         "type": "f32",
 633 |                         "value": 0.0,
 634 |                       },
 635 |                       "y": {
 636 |                         "type": "f32",
 637 |                         "value": 1.0,
 638 |                       },
 639 |                       "z": {
 640 |                         "type": "f32",
 641 |                         "value": 0.0,
 642 |                       },
 643 |                     },
 644 |                   },
 645 |                   "z_axis": {
 646 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 647 |                     "struct": {
 648 |                       "x": {
 649 |                         "type": "f32",
 650 |                         "value": 0.0,
 651 |                       },
 652 |                       "y": {
 653 |                         "type": "f32",
 654 |                         "value": 0.0,
 655 |                       },
 656 |                       "z": {
 657 |                         "type": "f32",
 658 |                         "value": 1.0,
 659 |                       },
 660 |                     },
 661 |                   },
 662 |                 },
 663 |               },
 664 |               "translation": {
 665 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
 666 |                 "struct": {
 667 |                   "x": {
 668 |                     "type": "f32",
 669 |                     "value": 1.8,
 670 |                   },
 671 |                   "y": {
 672 |                     "type": "f32",
 673 |                     "value": -1.5,
 674 |                   },
 675 |                   "z": {
 676 |                     "type": "f32",
 677 |                     "value": -1.5,
 678 |                   },
 679 |                 },
 680 |               },
 681 |             },
 682 |           },
 683 |         ],
 684 |       },
 685 |       {
 686 |         "type": "bevy_render::view::visibility::Visibility",
 687 |         "struct": {
 688 |           "is_visible": {
 689 |             "type": "bool",
 690 |             "value": true,
 691 |           },
 692 |         },
 693 |       },
 694 |       {
 695 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 696 |         "struct": {
 697 |           "is_visible_in_hierarchy": {
 698 |             "type": "bool",
 699 |             "value": true,
 700 |           },
 701 |           "is_visible_in_view": {
 702 |             "type": "bool",
 703 |             "value": true,
 704 |           },
 705 |         },
 706 |       },
 707 |       {
 708 |         "type": "bevy_render::primitives::Aabb",
 709 |         "struct": {
 710 |           "center": {
 711 |             "type": "glam::f32::sse2::vec3a::Vec3A",
 712 |             "struct": {
 713 |               "x": {
 714 |                 "type": "f32",
 715 |                 "value": 0.0,
 716 |               },
 717 |               "y": {
 718 |                 "type": "f32",
 719 |                 "value": 0.0,
 720 |               },
 721 |               "z": {
 722 |                 "type": "f32",
 723 |                 "value": 0.0,
 724 |               },
 725 |             },
 726 |           },
 727 |           "half_extents": {
 728 |             "type": "glam::f32::sse2::vec3a::Vec3A",
 729 |             "struct": {
 730 |               "x": {
 731 |                 "type": "f32",
 732 |                 "value": 1.0,
 733 |               },
 734 |               "y": {
 735 |                 "type": "f32",
 736 |                 "value": 1.0,
 737 |               },
 738 |               "z": {
 739 |                 "type": "f32",
 740 |                 "value": 1.0,
 741 |               },
 742 |             },
 743 |           },
 744 |         },
 745 |       },
 746 |       {
 747 |         "type": "bevy_asset::handle::Handle<bevy_render::mesh::mesh::Mesh>",
 748 |         "struct": {
 749 |           "id": {
 750 |             "type": "bevy_asset::handle::HandleId",
 751 |             "value": AssetPathId(((5156382302095500819), (10580036919940196184))),
 752 |           },
 753 |         },
 754 |       },
 755 |       {
 756 |         "type": "bevy_transform::components::transform::Transform",
 757 |         "struct": {
 758 |           "translation": {
 759 |             "type": "glam::f32::vec3::Vec3",
 760 |             "struct": {
 761 |               "x": {
 762 |                 "type": "f32",
 763 |                 "value": 1.8,
 764 |               },
 765 |               "y": {
 766 |                 "type": "f32",
 767 |                 "value": -1.5,
 768 |               },
 769 |               "z": {
 770 |                 "type": "f32",
 771 |                 "value": -1.5,
 772 |               },
 773 |             },
 774 |           },
 775 |           "rotation": {
 776 |             "type": "glam::f32::sse2::quat::Quat",
 777 |             "value": (0.0, 0.0, 0.0, 1.0),
 778 |           },
 779 |           "scale": {
 780 |             "type": "glam::f32::vec3::Vec3",
 781 |             "struct": {
 782 |               "x": {
 783 |                 "type": "f32",
 784 |                 "value": 1.0,
 785 |               },
 786 |               "y": {
 787 |                 "type": "f32",
 788 |                 "value": 1.0,
 789 |               },
 790 |               "z": {
 791 |                 "type": "f32",
 792 |                 "value": 1.0,
 793 |               },
 794 |             },
 795 |           },
 796 |         },
 797 |       },
 798 |       {
 799 |         "type": "bevy_asset::handle::Handle<bevy_pbr::pbr_material::StandardMaterial>",
 800 |         "struct": {
 801 |           "id": {
 802 |             "type": "bevy_asset::handle::HandleId",
 803 |             "value": Id("7494888b-c082-457b-aacf-517228cc0c22", 0),
 804 |           },
 805 |         },
 806 |       },
 807 |       {
 808 |         "type": "bevy_hierarchy::components::parent::Parent",
 809 |         "tuple_struct": [
 810 |           {
 811 |             "type": "bevy_ecs::entity::Entity",
 812 |             "value": 6,
 813 |           },
 814 |         ],
 815 |       },
 816 |     ],
 817 |   ),
 818 |   (
 819 |     entity: 8,
 820 |     components: [
 821 |       {
 822 |         "type": "bevy_transform::components::global_transform::GlobalTransform",
 823 |         "tuple_struct": [
 824 |           {
 825 |             "type": "glam::f32::affine3a::Affine3A",
 826 |             "struct": {
 827 |               "matrix3": {
 828 |                 "type": "glam::f32::sse2::mat3a::Mat3A",
 829 |                 "struct": {
 830 |                   "x_axis": {
 831 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 832 |                     "struct": {
 833 |                       "x": {
 834 |                         "type": "f32",
 835 |                         "value": 1.0,
 836 |                       },
 837 |                       "y": {
 838 |                         "type": "f32",
 839 |                         "value": 0.0,
 840 |                       },
 841 |                       "z": {
 842 |                         "type": "f32",
 843 |                         "value": 0.0,
 844 |                       },
 845 |                     },
 846 |                   },
 847 |                   "y_axis": {
 848 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 849 |                     "struct": {
 850 |                       "x": {
 851 |                         "type": "f32",
 852 |                         "value": 0.0,
 853 |                       },
 854 |                       "y": {
 855 |                         "type": "f32",
 856 |                         "value": 1.0,
 857 |                       },
 858 |                       "z": {
 859 |                         "type": "f32",
 860 |                         "value": 0.0,
 861 |                       },
 862 |                     },
 863 |                   },
 864 |                   "z_axis": {
 865 |                     "type": "glam::f32::sse2::vec3a::Vec3A",
 866 |                     "struct": {
 867 |                       "x": {
 868 |                         "type": "f32",
 869 |                         "value": 0.0,
 870 |                       },
 871 |                       "y": {
 872 |                         "type": "f32",
 873 |                         "value": 0.0,
 874 |                       },
 875 |                       "z": {
 876 |                         "type": "f32",
 877 |                         "value": 1.0,
 878 |                       },
 879 |                     },
 880 |                   },
 881 |                 },
 882 |               },
 883 |               "translation": {
 884 |                 "type": "glam::f32::sse2::vec3a::Vec3A",
 885 |                 "struct": {
 886 |                   "x": {
 887 |                     "type": "f32",
 888 |                     "value": 0.0,
 889 |                   },
 890 |                   "y": {
 891 |                     "type": "f32",
 892 |                     "value": 1.8,
 893 |                   },
 894 |                   "z": {
 895 |                     "type": "f32",
 896 |                     "value": -2.6,
 897 |                   },
 898 |                 },
 899 |               },
 900 |             },
 901 |           },
 902 |         ],
 903 |       },
 904 |       {
 905 |         "type": "bevy_render::view::visibility::Visibility",
 906 |         "struct": {
 907 |           "is_visible": {
 908 |             "type": "bool",
 909 |             "value": true,
 910 |           },
 911 |         },
 912 |       },
 913 |       {
 914 |         "type": "bevy_render::view::visibility::ComputedVisibility",
 915 |         "struct": {
 916 |           "is_visible_in_hierarchy": {
 917 |             "type": "bool",
 918 |             "value": true,
 919 |           },
 920 |           "is_visible_in_view": {
 921 |             "type": "bool",
 922 |             "value": true,
 923 |           },
 924 |         },
 925 |       },
 926 |       {
 927 |         "type": "bevy_render::primitives::Aabb",
 928 |         "struct": {
 929 |           "center": {
 930 |             "type": "glam::f32::sse2::vec3a::Vec3A",
 931 |             "struct": {
 932 |               "x": {
 933 |                 "type": "f32",
 934 |                 "value": 0.0,
 935 |               },
 936 |               "y": {
 937 |                 "type": "f32",
 938 |                 "value": 0.0,
 939 |               },
 940 |               "z": {
 941 |                 "type": "f32",
 942 |                 "value": 0.0,
 943 |               },
 944 |             },
 945 |           },
 946 |           "half_extents": {
 947 |             "type": "glam::f32::sse2::vec3a::Vec3A",
 948 |             "struct": {
 949 |               "x": {
 950 |                 "type": "f32",
 951 |                 "value": 1.0,
 952 |               },
 953 |               "y": {
 954 |                 "type": "f32",
 955 |                 "value": 1.0,
 956 |               },
 957 |               "z": {
 958 |                 "type": "f32",
 959 |                 "value": 1.0,
 960 |               },
 961 |             },
 962 |           },
 963 |         },
 964 |       },
 965 |       {
 966 |         "type": "bevy_asset::handle::Handle<bevy_render::mesh::mesh::Mesh>",
 967 |         "struct": {
 968 |           "id": {
 969 |             "type": "bevy_asset::handle::HandleId",
 970 |             "value": AssetPathId(((5156382302095500819), (10580036919940196184))),
 971 |           },
 972 |         },
 973 |       },
 974 |       {
 975 |         "type": "bevy_transform::components::transform::Transform",
 976 |         "struct": {
 977 |           "translation": {
 978 |             "type": "glam::f32::vec3::Vec3",
 979 |             "struct": {
 980 |               "x": {
 981 |                 "type": "f32",
 982 |                 "value": 0.0,
 983 |               },
 984 |               "y": {
 985 |                 "type": "f32",
 986 |                 "value": 1.8,
 987 |               },
 988 |               "z": {
 989 |                 "type": "f32",
 990 |                 "value": -2.6,
 991 |               },
 992 |             },
 993 |           },
 994 |           "rotation": {
 995 |             "type": "glam::f32::sse2::quat::Quat",
 996 |             "value": (0.0, 0.0, 0.0, 1.0),
 997 |           },
 998 |           "scale": {
 999 |             "type": "glam::f32::vec3::Vec3",
1000 |             "struct": {
1001 |               "x": {
1002 |                 "type": "f32",
1003 |                 "value": 1.0,
1004 |               },
1005 |               "y": {
1006 |                 "type": "f32",
1007 |                 "value": 1.0,
1008 |               },
1009 |               "z": {
1010 |                 "type": "f32",
1011 |                 "value": 1.0,
1012 |               },
1013 |             },
1014 |           },
1015 |         },
1016 |       },
1017 |       {
1018 |         "type": "bevy_asset::handle::Handle<bevy_pbr::pbr_material::StandardMaterial>",
1019 |         "struct": {
1020 |           "id": {
1021 |             "type": "bevy_asset::handle::HandleId",
1022 |             "value": Id("7494888b-c082-457b-aacf-517228cc0c22", 0),
1023 |           },
1024 |         },
1025 |       },
1026 |       {
1027 |         "type": "bevy_hierarchy::components::parent::Parent",
1028 |         "tuple_struct": [
1029 |           {
1030 |             "type": "bevy_ecs::entity::Entity",
1031 |             "value": 6,
1032 |           },
1033 |         ],
1034 |       },
1035 |     ],
1036 |   ),
1037 |   (
1038 |     entity: 9,
1039 |     components: [],
1040 |   ),
1041 |   (
1042 |     entity: 10,
1043 |     components: [],
1044 |   ),
1045 | ]


--------------------------------------------------------------------------------