particles

1 files changed, 207 insertions, 41 deletions

diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
index ff503c8..2aabd48 100644
--- a/src/renderer/mod.rs
+++ b/src/renderer/mod.rs
@@ -13,6 +13,7 @@ use crate::{
     sim::{
         cell::materials::MaterialId,
         cell_sim::world::World,
+        particle_sim::{ParticleManager, particle::Particle},
         rb_sim::{RbSimManager, debug_render::DebugVertex, rb_entity::RbEntity},
     },
 };
@@ -21,12 +22,13 @@ use crate::{
 const CHUNK_SLOTS: usize = 11 * 200;
 const RB_ENTITY_SLOTS: usize = 64;
 const CELL_SLOTS: usize = CHUNK_SLOTS + RB_ENTITY_SLOTS;
+const PARTICLE_SLOTS: usize = 10_000;
 
 const INITIAL_DEBUG_VERTEX_CAPACITY: usize = 4096;
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
-struct Instance {
+struct RendererInstance {
     centre: [f32; 2],
     cos_sin: [f32; 2],
     half_size: [f32; 2],
@@ -35,6 +37,14 @@ struct Instance {
     _padding: u32,
 }
 
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct RendererParticle {
+    position: [f32; 2],
+    data: u32,
+    _padding: u32,
+}
+
 fn srgb_to_linear(channel: u8) -> f32 {
     let channel = channel as f32 / 255.0;
     if channel <= 0.04045 {
@@ -70,12 +80,19 @@ pub struct RendererState {
     pub egui_state: egui_winit::State,
     egui_renderer: egui_wgpu::Renderer,
 
-    // world pixels
-    pixels_pipeline: wgpu::RenderPipeline,
+    // common
     camera_uniform_buffer: wgpu::Buffer,
+
+    // world pixels
+    instance_pipeline: wgpu::RenderPipeline,
     instance_buffer: wgpu::Buffer,
     cell_buffer: wgpu::Buffer,
-    pixels_bind_group: wgpu::BindGroup,
+    instance_bind_group: wgpu::BindGroup,
+
+    // particles
+    particle_pipeline: wgpu::RenderPipeline,
+    particle_buffer: wgpu::Buffer,
+    particle_bind_group: wgpu::BindGroup,
 
     // physics debug lines
     debug_pipeline: wgpu::RenderPipeline,
@@ -157,7 +174,26 @@ impl RendererState {
             }
         });
 
-        let pixels_bind_group_layout =
+        // --- PALETTE ---
+        let mut palette = [0.0f32; MaterialId::ALL.len() * 4];
+        for material in MaterialId::ALL {
+            let def = material.def();
+            let i = material as usize * 4;
+            palette[i] = srgb_to_linear(def.color.0);
+            palette[i + 1] = srgb_to_linear(def.color.1);
+            palette[i + 2] = srgb_to_linear(def.color.2);
+            palette[i + 3] = def.color.3 as f32 / 255.0;
+        }
+
+        let palette_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Palette buffer"),
+            size: size_of_val(&palette) as u64,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        // --- INSTANCES ---
+        let instance_bind_group_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                 label: None,
                 entries: &[
@@ -208,29 +244,29 @@ impl RendererState {
                 ],
             });
 
-        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Shader"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("../shader/shader.wgsl").into()),
+        let instance_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Instance shader"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("../shader/instance.wgsl").into()),
         });
 
-        let pixels_pipeline_layout =
+        let instance_pipeline_layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                 label: None,
                 immediate_size: 0,
-                bind_group_layouts: &[Some(&pixels_bind_group_layout)],
+                bind_group_layouts: &[Some(&instance_bind_group_layout)],
             });
 
-        let pixels_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        let instance_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
             label: None,
