@downdraft/engine 0.0.0 → 0.1.1

package/core/src/render/passes/fluid-render.ts

@@ -0,0 +1,137 @@
+import type { WgslStruct } from "@downdraft/engine/shader-graph";
+import { f32, u32, wgsl } from "@downdraft/engine/shader-graph";
+import type { FrameGraphBuilder, GraphRenderContext, TextureHandle } from "../frame-graph";
+import { PassType } from "../frame-graph";
+import { RenderPass } from "../render-pass";
+
+const FluidUniforms: WgslStruct = wgsl.struct("FluidUniforms", {
+  gridSize: u32,
+  dt: f32,
+  viscosity: f32,
+  diffusion: f32,
+  _pad0: u32,
+  _pad1: u32,
+});
+
+const RenderUniforms: WgslStruct = wgsl.struct("RenderUniforms", {
+  gridSize: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+});
+
+export interface FluidConfig {
+  gridResolution: number;
+  viscosity: number;
+  density: number;
+  diffusion: number;
+  pressureIterations: number;
+  enabled: boolean;
+}
+
+export const DEFAULT_FLUID_CONFIG: FluidConfig = {
+  gridResolution: 128,
+  viscosity: 0.0001,
+  density: 0.1,
+  diffusion: 0.0001,
+  pressureIterations: 20,
+  enabled: false,
+};
+
+const FLUID_ADVECT_SHADER = /* wgsl */ `
+${FluidUniforms.wgsl}
+
+@group(0) @binding(0) var<uniform> u: FluidUniforms;
+@group(0) @binding(1) var velocityTex: texture_2d<f32>;
+@group(0) @binding(2) var densityTex: texture_2d<f32>;
+@group(0) @binding(3) var<storage, read_write> outputVel: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read_write> outputDensity: array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8)
+fn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= u.gridSize || gid.y >= u.gridSize) { return; }
+  let idx = gid.y * u.gridSize + gid.x;
+  let texel = vec2<i32>(gid.xy);
+  let vel = textureLoad(velocityTex, texel, 0);
+  let dens = textureLoad(densityTex, texel, 0);
+
+  let pos = vec2<f32>(gid.xy);
+  let backPos = pos - vel.xy * u.dt * f32(u.gridSize);
+  let backTexel = vec2<i32>(clamp(backPos, vec2<f32>(0.0), vec2<f32>(f32(u.gridSize - 1u))));
+
+  let sampledVel = textureLoad(velocityTex, backTexel, 0);
+  let sampledDens = textureLoad(densityTex, backTexel, 0);
+
+  outputVel[idx] = sampledVel;
+  outputDensity[idx] = sampledDens;
+}
+`;
+
+const FLUID_RENDER_SHADER = /* wgsl */ `
+${RenderUniforms.wgsl}
+
+@group(0) @binding(0) var<uniform> u: RenderUniforms;
+@group(0) @binding(1) var densityTex: texture_2d<f32>;
+@group(0) @binding(2) var velocityTex: texture_2d<f32>;
+@group(0) @binding(3) var texSampler: sampler;
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VertexOutput {
+  let positions = 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),
+  );
+  let pos = positions[vi];
+  var output: VertexOutput;
+  output.clipPosition = vec4<f32>(pos, 0.0, 1.0);
+  output.uv = pos * 0.5 + 0.5;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let density = textureSample(densityTex, texSampler, input.uv);
+  let velocity = textureSample(velocityTex, texSampler, input.uv);
+  let color = vec3<f32>(density.r * 0.2, density.r * 0.5, density.r * 0.8 + 0.1);
+  return vec4<f32>(color, density.r);
+}
+`;
+
+export class FluidRenderPass extends RenderPass {
+  name = "fluid-render";
+  passType = PassType.Custom;
+
+  private config: FluidConfig;
+  private device: GPUDevice | null = null;
+
+  densityHandle: TextureHandle | null = null;
+  velocityHandle: TextureHandle | null = null;
+  outputHandle: TextureHandle | null = null;
+
+  constructor(config?: Partial<FluidConfig>, device?: GPUDevice | null) {
+    super();
+    this.config = { ...DEFAULT_FLUID_CONFIG, ...config };
+    this.device = device ?? null;
+  }
+
+  getConfig(): FluidConfig { return this.config; }
+
+  prepare(_device: GPUDevice): void {}
+
+  setup(builder: FrameGraphBuilder): void {
+    if (this.densityHandle) builder.read(this.densityHandle);
+    if (this.velocityHandle) builder.read(this.velocityHandle);
+    if (this.outputHandle) builder.colorAttachment({ handle: this.outputHandle, loadOp: "clear", storeOp: "store" });
+  }
+
+  execute(_ctx: GraphRenderContext): void {
+    if (!this.config.enabled) return;
+  }
+
+  destroy(): void {}
+}

