├── assets
    ├── cells.wgsl
    ├── compute.wgsl
    └── shader.wgsl
├── .gitignore
├── Cargo.toml
├── LICENSE
└── src
    ├── rtmaterial.rs
    ├── main.rs
    ├── fly_cam.rs
    ├── ca_compute.rs
    ├── rule.rs
    └── gui.rs


/assets/cells.wgsl:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | */target
3 | Cargo.lock
4 | */Cargo.lock


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "cas"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 7 | 
 8 | [dependencies]
 9 | bevy = "0.9"
10 | bytemuck = { version = "1.13.0", features = ["derive"] }
11 | bevy_egui = "0.19"


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Isidor Nielsen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/rtmaterial.rs:
--------------------------------------------------------------------------------
  1 | use std::num::NonZeroU64;
  2 | 
  3 | use bevy::{pbr::MaterialPipeline, prelude::*, reflect::TypeUuid, render::render_resource::*};
  4 | 
  5 | use crate::rule::{GPURule, Rule};
  6 | 
  7 | #[derive(Debug, Clone, TypeUuid)]
  8 | #[uuid = "1ae9c363-1234-4213-890e-192d81b00281"]
  9 | pub struct RTVolumeMaterial {
 10 |     pub volume: Option<Handle<Image>>,
 11 |     pub rule: Rule,
 12 | }
 13 | 
 14 | impl AsBindGroup for RTVolumeMaterial {
 15 |     type Data = ();
 16 | 
 17 |     fn as_bind_group(
 18 |         &self,
 19 |         layout: &BindGroupLayout,
 20 |         render_device: &bevy::render::renderer::RenderDevice,
 21 |         images: &bevy::render::render_asset::RenderAssets<Image>,
 22 |         _fallback_image: &bevy::render::texture::FallbackImage,
 23 |     ) -> Result<PreparedBindGroup<Self>, AsBindGroupError> {
 24 |         let volume = self
 25 |             .volume
 26 |             .as_ref()
 27 |             .ok_or(AsBindGroupError::RetryNextUpdate)?;
 28 |         let image = images
 29 |             .get(volume)
 30 |             .ok_or(AsBindGroupError::RetryNextUpdate)?;
 31 | 
 32 |         let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
 33 |             label: Some("rule_buffer"),
 34 |             contents: bytemuck::bytes_of(&GPURule::from(&self.rule)),
 35 |             usage: BufferUsages::UNIFORM,
 36 |         });
 37 | 
 38 |         let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
 39 |             label: None,
 40 |             layout,
 41 |             entries: &[
 42 |                 BindGroupEntry {
 43 |                     binding: 0,
 44 |                     resource: BindingResource::TextureView(&image.texture_view),
 45 |                 },
 46 |                 BindGroupEntry {
 47 |                     binding: 1,
 48 |                     resource: buffer.as_entire_binding(),
 49 |                 },
 50 |             ],
 51 |         });
 52 | 
 53 |         Ok(PreparedBindGroup {
 54 |             bindings: vec![OwnedBindingResource::Buffer(buffer)],
 55 |             bind_group,
 56 |             data: (),
 57 |         })
 58 |     }
 59 | 
 60 |     fn bind_group_layout(render_device: &bevy::render::renderer::RenderDevice) -> BindGroupLayout {
 61 |         render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
 62 |             label: None,
 63 |             entries: &[
 64 |                 BindGroupLayoutEntry {
 65 |                     binding: 0,
 66 |                     visibility: ShaderStages::FRAGMENT | ShaderStages::COMPUTE,
 67 |                     ty: BindingType::StorageTexture {
 68 |                         access: StorageTextureAccess::ReadWrite,
 69 |                         format: TextureFormat::R8Uint,
 70 |                         view_dimension: TextureViewDimension::D3,
 71 |                     },
 72 |                     count: None,
 73 |                 },
 74 |                 BindGroupLayoutEntry {
 75 |                     binding: 1,
 76 |                     visibility: ShaderStages::FRAGMENT | ShaderStages::COMPUTE,
 77 |                     ty: BindingType::Buffer {
 78 |                         ty: BufferBindingType::Uniform,
 79 |                         has_dynamic_offset: false,
 80 |                         min_binding_size: Some(NonZeroU64::new(64).unwrap()),
 81 |                     },
 82 |                     count: None,
 83 |                 },
 84 |             ],
 85 |         })
 86 |     }
 87 | }
 88 | 
 89 | impl Material for RTVolumeMaterial {
 90 |     fn vertex_shader() -> ShaderRef {
 91 |         "shader.wgsl".into()
 92 |     }
 93 | 
 94 |     fn fragment_shader() -> ShaderRef {
 95 |         "shader.wgsl".into()
 96 |     }
 97 | 
 98 |     fn specialize(
 99 |         _pipeline: &MaterialPipeline<Self>,
100 |         descriptor: &mut RenderPipelineDescriptor,
101 |         _layout: &bevy::render::mesh::MeshVertexBufferLayout,
102 |         _key: bevy::pbr::MaterialPipelineKey<Self>,
103 |     ) -> Result<(), SpecializedMeshPipelineError> {
104 |         descriptor.primitive.cull_mode = None;
105 |         Ok(())
106 |     }
107 | }
108 | 
109 | pub struct RTMatPlugin;
110 | 
111 | impl Plugin for RTMatPlugin {
112 |     fn build(&self, app: &mut App) {
113 |         app.add_plugin(MaterialPlugin::<RTVolumeMaterial>::default());
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | mod ca_compute;
  2 | mod fly_cam;
  3 | mod gui;
  4 | mod rtmaterial;
  5 | mod rule;
  6 | 
  7 | use bevy::{diagnostic::FrameTimeDiagnosticsPlugin, prelude::*, render::render_resource::*};
  8 | use ca_compute::{CAImage, CAPlugin};
  9 | use fly_cam::{MovementSettings, PlayerPlugin};
 10 | use gui::GuiPlugin;
 11 | use rtmaterial::{RTMatPlugin, RTVolumeMaterial};
 12 | use rule::{Rule, RulePlugin};
 13 | 
 14 | const WORKGROUP_SIZE: u32 = 9;
 15 | 
 16 | const START_SPEED: f32 = 0.1;
 17 | const START_SENSITIVITY: f32 = 0.0004;
 18 | 
 19 | fn main() {
 20 |     App::new()
 21 |         .add_startup_system(setup)
 22 |         .insert_resource(ClearColor(Color::BLACK))
 23 |         .add_plugins(
 24 |             DefaultPlugins
 25 |                 .set(WindowPlugin {
 26 |                     window: WindowDescriptor {
 27 |                         present_mode: bevy::window::PresentMode::Immediate,
 28 |                         title: "Cellular Automata".to_string(),
 29 |                         ..Default::default()
 30 |                     },
 31 |                     add_primary_window: true,
 32 |                     exit_on_all_closed: true,
 33 |                     close_when_requested: true,
 34 |                 })
 35 |                 .set(AssetPlugin {
 36 |                     watch_for_changes: true,
 37 |                     ..default()
 38 |                 }),
 39 |         )
 40 |         .add_plugin(FrameTimeDiagnosticsPlugin)
 41 |         .insert_resource(MovementSettings {
 42 |             sensitivity: START_SENSITIVITY,
 43 |             speed: START_SPEED,
 44 |         })
 45 |         .add_plugin(PlayerPlugin)
 46 |         .add_plugin(RulePlugin)
 47 |         .add_plugin(CAPlugin)
 48 |         .add_plugin(RTMatPlugin)
 49 |         .add_plugin(GuiPlugin)
 50 |         .add_system(update_size)
 51 |         .add_system(update_shape)
 52 |         .run();
 53 | }
 54 | 
 55 | #[derive(Resource)]
 56 | struct CurrentSize(u32);
 57 | 
 58 | #[derive(Resource)]
 59 | struct Meshes {
 60 |     meshes: Vec<(&'static str, Handle<Mesh>)>,
 61 |     current: usize,
 62 | }
 63 | 
 64 | fn setup(
 65 |     mut commands: Commands,
 66 |     mut images: ResMut<Assets<Image>>,
 67 |     mut materials: ResMut<Assets<RTVolumeMaterial>>,
 68 |     mut meshes: ResMut<Assets<Mesh>>,
 69 |     rule: Res<Rule>,
 70 | ) {
 71 |     let mut image = Image::new_fill(
 72 |         Extent3d {
 73 |             width: rule.size,
 74 |             height: rule.size,
 75 |             depth_or_array_layers: rule.size,
 76 |         },
 77 |         bevy::render::render_resource::TextureDimension::D3,
 78 |         &[0],
 79 |         TextureFormat::R8Uint,
 80 |     );
 81 |     image.texture_descriptor.usage =
 82 |         TextureUsages::STORAGE_BINDING | TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST;
 83 | 
 84 |     let meshes = Meshes {
 85 |         current: 0,
 86 |         meshes: vec![
 87 |             ("Box", meshes.add(Mesh::from(shape::Cube { size: 2.0 }))),
 88 |             (
 89 |                 "Sphere",
 90 |                 meshes.add(Mesh::from(shape::UVSphere {
 91 |                     radius: 1.0,
 92 |                     sectors: 50,
 93 |                     stacks: 50,
 94 |                 })),
 95 |             ),
 96 |             (
 97 |                 "Torus",
 98 |                 meshes.add(Mesh::from(shape::Torus {
 99 |                     radius: 0.8,
100 |                     ring_radius: 0.2,
101 |                     subdivisions_segments: 75,
102 |                     subdivisions_sides: 50,
103 |                 })),
104 |             ),
105 |         ],
106 |     };
107 |     let image = images.add(image);
108 |     commands.spawn(MaterialMeshBundle::<RTVolumeMaterial> {
109 |         mesh: meshes.meshes[meshes.current].1.clone(),
110 |         material: materials.add(RTVolumeMaterial {
111 |             volume: Some(image.clone()),
112 |             rule: rule.clone(),
113 |         }),
114 |         ..default()
115 |     });
116 | 
117 |     commands.insert_resource(meshes);
118 |     commands.insert_resource(CurrentSize(rule.size));
119 |     commands.insert_resource(CAImage(image));
120 | }
121 | 
122 | fn update_size(
123 |     image: Res<CAImage>,
124 |     mut images: ResMut<Assets<Image>>,
125 |     rule: Res<Rule>,
126 |     mut size: ResMut<CurrentSize>,
127 | ) {
128 |     if size.0 != rule.size {
129 |         size.0 = rule.size;
130 |         if let Some(image) = images.get_mut(&image.0) {
131 |             image.resize(Extent3d {
132 |                 width: rule.size,
133 |                 height: rule.size,
134 |                 depth_or_array_layers: rule.size,
135 |             });
136 |         }
137 |     }
138 | }
139 | 
140 | fn update_shape(meshes: Res<Meshes>, mut mesh: Query<&mut Handle<Mesh>>, mut last: Local<usize>) {
141 |     if *last != meshes.current {
142 |         for mut mesh in mesh.iter_mut() {
143 |             *mesh = meshes.meshes[meshes.current].1.clone();
144 |         }
145 |         *last = meshes.current;
146 |     }
147 | }
148 | 


--------------------------------------------------------------------------------
/assets/compute.wgsl:
--------------------------------------------------------------------------------
  1 | 
  2 | @group(0) @binding(0)
  3 | var r_cells: texture_storage_3d<r8uint, read_write>;
  4 | 
  5 | fn get_cell(pos: vec3<i32>, offset_x: i32, offset_y: i32, offset_z: i32) -> i32 {
  6 |     let value: vec4<u32> = textureLoad(r_cells, pos + vec3(offset_x, offset_y, offset_z));
  7 |     return i32(value.x);
  8 | }
  9 | 
 10 | struct Rule {
 11 |     size: u32,
 12 |     spawn_mode: u32,
 13 |     spawn_chance: f32,
 14 |     survival: u32,
 15 |     birth: u32,
 16 |     states: u32,
 17 |     neighbor_mode: u32,
 18 |     color_mode: u32,
 19 |     color0: vec4<f32>,
 20 |     color1: vec4<f32>,
 21 | };
 22 | 
 23 | @group(0) @binding(1)
 24 | var<uniform> r_rule: Rule;
 25 | 
 26 | fn is_alive(value: i32) -> i32 {
 27 |     return value / i32(r_rule.states);
 28 | }
 29 | 
 30 | fn should_survive(num_neighbours: i32) -> bool {
 31 |     return ((r_rule.survival >> u32(num_neighbours)) & u32(1)) != u32(0);
 32 | }
 33 | 
 34 | fn should_birth(num_neighbours: i32) -> bool {
 35 |     return ((r_rule.birth >> u32(num_neighbours)) & u32(1)) != u32(0);
 36 | }
 37 | 
 38 | fn count_alive(pos: vec3<i32>) -> i32 {
 39 |     switch i32(r_rule.neighbor_mode) {
 40 |         case 0: {
 41 |             return is_alive(get_cell(pos, -1, -1, -1)) + 
 42 |                    is_alive(get_cell(pos, -1, -1,  0)) + 
 43 |                    is_alive(get_cell(pos, -1, -1,  1)) + 
 44 |                    is_alive(get_cell(pos, -1,  0, -1)) + 
 45 |                    is_alive(get_cell(pos, -1,  0,  0)) + 
 46 |                    is_alive(get_cell(pos, -1,  0,  1)) + 
 47 |                    is_alive(get_cell(pos, -1,  1, -1)) + 
 48 |                    is_alive(get_cell(pos, -1,  1,  0)) + 
 49 |                    is_alive(get_cell(pos, -1,  1,  1)) + 
 50 |        
 51 |                    is_alive(get_cell(pos,  0, -1, -1)) + 
 52 |                    is_alive(get_cell(pos,  0, -1,  0)) + 
 53 |                    is_alive(get_cell(pos,  0, -1,  1)) + 
 54 |                    is_alive(get_cell(pos,  0,  0, -1)) + 
 55 |                    //is_alive(get_cell(pos,  0,  0,  0)) + Don't count yourself
 56 |                    is_alive(get_cell(pos,  0,  0,  1)) + 
 57 |                    is_alive(get_cell(pos,  0,  1, -1)) + 
 58 |                    is_alive(get_cell(pos,  0,  1,  0)) + 
 59 |                    is_alive(get_cell(pos,  0,  1,  1)) + 
 60 |        
 61 |                    is_alive(get_cell(pos,  1, -1, -1)) + 
 62 |                    is_alive(get_cell(pos,  1, -1,  0)) + 
 63 |                    is_alive(get_cell(pos,  1, -1,  1)) + 
 64 |                    is_alive(get_cell(pos,  1,  0, -1)) + 
 65 |                    is_alive(get_cell(pos,  1,  0,  0)) + 
 66 |                    is_alive(get_cell(pos,  1,  0,  1)) + 
 67 |                    is_alive(get_cell(pos,  1,  1, -1)) + 
 68 |                    is_alive(get_cell(pos,  1,  1,  0)) + 
 69 |                    is_alive(get_cell(pos,  1,  1,  1));
 70 |         }
 71 |         case 1: {
 72 |             return is_alive(get_cell(pos,  0,  0, -1)) + 
 73 |                    is_alive(get_cell(pos,  0,  0,  1)) + 
 74 |                    is_alive(get_cell(pos,  0, -1,  0)) + 
 75 |                    is_alive(get_cell(pos,  0,  1,  0)) + 
 76 |                    is_alive(get_cell(pos, -1,  0,  0)) + 
 77 |                    is_alive(get_cell(pos,  1,  0,  0));
 78 |         }
 79 |         default: {
 80 |             return 0;
 81 |         }
 82 |     }
 83 | }
 84 | 
 85 | fn hash(value: u32) -> u32 {
 86 |     var state = value;
 87 |     state = state ^ 2747636419u;
 88 |     state = state * 2654435769u;
 89 |     state = state ^ state >> 16u;
 90 |     state = state * 2654435769u;
 91 |     state = state ^ state >> 16u;
 92 |     state = state * 2654435769u;
 93 |     return state;
 94 | }
 95 | 
 96 | fn random_float(value: u32) -> f32 {
 97 |     return f32(hash(value)) / 4294967295.0;
 98 | }
 99 | 
100 | @compute @workgroup_size(9, 9, 9)
101 | fn init(@builtin(global_invocation_id) pos: vec3<u32>) {
102 |     var alive = false;
103 |     switch i32(r_rule.spawn_mode) {
104 |         // Random
105 |         case 0: {
106 |             let random_number = random_float(pos.z * r_rule.size * r_rule.size + pos.y * r_rule.size + pos.x);
107 |             alive = random_number > r_rule.spawn_chance;
108 |         }
109 |         // Menger Sponge
110 |         case 1: {
111 |             let size = r_rule.size;
112 |             var i = u32(3);
113 |             loop {
114 |                 let s = size / i;
115 |                 if size - s * i != u32(0) {
116 |                     alive = true;
117 |                     break;
118 |                 }
119 |                 let p = abs(vec3<i32>((pos / s) - (pos / s) / u32(3) * u32(3)) - vec3(1));
120 |                 if p.x + p.y + p.z <= 1 {
121 |                     break;
122 |                 }
123 |                 i = i * u32(3);
124 |             }
125 |         }
126 |         default: {}
127 |     }
128 |     
129 |     
130 |     textureStore(r_cells, vec3<i32>(pos), vec4<u32>(u32(alive) * u32(r_rule.states)));
131 | }
132 | 
133 | @compute @workgroup_size(9, 9, 9)
134 | fn update(@builtin(global_invocation_id) invocation_id: vec3<u32>) {
135 |     let pos = vec3<i32>(invocation_id);
136 |     var cur = get_cell(pos, 0, 0, 0);
137 | 
138 |     let alive = count_alive(pos);
139 | 
140 |     if is_alive(cur) == 1 {
141 |         if !should_survive(alive) {
142 |             cur = cur - 1;
143 |         }
144 |     } else if cur == 0 {
145 |         if should_birth(alive) {
146 |             cur = i32(r_rule.states);
147 |         }
148 |     } else {
149 |         cur = cur - 1;
150 |     }
151 | 
152 |     let alive = count_alive(pos);
153 | 
154 |     let res = u32(cur);
155 |     storageBarrier();
156 |     textureStore(r_cells, pos, vec4<u32>(res));
157 | }


--------------------------------------------------------------------------------
/src/fly_cam.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{ecs::event::Events, prelude::*, window::CursorGrabMode};
  2 | use bevy::{ecs::event::ManualEventReader, input::mouse::MouseMotion};
  3 | 
  4 | /// Keeps track of mouse motion events, pitch, and yaw
  5 | #[derive(Default, Resource)]
  6 | struct InputState {
  7 |     reader_motion: ManualEventReader<MouseMotion>,
  8 |     pitch: f32,
  9 |     yaw: f32,
 10 | }
 11 | 
 12 | #[derive(Resource)]
 13 | /// Mouse sensitivity and movement speed
 14 | pub struct MovementSettings {
 15 |     pub sensitivity: f32,
 16 |     pub speed: f32,
 17 | }
 18 | 
 19 | impl Default for MovementSettings {
 20 |     fn default() -> Self {
 21 |         Self {
 22 |             sensitivity: 0.00012,
 23 |             speed: 12.,
 24 |         }
 25 |     }
 26 | }
 27 | 
 28 | /// Used in queries when you want flycams and not other cameras
 29 | #[derive(Component)]
 30 | pub struct FlyCam;
 31 | 
 32 | /// Grabs/ungrabs mouse cursor
 33 | fn toggle_grab_cursor(window: &mut Window) {
 34 |     window.set_cursor_grab_mode(match window.cursor_grab_mode() {
 35 |         CursorGrabMode::None => CursorGrabMode::Confined,
 36 |         CursorGrabMode::Confined | CursorGrabMode::Locked => CursorGrabMode::None,
 37 |     });
 38 |     window.set_cursor_visibility(!window.cursor_visible());
 39 | }
 40 | 
 41 | /// Grabs the cursor when game first starts
 42 | fn initial_grab_cursor(mut windows: ResMut<Windows>) {
 43 |     toggle_grab_cursor(windows.get_primary_mut().unwrap());
 44 | }
 45 | 
 46 | /// Spawns the `Camera3dBundle` to be controlled
 47 | fn setup_player(mut commands: Commands) {
 48 |     let transform = Transform::from_xyz(-2.0, 3.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y);
 49 |     let rotation = transform.rotation.to_euler(EulerRot::XYZ);
 50 |     commands.insert_resource(InputState {
 51 |         pitch: rotation.0,
 52 |         yaw: rotation.2,
 53 |         ..Default::default()
 54 |     });
 55 |     commands
 56 |         .spawn(Camera3dBundle {
 57 |             transform,
 58 |             projection: Projection::Perspective(PerspectiveProjection {
 59 |                 near: 0.0001,
 60 |                 far: 15.0,
 61 |                 ..Default::default()
 62 |             }),
 63 |             ..Default::default()
 64 |         })
 65 |         .insert(FlyCam);
 66 | }
 67 | 
 68 | /// Handles keyboard input and movement
 69 | fn player_move(
 70 |     keys: Res<Input<KeyCode>>,
 71 |     time: Res<Time>,
 72 |     windows: Res<Windows>,
 73 |     settings: Res<MovementSettings>,
 74 |     mut query: Query<(&FlyCam, &mut Transform)>,
 75 | ) {
 76 |     let window = windows.get_primary().unwrap();
 77 |     for (_camera, mut transform) in query.iter_mut() {
 78 |         let mut velocity = Vec3::ZERO;
 79 |         let local_z = transform.local_z();
 80 |         let forward = -Vec3::new(local_z.x, 0., local_z.z);
 81 |         let right = Vec3::new(local_z.z, 0., -local_z.x);
 82 |         let mut boost = 1.0;
 83 | 
 84 |         for key in keys.get_pressed() {
 85 |             if matches!(window.cursor_grab_mode(), CursorGrabMode::Confined) {
 86 |                 match key {
 87 |                     KeyCode::W => velocity += forward,
 88 |                     KeyCode::S => velocity -= forward,
 89 |                     KeyCode::A => velocity -= right,
 90 |                     KeyCode::D => velocity += right,
 91 |                     KeyCode::Space => velocity += Vec3::Y,
 92 |                     KeyCode::LShift => velocity -= Vec3::Y,
 93 |                     KeyCode::LControl => boost *= 5.0,
 94 |                     _ => (),
 95 |                 }
 96 |             }
 97 |         }
 98 | 
 99 |         velocity = velocity.normalize_or_zero();
100 | 
101 |         const SPEED: f32 = 2.0;
102 |         transform.translation += velocity * time.delta_seconds() * settings.speed * SPEED * boost;
103 |     }
104 | }
105 | 
106 | fn reset_position(
107 |     input: Res<Input<KeyCode>>,
108 |     mut input_state: ResMut<InputState>,
109 |     mut query: Query<(&FlyCam, &mut Transform)>,
110 | ) {
111 |     if input.pressed(KeyCode::B) {
112 |         for (_camera, mut transform) in query.iter_mut() {
113 |             *transform = transform.looking_at(Vec3::ZERO, Vec3::Y);
114 |             let rotation = transform.rotation.to_euler(EulerRot::XYZ);
115 |             input_state.pitch = rotation.0;
116 |             input_state.yaw = rotation.2;
117 |         }
118 |     }
119 | }
120 | 
121 | /// Handles looking around if cursor is locked
122 | fn player_look(
123 |     settings: Res<MovementSettings>,
124 |     mut windows: ResMut<Windows>,
125 |     mut state: ResMut<InputState>,
126 |     motion: Res<Events<MouseMotion>>,
127 |     mut query: Query<(&FlyCam, &mut Transform)>,
128 | ) {
129 |     let window = windows.get_primary_mut().unwrap();
130 |     if matches!(window.cursor_grab_mode(), CursorGrabMode::Confined) {
131 |         for (_camera, mut transform) in query.iter_mut() {
132 |             let mut new_yaw = state.yaw;
133 |             let mut new_pitch = state.pitch;
134 | 
135 |             for ev in state.reader_motion.iter(&motion) {
136 |                 // Using smallest of height or width ensures equal vertical and horizontal sensitivity
137 |                 let window_scale = window.height().min(window.width());
138 |                 const SENSITIVITY: f32 = 0.2;
139 |                 new_pitch -= (settings.sensitivity * SENSITIVITY * ev.delta.y * window_scale).to_radians();
140 |                 new_yaw -= (settings.sensitivity * SENSITIVITY * ev.delta.x * window_scale).to_radians();
141 |             }
142 |             new_pitch = new_pitch.clamp(-1.54, 1.54);
143 | 
144 |             // Order is important to prevent unintended roll
145 |             transform.rotation =
146 |                 Quat::from_axis_angle(Vec3::Y, new_yaw) * Quat::from_axis_angle(Vec3::X, new_pitch);
147 |             state.pitch = new_pitch;
148 |             state.yaw = new_yaw;
149 |         }
150 |         window.set_cursor_position(Vec2::new(window.width() / 2.0, window.height() / 2.0));
151 |     }
152 | }
153 | 
154 | fn cursor_grab(keys: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
155 |     let window = windows.get_primary_mut().unwrap();
156 |     if keys.just_pressed(KeyCode::Escape) {
157 |         toggle_grab_cursor(window);
158 |     }
159 | }
160 | 
161 | /// Contains everything needed to add first-person fly camera behavior to your game
162 | pub struct PlayerPlugin;
163 | impl Plugin for PlayerPlugin {
164 |     fn build(&self, app: &mut App) {
165 |         app.init_resource::<InputState>()
166 |             .init_resource::<MovementSettings>()
167 |             .add_startup_system(setup_player)
168 |             .add_startup_system(initial_grab_cursor)
169 |             .add_system(player_move)
170 |             .add_system(player_look)
171 |             .add_system(reset_position)
172 |             .add_system(cursor_grab);
173 |     }
174 | }
175 | 
176 | /// Same as `PlayerPlugin` but does not spawn a camera
177 | pub struct NoCameraPlayerPlugin;
178 | impl Plugin for NoCameraPlayerPlugin {
179 |     fn build(&self, app: &mut App) {
180 |         app.init_resource::<MovementSettings>()
181 |             .add_startup_system(initial_grab_cursor)
182 |             .add_system(player_move)
183 |             .add_system(player_look)
184 |             .add_system(reset_position)
185 |             .add_system(cursor_grab);
186 |     }
187 | }
188 | 


--------------------------------------------------------------------------------
/assets/shader.wgsl:
--------------------------------------------------------------------------------
  1 | #import bevy_pbr::mesh_bindings
  2 | #import bevy_pbr::mesh_view_bindings
  3 | 
  4 | struct VertexOutput {
  5 |     @location(0) pos: vec3<f32>,
  6 |     @location(1) world_position: vec3<f32>,
  7 |     @location(2) cam_pos: vec3<f32>,
  8 |     @location(3) normal: vec3<f32>,
  9 |     @builtin(position) clip_position: vec4<f32>,
 10 | };
 11 | 
 12 | fn max_abs_e(v: vec3<f32>) -> f32 {
 13 |     return max(abs(v.x), max(abs(v.y), abs(v.z)));
 14 | }
 15 | 
 16 | let EPSILON = 0.0001;
 17 | 
 18 | @vertex
 19 | fn vertex(
 20 |     @location(0) position: vec3<f32>,
 21 |     @location(1) normal: vec3<f32>,
 22 | ) -> VertexOutput {
 23 |     let world_position = mesh.model * vec4(position, 1.0);
 24 |     let cam_pos = (mesh.inverse_transpose_model * vec4(view.world_position, 1.0)).xyz;
 25 |     var out: VertexOutput;
 26 | 
 27 |     let d = dot(normal, cam_pos - position);
 28 |     if d < 0.0 {
 29 |         out.pos = (cam_pos + 1.0) / 2.0;
 30 |     } else {
 31 |         out.pos = (position + 1.0) / 2.0;
 32 |     }
 33 | 
 34 |     out.world_position = world_position.xyz;
 35 |     out.cam_pos = cam_pos;
 36 |     out.clip_position = view.view_proj * world_position;
 37 |     out.normal = normal;
 38 |     return out;
 39 | }
 40 | 
 41 | @group(1) @binding(0)
 42 | var r_cells: texture_storage_3d<r8uint, read_write>;
 43 | 
 44 | struct Rule {
 45 |     size: u32,
 46 |     spawn_mode: u32,
 47 |     spawn_chance: f32,
 48 |     survival: u32,
 49 |     birth: u32,
 50 |     states: u32,
 51 |     neighbor_mode: u32,
 52 |     color_mode: u32,
 53 |     color0: vec4<f32>,
 54 |     color1: vec4<f32>,
 55 | };
 56 | 
 57 | @group(1) @binding(1)
 58 | var<uniform> r_rule: Rule;
 59 | 
 60 | /// MOVE THIS TO IMPORT
 61 | fn hash(value: u32) -> u32 {
 62 |     var state = value;
 63 |     state = state ^ 2747636419u;
 64 |     state = state * 2654435769u;
 65 |     state = state ^ state >> 16u;
 66 |     state = state * 2654435769u;
 67 |     state = state ^ state >> 16u;
 68 |     state = state * 2654435769u;
 69 |     return state;
 70 | }
 71 | fn random_float(value: u32) -> f32 {
 72 |     return f32(hash(value)) / 4294967295.0;
 73 | }
 74 | /// END
 75 | 
 76 | let ERR_COLOR = vec3<f32>(1.0, 0.2, 0.6);
 77 | 
 78 | fn color(state: u32, p: vec3<f32>) -> vec3<f32> {
 79 |     switch i32(r_rule.color_mode) {
 80 |         case 0: {
 81 |             return r_rule.color0.xyz;
 82 |         }
 83 |         case 1: {
 84 |             let t = f32(state) / f32(r_rule.states);
 85 |             return r_rule.color0.xyz * (1.0 - t) + r_rule.color1.xyz * t;
 86 |         }
 87 |         case 2: {
 88 |             let t = length(p - f32(r_rule.size) / 2.0) / f32(r_rule.size);
 89 |             return r_rule.color0.xyz * (1.0 - t) + r_rule.color1.xyz * t;
 90 |         }
 91 |         case 3: {
 92 |             // TODO: impl neighbor coloring
 93 |             return ERR_COLOR;
 94 |         }
 95 |         default: {
 96 |             return r_rule.color0.xyz;
 97 |         }
 98 |     }
 99 | }
100 | 
101 | fn frac0(v: f32) -> f32 {
102 |     return (v - floor(v));
103 | }
104 | fn frac1(v: f32) -> f32 {
105 |     return (1.0 - v + floor(v));
106 | }
107 | 
108 | struct RayHit {
109 |     fpos: vec3<f32>,
110 |     vpos: vec3<f32>,
111 |     norm: vec3<f32>,
112 |     dist: f32,
113 |     state: u32,
114 | }
115 | 
116 | fn cast_ray(origin: vec3<f32>, dir: vec3<f32>, start_normal: vec3<f32>) -> RayHit {
117 |     let step = sign(dir);
118 |     let delta = min(step / dir, vec3(1.0 / EPSILON));
119 |     var tmax = vec3(0.0);
120 |     if step.x > 0.0 {
121 |         tmax.x = delta.x * frac1(origin.x);
122 |     } else {
123 |         tmax.x = delta.x * frac0(origin.x);
124 |     }
125 |     if step.y > 0.0 {
126 |         tmax.y = delta.y * frac1(origin.y);
127 |     } else {
128 |         tmax.y = delta.y * frac0(origin.y);
129 |     }
130 |     if step.z > 0.0 {
131 |         tmax.z = delta.z * frac1(origin.z);
132 |     } else {
133 |         tmax.z = delta.z * frac0(origin.z);
134 |     }
135 |     var pos = floor(origin);
136 |     var norm = start_normal;
137 |     var dist = 0.0;
138 | 
139 |     loop {
140 |         let state = textureLoad(r_cells, vec3<i32>(pos)).x;
141 |         if state > u32(0) {
142 |             var result: RayHit;
143 |             result.fpos = origin + dir * dist;
144 |             result.vpos = pos;
145 |             result.norm = norm;
146 |             result.dist = dist;
147 |             result.state = state;
148 | 
149 |             return result;
150 |         }
151 |         if tmax.x < tmax.y {
152 |             if tmax.x < tmax.z {
153 |                 pos.x = pos.x + step.x;
154 |                 norm = vec3(step.x, 0.0, 0.0);
155 |                 dist = tmax.x;
156 |                 if pos.x < 0.0 || pos.x >= f32(r_rule.size) {
157 |                     break;
158 |                 }
159 |                 tmax.x = tmax.x + delta.x;
160 |             } else {
161 |                 pos.z = pos.z + step.z;
162 |                 norm = vec3(0.0, 0.0, step.z);
163 |                 dist = tmax.z;
164 |                 if pos.z < 0.0 || pos.z >= f32(r_rule.size) {
165 |                     break;
166 |                 }
167 |                 tmax.z = tmax.z + delta.z;
168 |             }
169 |         } else {
170 |             if tmax.y < tmax.z {
171 |                 pos.y = pos.y + step.y;
172 |                 norm = vec3(0.0, step.y, 0.0);
173 |                 dist = tmax.y;
174 |                 if pos.y < 0.0 || pos.y >= f32(r_rule.size) {
175 |                     break;
176 |                 }
177 |                 tmax.y = tmax.y + delta.y;
178 |             } else {
179 |                 pos.z = pos.z + step.z;
180 |                 dist = tmax.z;
181 |                 norm = vec3(0.0, 0.0, step.z);
182 |                 if pos.z < 0.0 || pos.z >= f32(r_rule.size) {
183 |                     break;
184 |                 }
185 |                 tmax.z = tmax.z + delta.z;
186 |             }
187 |         }
188 |     }
189 | 
190 |     let dist = min(tmax.x, min(tmax.y, tmax.z));
191 |     var result: RayHit;
192 |     result.fpos = origin + dir * dist;
193 |     result.vpos = pos;
194 |     result.norm = norm;
195 |     result.dist = dist;
196 |     result.state = u32(0);
197 | 
198 |     return result;
199 | }
200 | 
201 | 
202 | fn trace_ray(origin: vec3<f32>, dir: vec3<f32>, start_normal: vec3<f32>) -> vec3<f32> {
203 |     let result = cast_ray(origin, dir, start_normal);
204 |     let light_dir = normalize(vec3<f32>(0.1, -1.0, 0.1));
205 | 
206 |     if result.state != u32(0) {
207 |         let color = color(result.state, result.vpos);
208 | 
209 |         var light: f32;
210 | 
211 |         if cast_ray(result.fpos - light_dir * 0.01, -light_dir, -light_dir).state == u32(0) {
212 |             light = (1.0 + dot(light_dir, result.norm)) / 2.0;
213 |         } else {
214 |             light = 0.0;
215 |         }
216 | 
217 |         let ambient = 0.3 + 0.7 * (1.0 + dot(vec3(0.0, -1.0, 0.0), result.norm)) / 2.0;
218 | 
219 |         return color * (ambient * 0.3 + light * 0.7);
220 |     } else {
221 |         return vec3(0.0);
222 |     }
223 | }
224 | 
225 | @fragment
226 | fn fragment(in: VertexOutput) -> @location(0) vec4<f32> {
227 |     let dir = normalize(in.world_position - in.cam_pos);
228 |     
229 |     let fpos = in.pos.xyz * f32(r_rule.size);
230 |     let p = normalize((in.pos.xyz - 0.5) * 2.0);
231 |     let res = trace_ray(fpos, dir, -in.normal);
232 | 
233 |     return vec4(res, 1.0);
234 | }


--------------------------------------------------------------------------------
/src/ca_compute.rs:
--------------------------------------------------------------------------------
  1 | use std::borrow::Cow;
  2 | 
  3 | use bevy::{
  4 |     pbr::RenderMaterials,
  5 |     prelude::*,
  6 |     render::{
  7 |         extract_resource::{ExtractResource, ExtractResourcePlugin},
  8 |         render_graph::{self, RenderGraph},
  9 |         render_resource::*,
 10 |         renderer::{RenderContext, RenderDevice},
 11 |         Extract, RenderApp, RenderStage,
 12 |     },
 13 | };
 14 | 
 15 | use crate::{rtmaterial::RTVolumeMaterial, rule::Rule, WORKGROUP_SIZE};
 16 | 
 17 | pub struct CAPlugin;
 18 | 
 19 | impl Plugin for CAPlugin {
 20 |     fn build(&self, app: &mut App) {
 21 |         app.init_resource::<ReInit>().init_resource::<UpdateTime>();
 22 |         app.add_plugin(ExtractResourcePlugin::<CAImage>::default());
 23 |         let render_app = app.sub_app_mut(RenderApp);
 24 |         render_app
 25 |             .init_resource::<ReInit>()
 26 |             .init_resource::<CAPipeline>()
 27 |             .add_system_to_stage(RenderStage::Extract, extract_reinit)
 28 |             .add_system_to_stage(RenderStage::Extract, update_timer);
 29 | 
 30 |         let mut render_graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
 31 |         render_graph.add_node("cas", DispatchCA::default());
 32 |         render_graph
 33 |             .add_node_edge("cas", bevy::render::main_graph::node::CAMERA_DRIVER)
 34 |             .unwrap();
 35 |     }
 36 | }
 37 | 
 38 | #[derive(Default, Clone, Resource)]
 39 | pub struct ReInit(pub bool);
 40 | 
 41 | #[derive(Resource, Clone, ExtractResource)]
 42 | pub struct CAImage(pub Handle<Image>);
 43 | 
 44 | fn extract_reinit(
 45 |     mut commands: Commands,
 46 |     reinit: Extract<Res<ReInit>>,
 47 |     input: Extract<Res<Input<KeyCode>>>,
 48 | ) {
 49 |     commands.insert_resource(ReInit(reinit.0 || input.just_pressed(KeyCode::R)));
 50 | }
 51 | 
 52 | #[derive(Resource)]
 53 | pub struct UpdateTime(pub f64);
 54 | 
 55 | impl Default for UpdateTime {
 56 |     fn default() -> Self {
 57 |         UpdateTime(0.1)
 58 |     }
 59 | }
 60 | 
 61 | #[derive(Resource)]
 62 | struct DoUpdate(bool);
 63 | 
 64 | fn update_timer(
 65 |     mut commands: Commands,
 66 |     update_time: Extract<Res<UpdateTime>>,
 67 |     input: Extract<Res<Input<KeyCode>>>,
 68 |     time: Extract<Res<Time>>,
 69 |     mut last_update: Local<f64>,
 70 | ) {
 71 |     let t = time.elapsed_seconds_f64();
 72 |     if t - *last_update > update_time.0 || input.just_pressed(KeyCode::E) {
 73 |         *last_update = t;
 74 |         commands.insert_resource(DoUpdate(true));
 75 |     } else {
 76 |         commands.insert_resource(DoUpdate(false));
 77 |     }
 78 | }
 79 | 
 80 | #[derive(Resource)]
 81 | pub struct CAPipeline {
 82 |     init_pipeline: CachedComputePipelineId,
 83 |     update_pipeline: CachedComputePipelineId,
 84 | }
 85 | 
 86 | impl FromWorld for CAPipeline {
 87 |     fn from_world(world: &mut World) -> Self {
 88 |         let bind_group = RTVolumeMaterial::bind_group_layout(world.resource::<RenderDevice>());
 89 | 
 90 |         let shader = world
 91 |             .resource::<AssetServer>()
 92 |             .load("../assets/compute.wgsl");
 93 | 
 94 |         let mut pipeline_cache = world.resource_mut::<PipelineCache>();
 95 |         let init_pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
 96 |             label: None,
 97 |             layout: Some(vec![bind_group.clone()]),
 98 |             shader: shader.clone(),
 99 |             shader_defs: vec![],
100 |             entry_point: Cow::from("init"),
101 |         });
102 |         let update_pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
103 |             label: None,
104 |             layout: Some(vec![bind_group.clone()]),
105 |             shader,
106 |             shader_defs: vec![],
107 |             entry_point: Cow::from("update"),
108 |         });
109 | 
110 |         CAPipeline {
111 |             init_pipeline,
112 |             update_pipeline,
113 |         }
114 |     }
115 | }
116 | 
117 | enum CAState {
118 |     Loading,
119 |     Init,
120 |     Update,
121 |     UpdateRun,
122 | }
123 | 
124 | struct DispatchCA {
125 |     state: CAState,
126 | }
127 | 
128 | impl Default for DispatchCA {
129 |     fn default() -> Self {
130 |         Self {
131 |             state: CAState::Loading,
132 |         }
133 |     }
134 | }
135 | 
136 | impl render_graph::Node for DispatchCA {
137 |     fn update(&mut self, world: &mut World) {
138 |         let pipeline = world.resource::<CAPipeline>();
139 |         let pipeline_cache = world.resource::<PipelineCache>();
140 |         let do_update = world.resource::<DoUpdate>();
141 | 
142 |         match self.state {
143 |             CAState::Loading => {
144 |                 if let CachedPipelineState::Ok(_) =
145 |                     pipeline_cache.get_compute_pipeline_state(pipeline.init_pipeline)
146 |                 {
147 |                     self.state = CAState::Init
148 |                 }
149 |             }
150 |             CAState::Init => {
151 |                 if let CachedPipelineState::Ok(_) =
152 |                     pipeline_cache.get_compute_pipeline_state(pipeline.update_pipeline)
153 |                 {
154 |                     self.state = CAState::Update
155 |                 }
156 |             }
157 |             CAState::Update => {
158 |                 if do_update.0 {
159 |                     self.state = CAState::UpdateRun
160 |                 }
161 |             }
162 |             CAState::UpdateRun => {
163 |                 self.state = CAState::Update;
164 |             }
165 |         }
166 |         if let Some(ReInit(true)) = world.get_resource() {
167 |             self.state = CAState::Init;
168 |         }
169 |     }
170 | 
171 |     fn run(
172 |         &self,
173 |         _graph: &mut render_graph::RenderGraphContext,
174 |         render_context: &mut RenderContext,
175 |         world: &World,
176 |     ) -> Result<(), render_graph::NodeRunError> {
177 |         let materials = &world
178 |             .get_resource::<RenderMaterials<RTVolumeMaterial>>()
179 |             .unwrap()
180 |             .0;
181 |         let pipeline_cache = world.resource::<PipelineCache>();
182 |         let pipeline = world.resource::<CAPipeline>();
183 |         let rule = world.get_resource::<Rule>().unwrap();
184 | 
185 |         let mut pass = render_context
186 |             .command_encoder
187 |             .begin_compute_pass(&ComputePassDescriptor::default());
188 | 
189 |         for (_handle, prepared) in materials {
190 |             let wg: u32 = rule.size / WORKGROUP_SIZE;
191 |             pass.set_bind_group(0, &prepared.bind_group, &[]);
192 |             match self.state {
193 |                 CAState::Init => {
194 |                     let init_pipeline = pipeline_cache
195 |                         .get_compute_pipeline(pipeline.init_pipeline)
196 |                         .unwrap();
197 |                     pass.set_pipeline(init_pipeline);
198 |                     pass.dispatch_workgroups(wg, wg, wg);
199 |                 }
200 |                 CAState::UpdateRun => {
201 |                     let update_pipeline = pipeline_cache
202 |                         .get_compute_pipeline(pipeline.update_pipeline)
203 |                         .unwrap();
204 |                     pass.set_pipeline(update_pipeline);
205 |                     pass.dispatch_workgroups(wg, wg, wg);
206 |                 }
207 |                 _ => {}
208 |             }
209 |         }
210 | 
211 |         Ok(())
212 |     }
213 | }
214 | 


