@downdraft/engine 0.0.0 → 0.1.1

package/core/src/render/passes/point-light-shadow.ts

@@ -0,0 +1,266 @@
+import type { StructView, WgslStruct } from "@downdraft/engine/shader-graph";
+import { f32, mat4x4f, vec4f, wgsl } from "@downdraft/engine/shader-graph";
+import { mat4, vec3, type Mat4 } from "wgpu-matrix";
+import type { MeshData } from "../../mesh/builder";
+import { PassType, type FrameGraphBuilder, type GraphRenderContext, type TextureHandle } from "../frame-graph";
+import { RenderPass } from "../render-pass";
+import { destroyMapValues } from "../resource-tracker";
+import { createValidatedShaderModule } from "../shader-validator";
+import { TrackedRenderPass } from "../tracked-render-pass";
+
+export const MAX_POINT_LIGHT_SHADOWS = 4;
+const CUBE_FACES = 6;
+
+const FaceUniforms: WgslStruct = wgsl.struct("FaceUniforms", {
+  viewProj: mat4x4f,
+  lightPos: vec4f,
+  farPlane: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+});
+
+const POINT_SHADOW_SHADER = /* wgsl */ `
+${FaceUniforms.wgsl}
+
+@group(0) @binding(0) var<uniform> faceData: FaceUniforms;
+@group(0) @binding(1) var modelUniform: mat4x4<f32>;
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput) -> @builtin(position) vec4<f32> {
+  let worldPos = modelUniform * vec4<f32>(input.position, 1.0);
+  return faceData.viewProj * worldPos;
+}
+`;
+
+export interface PointLightShadowData {
+  position: [number, number, number];
+  farPlane: number;
+}
+
+export class PointLightShadowPass extends RenderPass {
+  name = "point-light-shadow";
+  passType = PassType.Custom;
+  shadowHandle: TextureHandle | null = null;
+
+  private device: GPUDevice;
+  private shadowMapSize: number;
+  private shaderModule: GPUShaderModule | null = null;
+  private shadowTextures: GPUTexture[] = [];
+  private shadowViews: GPUTextureView[] = [];
+  private shadowSamplers: GPUSampler[] = [];
+  private uniformBuffer: GPUBuffer | null = null;
+  private modelBuffer: GPUBuffer | null = null;
+  private _uniformView: StructView | null = null;
+  private _uniformBuf: Float32Array | null = null;
+  private pipelines: Map<number, GPURenderPipeline> = new Map();
+  private bindGroups: Map<number, GPUBindGroup> = new Map();
+  private vertexBuffers: Map<MeshData, GPUBuffer> = new Map();
+  private indexBuffers: Map<MeshData, GPUBuffer> = new Map();
+
+  constructor(device: GPUDevice, shadowMapSize: number = 512) {
+    super();
+    this.device = device;
+    this.shadowMapSize = shadowMapSize;
+  }
+
+  prepare(_device: GPUDevice): void {
+    if (!this.shaderModule) {
+      this.shaderModule = createValidatedShaderModule(this.device, { code: POINT_SHADOW_SHADER, label: "PointLightShadowPass" });
+    }
+
+    for (let i = 0; i < MAX_POINT_LIGHT_SHADOWS; i++) {
+      const tex = this.device.createTexture({
+        size: [this.shadowMapSize, this.shadowMapSize, CUBE_FACES],
+        format: "depth32float",
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+      });
+      this.shadowTextures.push(tex);
+      this.shadowViews.push(tex.createView({ dimension: "cube" }));
+      this.shadowSamplers.push(this.device.createSampler({ compare: "less", magFilter: "linear", minFilter: "linear" }));
+    }
+
+    this.uniformBuffer = this.device.createBuffer({
+      size: 96,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    this._uniformBuf = new Float32Array(FaceUniforms.floatCount);
+    this._uniformView = FaceUniforms.view(this._uniformBuf);
+
+    this.modelBuffer = this.device.createBuffer({
+      size: 64,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+  }
+
+  private getPipeline(stride: number): GPURenderPipeline {
+    let pipeline = this.pipelines.get(stride);
+    if (!pipeline) {
+      pipeline = this.device.createRenderPipeline({
+        layout: "auto",
+        vertex: {
+          module: this.shaderModule!,
+          entryPoint: "vs_main",
+          buffers: [{
+            arrayStride: stride,
+            attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }],
+          }],
+        },
+        primitive: { topology: "triangle-list", cullMode: "back" },
+        depthStencil: {
+          format: "depth32float",
+          depthWriteEnabled: true,
+          depthCompare: "less",
+        },
+      });
+      this.pipelines.set(stride, pipeline);
+      this.bindGroups.set(stride, this.device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: this.uniformBuffer! } },
+          { binding: 1, resource: { buffer: this.modelBuffer! } },
+        ],
+      }));
+    }
+    return pipeline;
+  }
+
+  private computeFaceViewProj(
+    lightPos: [number, number, number],
+    faceIndex: number,
+    aspect: number,
+    farPlane: number,
+  ): Mat4 {
+    const targets: [number, number, number][] = [
+      [lightPos[0] + 1, lightPos[1], lightPos[2]],
+      [lightPos[0] - 1, lightPos[1], lightPos[2]],
+      [lightPos[0], lightPos[1] + 1, lightPos[2]],
+      [lightPos[0], lightPos[1] - 1, lightPos[2]],
+      [lightPos[0], lightPos[1], lightPos[2] + 1],
+      [lightPos[0], lightPos[1], lightPos[2] - 1],
+    ];
+    const ups: [number, number, number][] = [
+      [0, -1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1], [0, -1, 0], [0, -1, 0],
+    ];
+
+    const view = mat4.lookAt(
+      vec3.create(...lightPos),
+      vec3.create(...targets[faceIndex]),
+      vec3.create(...ups[faceIndex]),
+    );
+    const proj = mat4.perspective(Math.PI / 2, aspect, 0.1, farPlane);
+    return mat4.multiply(proj, view);
+  }
+
+  renderPointLightShadow(
+    encoder: GPUCommandEncoder,
+    lightIndex: number,
+    lightPos: [number, number, number],
+    farPlane: number,
+    meshes: Array<{ mesh: MeshData; model: Mat4 }>,
+  ): void {
+    if (lightIndex >= MAX_POINT_LIGHT_SHADOWS || !this.shaderModule) return;
+
+    const aspect = 1.0;
+    const view = this.shadowViews[lightIndex];
+
+    for (let face = 0; face < CUBE_FACES; face++) {
+      const viewProj = this.computeFaceViewProj(lightPos, face, aspect, farPlane);
+
+      const uv = this._uniformView!;
+      uv.set("viewProj", viewProj);
+      uv.set("lightPos", [lightPos[0], lightPos[1], lightPos[2], farPlane]);
+      uv.set("farPlane", farPlane);
+      uv.set("_pad0", 0);
+      uv.set("_pad1", 0);
+      uv.set("_pad2", 0);
+      this.device.queue.writeBuffer(this.uniformBuffer!, 0, this._uniformBuf as unknown as BufferSource);
+
+      const pass = encoder.beginRenderPass({
+        colorAttachments: [],
+        depthStencilAttachment: {
+          view,
+          depthClearValue: 1.0,
+          depthLoadOp: face === 0 ? "clear" : "load",
+          depthStoreOp: "store",
+        },
+      });
+
+      const tracked = new TrackedRenderPass(pass);
+      meshes.forEach(({ mesh, model }) => {
+        this.device.queue.writeBuffer(this.modelBuffer!, 0, model as unknown as BufferSource);
+        const pipeline = this.getPipeline(mesh.layout.stride);
+        const bindGroup = this.bindGroups.get(mesh.layout.stride)!;
+        tracked.setPipeline(pipeline);
+        tracked.setBindGroup(0, bindGroup);
+        tracked.setVertexBuffer(0, this.getVertexBuffer(mesh));
+        tracked.setIndexBuffer(this.getIndexBuffer(mesh), mesh.indices instanceof Uint16Array ? "uint16" : "uint32");
+        tracked.drawIndexed(mesh.indexCount);
+      });
+      tracked.end();
+    }
+  }
+
+  getShadowView(index: number): GPUTextureView | null {
+    return this.shadowViews[index] ?? null;
+  }
+
+  getShadowSampler(index: number): GPUSampler | null {
+    return this.shadowSamplers[index] ?? null;
+  }
+
+  setup(builder: FrameGraphBuilder): void {
+    if (this.shadowHandle) {
+      builder.write(this.shadowHandle);
+    }
+  }
+
+  execute(_ctx: GraphRenderContext): void {
+  }
+
+  private getVertexBuffer(mesh: MeshData): GPUBuffer {
+    let buf = this.vertexBuffers.get(mesh);
+    if (!buf) {
+      buf = this.device.createBuffer({
+        size: mesh.vertices.byteLength,
+        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+      });
+      this.device.queue.writeBuffer(buf, 0, mesh.vertices.buffer);
+      this.vertexBuffers.set(mesh, buf);
+    }
+    return buf;
+  }
+
+  private getIndexBuffer(mesh: MeshData): GPUBuffer {
+    let buf = this.indexBuffers.get(mesh);
+    if (!buf) {
+      buf = this.device.createBuffer({
+        size: mesh.indices.byteLength,
+        usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+      });
+      this.device.queue.writeBuffer(buf, 0, mesh.indices.buffer);
+      this.indexBuffers.set(mesh, buf);
+    }
+    return buf;
+  }
+
+  destroy(): void {
+    this.shadowTextures.forEach((tex) => { tex.destroy();; });
+    // GPUSampler has no destroy() — it's GC'd automatically.
+    this.shadowSamplers.length = 0;
+    this.uniformBuffer?.destroy();
+    this.modelBuffer?.destroy();
+    this._uniformView = null;
+    this._uniformBuf = null;
+    for (const buf of this.vertexBuffers.values()) buf.destroy();
+    for (const buf of this.indexBuffers.values()) buf.destroy();
+    this.vertexBuffers.clear();
+    this.indexBuffers.clear();
+    destroyMapValues(this.pipelines);
+    destroyMapValues(this.bindGroups);
+  }
+}

