Refactor & improve

src/pipelines/diffusion/diffusion-pipeline.ts

@@ -1,41 +1,39 @@
 import { setUpFullScreenQuad } from '../../utils/graphics/full-screen-quad/full-screen-quad';
-import { generateNoise } from '../../utils/graphics/noise/noise';
-import random from '../../utils/graphics/random.wgsl';
 import { smartCompile } from '../../utils/graphics/smart-compile';
-import { CommonParameters } from '../common-parameters';
+import { CommonState } from '../common-state/common-state';
 import shader from './diffuse.wgsl';
 import { DiffusionSettings } from './diffusion-settings';
 
 export class DiffusionPipeline {
-  private static readonly UNIFORM_COUNT = 18;
+  private static readonly UNIFORM_COUNT = 4;
 
+  private readonly bindGroupLayout: GPUBindGroupLayout;
   private readonly pipeline: GPURenderPipeline;
   private readonly uniforms: GPUBuffer;
   private readonly quadVertexBuffer: GPUBuffer;
   private readonly noise: GPUTextureView;
 
   private bindGroup?: GPUBindGroup;
-  private previousTrailMapIn?: GPUTexture;
+  private previousTrailMapIn?: GPUTextureView;
 
-  public constructor(private readonly device: GPUDevice) {
-    this.noise = generateNoise({
-      device,
-      width: 256,
-      height: 256,
-      octaves: 8,
-      amplitude: 0.12,
-      gain: 0.7,
-      lacunarity: 80,
-    });
+  public constructor(
+    private readonly device: GPUDevice,
+    private readonly commonState: CommonState
+  ) {
+    this.bindGroupLayout = device.createBindGroupLayout(
+      DiffusionPipeline.bindGroupLayout
+    );
 
     const { buffer, vertex } = setUpFullScreenQuad(device);
     this.quadVertexBuffer = buffer;
 
     this.pipeline = device.createRenderPipeline({
-      layout: 'auto',
+      layout: device.createPipelineLayout({
+        bindGroupLayouts: [commonState.bindGroupLayout, this.bindGroupLayout],
+      }),
       vertex,
       fragment: {
-        module: smartCompile(device, random, shader),
+        module: smartCompile(device, CommonState.shaderCode, shader),
         entryPoint: 'fragment',
         targets: [
           {
@@ -55,22 +53,15 @@ export class DiffusionPipeline {
   }
 
   public setParameters({
-    canvasSize,
-    deltaTime,
-    time,
     diffusionRateTrails,
     decayRateTrails,
     diffusionRateBrush,
     decayRateBrush,
-  }: CommonParameters & DiffusionSettings) {
+  }: DiffusionSettings) {
     this.device.queue.writeBuffer(
       this.uniforms,
       0,
       new Float32Array([
-        canvasSize[0],
-        canvasSize[1],
-        deltaTime,
-        time,
         diffusionRateTrails,
         decayRateTrails,
         diffusionRateBrush,
@@ -81,16 +72,16 @@ export class DiffusionPipeline {
 
   public execute(
     commandEncoder: GPUCommandEncoder,
-    trailMapIn: GPUTexture,
-    trailMapOut: GPUTexture
+    trailMapIn: GPUTextureView,
+    trailMapOut: GPUTextureView
   ) {
     this.ensureBindGroupExists(trailMapIn);
 
     const renderPassDescriptor: GPURenderPassDescriptor = {
       colorAttachments: [
         {
-          view: trailMapOut.createView(),
-          clearValue: { r: 1.0, g: 1.0, b: 1.0, a: 1.0 },
+          view: trailMapOut,
+          clearValue: { r: 0, g: 0, b: 0, a: 0 },
           loadOp: 'clear',
           storeOp: 'store',
         },
@@ -100,15 +91,16 @@ export class DiffusionPipeline {
     const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
     passEncoder.setPipeline(this.pipeline);
     passEncoder.setVertexBuffer(0, this.quadVertexBuffer);
-    passEncoder.setBindGroup(0, this.bindGroup);
+    this.commonState.execute(passEncoder);
+    passEncoder.setBindGroup(1, this.bindGroup);
     passEncoder.draw(4, 1);
     passEncoder.end();
   }
 
-  private ensureBindGroupExists(trailMapIn: GPUTexture) {
+  private ensureBindGroupExists(trailMapIn: GPUTextureView) {
     if (this.previousTrailMapIn !== trailMapIn) {
       this.bindGroup = this.device.createBindGroup({
-        layout: this.pipeline.getBindGroupLayout(0),
+        layout: this.bindGroupLayout,
         entries: [
           {
             binding: 0,
@@ -125,11 +117,7 @@ export class DiffusionPipeline {
           },
           {
             binding: 2,
-            resource: trailMapIn.createView(),
-          },
-          {
-            binding: 3,
-            resource: this.noise,
+            resource: trailMapIn,
           },
         ],
       });
@@ -142,4 +130,32 @@ export class DiffusionPipeline {
     this.quadVertexBuffer.destroy();
     this.uniforms.destroy();
   }
+
+  private static get bindGroupLayout(): GPUBindGroupLayoutDescriptor {
+    return {
+      entries: [
+        {
+          binding: 0,
+          visibility: GPUShaderStage.FRAGMENT,
+          buffer: {
+            type: 'uniform',
+          },
+        },
+        {
+          binding: 1,
+          visibility: GPUShaderStage.FRAGMENT,
+          sampler: {
+            type: 'filtering',
+          },
+        },
+        {
+          binding: 2,
+          visibility: GPUShaderStage.FRAGMENT,
+          texture: {
+            sampleType: 'float',
+          },
+        },
+      ],
+    };
+  }
 }