--------------------------------------------------------------------------------
/src/rule.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     prelude::*,
  3 |     render::extract_resource::{ExtractResource, ExtractResourcePlugin},
  4 | };
  5 | use bytemuck::{Pod, Zeroable};
  6 | 
  7 | use crate::rtmaterial::RTVolumeMaterial;
  8 | 
  9 | #[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
 10 | pub struct Value([bool; 27]);
 11 | 
 12 | impl Value {
 13 |     pub fn at(&self, index: usize) -> &bool {
 14 |         &self.0[index]
 15 |     }
 16 | 
 17 |     pub fn at_mut(&mut self, index: usize) -> &mut bool {
 18 |         &mut self.0[index]
 19 |     }
 20 | 
 21 |     pub fn try_parse(s: &str) -> Option<Value> {
 22 |         if s.len() == 0 {
 23 |             return Some(Value::default());
 24 |         }
 25 |         let mut res = Value::default();
 26 |         for value in s.split(",") {
 27 |             let value = value.trim();
 28 |             if let Some((r0, r1)) = value.split_once('-') {
 29 |                 let r0 = r0.trim_end();
 30 |                 let r1 = r1.trim_start();
 31 |                 for i in r0.parse::<usize>().ok()?..=r1.parse::<usize>().ok()? {
 32 |                     *res.0.get_mut(26 - i)? = true;
 33 |                 }
 34 |             } else {
 35 |                 *res.0.get_mut(26 - value.parse::<usize>().ok()?)? = true;
 36 |             }
 37 |         }
 38 |         Some(res)
 39 |     }
 40 | }
 41 | 
 42 | impl ToString for Value {
 43 |     fn to_string(&self) -> String {
 44 |         let mut elems = Vec::new();
 45 |         let mut i = 0;
 46 |         while i < 27 {
 47 |             if *self.at(i) {
 48 |                 let end = 26 - i;
 49 |                 while i < 27 && *self.at(i) {
 50 |                     i += 1;
 51 |                 }
 52 |                 let start = 26 - (i - 1);
 53 |                 if start == end {
 54 |                     elems.push(start.to_string());
 55 |                 } else if start + 1 == end {
 56 |                     elems.push(format!("{},{}", start, end));
 57 |                 } else {
 58 |                     elems.push(format!("{}-{}", start, end));
 59 |                 }
 60 |             } else {
 61 |                 i += 1;
 62 |             }
 63 |         }
 64 |         if elems.is_empty() {
 65 |             String::new()
 66 |         } else {
 67 |             elems
 68 |                 .iter()
 69 |                 //.rev()
 70 |                 .skip(1)
 71 |                 .fold(elems[0].clone(), |acc, x| format!("{},{}", x, acc))
 72 |         }
 73 |     }
 74 | }
 75 | 
 76 | impl From<Vec<usize>> for Value {
 77 |     fn from(vec: Vec<usize>) -> Self {
 78 |         let mut value = [false; 27];
 79 |         for i in vec {
 80 |             value[26 - i] = true;
 81 |         }
 82 |         Self(value)
 83 |     }
 84 | }
 85 | 
 86 | impl From<Value> for u32 {
 87 |     fn from(v: Value) -> Self {
 88 |         v.0.iter().fold(0, |acc, &b| (acc << 1) | (b as u32))
 89 |     }
 90 | }
 91 | 
 92 | #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 93 | pub enum NeighborMode {
 94 |     Moore = 0,
 95 |     VonNeumann = 1,
 96 | }
 97 | 
 98 | impl NeighborMode {
 99 |     pub fn as_str(&self) -> &'static str {
100 |         match self {
101 |             Self::Moore => "Moore",
102 |             Self::VonNeumann => "VonNeumann",
103 |         }
104 |     }
105 | }
106 | 
107 | #[derive(Clone, Debug, PartialEq)]
108 | pub enum ColorMode {
109 |     Single(Color),
110 |     StateLerp(Color, Color),
111 |     DistToCenter(Color, Color),
112 |     Neighbour(Color, Color),
113 | }
114 | 
115 | impl Eq for ColorMode {}
116 | 
117 | impl ColorMode {
118 |     pub fn kind(&self) -> ColorModeKind {
119 |         match self {
120 |             Self::Single(_) => ColorModeKind::Single,
121 |             Self::StateLerp(_, _) => ColorModeKind::StateLerp,
122 |             Self::DistToCenter(_, _) => ColorModeKind::DistToCenter,
123 |             Self::Neighbour(_, _) => ColorModeKind::Neighbour,
124 |         }
125 |     }
126 | 
127 |     pub fn colors(&self) -> (Color, Color) {
128 |         match self {
129 |             Self::Single(c) => (*c, *c),
130 |             Self::StateLerp(c1, c2) => (*c1, *c2),
131 |             Self::DistToCenter(c1, c2) => (*c1, *c2),
132 |             Self::Neighbour(c1, c2) => (*c1, *c2),
133 |         }
134 |     }
135 | }
136 | 
137 | #[derive(Clone, Copy, PartialEq, Eq)]
138 | pub enum ColorModeKind {
139 |     Single,
140 |     StateLerp,
141 |     DistToCenter,
142 |     Neighbour,
143 | }
144 | 
145 | impl ColorModeKind {
146 |     pub fn as_str(&self) -> &'static str {
147 |         match self {
148 |             Self::Single => "Single",
149 |             Self::StateLerp => "State Lerp",
150 |             Self::DistToCenter => "Distance To Center",
151 |             Self::Neighbour => "Neighbour Count Lerp",
152 |         }
153 |     }
154 | 
155 |     pub fn update(&self, mode: &mut ColorMode) {
156 |         let colors = mode.colors();
157 |         match self {
158 |             Self::Single => {
159 |                 *mode = ColorMode::Single(colors.0);
160 |             }
161 |             Self::StateLerp => {
162 |                 *mode = ColorMode::StateLerp(colors.0, colors.1);
163 |             }
164 |             Self::DistToCenter => {
165 |                 *mode = ColorMode::DistToCenter(colors.0, colors.1);
166 |             }
167 |             Self::Neighbour => {
168 |                 *mode = ColorMode::Neighbour(colors.0, colors.1);
169 |             }
170 |         }
171 |     }
172 | }
173 | 
174 | #[derive(Clone, Debug, PartialEq)]
175 | pub enum SpawnMode {
176 |     Random(f32),
177 |     MengerSponge,
178 | }
179 | 
180 | impl Eq for SpawnMode {}
181 | 
182 | impl SpawnMode {
183 |     pub fn kind(&self) -> SpawnModeKind {
184 |         match self {
185 |             Self::Random(_) => SpawnModeKind::Random,
186 |             Self::MengerSponge => SpawnModeKind::MengerSponge,
187 |         }
188 |     }
189 | 
190 |     pub fn float(&self) -> f32 {
191 |         match self {
192 |             Self::Random(f) => *f,
193 |             Self::MengerSponge => 0.0,
194 |         }
195 |     }
196 | }
197 | 
198 | #[derive(Clone, Copy, PartialEq, Eq)]
199 | #[repr(u32)]
200 | pub enum SpawnModeKind {
201 |     Random,
202 |     MengerSponge,
203 | }
204 | 
205 | impl SpawnModeKind {
206 |     pub fn update(&self, mode: &mut SpawnMode) {
207 |         let float = mode.float();
208 |         match self {
209 |             Self::Random => {
210 |                 *mode = SpawnMode::Random(float);
211 |             }
212 |             Self::MengerSponge => {
213 |                 *mode = SpawnMode::MengerSponge;
214 |             }
215 |         }
216 |     }
217 | 
218 |     pub fn as_str(&self) -> &'static str {
219 |         match self {
220 |             Self::Random => "Random",
221 |             Self::MengerSponge => "Menger Sponge",
222 |         }
223 |     }
224 | }
225 | #[repr(C)]
226 | #[derive(Clone, Copy, PartialEq, Default, Pod, Zeroable)]
227 | pub struct GPURule {
228 |     size: u32,
229 |     spawn_mode: u32,
230 |     spawn_chance: f32,
231 |     survival: u32,
232 |     birth: u32,
233 |     states: u32,
234 |     neighbor_mode: u32,
235 |     color_mode: u32,
236 |     color0: [f32; 4],
237 |     color1: [f32; 4],
238 | }
239 | 
240 | impl From<&Rule> for GPURule {
241 |     fn from(rule: &Rule) -> Self {
242 |         let (color_mode, color0, color1) = match rule.color_mode {
243 |             ColorMode::Single(c) => (0, c.as_rgba_f32(), [0.0; 4]),
244 |             ColorMode::StateLerp(c0, c1) => (1, c0.as_rgba_f32(), c1.as_rgba_f32()),
245 |             ColorMode::DistToCenter(c0, c1) => (2, c0.as_rgba_f32(), c1.as_rgba_f32()),
246 |             ColorMode::Neighbour(c0, c1) => (3, c0.as_rgba_f32(), c1.as_rgba_f32()),
247 |         };
248 |         Self {
249 |             size: rule.size,
250 |             spawn_mode: rule.spawn_mode.kind() as u32,
251 |             spawn_chance: rule.spawn_mode.float(),
252 |             survival: rule.survival.into(),
253 |             birth: rule.birth.into(),
254 |             states: rule.states,
255 |             neighbor_mode: rule.neighbor_mode as u32,
256 |             color_mode,
257 |             color0,
258 |             color1,
259 |         }
260 |     }
261 | }
262 | 
263 | #[derive(Clone, Resource, PartialEq, Eq, Debug, ExtractResource)]
264 | pub struct Rule {
265 |     pub size: u32,
266 |     pub spawn_mode: SpawnMode,
267 |     pub survival: Value,
268 |     pub birth: Value,
269 |     pub states: u32,
270 |     pub neighbor_mode: NeighborMode,
271 |     pub color_mode: ColorMode,
272 | }
273 | 
274 | fn update_materials(
275 |     rule: Res<Rule>,
276 |     material_query: Query<&Handle<RTVolumeMaterial>>,
277 |     mut materials: ResMut<Assets<RTVolumeMaterial>>,
278 | ) {
279 |     for material in material_query.iter() {
280 |         if let Some(material) = materials.get_mut(material) {
281 |             if material.rule != *rule {
282 |                 material.rule = rule.clone();
283 |             }
284 |         }
285 |     }
286 | }
287 | 
288 | pub struct RulePlugin;
289 | 
290 | impl Plugin for RulePlugin {
291 |     fn build(&self, app: &mut App) {
292 |         app.insert_resource(Rule {
293 |             size: 243 * 3,
294 |             spawn_mode: SpawnMode::MengerSponge,
295 |             survival: vec![4,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26].into(),
296 |             birth: vec![4, 18,19,20,21,22,23,24].into(),
297 |             states: 5,
298 |             neighbor_mode: NeighborMode::Moore,
299 |             color_mode: ColorMode::StateLerp(Color::rgb_u8(94, 25, 146), Color::rgb_u8(12, 227, 227)),
300 |         })
301 |         .add_plugin(ExtractResourcePlugin::<Rule>::default())
302 |         .add_system(update_materials);
303 |     }
304 | }
305 | 