-            layout: Some(&pixels_pipeline_layout),
+            layout: Some(&instance_pipeline_layout),
             vertex: wgpu::VertexState {
-                module: &shader,
+                module: &instance_shader,
                 entry_point: Some("vs_main"),
                 buffers: &[],
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
             },
             fragment: Some(wgpu::FragmentState {
-                module: &shader,
+                module: &instance_shader,
                 entry_point: Some("fs_main"),
                 targets: &[Some(wgpu::ColorTargetState {
                     format: config.format,
@@ -261,28 +297,11 @@ impl RendererState {
             mapped_at_creation: false,
         });
 
-        let mut palette = [0.0f32; MaterialId::ALL.len() * 4];
-        for material in MaterialId::ALL {
-            let def = material.def();
-            let i = material as usize * 4;
-            palette[i] = srgb_to_linear(def.color.0);
-            palette[i + 1] = srgb_to_linear(def.color.1);
-            palette[i + 2] = srgb_to_linear(def.color.2);
-            palette[i + 3] = def.color.3 as f32 / 255.0;
-        }
-
-        let palette_buffer = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Palette buffer"),
-            size: size_of_val(&palette) as u64,
-            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-
         queue.write_buffer(&palette_buffer, 0, bytemuck::cast_slice(&palette));
 
         let instance_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Instance buffer"),
-            size: (CELL_SLOTS * size_of::<Instance>()) as u64,
+            size: (CELL_SLOTS * size_of::<RendererInstance>()) as u64,
             usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
@@ -294,9 +313,9 @@ impl RendererState {
             mapped_at_creation: false,
         });
 
-        let pixels_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        let instance_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
             label: None,
-            layout: &pixels_bind_group_layout,
+            layout: &instance_bind_group_layout,
             entries: &[
                 wgpu::BindGroupEntry {
                     binding: 0,
@@ -317,6 +336,120 @@ impl RendererState {
             ],
         });
 
+        // --- PARTICLES ---
+        let particle_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: None,
+                entries: &[
+                    // camera uniform
+                    wgpu::BindGroupLayoutEntry {
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Uniform,
+                            has_dynamic_offset: false,
+                            min_binding_size: None,
+                        },
+                        binding: 0,
+                        count: None,
+                        visibility: wgpu::ShaderStages::VERTEX,
+                    },
+                    // palette
+                    wgpu::BindGroupLayoutEntry {
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Storage { read_only: true },
+                            has_dynamic_offset: false,
+                            min_binding_size: None,
+                        },
+                        binding: 1,
+                        count: None,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                    },
+                    // instance buffer
+                    wgpu::BindGroupLayoutEntry {
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Storage { read_only: true },
+                            has_dynamic_offset: false,
+                            min_binding_size: None,
+                        },
+                        binding: 2,
+                        count: None,
+                        visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
+                    },
+                ],
+            });
+
+        let particle_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Particle shader"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("../shader/particle.wgsl").into()),
+        });
+
+        let particle_pipeline_layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                immediate_size: 0,
+                bind_group_layouts: &[Some(&particle_bind_group_layout)],
+            });
+
+        let particle_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&particle_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &particle_shader,
+                entry_point: Some("vs_main"),
+                buffers: &[],
+                compilation_options: wgpu::PipelineCompilationOptions::default(),
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &particle_shader,
+                entry_point: Some("fs_main"),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: config.format,
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+                compilation_options: wgpu::PipelineCompilationOptions::default(),
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleStrip,
+                strip_index_format: None,
+                front_face: wgpu::FrontFace::Ccw,
+                cull_mode: None,
+                polygon_mode: wgpu::PolygonMode::Fill,
+                unclipped_depth: false,
+                conservative: false,
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+            multiview_mask: None,
+            cache: None,
+        });
+
+        let particle_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Particle buffer"),
+            size: (PARTICLE_SLOTS * size_of::<RendererParticle>()) as u64,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        let particle_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: None,
+            layout: &particle_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: camera_uniform_buffer.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: palette_buffer.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: particle_buffer.as_entire_binding(),
+                },
+            ],
+        });
+
+        // --- DEBUG ---
         let debug_bind_group_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                 label: Some("Debug bind group layout"),