package/core/src/render/passes/gi-types.ts

@@ -0,0 +1,118 @@
+export interface RSMConfig {
+  resolution: number;
+  maxVPLs: number;
+  intensity: number;
+  depthBias: number;
+  rsmRadius: number;
+  enabled: boolean;
+}
+
+export const DEFAULT_RSM_CONFIG: RSMConfig = {
+  resolution: 512,
+  maxVPLs: 512,
+  intensity: 1.0,
+  depthBias: 0.001,
+  rsmRadius: 0.15,
+  enabled: false,
+};
+
+export interface VPLData {
+  position: [number, number, number];
+  color: [number, number, number];
+  intensity: number;
+  range: number;
+  normal: [number, number, number];
+}
+
+export const VPL_FLOATS = 12; // 3 pos + 1 range + 3 color + 1 intensity + 3 normal + 1 pad
+export const VPL_SIZE = VPL_FLOATS * 4; // 48 bytes
+
+export function packVPLsToBuffer(vpls: VPLData[], maxVPLs: number): Float32Array {
+  const buf = new Float32Array(maxVPLs * VPL_FLOATS);
+  for (let i = 0; i < Math.min(vpls.length, maxVPLs); i++) {
+    const vpl = vpls[i];
+    const offset = i * VPL_FLOATS;
+    buf[offset] = vpl.position[0];
+    buf[offset + 1] = vpl.position[1];
+    buf[offset + 2] = vpl.position[2];
+    buf[offset + 3] = vpl.range;
+    buf[offset + 4] = vpl.color[0];
+    buf[offset + 5] = vpl.color[1];
+    buf[offset + 6] = vpl.color[2];
+    buf[offset + 7] = vpl.intensity;
+    buf[offset + 8] = vpl.normal[0];
+    buf[offset + 9] = vpl.normal[1];
+    buf[offset + 10] = vpl.normal[2];
+    buf[offset + 11] = 0; // pad
+  }
+  return buf;
+}
+
+export function sampleRSMToVPLs(
+  rsmDepth: Float32Array,
+  rsmAlbedo: Float32Array,
+  rsmNormal: Float32Array,
+  rsmFlux: Float32Array,
+  width: number,
+  height: number,
+  lightViewProj: Float32Array,
+  invLightViewProj: Float32Array,
+  maxVPLs: number,
+  intensity: number,
+  rsmRadius: number,
+): VPLData[] {
+  const vpls: VPLData[] = [];
+  const sampleStride = Math.max(1, Math.floor((width * height) / maxVPLs));
+
+  let sampleIdx = 0;
+  for (let y = 0; y < height && vpls.length < maxVPLs; y++) {
+    for (let x = 0; x < width && vpls.length < maxVPLs; x++) {
+      if (sampleIdx % sampleStride !== 0) {
+        sampleIdx++;
+        continue;
+      }
+      sampleIdx++;
+
+      const pixelIdx = y * width + x;
+      const depth = rsmDepth[pixelIdx];
+      if (depth >= 1.0) continue;
+
+      // Reconstruct world position from RSM depth
+      const u = (x / width) * 2.0 - 1.0;
+      const v = (y / height) * 2.0 - 1.0;
+      const ndc = [u, -v, depth, 1.0];
+
+      // Transform by inverse light view-proj
+      const worldX = invLightViewProj[0] * ndc[0] + invLightViewProj[4] * ndc[1] + invLightViewProj[8] * ndc[2] + invLightViewProj[12] * ndc[3];
+      const worldY = invLightViewProj[1] * ndc[0] + invLightViewProj[5] * ndc[1] + invLightViewProj[9] * ndc[2] + invLightViewProj[13] * ndc[3];
+      const worldZ = invLightViewProj[2] * ndc[0] + invLightViewProj[6] * ndc[1] + invLightViewProj[10] * ndc[2] + invLightViewProj[14] * ndc[3];
+      const worldW = invLightViewProj[3] * ndc[0] + invLightViewProj[7] * ndc[1] + invLightViewProj[11] * ndc[2] + invLightViewProj[15] * ndc[3];
+
+      const pos: [number, number, number] = [worldX / worldW, worldY / worldW, worldZ / worldW];
+
+      const albedoIdx = pixelIdx * 4;
+      const color: [number, number, number] = [
+        rsmAlbedo[albedoIdx] * rsmFlux[pixelIdx * 3] * intensity,
+        rsmAlbedo[albedoIdx + 1] * rsmFlux[pixelIdx * 3 + 1] * intensity,
+        rsmAlbedo[albedoIdx + 2] * rsmFlux[pixelIdx * 3 + 2] * intensity,
+      ];
+
+      const normalIdx = pixelIdx * 4;
+      const normal: [number, number, number] = [
+        rsmNormal[normalIdx] * 2.0 - 1.0,
+        rsmNormal[normalIdx + 1] * 2.0 - 1.0,
+        rsmNormal[normalIdx + 2] * 2.0 - 1.0,
+      ];
+
+      vpls.push({
+        position: pos,
+        color,
+        intensity: 1.0,
+        range: rsmRadius * 10,
+        normal,
+      });
+    }
+  }
+
+  return vpls;
+}

