Optimize performance with instanced rendering and concurrent spatial grid, and fix WASM simulation panic

Author: rgilks

Cargo.lock

@@ -19,6 +19,7 @@ rayon = "1.8"
 rand = { version = "0.8", features = ["getrandom"] }
 getrandom = { version = "0.2", features = ["js"] }
 indexmap = "=2.2.6" # Pin version to avoid E0658 with our toolchain
+dashmap = "5.5"
 
 # Graphics - match galacto version
 wgpu = { version = "24.0", features = ["webgl"] }
@@ -44,6 +45,10 @@ serde-wasm-bindgen = "0.6"
 console_error_panic_hook = "0.1"
 raw-window-handle = { version = "0.6", features = ["wasm-bindgen-0-2"] }
 
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+parking_lot = { version = "0.12", features = ["nightly"] }
+instant = { version = "0.1", features = ["wasm-bindgen"] }
+
 [profile.release]
 opt-level = 3
 lto = true

Cargo.toml

@@ -1,57 +1,66 @@
-struct VertexInput {
-    @location(0) position: vec2<f32>,
-    @location(1) color: vec3<f32>,
-    @location(2) center: vec2<f32>,
-    @location(3) radius: f32,
+// Instance data: position (xy), radius, color (rgb)
+struct InstanceInput {
+    @location(0) pos_radius: vec4<f32>,  // xy = position, z = radius, w = unused
+    @location(1) color: vec4<f32>,       // rgb = color, a = unused
 }
 
 struct VertexOutput {
     @builtin(position) position: vec4<f32>,
     @location(0) color: vec3<f32>,
-    @location(1) center: vec2<f32>,
-    @location(2) radius: f32,
-    @location(3) uv: vec2<f32>,
+    @location(1) uv: vec2<f32>,
 }
 
+// Quad vertices (generated in shader)
+const QUAD_VERTICES: array<vec2<f32>, 6> = array<vec2<f32>, 6>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>(1.0, -1.0),
+    vec2<f32>(-1.0, 1.0),
+    vec2<f32>(1.0, -1.0),
+    vec2<f32>(1.0, 1.0),
+    vec2<f32>(-1.0, 1.0),
+);
+
 @vertex
-fn vs_main(vertex: VertexInput) -> VertexOutput {
+fn vs_main(
+    instance: InstanceInput,
+    @builtin(vertex_index) vertex_index: u32,
+) -> VertexOutput {
     var out: VertexOutput;
-    out.position = vec4<f32>(vertex.position, 0.0, 1.0);
-    out.color = vertex.color;
-    out.center = vertex.center;
-    out.radius = vertex.radius;
-    
-    // Calculate UV coordinates relative to the ball's center
-    out.uv = (vertex.position - vertex.center) / vertex.radius;
+
+    let quad_pos = QUAD_VERTICES[vertex_index];
+    let screen_pos = instance.pos_radius.xy;
+    let radius = instance.pos_radius.z;
 
+    // Expand quad by radius with glow extension
+    let glow_extension = radius * 0.5;
+    let quad_size = radius + glow_extension;
+
+    out.position = vec4<f32>(screen_pos + quad_pos * quad_size, 0.0, 1.0);
+    out.color = instance.color.rgb;
+    out.uv = quad_pos;  // -1 to 1 range
+
     return out;
 }
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    // Calculate distance from center of the ball
+    // Distance from center (uv is -1 to 1)
     let dist = length(in.uv);
 
-    // Create a proper circular shape with smooth falloff
-    let circle = smoothstep(1.0, 0.0, dist);
-    
-    // Create a more pronounced glowing effect with multiple layers
-    let core = smoothstep(1.0, 0.0, dist * 2.0); // Bright core
-    let glow_inner = smoothstep(1.0, 0.0, dist * 1.5) * 0.9; // Inner glow
-    let glow_middle = smoothstep(1.0, 0.0, dist * 1.2) * 0.7; // Middle glow
-    let glow_outer = smoothstep(1.0, 0.0, dist * 0.8) * 0.5; // Outer glow
-    let glow_far = smoothstep(1.0, 0.0, dist * 0.5) * 0.3; // Far glow
-    
-    // Combine all glow layers for a more intense effect
+    // Create glowing ball effect
+    let core = smoothstep(1.0, 0.0, dist * 2.0);
+    let glow_inner = smoothstep(1.0, 0.0, dist * 1.5) * 0.9;
+    let glow_middle = smoothstep(1.0, 0.0, dist * 1.2) * 0.7;
+    let glow_outer = smoothstep(1.0, 0.0, dist * 0.8) * 0.5;
+    let glow_far = smoothstep(1.0, 0.0, dist * 0.5) * 0.3;
+
     let glow = core + glow_inner + glow_middle + glow_outer + glow_far;
-    
-    // Create the final color with transparency
-    let alpha = glow * 0.95; // More opaque for better visibility
+    let alpha = glow * 0.95;
     let final_color = in.color * glow;
 
-    // Add a subtle white glow around the edges for better definition
+    // White glow for definition
     let white_glow = smoothstep(1.0, 0.0, dist * 0.4) * 0.2;
     let final_color_with_glow = final_color + vec3<f32>(white_glow);
-    
+
     return vec4<f32>(final_color_with_glow, alpha);
-} 
+}

src/shader.wgsl

@@ -154,19 +154,14 @@ impl Simulation {
     fn rebuild_spatial_grid(&mut self) {
         self.grid.clear();
 
-        // Use parallel processing for grid building
-        let grid_entities: Vec<_> = self
-            .world
+        // Parallel inserts directly into DashMap (thread-safe)
+        self.world
             .query::<(&Position,)>()
             .iter()
             .par_bridge()
-            .map(|(entity, (pos,))| (entity, pos.x, pos.y))
-            .collect();
-
-        // Insert entities into grid (this part needs to be sequential due to HashMap)
-        for (entity, x, y) in grid_entities {
-            self.grid.insert(entity, x, y);
-        }
+            .for_each(|(entity, (pos,))| {
+                self.grid.insert(entity, pos.x, pos.y);
+            });
     }
 
     fn process_entities_parallel(&self) -> Vec<EntityUpdate> {