package/core/src/render/passes/procedural-texture.ts

@@ -0,0 +1,185 @@
+export type ProceduralTextureType =
+  | "checkerboard"
+  | "noise"
+  | "perlin"
+  | "voronoi"
+  | "brick"
+  | "wood"
+  | "marble"
+  | "grid"
+  | "gradient";
+
+export interface ProceduralTextureConfig {
+  type: ProceduralTextureType;
+  width: number;
+  height: number;
+  scale: number;
+  octaves: number;
+  persistence: number;
+  lacunarity: number;
+  seed: number;
+  colorA: [number, number, number, number];
+  colorB: [number, number, number, number];
+}
+
+export const DEFAULT_PROCEDURAL_CONFIG: ProceduralTextureConfig = {
+  type: "checkerboard",
+  width: 256,
+  height: 256,
+  scale: 8,
+  octaves: 4,
+  persistence: 0.5,
+  lacunarity: 2.0,
+  seed: 0,
+  colorA: [1, 1, 1, 1],
+  colorB: [0, 0, 0, 1],
+};
+
+function hash(x: number, y: number, seed: number): number {
+  let h = x * 374761393 + y * 668265263 + seed * 982451653;
+  h = (h ^ (h >> 13)) * 1274126177;
+  return ((h ^ (h >> 16)) >>> 0) / 4294967295;
+}
+
+function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}
+
+function smoothstep(edge0: number, edge1: number, x: number): number {
+  const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+}
+
+function valueNoise(x: number, y: number, seed: number): number {
+  const ix = Math.floor(x);
+  const iy = Math.floor(y);
+  const fx = x - ix;
+  const fy = y - iy;
+  const a = hash(ix, iy, seed);
+  const b = hash(ix + 1, iy, seed);
+  const c = hash(ix, iy + 1, seed);
+  const d = hash(ix + 1, iy + 1, seed);
+  const ux = smoothstep(0, 1, fx);
+  const uy = smoothstep(0, 1, fy);
+  return lerp(lerp(a, b, ux), lerp(c, d, ux), uy);
+}
+
+function fbm(x: number, y: number, octaves: number, persistence: number, lacunarity: number, seed: number): number {
+  let total = 0;
+  let amplitude = 1;
+  let frequency = 1;
+  let maxValue = 0;
+  for (let i = 0; i < octaves; i++) {
+    total += valueNoise(x * frequency, y * frequency, seed + i) * amplitude;
+    maxValue += amplitude;
+    amplitude *= persistence;
+    frequency *= lacunarity;
+  }
+  return total / maxValue;
+}
+
+export function generateProceduralTexture(config: ProceduralTextureConfig): Uint8Array {
+  const { width, height, scale, type, colorA, colorB, octaves, persistence, lacunarity, seed } = config;
+  const data = new Uint8Array(width * height * 4);
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const u = x / width;
+      const v = y / height;
+      let t = 0;
+
+      switch (type) {
+        case "checkerboard": {
+          const cx = Math.floor(u * scale);
+          const cy = Math.floor(v * scale);
+          t = (cx + cy) % 2 === 0 ? 0 : 1;
+          break;
+        }
+        case "noise": {
+          t = hash(Math.floor(u * scale), Math.floor(v * scale), seed);
+          break;
+        }
+        case "perlin": {
+          t = fbm(u * scale, v * scale, octaves, persistence, lacunarity, seed);
+          break;
+        }
+        case "voronoi": {
+          const px = u * scale;
+          const py = v * scale;
+          const ix = Math.floor(px);
+          const iy = Math.floor(py);
+          let minDist = Infinity;
+          for (let dx = -1; dx <= 1; dx++) {
+            for (let dy = -1; dy <= 1; dy++) {
+              const cx = ix + dx + hash(ix + dx, iy + dy, seed);
+              const cy = iy + dy + hash(ix + dx, iy + dy, seed + 1);
+              const dist = (cx - px) ** 2 + (cy - py) ** 2;
+              minDist = Math.min(minDist, dist);
+            }
+          }
+          t = Math.sqrt(minDist);
+          break;
+        }
+        case "brick": {
+          const bx = Math.floor(u * scale);
+          const by = Math.floor(v * scale * 0.5);
+          const offset = by % 2 === 0 ? 0 : 0.5;
+          const bxOffset = Math.floor((u + offset) * scale);
+          const mortar = Math.abs((u + offset) * scale - bxOffset - 0.5);
+          const mortarY = Math.abs(v * scale * 0.5 - by - 0.5);
+          t = (mortar < 0.05 || mortarY < 0.05) ? 1 : 0;
+          break;
+        }
+        case "wood": {
+          const nx = u * scale - scale * 0.5;
+          const ny = v * scale - scale * 0.5;
+          const dist = Math.sqrt(nx * nx + ny * ny);
+          t = Math.sin(dist * 2.0 + fbm(u * scale * 0.5, v * scale * 0.5, 3, 0.5, 2, seed) * 5) * 0.5 + 0.5;
+          break;
+        }
+        case "marble": {
+          t = Math.sin((u + fbm(u * scale, v * scale, octaves, persistence, lacunarity, seed)) * scale * 2) * 0.5 + 0.5;
+          break;
+        }
+        case "grid": {
+          const gx = Math.abs((u * scale) % 1 - 0.5);
+          const gy = Math.abs((v * scale) % 1 - 0.5);
+          t = (gx < 0.02 || gy < 0.02) ? 1 : 0;
+          break;
+        }
+        case "gradient": {
+          t = v;
+          break;
+        }
+      }
+
+      const idx = (y * width + x) * 4;
+      data[idx] = Math.round(lerp(colorA[0], colorB[0], t) * 255);
+      data[idx + 1] = Math.round(lerp(colorA[1], colorB[1], t) * 255);
+      data[idx + 2] = Math.round(lerp(colorA[2], colorB[2], t) * 255);
+      data[idx + 3] = Math.round(lerp(colorA[3], colorB[3], t) * 255);
+    }
+  }
+
+  return data;
+}
+
+export function createProceduralGpuTexture(
+  device: GPUDevice,
+  config: ProceduralTextureConfig,
+): GPUTexture {
+  const data = generateProceduralTexture(config);
+  const texture = device.createTexture({
+    label: `procedural-${config.type}`,
+    size: [config.width, config.height],
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+  });
+  device.queue.writeTexture(
+    { texture },
+    data as unknown as GPUAllowSharedBufferSource,
+    { bytesPerRow: config.width * 4, rowsPerImage: config.height },
+    [config.width, config.height],
+  );
+  return texture;
+}

