more cleaning up

src/pipelines/agents/agent-generation/agent-generation-pipeline.ts

@@ -1,37 +1,29 @@
 import { vec2 } from 'gl-matrix';
 
-import { getWorkgroupCounts } from '../../../utils/graphics/get-workgroup-counts';
+import { getWorkgroupCount } from '../../../utils/graphics/get-workgroup-count';
 import { smartCompile } from '../../../utils/graphics/smart-compile';
-import { CommonState } from '../../common-state/common-state';
 import { AGENT_SIZE_IN_BYTES } from './agent';
 import compactionShader from './agent-compaction.wgsl?raw';
-import countingShader from './agent-counting.wgsl?raw';
-import firstGenerationShader from './agent-first-generation.wgsl?raw';
 import resizeShader from './agent-resize.wgsl?raw';
 import agentSchema from './agent-schema.wgsl?raw';
-import { GenerationCounts } from './generation-counts';
 
 export class AgentGenerationPipeline {
   private static readonly WORKGROUP_SIZE = 64;
   private static readonly UNIFORM_COUNT = 4;
-  private static readonly COUNTER_COUNT = 3;
+  private static readonly COUNTER_COUNT = 1;
 
   private readonly bindGroupLayout: GPUBindGroupLayout;
-  private readonly compactionBindGroupLayout: GPUBindGroupLayout;
   private readonly uniforms: GPUBuffer;
   private readonly bindGroup: GPUBindGroup;
-  private readonly compactionBindGroup: GPUBindGroup;
 
-  private readonly firstGenerationPipeline: GPUComputePipeline;
-  private readonly countingPipeline: GPUComputePipeline;
   private readonly resizePipeline: GPUComputePipeline;
   private readonly compactionPipeline: GPUComputePipeline;
   private readonly compactedAgentsCopyPipeline: GPUComputePipeline;
 
   public readonly agentsBuffer: GPUBuffer;
   private readonly compactedAgentsBuffer: GPUBuffer;
-  public readonly countersBuffer: GPUBuffer;
-  public readonly countersStagingBuffer: GPUBuffer;
+  private readonly countersBuffer: GPUBuffer;
+  private readonly countersStagingBuffer: GPUBuffer;
   private readonly counterClearValues = new Uint32Array(
     AgentGenerationPipeline.COUNTER_COUNT
   );
@@ -41,36 +33,10 @@ export class AgentGenerationPipeline {
 
   public constructor(
     private readonly device: GPUDevice,
-    private readonly commonState: CommonState,
     private readonly maxAgentCountUpperLimit: number
   ) {
+    const emptyBindGroupLayout = device.createBindGroupLayout({ entries: [] });
     this.bindGroupLayout = device.createBindGroupLayout({
-      entries: [
-        {
-          binding: 0,
-          visibility: GPUShaderStage.COMPUTE,
-          buffer: {
-            type: 'uniform',
-          },
-        },
-        {
-          binding: 1,
-          visibility: GPUShaderStage.COMPUTE,
-          buffer: {
-            type: 'storage',
-          },
-        },
-        {
-          binding: 2,
-          visibility: GPUShaderStage.COMPUTE,
-          buffer: {
-            type: 'storage',
-          },
-        },
-      ],
-    });
-
-    this.compactionBindGroupLayout = device.createBindGroupLayout({
       entries: [
         {
           binding: 0,
@@ -130,30 +96,6 @@ export class AgentGenerationPipeline {
 
     this.bindGroup = this.device.createBindGroup({
       layout: this.bindGroupLayout,
-      entries: [
-        {
-          binding: 0,
-          resource: {
-            buffer: this.uniforms,
-          },
-        },
-        {
-          binding: 1,
-          resource: {
-            buffer: this.agentsBuffer,
-          },
-        },
-        {
-          binding: 2,
-          resource: {
-            buffer: this.countersBuffer,
-          },
-        },
-      ],
-    });
-
-    this.compactionBindGroup = this.device.createBindGroup({
-      layout: this.compactionBindGroupLayout,
       entries: [
         {
           binding: 0,
@@ -182,51 +124,21 @@ export class AgentGenerationPipeline {
       ],
     });
 
-    this.firstGenerationPipeline = device.createComputePipeline({
-      layout: device.createPipelineLayout({
-        bindGroupLayouts: [commonState.bindGroupLayout, this.bindGroupLayout],
-      }),
-      compute: {
-        module: smartCompile(
-          device,
-          CommonState.shaderCode,
-          agentSchema,
-          firstGenerationShader
-        ),
-        entryPoint: 'main',
-      },
-    });
-
-    this.countingPipeline = device.createComputePipeline({
-      layout: device.createPipelineLayout({
-        bindGroupLayouts: [commonState.bindGroupLayout, this.bindGroupLayout],
-      }),
-      compute: {
-        module: smartCompile(device, CommonState.shaderCode, agentSchema, countingShader),
-        entryPoint: 'main',
-      },
-    });
-
     this.resizePipeline = device.createComputePipeline({
       layout: device.createPipelineLayout({
-        bindGroupLayouts: [commonState.bindGroupLayout, this.bindGroupLayout],
+        bindGroupLayouts: [emptyBindGroupLayout, this.bindGroupLayout],
       }),
       compute: {
-        module: smartCompile(device, CommonState.shaderCode, agentSchema, resizeShader),
+        module: smartCompile(device, agentSchema, resizeShader),
         entryPoint: 'main',
       },
     });
 
-    const compactionModule = smartCompile(
-      device,
-      CommonState.shaderCode,
-      agentSchema,
-      compactionShader
-    );
+    const compactionModule = smartCompile(device, agentSchema, compactionShader);
 
     this.compactionPipeline = device.createComputePipeline({
       layout: device.createPipelineLayout({
-        bindGroupLayouts: [commonState.bindGroupLayout, this.compactionBindGroupLayout],
+        bindGroupLayouts: [emptyBindGroupLayout, this.bindGroupLayout],
       }),
       compute: {
         module: compactionModule,
@@ -236,7 +148,7 @@ export class AgentGenerationPipeline {
 
     this.compactedAgentsCopyPipeline = device.createComputePipeline({
       layout: device.createPipelineLayout({
-        bindGroupLayouts: [commonState.bindGroupLayout, this.compactionBindGroupLayout],
+        bindGroupLayouts: [emptyBindGroupLayout, this.bindGroupLayout],
       }),
       compute: {
         module: compactionModule,
@@ -251,7 +163,8 @@ export class AgentGenerationPipeline {
         ? this.maxAgentCountUpperLimit
         : Number.POSITIVE_INFINITY,
       Math.floor(this.device.limits.maxBufferSize / AGENT_SIZE_IN_BYTES) - 1,
-      this.device.limits.maxComputeWorkgroupsPerDimension ** 3
+      this.device.limits.maxComputeWorkgroupsPerDimension *
+        AgentGenerationPipeline.WORKGROUP_SIZE
     );
   }
 
@@ -276,82 +189,16 @@ export class AgentGenerationPipeline {
 
     const commandEncoder = this.device.createCommandEncoder();
     const passEncoder = commandEncoder.beginComputePass();
-    this.commonState.execute(passEncoder);
     passEncoder.setPipeline(this.resizePipeline);
     passEncoder.setBindGroup(1, this.bindGroup);
     passEncoder.dispatchWorkgroups(
-      ...getWorkgroupCounts(
-        this.device,
-        agentCount,
-        AgentGenerationPipeline.WORKGROUP_SIZE
-      )
+      getWorkgroupCount(agentCount, AgentGenerationPipeline.WORKGROUP_SIZE)
     );
     passEncoder.end();
 
     this.device.queue.submit([commandEncoder.finish()]);
   }
 
-  public spawnFirstGeneration(): void {
-    const commandEncoder = this.device.createCommandEncoder();
-
-    const passEncoder = commandEncoder.beginComputePass();
-    this.commonState.execute(passEncoder);
-    passEncoder.setPipeline(this.firstGenerationPipeline);
-    passEncoder.setBindGroup(1, this.bindGroup);
-    passEncoder.dispatchWorkgroups(
-      ...getWorkgroupCounts(
-        this.device,
-        this.maxAgentCount,
-        AgentGenerationPipeline.WORKGROUP_SIZE
-      )
-    );
-    passEncoder.end();
-
-    this.device.queue.submit([commandEncoder.finish()]);
-  }
-
-  public async countAgents(agentCount: number): Promise<GenerationCounts> {
-    this.counterClearValues.fill(0);
-    this.agentCountUniformValues.fill(0);
-    this.agentCountUniformValues[0] = agentCount;
-    this.device.queue.writeBuffer(this.countersBuffer, 0, this.counterClearValues);
-    this.device.queue.writeBuffer(this.uniforms, 0, this.agentCountUniformValues);
-
-    const commandEncoder = this.device.createCommandEncoder();
-
-    const passEncoder = commandEncoder.beginComputePass();
-    passEncoder.setPipeline(this.countingPipeline);
-    this.commonState.execute(passEncoder);
-    passEncoder.setBindGroup(1, this.bindGroup);
-    passEncoder.dispatchWorkgroups(
-      ...getWorkgroupCounts(
-        this.device,
-        agentCount,
-        AgentGenerationPipeline.WORKGROUP_SIZE
-      )
-    );
-    passEncoder.end();
-
-    commandEncoder.copyBufferToBuffer(
-      this.countersBuffer,
-      0,
-      this.countersStagingBuffer,
-      0,
-      AgentGenerationPipeline.COUNTER_COUNT * Uint32Array.BYTES_PER_ELEMENT
-    );
-
-    this.device.queue.submit([commandEncoder.finish()]);
-
-    await this.countersStagingBuffer.mapAsync(GPUMapMode.READ);
-
-    const data = new Uint32Array(this.countersStagingBuffer.getMappedRange().slice(0));
-    this.countersStagingBuffer.unmap();
-    return {
-      evenGenerationCount: data[0],
-      oddGenerationCount: data[1],
-    };
-  }
-
   public async compactAgents(agentCount: number): Promise<number> {
     if (agentCount <= 0) {
       return 0;
@@ -366,27 +213,17 @@ export class AgentGenerationPipeline {
     const commandEncoder = this.device.createCommandEncoder();
     const passEncoder = commandEncoder.beginComputePass();
     passEncoder.setPipeline(this.compactionPipeline);
-    this.commonState.execute(passEncoder);
-    passEncoder.setBindGroup(1, this.compactionBindGroup);
+    passEncoder.setBindGroup(1, this.bindGroup);
     passEncoder.dispatchWorkgroups(
-      ...getWorkgroupCounts(
-        this.device,
-        agentCount,
-        AgentGenerationPipeline.WORKGROUP_SIZE
-      )
+      getWorkgroupCount(agentCount, AgentGenerationPipeline.WORKGROUP_SIZE)
     );
     passEncoder.end();
 
     const copyPassEncoder = commandEncoder.beginComputePass();
     copyPassEncoder.setPipeline(this.compactedAgentsCopyPipeline);
-    this.commonState.execute(copyPassEncoder);
-    copyPassEncoder.setBindGroup(1, this.compactionBindGroup);
+    copyPassEncoder.setBindGroup(1, this.bindGroup);
     copyPassEncoder.dispatchWorkgroups(
-      ...getWorkgroupCounts(
-        this.device,
-        agentCount,
-        AgentGenerationPipeline.WORKGROUP_SIZE
-      )
+      getWorkgroupCount(agentCount, AgentGenerationPipeline.WORKGROUP_SIZE)
     );
     copyPassEncoder.end();