Refactor

src/pipelines/agents/agent-pipeline.ts

@@ -34,24 +34,23 @@ export class AgentPipeline {
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
     });
 
-    const serializedAgents = new Float32Array(
-      new ArrayBuffer(agents.length * AGENT_SIZE_IN_BYTES)
-    );
-    agents.forEach((agent, i) => {
-      serializedAgents[(i * AGENT_SIZE_IN_BYTES) / Float32Array.BYTES_PER_ELEMENT + 0] =
-        agent.position[0];
-      serializedAgents[(i * AGENT_SIZE_IN_BYTES) / Float32Array.BYTES_PER_ELEMENT + 1] =
-        agent.position[1];
-      serializedAgents[(i * AGENT_SIZE_IN_BYTES) / Float32Array.BYTES_PER_ELEMENT + 2] =
-        agent.angle;
-    });
-
     this.agentsBuffer = device.createBuffer({
       size: agents.length * AGENT_SIZE_IN_BYTES,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+      usage: GPUBufferUsage.STORAGE,
+      mappedAtCreation: true,
     });
 
-    device.queue.writeBuffer(this.agentsBuffer, 0, serializedAgents.buffer);
+    new Float32Array(this.agentsBuffer.getMappedRange()).set(
+      agents.flatMap((agent) => [
+        agent.position[0],
+        agent.position[1],
+        agent.angle,
+        agent.species,
+        agent.timeToLive,
+        0, // padding
+      ])
+    );
+    this.agentsBuffer.unmap();
   }
 
   public setParameters({

src/pipelines/agents/agent.ts

@@ -3,6 +3,8 @@ import { vec2 } from 'gl-matrix';
 export interface Agent {
   position: vec2;
   angle: number;
+  species: number;
+  timeToLive: number;
 }
 
-export const AGENT_SIZE_IN_BYTES = 4 * 4;
+export const AGENT_SIZE_IN_BYTES = 6 * Float32Array.BYTES_PER_ELEMENT;

src/pipelines/agents/agent.wgsl

@@ -1,6 +1,8 @@
 struct Agent {
   position: vec2<f32>,
   angle: f32,
+  species: f32,
+  timeToLive: f32
 }
 
 struct Settings {
@@ -30,7 +32,7 @@ fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
 
   var agent = agents[id];
 
-  let random = f32(hash(id + u32(settings.time * 10000 + agent.position.y * 10 + agent.position.x))) / 4294967295.0;
+  let random = random(id + u32(settings.time * 10000 + agent.position.y * 10 + agent.position.x));
 
   let weightForward : f32 = sense(agent, 0.);
   let weightLeft : f32 = sense(agent, settings.sensorAngle);
@@ -54,28 +56,27 @@ fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
   textureStore(
     TrailMapOut, 
     vec2<i32>(newPos * settings.size),
-    vec4(vec3<f32>(1.) * settings.trailWeight * 0.02, 1.)
+    vec4(1)
   );
 
   agent.position = newPos;
   agents[id] = agent;
 }
 
-fn hash(state0 : u32) -> u32 {
-  // Hash function www.cs.ubc.ca/~rbridson/docs/schechter-sca08-turbulence.pdf
-  var state : u32 = state0;
-  state = state ^ 2747636419u;
-  state = state * 2654435769u;
-  state = state ^ (state >> 16u);
-  state = state * 2654435769u;
-  state = state ^ (state >> 16u);
-  state = state * 2654435769u;
-  return state;
-}
-
 fn sense(agent : Agent, sensorAngleOffset : f32) -> f32 {
   let sensorAngle : f32 = agent.angle + sensorAngleOffset;
   let sensorDir : vec2<f32> = vec2(cos(sensorAngle), sin(sensorAngle)) / normalize(settings.size);
   let sensorPos : vec2<f32> = agent.position + sensorDir * settings.sensorOffsetDst;
   return textureLoad(TrailMapIn, vec2<i32>(sensorPos * settings.size), 0).x;  
 }
+
+fn random(state0 : u32) -> f32 {
+  var state : u32 = state0;
+  state = state ^ 2747636419u;
+  state = state * 2654435769u;
+  state = state ^ (state >> 16u);
+  state = state * 2654435769u;
+  state = state ^ (state >> 16u);
+  state = state * 2654435769u;
+  return f32(state) / 4294967295.0;
+}

src/pipelines/diffusion/diffuse.wgsl

@@ -20,11 +20,11 @@ fn fragment(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
     + textureSample(trailMap, Sampler, uv + vec2<f32>(0, -1) / settings.size)
     + textureSample(trailMap, Sampler, uv + vec2<f32>(-1, 0) / settings.size)
     + textureSample(trailMap, Sampler, uv + vec2<f32>(1, 0) / settings.size)
-  );
+  ) / 4;
 
   let mixed = mix(
     current,
-    neighbours / 4.0,
+    neighbours,
     settings.diffusionRate
   ) * (1.0 - settings.decayRate);