package/core/src/render/passes/graph-compute.ts

@@ -0,0 +1,300 @@
+// ============================================================================
+// GraphComputePass — frame-graph-integrated compute dispatch from a ComputeGraph
+// Extends RenderPass with PassType.Custom (manages its own beginComputePass/end
+// on the shared encoder, like GpuCullPass). Supports both auto-allocated buffers
+// (from StorageBufferDecl/UniformBufferDecl) and externally-provided buffers
+// for interop with existing systems.
+// ============================================================================
+
+import {
+    ComputeGraphCompiler,
+    type ComputeGraph,
+    type ComputeProfile
+} from "@downdraft/engine/shader-graph";
+import { createLogger } from "../../util/logger";
+import type { RenderContext } from "../frame-graph";
+import { PassType } from "../frame-graph";
+import type { FrameGraphBuilder } from "../render-pass";
+import { RenderPass } from "../render-pass";
+import { createValidatedShaderModule } from "../shader-validator";
+
+const log = createLogger();
+
+/** Default allocation size for runtime-sized storage buffers (1 MB). */
+const DEFAULT_RUNTIME_BUFFER_SIZE = 1 << 20;
+
+/** GPUShaderStage.COMPUTE = 0x4. Defined locally to avoid runtime WebGPU dependency in tests. */
+const SHADER_STAGE_COMPUTE = 0x4;
+
+/** GPUBufferUsage flags. Defined locally for testability. */
+const BUFFER_USAGE = {
+  UNIFORM: 0x40,
+  STORAGE: 0x80,
+  COPY_DST: 0x8,
+  COPY_SRC: 0x4,
+} as const;
+
+export interface GraphComputeBuffer {
+  name: string;
+  buffer: GPUBuffer;
+}
+
+export class GraphComputePass extends RenderPass {
+  readonly name: string;
+  passType: PassType = PassType.Custom;
+
+  private graph: ComputeGraph;
+  private profile: ComputeProfile | undefined;
+  private device: GPUDevice | null = null;
+  private pipeline: GPUComputePipeline | null = null;
+  private shaderModule: GPUShaderModule | null = null;
+  private bindGroup: GPUBindGroup | null = null;
+  private bindGroupLayout: GPUBindGroupLayout | null = null;
+
+  // Buffer management — both modes
+  private ownedBuffers: Map<string, GPUBuffer> = new Map();
+  private externalBuffers: Map<string, GPUBuffer> = new Map();
+  private pendingUniformData: Map<string, ArrayBufferView> = new Map();
+
+  constructor(name: string, graph: ComputeGraph, profile?: ComputeProfile) {
+    super();
+    this.name = name;
+    this.graph = graph;
+    this.profile = profile;
+  }
+
+  prepare(device: GPUDevice): void {
+    this.device = device;
+    this.recompile();
+    this.allocateOwnedBuffers();
+    this.createBindGroup();
+  }
+
+  /** Recompile the graph → new shader module → new pipeline. Supports hot-reload. */
+  recompile(): void {
+    if (!this.device) return;
+
+    const compiler = new ComputeGraphCompiler();
+    const result = compiler.compileDetailed(this.graph, { profile: this.profile });
+    if (result.errors.length > 0) {
+      log.warn(`GraphComputePass:${this.name}`, `Compilation errors: ${result.errors.join("; ")}`);
+    }
+
+    this.shaderModule = createValidatedShaderModule(this.device, {
+      label: this.name,
+      code: result.wgsl,
+    });
+
+    this.bindGroupLayout = this.buildBindGroupLayout();
+    const pipelineLayout = this.device.createPipelineLayout({
+      bindGroupLayouts: [this.bindGroupLayout],
+    });
+
+    this.pipeline = this.device.createComputePipeline({
+      label: this.name,
+      layout: pipelineLayout,
+      compute: { module: this.shaderModule, entryPoint: this.graph.getEntryPoint() },
+    });
+  }
+
+  setup(builder: FrameGraphBuilder): void {
+    void builder;
+    // Compute passes operate on buffers, not textures. The frame graph's
+    // resource tracking is texture-only, so we don't declare reads/writes here.
+    // Ordering is handled via slot registration (same approach as GpuCullPass).
+  }
+
+  execute(ctx: RenderContext): void {
+    if (!this.pipeline || !this.bindGroup || !this.device) return;
+
+    // Flush pending uniform data
+    for (const [name, data] of this.pendingUniformData.entries()) {
+      const buf = this.getBuffer(name);
+      if (buf) {
+        ctx.device.queue.writeBuffer(buf, 0, data as unknown as BufferSource);
+      }
+    }
+    this.pendingUniformData.clear();
+
+    // Rebuild bind group if external buffers changed
+    this.createBindGroup();
+
+    const pass = ctx.encoder.beginComputePass({ label: this.name });
+    pass.setPipeline(this.pipeline);
+    pass.setBindGroup(0, this.bindGroup);
+
+    const dispatch = this.graph.getDispatchConfig().dispatchCount;
+    if (dispatch !== "runtime") {
+      pass.dispatchWorkgroups(dispatch[0], dispatch[1], dispatch[2]);
+    }
+    // "runtime" dispatch requires an indirect buffer — caller handles via
+    // dispatchWorkgroupsIndirect before calling execute, or we extend the API.
+
+    pass.end();
+  }
+
+  // ── Buffer management API ────────────────────────────────────────────────
+
+  /** Provide an externally-owned buffer (skips auto-allocation for this name). */
+  setExternalBuffer(name: string, buffer: GPUBuffer): void {
+    this.externalBuffers.set(name, buffer);
+  }
+
+  /** Get a buffer by name (owned or external). */
+  getBuffer(name: string): GPUBuffer | null {
+    return this.externalBuffers.get(name) ?? this.ownedBuffers.get(name) ?? null;
+  }
+
+  /** Queue uniform data to be written before the next dispatch. */
+  writeUniform(name: string, data: ArrayBufferView): void {
+    this.pendingUniformData.set(name, data);
+  }
+
+  /** Immediately write storage buffer data via the device queue. */
+  writeStorage(name: string, data: ArrayBufferView): void {
+    if (!this.device) return;
+    const buf = this.getBuffer(name);
+    if (buf) {
+      this.device.queue.writeBuffer(buf, 0, data as unknown as BufferSource);
+    }
+  }
+
+  /** Get all owned buffers (for interop with other passes). */
+  getOwnedBuffers(): GraphComputeBuffer[] {
+    return [...this.ownedBuffers.entries()].map(([name, buffer]) => ({ name, buffer }));
+  }
+
+  destroy(): void {
+    for (const buf of this.ownedBuffers.values()) {
+      buf.destroy();
+    }
+    this.ownedBuffers.clear();
+    this.externalBuffers.clear();
+    this.pendingUniformData.clear();
+    this.shaderModule = null;
+    this.pipeline = null;
+    this.bindGroup = null;
+    this.bindGroupLayout = null;
+    this.device = null;
+  }
+
+  // ── Internal helpers ─────────────────────────────────────────────────────
+
+  private buildBindGroupLayout(): GPUBindGroupLayout {
+    if (!this.device) throw new Error("Device not initialized");
+
+    const entries: GPUBindGroupLayoutEntry[] = [];
+    const maxBinding = new Map<number, number>();
+
+    for (const sb of this.graph.getStorageBuffers()) {
+      const access: "read-only" | "read-write" =
+        sb.access === "read" ? "read-only" : "read-write";
+      entries.push({
+        binding: sb.binding,
+        visibility: SHADER_STAGE_COMPUTE,
+        buffer: { type: access === "read-write" ? "storage" : "read-only-storage" },
+      });
+      maxBinding.set(sb.group, Math.max(maxBinding.get(sb.group) ?? 0, sb.binding));
+    }
+
+    for (const ub of this.graph.getUniformBuffers()) {
+      entries.push({
+        binding: ub.binding,
+        visibility: SHADER_STAGE_COMPUTE,
+        buffer: { type: "uniform" },
+      });
+      maxBinding.set(ub.group, Math.max(maxBinding.get(ub.group) ?? 0, ub.binding));
+    }
+
+    return this.device.createBindGroupLayout({ entries });
+  }
+
+  private allocateOwnedBuffers(): void {
+    if (!this.device) return;
+
+    for (const sb of this.graph.getStorageBuffers()) {
+      if (this.externalBuffers.has(sb.name)) continue;
+
+      const structSize = this.computeStructSize(sb.structFields);
+      const elementCount = sb.elementCount ?? Math.floor(
+        (sb.defaultSize ?? DEFAULT_RUNTIME_BUFFER_SIZE) / Math.max(structSize, 4),
+      );
+      const size = Math.max(structSize * elementCount, 16);
+
+      const buffer = this.device.createBuffer({
+        label: `${this.name}:${sb.name}`,
+        size,
+        usage: BUFFER_USAGE.STORAGE | BUFFER_USAGE.COPY_DST | BUFFER_USAGE.COPY_SRC,
+      });
+      this.ownedBuffers.set(sb.name, buffer);
+    }
+
+    for (const ub of this.graph.getUniformBuffers()) {
+      if (this.externalBuffers.has(ub.name)) continue;
+
+      const structSize = this.computeStructSize(ub.structFields);
+      const size = Math.max(structSize, 16);
+
+      const buffer = this.device.createBuffer({
+        label: `${this.name}:${ub.name}`,
+        size,
+        usage: BUFFER_USAGE.UNIFORM | BUFFER_USAGE.COPY_DST,
+      });
+      this.ownedBuffers.set(ub.name, buffer);
+    }
+  }
+
+  private createBindGroup(): void {
+    if (!this.device || !this.bindGroupLayout) return;
+
+    const entries: GPUBindGroupEntry[] = [];
+    let hasAllBuffers = true;
+
+    for (const sb of this.graph.getStorageBuffers()) {
+      const buf = this.getBuffer(sb.name);
+      if (!buf) {
+        hasAllBuffers = false;
+        break;
+      }
+      entries.push({ binding: sb.binding, resource: { buffer: buf } });
+    }
+
+    if (hasAllBuffers) {
+      for (const ub of this.graph.getUniformBuffers()) {
+        const buf = this.getBuffer(ub.name);
+        if (!buf) {
+          hasAllBuffers = false;
+          break;
+        }
+        entries.push({ binding: ub.binding, resource: { buffer: buf } });
+      }
+    }
+
+    if (hasAllBuffers) {
+      this.bindGroup = this.device.createBindGroup({
+        label: `${this.name}:bindgroup`,
+        layout: this.bindGroupLayout,
+        entries,
+      });
+    }
+  }
+
+  private computeStructSize(fields: { name: string; type: string }[]): number {
+    let size = 0;
+    fields.forEach((f) => {
+      size += this.wgslTypeSize(f.type);
+    });
+    // Round up to 16-byte alignment (WGSL uniform buffer min alignment)
+    return Math.ceil(size / 16) * 16;
+  }
+
+  private wgslTypeSize(type: string): number {
+    if (type.startsWith("vec2")) return 8;
+    if (type.startsWith("vec3")) return 12;
+    if (type.startsWith("vec4")) return 16;
+    if (type.startsWith("mat4x4")) return 64;
+    if (type.startsWith("mat3x3")) return 48;
+    if (type === "f32" || type === "u32" || type === "i32") return 4;
+    return 4; // default to scalar
+  }
+}