package/core/src/render/passes/reflection-probe.ts

@@ -0,0 +1,140 @@
+import type { Vec3 } from "wgpu-matrix";
+
+export interface ReflectionProbeData {
+  id: string;
+  position: Vec3;
+  boxMin: Vec3;
+  boxMax: Vec3;
+  cubemapTexture: GPUTexture | null;
+  cubemapView: GPUTextureView | null;
+  irradianceTexture: GPUTexture | null;
+  prefilteredTexture: GPUTexture | null;
+  weight: number;
+  lastUpdated: number;
+  resolution: number;
+  priority: number;
+}
+
+export interface ReflectionProbeConfig {
+  maxProbes: number;
+  resolution: number;
+  refreshRate: number;
+  blendDistance: number;
+}
+
+export const DEFAULT_REFLECTION_PROBE_CONFIG: ReflectionProbeConfig = {
+  maxProbes: 8,
+  resolution: 256,
+  refreshRate: 30,
+  blendDistance: 5.0,
+};
+
+export class ReflectionProbeManager {
+  private probes: Map<string, ReflectionProbeData> = new Map();
+  private config: ReflectionProbeConfig;
+  private device: GPUDevice | null = null;
+
+  constructor(config?: Partial<ReflectionProbeConfig>, device?: GPUDevice | null) {
+    this.config = { ...DEFAULT_REFLECTION_PROBE_CONFIG, ...config };
+    this.device = device ?? null;
+  }
+
+  addProbe(id: string, position: Vec3, boxMin: Vec3, boxMax: Vec3, priority: number = 0): ReflectionProbeData | null {
+    if (this.probes.size >= this.config.maxProbes) {
+      return null;
+    }
+
+    let cubemapTexture: GPUTexture | null = null;
+    let cubemapView: GPUTextureView | null = null;
+
+    if (this.device) {
+      cubemapTexture = this.device.createTexture({
+        label: `reflection-probe-${id}`,
+        size: [this.config.resolution, this.config.resolution, 6],
+        format: "rgba16float",
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+      });
+      cubemapView = cubemapTexture.createView({ dimension: "cube" });
+    }
+
+    const probe: ReflectionProbeData = {
+      id,
+      position,
+      boxMin,
+      boxMax,
+      cubemapTexture,
+      cubemapView,
+      irradianceTexture: null,
+      prefilteredTexture: null,
+      weight: 0,
+      lastUpdated: 0,
+      resolution: this.config.resolution,
+      priority,
+    };
+
+    this.probes.set(id, probe);
+    return probe;
+  }
+
+  removeProbe(id: string): void {
+    const probe = this.probes.get(id);
+    if (probe) {
+      probe.cubemapTexture?.destroy();
+      probe.irradianceTexture?.destroy();
+      probe.prefilteredTexture?.destroy();
+      this.probes.delete(id);
+    }
+  }
+
+  getProbe(id: string): ReflectionProbeData | null {
+    return this.probes.get(id) ?? null;
+  }
+
+  getProbes(): ReflectionProbeData[] {
+    return Array.from(this.probes.values()).sort((a, b) => b.priority - a.priority);
+  }
+
+  findProbesForPosition(pos: Vec3): ReflectionProbeData[] {
+    const inside: ReflectionProbeData[] = [];
+    for (const probe of this.probes.values()) {
+      if (
+        pos[0] >= probe.boxMin[0] && pos[0] <= probe.boxMax[0] &&
+        pos[1] >= probe.boxMin[1] && pos[1] <= probe.boxMax[1] &&
+        pos[2] >= probe.boxMin[2] && pos[2] <= probe.boxMax[2]
+      ) {
+        inside.push(probe);
+      }
+    }
+    return inside.sort((a, b) => b.priority - a.priority);
+  }
+
+  computeProbeWeights(pos: Vec3): Array<{ probe: ReflectionProbeData; weight: number }> {
+    const probes = this.findProbesForPosition(pos);
+    if (probes.length === 0) return [];
+
+    const weights = probes.map((probe) => {
+      const dx = Math.max(probe.boxMin[0] - pos[0], 0, pos[0] - probe.boxMax[0]);
+      const dy = Math.max(probe.boxMin[1] - pos[1], 0, pos[1] - probe.boxMax[1]);
+      const dz = Math.max(probe.boxMin[2] - pos[2], 0, pos[2] - probe.boxMax[2]);
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      return { probe, weight: 1.0 / (1.0 + dist * dist) };
+    });
+
+    const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
+    if (totalWeight === 0) return [];
+
+    return weights.map((w) => ({
+      probe: w.probe,
+      weight: w.weight / totalWeight,
+    }));
+  }
+
+  destroy(): void {
+    for (const probe of this.probes.values()) {
+      probe.cubemapTexture?.destroy();
+      probe.irradianceTexture?.destroy();
+      probe.prefilteredTexture?.destroy();
+    }
+    this.probes.clear();
+  }
+}