@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/core/src/render/passes/point-light-shadow.js

@@ -0,0 +1,221 @@
+import { f32, mat4x4f, vec4f, wgsl } from "@downdraft/engine/shader-graph";
+import { mat4, vec3 } from "wgpu-matrix";
+import { PassType } from "../frame-graph.js";
+import { RenderPass } from "../render-pass.js";
+import { destroyMapValues } from "../resource-tracker.js";
+import { createValidatedShaderModule } from "../shader-validator.js";
+import { TrackedRenderPass } from "../tracked-render-pass.js";
+export const MAX_POINT_LIGHT_SHADOWS = 4;
+const CUBE_FACES = 6;
+const FaceUniforms = 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 class PointLightShadowPass extends RenderPass {
+    name = "point-light-shadow";
+    passType = PassType.Custom;
+    shadowHandle = null;
+    device;
+    shadowMapSize;
+    shaderModule = null;
+    shadowTextures = [];
+    shadowViews = [];
+    shadowSamplers = [];
+    uniformBuffer = null;
+    modelBuffer = null;
+    _uniformView = null;
+    _uniformBuf = null;
+    pipelines = new Map();
+    bindGroups = new Map();
+    vertexBuffers = new Map();
+    indexBuffers = new Map();
+    constructor(device, shadowMapSize = 512) {
+        super();
+        this.device = device;
+        this.shadowMapSize = shadowMapSize;
+    }
+    prepare(_device) {
+        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,
+        });
+    }
+    getPipeline(stride) {
+        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;
+    }
+    computeFaceViewProj(lightPos, faceIndex, aspect, farPlane) {
+        const targets = [
+            [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 = [
+            [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, lightIndex, lightPos, farPlane, meshes) {
+        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);
+            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);
+                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) {
+        return this.shadowViews[index] ?? null;
+    }
+    getShadowSampler(index) {
+        return this.shadowSamplers[index] ?? null;
+    }
+    setup(builder) {
+        if (this.shadowHandle) {
+            builder.write(this.shadowHandle);
+        }
+    }
+    execute(_ctx) {
+    }
+    getVertexBuffer(mesh) {
+        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;
+    }
+    getIndexBuffer(mesh) {
+        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() {
+        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/dist/core/src/render/passes/procedural-texture.js

@@ -0,0 +1,142 @@
+export const DEFAULT_PROCEDURAL_CONFIG = {
+    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, y, seed) {
+    let h = x * 374761393 + y * 668265263 + seed * 982451653;
+    h = (h ^ (h >> 13)) * 1274126177;
+    return ((h ^ (h >> 16)) >>> 0) / 4294967295;
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function smoothstep(edge0, edge1, x) {
+    const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+    return t * t * (3 - 2 * t);
+}
+function valueNoise(x, y, seed) {
+    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, y, octaves, persistence, lacunarity, seed) {
+    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) {
+    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, config) {
+    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, { bytesPerRow: config.width * 4, rowsPerImage: config.height }, [config.width, config.height]);
+    return texture;
+}

package/dist/core/src/render/passes/reflection-probe.js

@@ -0,0 +1,100 @@
+export const DEFAULT_REFLECTION_PROBE_CONFIG = {
+    maxProbes: 8,
+    resolution: 256,
+    refreshRate: 30,
+    blendDistance: 5.0,
+};
+export class ReflectionProbeManager {
+    probes = new Map();
+    config;
+    device = null;
+    constructor(config, device) {
+        this.config = { ...DEFAULT_REFLECTION_PROBE_CONFIG, ...config };
+        this.device = device ?? null;
+    }
+    addProbe(id, position, boxMin, boxMax, priority = 0) {
+        if (this.probes.size >= this.config.maxProbes) {
+            return null;
+        }
+        let cubemapTexture = null;
+        let cubemapView = 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 = {
+            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) {
+        const probe = this.probes.get(id);
+        if (probe) {
+            probe.cubemapTexture?.destroy();
+            probe.irradianceTexture?.destroy();
+            probe.prefilteredTexture?.destroy();
+            this.probes.delete(id);
+        }
+    }
+    getProbe(id) {
+        return this.probes.get(id) ?? null;
+    }
+    getProbes() {
+        return Array.from(this.probes.values()).sort((a, b) => b.priority - a.priority);
+    }
+    findProbesForPosition(pos) {
+        const inside = [];
+        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) {
+        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() {
+        for (const probe of this.probes.values()) {
+            probe.cubemapTexture?.destroy();
+            probe.irradianceTexture?.destroy();
+            probe.prefilteredTexture?.destroy();
+        }
+        this.probes.clear();
+    }
+}

package/dist/core/src/render/passes/rsm-pass.js

@@ -0,0 +1,228 @@
+import { f32, mat4x4f, u32, vec2f, vec3f, wgsl } from "@downdraft/engine/shader-graph";
+import { PassType } from "../frame-graph.js";
+import { RenderPass } from "../render-pass.js";
+import { createValidatedShaderModule } from "../shader-validator.js";
+import { DEFAULT_RSM_CONFIG, VPL_FLOATS } from "./gi-types.js";
+const RSMUniforms = wgsl.struct("RSMUniforms", {
+    lightViewProj: mat4x4f,
+    invLightViewProj: mat4x4f,
+    rsmResolution: u32,
+    maxVPLs: u32,
+    intensity: f32,
+    rsmRadius: f32,
+    _pad0: u32,
+    _pad1: u32,
+});
+const RSMEvalUniforms = 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;
+    device;
+    config;
+    injectPipeline = null;
+    injectBindGroup = null;
+    vplBuffer = null;
+    rsmUniformBuffer = null;
+    _uniformView = null;
+    _uniformBuf = null;
+    rsmDepthHandle = null;
+    rsmAlbedoHandle = null;
+    rsmNormalHandle = null;
+    rsmFluxHandle = null;
+    lightViewProj = new Float32Array(16);
+    invLightViewProj = new Float32Array(16);
+    constructor(config, device) {
+        super();
+        this.config = { ...DEFAULT_RSM_CONFIG, ...config };
+        this.device = device ?? null;
+    }
+    prepare(device) {
+        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, invLightViewProj) {
+        this.lightViewProj = lightViewProj;
+        this.invLightViewProj = invLightViewProj;
+    }
+    updateUniforms() {
+        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);
+        }
+    }
+    updateVPLs(vpls) {
+        if (this.device && this.vplBuffer) {
+            this.device.queue.writeBuffer(this.vplBuffer, 0, vpls);
+        }
+    }
+    getVPLBuffer() {
+        return this.vplBuffer;
+    }
+    getConfig() {
+        return this.config;
+    }
+    setup(builder) {
+        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) {
+        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() {
+        this.vplBuffer?.destroy();
+        this.rsmUniformBuffer?.destroy();
+        this._uniformView = null;
+        this._uniformBuf = null;
+    }
+}