start implementing

lucascompython · lucascompython · commit 14fe902c123e · 2025-04-22T15:53:44.000+01:00
diff --git a/src/app.rs b/src/app.rs
@@ -14,6 +14,7 @@ use std::time::Instant;
 
 pub struct ParticleApp {
     simulation: Box<dyn ParticleSimulation>,
+    surface_format: wgpu::TextureFormat,
     renderer: ParticleRenderer,
     camera: Camera,
 
@@ -94,20 +95,33 @@ impl ParticleApp {
             SimulationMethod::TransformFeedback
         };
 
-        // Create simulation based on method
+        let surface_format = wgpu_render_state.target_format;
+
         let initial_particles;
         let simulation: Box<dyn ParticleSimulation> = match default_method {
             SimulationMethod::Cpu => {
                 initial_particles = 10_000;
-                Box::new(CpuParticleSimulation::new(device, initial_particles))
+                Box::new(CpuParticleSimulation::new(
+                    device,
+                    initial_particles,
+                    surface_format,
+                ))
             }
             SimulationMethod::ComputeShader => {
                 initial_particles = 1_000_000;
-                Box::new(ComputeParticleSimulation::new(device, initial_particles))
+                Box::new(ComputeParticleSimulation::new(
+                    device,
+                    initial_particles,
+                    surface_format,
+                ))
             }
             SimulationMethod::TransformFeedback => {
                 initial_particles = 100_000;
-                Box::new(TransformFeedbackSimulation::new(device, initial_particles))
+                Box::new(TransformFeedbackSimulation::new(
+                    device,
+                    initial_particles,
+                    surface_format,
+                ))
             }
         };
 
@@ -122,6 +136,7 @@ impl ParticleApp {
 
         Self {
             simulation,
+            surface_format,
             renderer,
             camera,
 
@@ -161,13 +176,21 @@ impl ParticleApp {
 
         // Create new simulation with the same particle count
         self.simulation = match new_method {
-            SimulationMethod::Cpu => Box::new(CpuParticleSimulation::new(device, current_count)),
-            SimulationMethod::ComputeShader => {
-                Box::new(ComputeParticleSimulation::new(device, current_count))
-            }
-            SimulationMethod::TransformFeedback => {
-                Box::new(TransformFeedbackSimulation::new(device, current_count))
-            }
+            SimulationMethod::Cpu => Box::new(CpuParticleSimulation::new(
+                device,
+                current_count,
+                self.surface_format,
+            )),
+            SimulationMethod::ComputeShader => Box::new(ComputeParticleSimulation::new(
+                device,
+                current_count,
+                self.surface_format,
+            )),
+            SimulationMethod::TransformFeedback => Box::new(TransformFeedbackSimulation::new(
+                device,
+                current_count,
+                self.surface_format,
+            )),
         };
 
         self.simulation.set_paused(was_paused);
diff --git a/src/main.rs b/src/main.rs
@@ -48,6 +48,8 @@ fn main() -> eframe::Result {
                     limits.max_storage_buffer_binding_size =
                         limits.max_storage_buffer_binding_size.max(128 << 20); // 128 MB
 
+                    let mut features = wgpu::Features::empty();
+
                     wgpu::DeviceDescriptor {
                         label: Some("Particle Simulation Device"),
                         required_features: wgpu::Features::empty(),
diff --git a/src/renderer.rs b/src/renderer.rs
@@ -72,30 +72,19 @@ impl ParticleRenderer {
                 entry_point: Some("fs_main"),
                 targets: &[Some(wgpu::ColorTargetState {
                     format: *surface_format,
-                    blend: Some(wgpu::BlendState {
-                        color: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
-                        },
-                        alpha: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::One,
-                            dst_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
-                        },
-                    }),
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                     write_mask: wgpu::ColorWrites::ALL,
                 })],
                 compilation_options: Default::default(),
             }),
             primitive: wgpu::PrimitiveState {
                 topology: wgpu::PrimitiveTopology::PointList,
-                strip_index_format: None,
-                front_face: wgpu::FrontFace::Ccw,
-                cull_mode: Some(wgpu::Face::Back),
-                polygon_mode: wgpu::PolygonMode::Fill,
-                unclipped_depth: false,
-                conservative: false,
+                ..Default::default() // strip_index_format: None,
+                                     // front_face: wgpu::FrontFace::Ccw,
+                                     // cull_mode: Some(wgpu::Face::Back),
+                                     // polygon_mode: wgpu::PolygonMode::Fill,
+                                     // unclipped_depth: false,
+                                     // conservative: false,
             },
             depth_stencil: None,
             multisample: wgpu::MultisampleState {
diff --git a/src/shaders/transform_feedback.wgsl b/src/shaders/transform_feedback.wgsl
@@ -1,106 +1,125 @@
-struct Particle {
-  position: vec3<f32>,
-  padding1: f32,
-  velocity: vec3<f32>,
-  padding2: f32,
-  color: vec4<f32>,
+struct ParticleInput {
+    @location(0) position: vec3<f32>,
+    @location(1) padding1: f32,
+    @location(2) velocity: vec3<f32>,
+    @location(3) padding2: f32,
+    @location(4) color: vec4<f32>,
 };
 
+// Output structure matching the Particle struct layout for TF capture
+struct ParticleOutput {
+    @location(0) out_position: vec3<f32>,
+    @location(1) out_padding1: f32,
+    @location(2) out_velocity: vec3<f32>,
+    @location(3) out_padding2: f32,
+    @location(4) out_color: vec4<f32>,
+    // We still need a dummy @builtin(position) for the rasterizer, even if TF is active
+    @builtin(position) clip_position: vec4<f32>,
+};
+
+// Uniforms (same as compute shader)
 struct SimParams {
+  // First 16 bytes
   delta_time: f32,
   gravity: f32,
   color_mode: u32,
   mouse_force: f32,
+
+  // Second 16 bytes
   mouse_radius: f32,
-  mouse_position: vec3<f32>,
   is_mouse_dragging: u32,
   damping: f32,
-};
-
-@group(0) @binding(0)
-var<storage, read> particles_in: array<Particle>;
-
-@group(0) @binding(1)
-var<uniform> params: SimParams;
-
-@group(0) @binding(2)
-var<storage, read_write> particles_out: array<Particle>;
+  _padding1: u32, // Ensure correct padding for std140/std430 alignment
 
-struct VertexOutput {
-  @builtin(position) position: vec4<f32>,
+  // Last 16 bytes
+  mouse_position: vec3<f32>,
+  _padding2: u32, // Ensure correct padding
 };
 
+@group(0) @binding(0) var<uniform> params: SimParams;
+
 @vertex
-fn vs_main(@builtin(vertex_index) vertex_index: u32) -> VertexOutput {
-  var output: VertexOutput;
+fn vs_main(particle_in: ParticleInput) -> ParticleOutput {
+
+    // --- Simulation Logic (using particle_in) ---
+    var new_velocity = particle_in.velocity;
+    var new_position = particle_in.position;
+    var new_color    = particle_in.color;
+
+    // Apply gravity
+    new_velocity.y -= params.gravity * params.delta_time;
+
+    // Apply mouse force
+    if (params.is_mouse_dragging > 0u) {
+        let dir = params.mouse_position - new_position;
+        let dist = length(dir);
+
+        if (dist < params.mouse_radius * 2.0) {
+            // Make the force stronger overall and more dramatic for closer particles
+            let force_factor = pow(1.0 - dist / (params.mouse_radius * 2.0), 2.0) * 2.0;
+            let force = normalize(dir) * params.mouse_force * force_factor;
+            new_velocity += force * params.delta_time;
+        }
+    }
 
-  // Get current particle
-  var particle = particles_in[vertex_index];
+    // Update position
+    new_position += new_velocity * params.delta_time;
+
+    // Handle boundaries
+    let bounds = 500.0;
+    if (new_position.x < -bounds) {
+        new_position.x = -bounds;
+        new_velocity.x = abs(new_velocity.x) * 0.5;
+    } else if (new_position.x > bounds) {
+        new_position.x = bounds;
+        new_velocity.x = -abs(new_velocity.x) * 0.5;
+    }
+    // ... (repeat for y and z boundaries) ...
+    if (new_position.y < -bounds) {
+        new_position.y = -bounds;
+        new_velocity.y = abs(new_velocity.y) * 0.5;
+    } else if (new_position.y > bounds) {
+        new_position.y = bounds;
+        new_velocity.y = -abs(new_velocity.y) * 0.5;
+    }
+    if (new_position.z < -bounds) {
+        new_position.z = -bounds;
+        new_velocity.z = abs(new_velocity.z) * 0.5;
+    } else if (new_position.z > bounds) {
+        new_position.z = bounds;
+        new_velocity.z = -abs(new_velocity.z) * 0.5;
+    }
 
-  // Apply gravity
-  particle.velocity.y -= params.gravity * params.delta_time;
 
-  // Apply mouse force (same as compute shader)
-  if (params.is_mouse_dragging > 0u) {
-    let dir = params.mouse_position - particle.position;
-    let dist = length(dir);
+    // Apply damping
+    new_velocity *= params.damping;
 
-    if (dist < params.mouse_radius * 2.0) {
-      let force_factor = pow(1.0 - dist / (params.mouse_radius * 2.0), 2.0) * 2.0;
-      let force = normalize(dir) * params.mouse_force * force_factor;
-      particle.velocity += force * params.delta_time;
+    // Update color based on mode
+    if (params.color_mode == 1u) {
+        // Velocity-based coloring
+        let speed = length(new_velocity);
+        let norm_speed = min(speed / 5.0, 1.0);
+        new_color = vec4<f32>(norm_speed, 0.5 - norm_speed * 0.5, 1.0 - norm_speed, 1.0);
+    } else if (params.color_mode == 2u) {
+        // Position-based coloring
+        let norm_pos = (new_position / bounds + vec3<f32>(1.0)) * 0.5;
+        new_color = vec4<f32>(norm_pos.x, norm_pos.y, norm_pos.z, 1.0);
     }
-  }
-
-  // Update position
-  particle.position += particle.velocity * params.delta_time;
-
-  // Handle boundaries
-  let bounds = 500.0;
-
-  if (particle.position.x < -bounds) {
-    particle.position.x = -bounds;
-    particle.velocity.x = abs(particle.velocity.x) * 0.5;
-  } else if (particle.position.x > bounds) {
-    particle.position.x = bounds;
-    particle.velocity.x = -abs(particle.velocity.x) * 0.5;
-  }
-
-  if (particle.position.y < -bounds) {
-    particle.position.y = -bounds;
-    particle.velocity.y = abs(particle.velocity.y) * 0.5;
-  } else if (particle.position.y > bounds) {
-    particle.position.y = bounds;
-    particle.velocity.y = -abs(particle.velocity.y) * 0.5;
-  }
-  
-  if (particle.position.z < -bounds) {
-    particle.position.z = -bounds;
-    particle.velocity.z = abs(particle.velocity.z) * 0.5;
-  } else if (particle.position.z > bounds) {
-    particle.position.z = bounds;
-    particle.velocity.z = -abs(particle.velocity.z) * 0.5;
-  }
-
-  // Apply damping
-  particle.velocity *= params.damping;
-
-  // Update color based on mode (same logic as compute shader)
-  if (params.color_mode == 1u) {
-    // Velocity-based coloring
-    let speed = length(particle.velocity);
-    let norm_speed = min(speed / 5.0, 1.0);
-    particle.color = vec4<f32>(norm_speed, 0.5 - norm_speed * 0.5, 1.0 - norm_speed, 1.0);
-  } else if (params.color_mode == 2u) {
-    // Position-based coloring
-    let norm_pos = (particle.position / bounds + 1.0) * 0.5;
-    particle.color = vec4<f32>(norm_pos.x, norm_pos.y, norm_pos.z, 1.0);
-  }
-
-  // Write updated particle to output buffer
-  particles_out[vertex_index] = particle;
-
-  // We don't actually render anything in this pass
-  output.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
-  return output;
+    // else: keep original color (already in new_color)
+
+    // --- Output the NEW state ---
+    var output: ParticleOutput;
+    output.out_position = new_position;
+    output.out_padding1 = 0.0; // Ensure padding is written
+    output.out_velocity = new_velocity;
+    output.out_padding2 = 0.0; // Ensure padding is written
+    output.out_color = new_color;
+    output.clip_position = vec4(0.0, 0.0, 0.0, 1.0); // Dummy position, not used for rendering here
+
+    return output;
 }
+
+@fragment
+fn fs_dummy_main() {
+    
+}
diff --git a/src/simulation/compute.rs b/src/simulation/compute.rs
@@ -14,7 +14,11 @@ pub struct ComputeParticleSimulation {
 }
 
 impl ParticleSimulation for ComputeParticleSimulation {
-    fn new(device: &wgpu::Device, initial_particle_count: u32) -> Self {
+    fn new(
+        device: &wgpu::Device,
+        initial_particle_count: u32,
+        _surface_format: wgpu::TextureFormat,
+    ) -> Self {
         // Create initial particles
         let particles = generate_initial_particles(initial_particle_count);
 
diff --git a/src/simulation/cpu.rs b/src/simulation/cpu.rs
@@ -11,7 +11,11 @@ pub struct CpuParticleSimulation {
 }
 
 impl ParticleSimulation for CpuParticleSimulation {
-    fn new(device: &wgpu::Device, initial_particle_count: u32) -> Self {
+    fn new(
+        device: &wgpu::Device,
+        initial_particle_count: u32,
+        _surface_format: wgpu::TextureFormat,
+    ) -> Self {
         let particles = generate_initial_particles(initial_particle_count);
 
         let particle_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
diff --git a/src/simulation/mod.rs b/src/simulation/mod.rs
@@ -14,7 +14,11 @@ pub enum SimulationMethod {
 }
 
 pub trait ParticleSimulation {
-    fn new(device: &Device, initial_particle_count: u32) -> Self
+    fn new(
+        device: &Device,
+        initial_particle_count: u32,
+        surface_format: wgpu::TextureFormat,
+    ) -> Self
     where
         Self: Sized;
     fn update(
@@ -100,7 +104,7 @@ pub fn generate_initial_particles(count: u32) -> Vec<Particle> {
         let g = rng.random::<f32>();
         let b = rng.random::<f32>();
 
-        let phi = rng.random::<f32>() * std::f32::consts::PI * 2.0;
+        let phi = rng.random::<f32>() * std::f32::consts::TAU;
         let theta = (rng.random::<f32>() - 0.5) * std::f32::consts::PI;
         let radius = rng.random::<f32>() * 50.0;
 
diff --git a/src/simulation/transform_feedback.rs b/src/simulation/transform_feedback.rs