--------------------------------------------------------------------------------
/src/gui.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin},
  3 |     prelude::*,
  4 | };
  5 | use bevy_egui::{
  6 |     egui::{self, panel::Side},
  7 |     EguiContext, EguiPlugin,
  8 | };
  9 | 
 10 | use crate::{
 11 |     ca_compute::{ReInit, UpdateTime},
 12 |     fly_cam::MovementSettings,
 13 |     rule::{ColorMode, ColorModeKind, NeighborMode, Rule, SpawnMode, SpawnModeKind, Value},
 14 |     Meshes, START_SENSITIVITY, START_SPEED,
 15 | };
 16 | 
 17 | pub struct GuiPlugin;
 18 | 
 19 | impl Plugin for GuiPlugin {
 20 |     fn build(&self, app: &mut App) {
 21 |         app.add_plugin(EguiPlugin).add_system(egui_system);
 22 |     }
 23 | }
 24 | 
 25 | #[derive(Default)]
 26 | struct State {
 27 |     import: String,
 28 |     survival: String,
 29 |     birth: String,
 30 |     // size: u32,
 31 | }
 32 | 
 33 | fn egui_system(
 34 |     mut ctx: ResMut<EguiContext>,
 35 |     rule: Option<ResMut<Rule>>,
 36 |     update_time: Option<ResMut<UpdateTime>>,
 37 |     reinit: Option<ResMut<ReInit>>,
 38 |     movement: Option<ResMut<MovementSettings>>,
 39 |     meshes: Option<ResMut<Meshes>>,
 40 |     diagnostics: Res<Diagnostics>,
 41 |     mut state: Local<State>,
 42 | ) {
 43 |     egui::SidePanel::new(Side::Left, "settings").show(ctx.ctx_mut(), |ui| {
 44 |         if let Some(mut rule) = rule {
 45 |             if let Some(mut reinit) = reinit {
 46 |                 ui.heading("Spawn");
 47 |                 let mut mode = rule.spawn_mode.kind();
 48 |                 egui::ComboBox::from_label("Spawn mode")
 49 |                     .selected_text(mode.as_str())
 50 |                     .show_ui(ui, |ui| {
 51 |                         ui.selectable_value(
 52 |                             &mut mode,
 53 |                             SpawnModeKind::Random,
 54 |                             SpawnModeKind::Random.as_str(),
 55 |                         );
 56 |                         ui.selectable_value(
 57 |                             &mut mode,
 58 |                             SpawnModeKind::MengerSponge,
 59 |                             SpawnModeKind::MengerSponge.as_str(),
 60 |                         );
 61 |                     });
 62 |                 mode.update(&mut rule.spawn_mode);
 63 |                 match &mut rule.spawn_mode {
 64 |                     SpawnMode::Random(f) => {
 65 |                         *f = 1.0 - *f;
 66 |                         ui.add(egui::Slider::new(f, 0.0..=1.0));
 67 |                         *f = 1.0 - *f;
 68 |                     }
 69 |                     _ => {}
 70 |                 }
 71 |                 ui.end_row();
 72 |                 reinit.0 = ui.button("Reset").clicked();
 73 |             }
 74 | 
 75 |             ui.heading("Rule");
 76 |             ui.end_row();
 77 | 
 78 |             ui.label("Import: ");
 79 |             let re = ui.text_edit_singleline(&mut state.import);
 80 |             if re.lost_focus() && re.ctx.input().key_pressed(egui::Key::Enter) {
 81 |                 let mut items = state.import.trim().split('/');
 82 |                 if let (Some(survival), Some(birth), Some(states), Some(neighbor_mode)) = (
 83 |                     items.next().and_then(Value::try_parse),
 84 |                     items.next().and_then(Value::try_parse),
 85 |                     items.next().and_then(|s| s.parse().ok()),
 86 |                     items.next().and_then(|s| match s {
 87 |                         "M" => Some(NeighborMode::Moore),
 88 |                         "N" => Some(NeighborMode::VonNeumann),
 89 |                         _ => None,
 90 |                     }),
 91 |                 ) {
 92 |                     rule.survival = survival;
 93 |                     rule.birth = birth;
 94 |                     rule.states = states;
 95 |                     rule.neighbor_mode = neighbor_mode;
 96 |                 }
 97 |                 state.import.clear();
 98 |             }
 99 | 
100 |             // TODO: Fix resizing.
101 |             /*
102 |             ui.label("Size");
103 |             if state.size == 0 {
104 |                 state.size = rule.size;
105 |             }
106 |             let res = ui.add(egui::Slider::new(&mut state.size, 2..=1024));
107 |             if res.lost_focus() || res.drag_released() {
108 |                 rule.size = state.size;
109 |             }
110 |             ui.end_row();
111 |             */
112 | 
113 |             ui.label("Survival");
114 |             let survival = ui.text_edit_singleline(&mut state.survival);
115 |             if survival.changed() {
116 |                 if let Some(survival) = Value::try_parse(&state.survival) {
117 |                     rule.survival = survival;
118 |                 }
119 |             } else if !survival.has_focus() {
120 |                 state.survival = rule.survival.to_string();
121 |             }
122 | 
123 |             ui.label("Birth");
124 |             let birth = ui.text_edit_singleline(&mut state.birth);
125 |             if birth.changed() {
126 |                 if let Some(birth) = Value::try_parse(&state.birth) {
127 |                     rule.birth = birth;
128 |                 }
129 |             } else if !birth.has_focus() {
130 |                 state.birth = rule.birth.to_string();
131 |             }
132 | 
133 |             ui.label("States");
134 |             ui.add(egui::Slider::new(&mut rule.states, 1..=40));
135 |             ui.end_row();
136 | 
137 |             egui::ComboBox::from_label("Neighbor mode")
138 |                 .selected_text(rule.neighbor_mode.as_str())
139 |                 .show_ui(ui, |ui| {
140 |                     ui.selectable_value(
141 |                         &mut rule.neighbor_mode,
142 |                         NeighborMode::Moore,
143 |                         NeighborMode::Moore.as_str(),
144 |                     );
145 |                     ui.selectable_value(
146 |                         &mut rule.neighbor_mode,
147 |                         NeighborMode::VonNeumann,
148 |                         NeighborMode::VonNeumann.as_str(),
149 |                     );
150 |                 });
151 |             let mut mode = rule.color_mode.kind();
152 |             egui::ComboBox::from_label("Color mode")
153 |                 .selected_text(mode.as_str())
154 |                 .show_ui(ui, |ui| {
155 |                     ui.selectable_value(
156 |                         &mut mode,
157 |                         ColorModeKind::Single,
158 |                         ColorModeKind::Single.as_str(),
159 |                     );
160 |                     ui.selectable_value(
161 |                         &mut mode,
162 |                         ColorModeKind::StateLerp,
163 |                         ColorModeKind::StateLerp.as_str(),
164 |                     );
165 |                     ui.selectable_value(
166 |                         &mut mode,
167 |                         ColorModeKind::DistToCenter,
168 |                         ColorModeKind::DistToCenter.as_str(),
169 |                     );
170 |                     ui.selectable_value(
171 |                         &mut mode,
172 |                         ColorModeKind::Neighbour,
173 |                         ColorModeKind::Neighbour.as_str(),
174 |                     );
175 |                 });
176 |             mode.update(&mut rule.color_mode);
177 |             fn color_edit(ui: &mut egui::Ui, color: &mut Color) -> egui::Response {
178 |                 match *color {
179 |                     Color::Rgba {
180 |                         red,
181 |                         green,
182 |                         blue,
183 |                         alpha,
184 |                     } => {
185 |                         let mut rgb = [red, green, blue];
186 |                         let res = ui.color_edit_button_rgb(&mut rgb);
187 |                         *color = Color::Rgba {
188 |                             red: rgb[0],
189 |                             green: rgb[1],
190 |                             blue: rgb[2],
191 |                             alpha,
192 |                         };
193 |                         res
194 |                     }
195 |                     Color::Hsla {
196 |                         hue,
197 |                         saturation,
198 |                         lightness,
199 |                         alpha,
200 |                     } => {
201 |                         let mut c = egui::epaint::Hsva::new(hue, saturation, lightness, alpha);
202 |                         let res = ui.color_edit_button_hsva(&mut c);
203 |                         *color = Color::Hsla {
204 |                             hue: c.h,
205 |                             saturation: c.s,
206 |                             lightness: c.v,
207 |                             alpha: c.a,
208 |                         };
209 |                         res
210 |                     }
211 |                     _ => todo!(),
212 |                 }
213 |             }
214 |             match &mut rule.color_mode {
215 |                 ColorMode::Single(c) => {
216 |                     ui.label("Color");
217 |                     color_edit(ui, c);
218 |                     ui.end_row();
219 |                 }
220 | 
221 |                 ColorMode::StateLerp(c0, c1)
222 |                 | ColorMode::DistToCenter(c0, c1)
223 |                 | ColorMode::Neighbour(c0, c1) => {
224 |                     ui.label("Color A");
225 |                     color_edit(ui, c0);
226 |                     ui.end_row();
227 | 
228 |                     ui.label("Color B");
229 |                     color_edit(ui, c1);
230 |                     ui.end_row();
231 |                 }
232 |             }
233 |         }
234 | 
235 |         ui.heading("Misc");
236 |         if let Some(mut update_time) = update_time {
237 |             ui.label("Update time");
238 |             ui.add(egui::Slider::new(&mut update_time.0, 0.0..=5.0).logarithmic(true));
239 |             if update_time.0 == 5.0 {
240 |                 update_time.0 = f64::INFINITY;
241 |             }
242 |             ui.end_row();
243 |         }
244 |         if let Some(mut meshes) = meshes {
245 |             egui::ComboBox::from_label("Shape")
246 |                 .selected_text(meshes.meshes[meshes.current].0)
247 |                 .show_ui(ui, |ui| {
248 |                     for i in 0..meshes.meshes.len() {
249 |                         let s = meshes.meshes[i].0;
250 |                         ui.selectable_value(&mut meshes.current, i, s);
251 |                     }
252 |                 });
253 |         }
254 |         if let Some(mut movement) = movement {
255 |             ui.heading("Movement");
256 |             ui.label("Speed");
257 |             let mut speed = movement.speed / START_SPEED;
258 |             ui.add(egui::Slider::new(&mut speed, 0.1..=10.0).logarithmic(true));
259 |             movement.speed = speed * START_SPEED;
260 |             ui.end_row();
261 |             ui.label("Sensitivity");
262 |             let mut sensitivity = movement.sensitivity / START_SENSITIVITY;
263 |             ui.add(egui::Slider::new(&mut sensitivity, 0.1..=10.0).logarithmic(true));
264 |             movement.sensitivity = sensitivity * START_SENSITIVITY;
265 |             ui.end_row();
266 |         }
267 | 
268 |         ui.heading("Info");
269 |         ui.label(format!(
270 |             "FPS: {}",
271 |             diagnostics
272 |                 .get(FrameTimeDiagnosticsPlugin::FPS)
273 |                 .and_then(|diagnostic| diagnostic.smoothed())
274 |                 .unwrap_or(0.0)
275 |         ));
276 |     });
277 | }
278 | 


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