Rework garden simulation pipelines

2026-05-24 10:58:11 +01:00 · 2026-05-24 10:58:11 +01:00 · 018f8c9d4d
commit 018f8c9d4d
parent c2efb33683
67 changed files with 6499 additions and 1682 deletions
--- a/src/game-loop/game-loop-resources.ts
+++ b/src/game-loop/game-loop-resources.ts
@ -0,0 +1,186 @@
+import { vec2 } from 'gl-matrix';
+
+import { appConfig, type GardenRuntimeSettings } from '../config';
+import { AgentGenerationPipeline } from '../pipelines/agents/agent-generation/agent-generation-pipeline';
+import { AgentPipeline } from '../pipelines/agents/agent-pipeline';
+import { BrushPipeline } from '../pipelines/brush/brush-pipeline';
+import { CommonState } from '../pipelines/common-state/common-state';
+import { DiffusionPipeline } from '../pipelines/diffusion/diffusion-pipeline';
+import { EraserAgentPipeline } from '../pipelines/eraser/eraser-agent-pipeline';
+import { EraserTexturePipeline } from '../pipelines/eraser/eraser-texture-pipeline';
+import { RenderPipeline } from '../pipelines/render/render-pipeline';
+import { initializeContext } from '../utils/graphics/initialize-context';
+import { CanvasReadbackRequest, RenderInputs } from './game-loop-types';
+import { GpuProfiler } from './gpu-profiler';
+import { SimulationFrameRenderer } from './simulation-frame';
+import { SimulationTextures } from './simulation-textures';
+
+interface FrameParameters extends RenderInputs {
+  time: number;
+  deltaTime: number;
+  canvasSize: vec2;
+  activeAgentCount: number;
+  canvasPixelRatio: number;
+  introProgress: number;
+  selectedColorIndex: number;
+  eraserPixelSize: number;
+  runtimeSettings: GardenRuntimeSettings;
+}
+
+export class GameLoopResources {
+  public readonly textures: SimulationTextures;
+  public readonly commonState: CommonState;
+  public readonly agentGenerationPipeline: AgentGenerationPipeline;
+  public readonly agentPipeline: AgentPipeline;
+  public readonly brushPipeline: BrushPipeline;
+  public readonly eraserAgentPipeline: EraserAgentPipeline;
+  public readonly eraserTexturePipeline: EraserTexturePipeline;
+  public readonly diffusionPipeline: DiffusionPipeline;
+  public readonly renderPipeline: RenderPipeline;
+  public readonly gpuProfiler: GpuProfiler | null;
+
+  private readonly frameRenderer: SimulationFrameRenderer;
+
+  public constructor(
+    canvas: HTMLCanvasElement,
+    private readonly device: GPUDevice,
+    private readonly canvasFormat: GPUTextureFormat,
+    canvasSize: vec2,
+    initialAgentCapacity: number,
+    initialMaxAgentCount: number
+  ) {
+    const context = initializeContext({ device, canvas, format: canvasFormat });
+
+    this.textures = new SimulationTextures(this.device, canvasSize);
+
+    this.commonState = new CommonState(this.device);
+    this.commonState.setParameters({
+      canvasSize,
+    });
+
+    this.agentGenerationPipeline = new AgentGenerationPipeline(
+      this.device,
+      Math.min(initialMaxAgentCount, initialAgentCapacity)
+    );
+
+    this.agentPipeline = new AgentPipeline(
+      this.device,
+      this.commonState,
+      () => this.agentGenerationPipeline.agentsBuffer
+    );
+    this.brushPipeline = new BrushPipeline(this.device, this.commonState);
+    this.eraserAgentPipeline = new EraserAgentPipeline(
+      this.device,
+      () => this.agentGenerationPipeline.agentsBuffer
+    );
+    this.eraserTexturePipeline = new EraserTexturePipeline(this.device, this.commonState);
+    this.diffusionPipeline = new DiffusionPipeline(this.device);
+    this.renderPipeline = new RenderPipeline(context, this.device, this.canvasFormat);
+    this.gpuProfiler = GpuProfiler.create(
+      this.device,
+      () => appConfig.tuningPane.showFpsOverlay
+    );
+
+    this.frameRenderer = new SimulationFrameRenderer(
+      this.device,
+      this.textures,
+      {
+        agentPipeline: this.agentPipeline,
+        brushPipeline: this.brushPipeline,
+        eraserAgentPipeline: this.eraserAgentPipeline,
+        eraserTexturePipeline: this.eraserTexturePipeline,
+        diffusionPipeline: this.diffusionPipeline,
+        renderPipeline: this.renderPipeline,
+      },
+      this.gpuProfiler
+    );
+  }
+
+  public resizeSimulationTo(nextSize: vec2): vec2 | null {
+    return this.textures.resizeTo(nextSize);
+  }
+
+  public clearSimulation(): void {
+    this.textures.clear();
+    this.frameRenderer.resetSourceMapActivity();
+  }
+
+  public get isSourceMapActive(): boolean {
+    return this.frameRenderer.isSourceMapActive;
+  }
+
+  public get gpuPassTimeMs(): number | undefined {
+    return this.gpuProfiler?.latestTotalPassMs;
+  }
+
+  public setFrameParameters({
+    time,
+    deltaTime,
+    canvasSize,
+    activeAgentCount,
+    canvasPixelRatio,
+    introProgress,
+    selectedColorIndex,
+    channelColors,
+    backgroundColor,
+    eraserPixelSize,
+    runtimeSettings,
+  }: FrameParameters): void {
+    this.commonState.setParameters({
+      canvasSize,
+    });
+    this.agentPipeline.setParameters({
+      ...runtimeSettings,
+      deltaTime,
+      time,
+      agentCount: activeAgentCount,
+      introMoveSpeed: appConfig.simulation.introMoveSpeed,
+      introProgress,
+    });
+    this.brushPipeline.setParameters({
+      ...runtimeSettings,
+      pixelRatio: canvasPixelRatio,
+      selectedColorIndex,
+    });
+    this.diffusionPipeline.setParameters(runtimeSettings);
+    this.renderPipeline.setParameters({
+      ...runtimeSettings,
+      channelColors,
+      backgroundColor,
+    });
+    this.eraserAgentPipeline.setParameters({
+      agentCount: activeAgentCount,
+      eraserSize: eraserPixelSize,
+      eraserMaskAlphaThreshold: runtimeSettings.eraserMaskAlphaThreshold,
+      maskSize: canvasSize,
+    });
+    this.eraserTexturePipeline.setParameters({
+      eraserSize: eraserPixelSize,
+      eraserLineDistanceEpsilon: runtimeSettings.eraserLineDistanceEpsilon,
+      eraserClearRed: runtimeSettings.eraserClearRed,
+      eraserClearGreen: runtimeSettings.eraserClearGreen,
+      eraserClearBlue: runtimeSettings.eraserClearBlue,
+      eraserClearAlpha: runtimeSettings.eraserClearAlpha,
+    });
+  }
+
+  public executeFrame(
+    isErasing: boolean,
+    canvasReadbackRequest?: CanvasReadbackRequest | null
+  ): void {
+    this.frameRenderer.execute(isErasing, canvasReadbackRequest);
+  }
+
+  public destroy(): void {
+    this.agentGenerationPipeline.destroy();
+    this.agentPipeline.destroy();
+    this.brushPipeline.destroy();
+    this.eraserAgentPipeline.destroy();
+    this.eraserTexturePipeline.destroy();
+    this.diffusionPipeline.destroy();
+    this.renderPipeline.destroy();
+    this.gpuProfiler?.destroy();
+    this.commonState.destroy();
+    this.textures.destroy();
+  }
+}