@downdraft/engine 0.0.0 → 0.1.0

package/core/src/render/passes/rsm-pass.ts

@@ -0,0 +1,248 @@
+import type { StructView, WgslStruct } from "@downdraft/engine/shader-graph";
+import { f32, mat4x4f, u32, vec2f, vec3f, wgsl } from "@downdraft/engine/shader-graph";
+import type { FrameGraphBuilder, GraphRenderContext, TextureHandle } from "../frame-graph";
+import { PassType } from "../frame-graph";
+import { RenderPass } from "../render-pass";
+import { createValidatedShaderModule } from "../shader-validator";
+import { DEFAULT_RSM_CONFIG, type RSMConfig, VPL_FLOATS, packVPLsToBuffer } from "./gi-types";
+
+const RSMUniforms: WgslStruct = wgsl.struct("RSMUniforms", {
+  lightViewProj: mat4x4f,
+  invLightViewProj: mat4x4f,
+  rsmResolution: u32,
+  maxVPLs: u32,
+  intensity: f32,
+  rsmRadius: f32,
+  _pad0: u32,
+  _pad1: u32,
+});
+
+const RSMEvalUniforms: WgslStruct = wgsl.struct("RSMEvalUniforms", {
+  cameraPos: vec3f,
+  numVPLs: u32,
+  viewProj: mat4x4f,
+  invViewProj: mat4x4f,
+  screenSize: vec2f,
+  _pad0: f32,
+  _pad1: f32,
+});
+
+const RSM_INJECT_SHADER = /* wgsl */ `
+${RSMUniforms.wgsl}
+
+struct VPL {
+  position: vec4<f32>,
+  color: vec4<f32>,
+  normal: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> uniforms: RSMUniforms;
+@group(0) @binding(1) var rsmDepthTex: texture_2d<f32>;
+@group(0) @binding(2) var rsmAlbedoTex: texture_2d<f32>;
+@group(0) @binding(3) var rsmNormalTex: texture_2d<f32>;
+@group(0) @binding(4) var rsmFluxTex: texture_2d<f32>;
+@group(0) @binding(5) var<storage, read_write> vplBuffer: array<VPL>;
+
+fn reconstructWorldPos(uv: vec2<f32>, depth: f32) -> vec3<f32> {
+  let ndc = vec3<f32>(uv * 2.0 - 1.0, depth);
+  let worldPos = uniforms.invLightViewProj * vec4<f32>(ndc, 1.0);
+  return worldPos.xyz / worldPos.w;
+}
+
+@compute @workgroup_size(64)
+fn cs_main(@builtin(global_invocation_id) gid: u32) {
+  if (gid >= uniforms.maxVPLs) { return; }
+
+  let totalTexels = uniforms.rsmResolution * uniforms.rsmResolution;
+  let stride = totalTexels / uniforms.maxVPLs;
+  let texelIdx = gid * stride;
+
+  let y = texelIdx / uniforms.rsmResolution;
+  let x = texelIdx % uniforms.rsmResolution;
+  if (x >= uniforms.rsmResolution || y >= uniforms.rsmResolution) { return; }
+
+  let texel = vec2<i32>(i32(x), i32(y));
+  let depth = textureLoad(rsmDepthTex, texel, 0);
+  if (depth >= 1.0) {
+    vplBuffer[gid] = VPL(vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0));
+    return;
+  }
+
+  let uv = vec2<f32>(f32(x) / f32(uniforms.rsmResolution), f32(y) / f32(uniforms.rsmResolution));
+  let worldPos = reconstructWorldPos(uv, depth);
+
+  let albedo = textureLoad(rsmAlbedoTex, texel, 0);
+  let normal = textureLoad(rsmNormalTex, texel, 0);
+  let flux = textureLoad(rsmFluxTex, texel, 0);
+
+  let color = albedo.rgb * flux.rgb * uniforms.intensity;
+  let range = uniforms.rsmRadius * 10.0;
+
+  vplBuffer[gid] = VPL(
+    vec4<f32>(worldPos, range),
+    vec4<f32>(color, 1.0),
+    vec4<f32>(normal.rgb * 2.0 - 1.0, 0.0),
+  );
+}
+`;
+
+const RSM_EVALUATE_SHADER = /* wgsl */ `
+${RSMEvalUniforms.wgsl}
+
+struct VPL {
+  position: vec4<f32>,
+  color: vec4<f32>,
+  normal: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> uniforms: RSMEvalUniforms;
+@group(0) @binding(1) var depthTex: texture_depth_2d;
+@group(0) @binding(2) var normalTex: texture_2d<f32>;
+@group(0) @binding(3) var<storage> vplBuffer: array<VPL>;
+
+fn reconstructWorldPos(uv: vec2<f32>, depth: f32) -> vec3<f32> {
+  let ndc = vec3<f32>(uv * 2.0 - 1.0, depth);
+  let worldPos = uniforms.invViewProj * vec4<f32>(ndc, 1.0);
+  return worldPos.xyz / worldPos.w;
+}
+
+@compute @workgroup_size(8, 8)
+fn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let dims = vec2<u32>(textureDimensions(depthTex));
+  if (gid.x >= dims.x || gid.y >= dims.y) { return; }
+
+  let texel = vec2<i32>(gid.xy);
+  let depth = textureLoad(depthTex, texel, 0);
+  if (depth >= 1.0) { return; }
+
+  let uv = vec2<f32>(gid.xy) / vec2<f32>(dims);
+  let worldPos = reconstructWorldPos(uv, depth);
+
+  let normalSample = textureLoad(normalTex, texel, 0);
+  let N = normalize(normalSample.rgb * 2.0 - 1.0);
+
+  var indirect = vec3<f32>(0.0);
+  for (var i = 0u; i < uniforms.numVPLs; i = i + 1u) {
+    let vpl = vplBuffer[i];
+    if (vpl.color.w < 0.01) { continue; }
+
+    let toVPL = vpl.position.xyz - worldPos;
+    let dist = length(toVPL);
+    if (dist > vpl.position.w) { continue; }
+
+    let L = toVPL / max(dist, 0.001);
+    let NdotL = max(dot(N, L), 0.0);
+    let vplNdotL = max(dot(-vpl.normal.xyz, L), 0.0);
+
+    let attenuation = 1.0 / (1.0 + dist * dist);
+    indirect += vpl.color.rgb * NdotL * vplNdotL * attenuation;
+  }
+
+  // Output is stored in a texture for compositing
+  // This compute shader writes to a storage texture
+}
+`;
+
+export class RSMPass extends RenderPass {
+  name = "rsm-inject";
+  passType = PassType.Custom;
+
+  private device: GPUDevice | null;
+  private config: RSMConfig;
+
+  private injectPipeline: GPUComputePipeline | null = null;
+  private injectBindGroup: GPUBindGroup | null = null;
+  private vplBuffer: GPUBuffer | null = null;
+  private rsmUniformBuffer: GPUBuffer | null = null;
+  private _uniformView: StructView | null = null;
+  private _uniformBuf: Float32Array | null = null;
+
+  rsmDepthHandle: TextureHandle | null = null;
+  rsmAlbedoHandle: TextureHandle | null = null;
+  rsmNormalHandle: TextureHandle | null = null;
+  rsmFluxHandle: TextureHandle | null = null;
+
+  private lightViewProj: Float32Array = new Float32Array(16);
+  private invLightViewProj: Float32Array = new Float32Array(16);
+
+  constructor(config?: Partial<RSMConfig>, device?: GPUDevice | null) {
+    super();
+    this.config = { ...DEFAULT_RSM_CONFIG, ...config };
+    this.device = device ?? null;
+  }
+
+  prepare(device: GPUDevice): void {
+    this.device = device;
+
+    this.vplBuffer = device.createBuffer({
+      label: "rsm-vpl-buffer",
+      size: this.config.maxVPLs * VPL_FLOATS * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+
+    this.rsmUniformBuffer = device.createBuffer({
+      label: "rsm-uniforms",
+      size: RSMUniforms.size,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    this._uniformBuf = new Float32Array(RSMUniforms.floatCount);
+    this._uniformView = RSMUniforms.view(this._uniformBuf);
+
+    const shader = createValidatedShaderModule(device, { code: RSM_INJECT_SHADER, label: "RSMPass.inject" });
+    this.injectPipeline = device.createComputePipeline({
+      label: "rsm-inject",
+      layout: "auto",
+      compute: { module: shader, entryPoint: "cs_main" },
+    });
+  }
+
+  setLightMatrices(lightViewProj: Float32Array, invLightViewProj: Float32Array): void {
+    this.lightViewProj = lightViewProj;
+    this.invLightViewProj = invLightViewProj;
+  }
+
+  updateUniforms(): void {
+    const view = this._uniformView!;
+    view.set("lightViewProj", this.lightViewProj);
+    view.set("invLightViewProj", this.invLightViewProj);
+
+    if (this.device && this.rsmUniformBuffer) {
+      this.device.queue.writeBuffer(this.rsmUniformBuffer, 0, this._uniformBuf as unknown as BufferSource);
+    }
+  }
+
+  updateVPLs(vpls: ReturnType<typeof packVPLsToBuffer>): void {
+    if (this.device && this.vplBuffer) {
+      this.device.queue.writeBuffer(this.vplBuffer, 0, vpls as unknown as BufferSource);
+    }
+  }
+
+  getVPLBuffer(): GPUBuffer | null {
+    return this.vplBuffer;
+  }
+
+  getConfig(): RSMConfig {
+    return this.config;
+  }
+
+  setup(builder: FrameGraphBuilder): void {
+    if (this.rsmDepthHandle) builder.read(this.rsmDepthHandle);
+    if (this.rsmAlbedoHandle) builder.read(this.rsmAlbedoHandle);
+    if (this.rsmNormalHandle) builder.read(this.rsmNormalHandle);
+    if (this.rsmFluxHandle) builder.read(this.rsmFluxHandle);
+  }
+
+  execute(ctx: GraphRenderContext): void {
+    if (!this.config.enabled) return;
+    this.updateUniforms();
+    // The actual compute dispatch happens in the render loop
+    // This pass is a Custom pass — it dispatches compute directly
+  }
+
+  destroy(): void {
+    this.vplBuffer?.destroy();
+    this.rsmUniformBuffer?.destroy();
+    this._uniformView = null;
+    this._uniformBuf = null;
+  }
+}

package/core/src/render/passes/sdf-text.ts

@@ -0,0 +1,155 @@
+import type { WgslStruct } from "@downdraft/engine/shader-graph";
+import { f32, vec4f, wgsl } from "@downdraft/engine/shader-graph";
+
+export interface SDFGlyph {
+  char: string;
+  charCode: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  advance: number;
+  bearingX: number;
+  bearingY: number;
+}
+
+export interface SDFFontData {
+  glyphs: Map<number, SDFGlyph>;
+  atlasWidth: number;
+  atlasHeight: number;
+  fontSize: number;
+  distanceRange: number;
+  lineHeight: number;
+  ascent: number;
+  descent: number;
+  name: string;
+}
+
+export function parseSDFFont(json: string): SDFFontData {
+  const data = JSON.parse(json);
+  const glyphs = new Map<number, SDFGlyph>();
+
+  if (data.glyphs) {
+    data.glyphs.forEach((glyph: any) => {
+      glyphs.set(glyph.unicode, {
+        char: String.fromCodePoint(glyph.unicode),
+        charCode: glyph.unicode,
+        x: glyph.planeBounds?.left ?? glyph.x ?? 0,
+        y: glyph.planeBounds?.bottom ?? glyph.y ?? 0,
+        width: glyph.planeBounds ? glyph.planeBounds.right - glyph.planeBounds.left : (glyph.width ?? 0),
+        height: glyph.planeBounds ? glyph.planeBounds.top - glyph.planeBounds.bottom : (glyph.height ?? 0),
+        advance: glyph.advance,
+        bearingX: glyph.planeBounds?.left ?? 0,
+        bearingY: glyph.planeBounds?.top ?? 0,
+      });
+    });
+  }
+
+  return {
+    glyphs,
+    atlasWidth: data.atlas?.width ?? 512,
+    atlasHeight: data.atlas?.height ?? 512,
+    fontSize: data.atlas?.size ?? 32,
+    distanceRange: data.atlas?.distanceRange ?? 4,
+    lineHeight: data.metrics?.lineHeight ?? 1.2,
+    ascent: data.metrics?.ascender ?? 0.8,
+    descent: data.metrics?.descender ?? -0.2,
+    name: data.name ?? "sdf-font",
+  };
+}
+
+export function layoutSDFText(
+  text: string,
+  font: SDFFontData,
+  fontSize: number,
+  maxWidth: number = Infinity,
+): { quads: Array<{ x: number; y: number; w: number; h: number; u: number; v: number; uw: number; vh: number }>; width: number; height: number } {
+  const scale = fontSize / font.fontSize;
+  const quads: Array<{ x: number; y: number; w: number; h: number; u: number; v: number; uw: number; vh: number }> = [];
+  let penX = 0;
+  let penY = 0;
+  const lineHeight = font.lineHeight * fontSize;
+
+  for (let _i = 0, _it = text, _n = _it.length; _i < _n; _i++) { const char = _it[_i];
+    const charCode = char.codePointAt(0);
+    if (charCode === undefined) continue;
+
+    if (char === "\n") {
+      penX = 0;
+      penY += lineHeight;
+      continue;
+    }
+
+    const glyph = font.glyphs.get(charCode);
+    if (!glyph) continue;
+
+    if (maxWidth !== Infinity && penX + glyph.advance * scale > maxWidth) {
+      penX = 0;
+      penY += lineHeight;
+    }
+
+    const w = glyph.width * scale;
+    const h = glyph.height * scale;
+    const x = penX + glyph.bearingX * scale;
+    const y = penY - glyph.bearingY * scale + font.ascent * fontSize;
+
+    quads.push({
+      x, y, w, h,
+      u: glyph.x / font.atlasWidth,
+      v: 1.0 - (glyph.y + glyph.height) / font.atlasHeight,
+      uw: glyph.width / font.atlasWidth,
+      vh: glyph.height / font.atlasHeight,
+    });
+
+    penX += glyph.advance * scale;
+  }
+
+  return { quads, width: penX, height: penY + lineHeight };
+}
+
+const TextUniforms: WgslStruct = wgsl.struct("TextUniforms", {
+  color: vec4f,
+  outlineColor: vec4f,
+  outlineWidth: f32,
+  smoothing: f32,
+  _pad0: f32,
+  _pad1: f32,
+});
+
+export const SDF_TEXT_SHADER = /* wgsl */ `
+${TextUniforms.wgsl}
+
+@group(0) @binding(0) var<uniform> u: TextUniforms;
+@group(0) @binding(1) var atlasTex: texture_2d<f32>;
+@group(0) @binding(2) var texSampler: sampler;
+
+struct VertexInput {
+  @location(0) position: vec2<f32>,
+  @location(1) uv: vec2<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  output.clipPosition = vec4<f32>(input.position, 0.0, 1.0);
+  output.uv = input.uv;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let sdf = textureSample(atlasTex, texSampler, input.uv).r;
+  let smoothing = u.smoothing;
+  let outlineThreshold = 0.5 - u.outlineWidth;
+  let fillAlpha = smoothstep(0.5 - smoothing, 0.5 + smoothing, sdf);
+  let outlineAlpha = smoothstep(outlineThreshold - smoothing, outlineThreshold + smoothing, sdf) - fillAlpha;
+  let color = u.color.rgb * fillAlpha + u.outlineColor.rgb * outlineAlpha;
+  let alpha = fillAlpha + outlineAlpha * u.outlineColor.a;
+  return vec4<f32>(color, alpha);
+}
+`;

package/core/src/render/passes/shadow-map.ts

@@ -0,0 +1,163 @@
+// ============================================================================
+// Shadow Map System — single-cascade directional shadow mapping
+// Renders scene depth from the sun's perspective into a depth texture.
+// Provides a bind group with the shadow map, comparison sampler, and light VP
+// matrix for PCF-filtered shadow sampling in lit shaders.
+// ============================================================================
+
+import { mat4 } from "wgpu-matrix";
+
+export interface ShadowMapOptions {
+  depthFormat?: GPUTextureFormat;
+  shadowMapSize?: number;
+  shadowDistance?: number;
+  shadowRadius?: number;
+}
+
+const DEFAULT_SHADOW_MAP_SIZE = 2048;
+const DEFAULT_SHADOW_DISTANCE = 600;
+const DEFAULT_SHADOW_RADIUS = 350;
+
+export class ShadowMapSystem {
+  private device: GPUDevice;
+  private depthFormat: GPUTextureFormat;
+  private shadowMapSize: number;
+  private shadowDistance: number;
+  private shadowRadius: number;
+
+  private shadowTexture: GPUTexture | null = null;
+  private shadowDepthView: GPUTextureView | null = null;
+  private shadowUniformBuffer: GPUBuffer | null = null;
+  private shadowSampler: GPUSampler | null = null;
+  private shadowBindGroupLayout: GPUBindGroupLayout | null = null;
+  private shadowBindGroup: GPUBindGroup | null = null;
+
+  private shadowUniformData = new Float32Array(20);
+  private lightVP = new Float32Array(16);
+
+  constructor(device: GPUDevice, options?: ShadowMapOptions) {
+    this.device = device;
+    this.depthFormat = options?.depthFormat ?? "depth32float";
+    this.shadowMapSize = options?.shadowMapSize ?? DEFAULT_SHADOW_MAP_SIZE;
+    this.shadowDistance = options?.shadowDistance ?? DEFAULT_SHADOW_DISTANCE;
+    this.shadowRadius = options?.shadowRadius ?? DEFAULT_SHADOW_RADIUS;
+  }
+
+  init(): void {
+    this.shadowTexture = this.device.createTexture({
+      size: [this.shadowMapSize, this.shadowMapSize],
+      format: this.depthFormat,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+    });
+    this.shadowDepthView = this.shadowTexture.createView();
+
+    this.shadowUniformBuffer = this.device.createBuffer({
+      size: 256,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+
+    this.shadowSampler = this.device.createSampler({
+      compare: "less",
+      magFilter: "linear",
+      minFilter: "linear",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+    });
+
+    this.shadowBindGroupLayout = this.device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
+        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } },
+      ],
+    });
+
+    this.shadowBindGroup = this.device.createBindGroup({
+      layout: this.shadowBindGroupLayout,
+      entries: [
+        { binding: 0, resource: { buffer: this.shadowUniformBuffer } },
+        { binding: 1, resource: this.shadowDepthView },
+        { binding: 2, resource: this.shadowSampler },
+      ],
+    });
+  }
+
+  getBindGroupLayout(): GPUBindGroupLayout | null {
+    return this.shadowBindGroupLayout;
+  }
+
+  getBindGroup(): GPUBindGroup | null {
+    return this.shadowBindGroup;
+  }
+
+  getShadowDepthView(): GPUTextureView | null {
+    return this.shadowDepthView;
+  }
+
+  getShadowUniformBuffer(): GPUBuffer | null {
+    return this.shadowUniformBuffer;
+  }
+
+  getShadowSampler(): GPUSampler | null {
+    return this.shadowSampler;
+  }
+
+  getLightVP(): Float32Array {
+    return this.lightVP;
+  }
+
+  getShadowMapSize(): number {
+    return this.shadowMapSize;
+  }
+
+  updateLightVP(
+    sunDir: [number, number, number],
+    cameraTarget: [number, number, number],
+  ): void {
+    const len = Math.sqrt(sunDir[0] ** 2 + sunDir[1] ** 2 + sunDir[2] ** 2) || 1;
+    const dir: [number, number, number] = [
+      sunDir[0] / len,
+      sunDir[1] / len,
+      sunDir[2] / len,
+    ];
+
+    // sunDir points toward the sun — the light sits on the sun side of the
+    // target and looks back down at it.
+    const lightPos: [number, number, number] = [
+      cameraTarget[0] + dir[0] * this.shadowDistance,
+      cameraTarget[1] + dir[1] * this.shadowDistance,
+      cameraTarget[2] + dir[2] * this.shadowDistance,
+    ];
+
+    const up: [number, number, number] =
+      Math.abs(dir[1]) > 0.99 ? [0, 0, 1] : [0, 1, 0];
+
+    const lightView = mat4.lookAt(lightPos, cameraTarget, up);
+
+    const lightProj = mat4.ortho(
+      -this.shadowRadius, this.shadowRadius,
+      -this.shadowRadius, this.shadowRadius,
+      1.0, this.shadowDistance * 2.0,
+    );
+
+    this.lightVP = mat4.multiply(lightProj, lightView, this.lightVP);
+
+    for (let i = 0; i < 16; i++) {
+      this.shadowUniformData[i] = this.lightVP[i];
+    }
+    this.shadowUniformData[16] = 1.0 / this.shadowMapSize;
+    this.shadowUniformData[17] = 0.003;
+    this.shadowUniformData[18] = 0.015;
+    this.shadowUniformData[19] = 0.85;
+
+    this.device.queue.writeBuffer(this.shadowUniformBuffer!, 0, this.shadowUniformData as unknown as GPUAllowSharedBufferSource);
+  }
+
+  destroy(): void {
+    this.shadowTexture?.destroy();
+    this.shadowUniformBuffer?.destroy();
+    this.shadowTexture = null;
+    this.shadowDepthView = null;
+    this.shadowUniformBuffer = null;
+  }
+}