@@ -409,11 +542,16 @@ impl RendererState {
             egui_state,
             egui_renderer,
 
-            pixels_pipeline,
             camera_uniform_buffer,
+
+            instance_pipeline,
             instance_buffer,
             cell_buffer,
-            pixels_bind_group,
+            instance_bind_group,
+
+            particle_pipeline,
+            particle_buffer,
+            particle_bind_group,
 
             debug_pipeline,
             debug_bind_group,
@@ -437,6 +575,7 @@ impl RendererState {
         &mut self,
         world: &mut World,
         rb_sim_manager: &mut RbSimManager,
+        particle_manager: &mut ParticleManager,
         camera: &mut Camera,
         config: &mut Config,
         diagnostics: &Diagnostics,
@@ -528,7 +667,7 @@ impl RendererState {
         );
 
         let mut cell_buffer: [u8; CELLS_IN_CHUNK] = [0; CELLS_IN_CHUNK];
-        let mut instances: Vec<Instance> = Vec::new();
+        let mut instances: Vec<RendererInstance> = Vec::new();
 
         {
             puffin::profile_scope!("Upload chunk cells");
@@ -587,7 +726,7 @@ impl RendererState {
             for cx in cxl..=cxu {
                 for cy in cyl..=cyu {
                     if let Some(idx) = world.chunk_position_to_chunk_idx.get(&(cx, cy)) {
-                        instances.push(Instance {
+                        instances.push(RendererInstance {
                             centre: [
                                 (cx * CHUNK_SIZE) as f32 + half_size[0],
                                 (cy * CHUNK_SIZE) as f32 + half_size[1],
@@ -606,7 +745,7 @@ impl RendererState {
                 if let Some(&RbEntity { width, height, .. }) = rb_sim_manager.rb_entities.get(id)
                     && let Some((x, y, cos, sin)) = rb_sim_manager.get_rb_entity_transform(*id)
                 {
-                    instances.push(Instance {
+                    instances.push(RendererInstance {
                         centre: [x, y],
                         cos_sin: [cos, sin],
                         half_size: [width as f32 / 2.0, height as f32 / 2.0],
@@ -621,6 +760,25 @@ impl RendererState {
                 .write_buffer(&self.instance_buffer, 0, bytemuck::cast_slice(&instances));
         }
 
+        let mut particles: Vec<RendererParticle> = Vec::new();
+
+        {
+            puffin::profile_scope!("Build particles");
+            // TODO could cull this to visible, maybe it's slower?
+            particles = particle_manager
+                .particles
+                .iter()
+                .map(|p| RendererParticle {
+                    position: [p.position.x, p.position.y],
+                    data: p.material as u32,
+                    _padding: 0,
+                })
+                .collect();
+
+            self.queue
+                .write_buffer(&self.particle_buffer, 0, bytemuck::cast_slice(&particles));
+        }
+
         let debug_vertex_count = if config.debug_render {
             puffin::profile_scope!("Build physics debug lines");
             let vertices = rb_sim_manager.debug_render(config.debug_render_mode);
@@ -671,6 +829,7 @@ impl RendererState {
                     multiview_mask: None,
                 });
 
+            // this is kind of a hack
             let instances_start = u32::min(
                 if config.cells_render {
                     0
@@ -680,10 +839,17 @@ impl RendererState {
                 instances.len() as u32 - 1,
             );
 
-            render_pass.set_pipeline(&self.pixels_pipeline);
-            render_pass.set_bind_group(0, &self.pixels_bind_group, &[]);
+            // instances
+            render_pass.set_pipeline(&self.instance_pipeline);
+            render_pass.set_bind_group(0, &self.instance_bind_group, &[]);
             render_pass.draw(0..4, instances_start..instances.len() as u32);
 
+            // particles
+            render_pass.set_pipeline(&self.particle_pipeline);
+            render_pass.set_bind_group(0, &self.particle_bind_group, &[]);
+            render_pass.draw(0..4, 0..particles.len() as u32);
+
+            // debug
             if debug_vertex_count > 0 {
                 render_pass.set_pipeline(&self.debug_pipeline);
                 render_pass.set_bind_group(0, &self.debug_bind_group, &[]);