@meimu/mutracer 0.2.0 → 0.3.1

package/lib/renderer/WGPUCausticLightPass.d.ts

@@ -0,0 +1,48 @@
+export { packCausticLightUniform } from './causticUniform.js';
+import { type ResourceTable } from './wgpuBindless.js';
+import type { CasterSphere } from './caustics.js';
+/** Per-target photon splats and independent floating-point batch accumulation. */
+export declare class WGPUCausticLightPass {
+    private readonly device;
+    private readonly photonMapping;
+    private distribution?;
+    private emissionGroups;
+    private casterCount;
+    private choiceCount;
+    private pipeline?;
+    private readonly outputs;
+    private readonly uniform;
+    private readonly layout;
+    private readonly accumulate;
+    constructor(device: GPUDevice, photonMapping?: boolean);
+    /** Compiles an emitter for one trace pipeline's layouts; select it with use(). */
+    prepare(source: string, groups: GPUBindGroupLayout[], bindless?: boolean): Promise<GPUComputePipeline>;
+    use(pipeline: GPUComputePipeline): void;
+    setDistribution(spheres: readonly CasterSphere[], lights: {
+        data: Float32Array;
+        count: number;
+    }): void;
+    get(target: object): GPUBuffer | undefined;
+    bytes(target: object): number;
+    release(target: object): void;
+    encode(encoder: GPUCommandEncoder, groups: GPUBindGroup[], target: object, options: {
+        photonMapping?: boolean;
+        photonDirections?: GPUTexture;
+        querySet?: GPUQuerySet;
+        resourceTable?: ResourceTable;
+        width: number;
+        height: number;
+        clear: boolean;
+        run: boolean;
+        photons: number;
+        batch: number;
+        viewProjection: Float32Array | Float64Array | number[];
+        casterSphere: readonly number[];
+        cameraScale: number;
+        casterCount?: number;
+        choiceCount?: number;
+        orthographic?: boolean;
+    }): void;
+    emit(encoder: GPUCommandEncoder, groups: GPUBindGroup[], storage: GPUBuffer | GPUTexture, options: Parameters<WGPUCausticLightPass['encode']>[3]): void;
+    dispose(): void;
+}

package/lib/renderer/WGPUCausticLightPass.js

@@ -0,0 +1,217 @@
+import { causticDiagnostics } from './causticDiagnostics.js';
+import { packCausticLightUniform } from './causticUniform.js';
+export { packCausticLightUniform } from './causticUniform.js';
+import { resourceTableLayout, setResourceTable } from './wgpuBindless.js';
+import { CAUSTIC_UNIFORM_BYTES, causticAccumulateCompute } from './wgsl/causticLight.compute.js';
+/** Per-target photon splats and independent floating-point batch accumulation. */
+export class WGPUCausticLightPass {
+    device;
+    photonMapping;
+    distribution;
+    emissionGroups = new WeakMap();
+    casterCount = 0;
+    choiceCount = 0;
+    pipeline;
+    outputs = new Map();
+    uniform;
+    layout;
+    accumulate;
+    constructor(device, photonMapping = false) {
+        this.device = device;
+        this.photonMapping = photonMapping;
+        this.uniform = device.createBuffer({
+            label: 'Caustic light uniforms',
+            size: CAUSTIC_UNIFORM_BYTES,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        });
+        this.layout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } },
+                {
+                    binding: 1,
+                    visibility: GPUShaderStage.COMPUTE,
+                    ...(photonMapping
+                        ? { storageTexture: { access: 'write-only', format: 'rgba32uint' } }
+                        : { buffer: { type: 'storage' } })
+                },
+                { binding: 2, visibility: GPUShaderStage.COMPUTE, texture: { sampleType: 'unfilterable-float' } },
+                ...(photonMapping
+                    ? [
+                        {
+                            binding: 3,
+                            visibility: GPUShaderStage.COMPUTE,
+                            storageTexture: { access: 'write-only', format: 'r32uint' }
+                        }
+                    ]
+                    : [])
+            ]
+        });
+        this.accumulate = device.createComputePipeline({
+            label: 'Caustic batch accumulation',
+            layout: 'auto',
+            compute: { module: device.createShaderModule({ code: causticAccumulateCompute }), entryPoint: 'main' }
+        });
+    }
+    /** Compiles an emitter for one trace pipeline's layouts; select it with use(). */
+    async prepare(source, groups, bindless = false) {
+        const module = this.device.createShaderModule({ label: 'Caustic light tracing', code: source });
+        const info = await module.getCompilationInfo();
+        const errors = info.messages.filter((m) => m.type === 'error');
+        if (errors.length)
+            throw Error(errors.map((m) => `Caustic WGSL ${m.lineNum}:${m.linePos} ${m.message}`).join('\n'));
+        return this.device.createComputePipelineAsync({
+            label: 'Caustic light tracing',
+            layout: this.device.createPipelineLayout(bindless
+                ? resourceTableLayout({ bindGroupLayouts: [...groups, this.layout] })
+                : { bindGroupLayouts: [...groups, this.layout] }),
+            compute: { module, entryPoint: 'main' }
+        });
+    }
+    use(pipeline) {
+        this.pipeline = pipeline;
+    }
+    setDistribution(spheres, lights) {
+        this.choiceCount = lights.count;
+        this.casterCount = spheres.length;
+        this.distribution?.destroy();
+        this.emissionGroups = new WeakMap();
+        const texels = Math.max(1, spheres.length + lights.count * 2), width = Math.min(texels, this.device.limits.maxTextureDimension2D), height = Math.ceil(texels / width);
+        this.distribution = this.device.createTexture({
+            label: 'Caustic emission distribution',
+            size: [width, height],
+            format: 'rgba32float',
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+        });
+        const data = new Float32Array(width * height * 4);
+        spheres.forEach((sphere, i) => data.set(sphere, i * 4));
+        data.set(lights.data, spheres.length * 4);
+        this.device.queue.writeTexture({ texture: this.distribution }, data, { bytesPerRow: width * 16 }, [
+            width,
+            height
+        ]);
+    }
+    get(target) {
+        return this.outputs.get(target)?.accumulation;
+    }
+    bytes(target) {
+        const o = this.outputs.get(target);
+        return o ? o.splats.size + o.accumulation.size : 0;
+    }
+    release(target) {
+        const o = this.outputs.get(target);
+        o?.splats.destroy();
+        o?.accumulation.destroy();
+        this.outputs.delete(target);
+    }
+    encode(encoder, groups, target, options) {
+        const { width, height } = options;
+        let output = this.outputs.get(target);
+        if (output && output.accumulation.size !== width * height * 16) {
+            this.release(target);
+            output = undefined;
+        }
+        if (!output) {
+            output = {
+                splats: this.device.createBuffer({
+                    label: 'Caustic floating-point splats',
+                    size: width * height * 12,
+                    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+                }),
+                resolveGroup: undefined,
+                accumulation: this.device.createBuffer({
+                    label: 'Caustic batch accumulation',
+                    size: width * height * 16,
+                    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+                })
+            };
+            output.resolveGroup = this.device.createBindGroup({
+                layout: this.accumulate.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: output.splats } },
+                    { binding: 1, resource: { buffer: output.accumulation } }
+                ]
+            });
+            this.outputs.set(target, output);
+        }
+        if (options.clear)
+            encoder.clearBuffer(output.accumulation);
+        if (!options.run || !this.pipeline)
+            return;
+        encoder.clearBuffer(output.splats);
+        this.emit(encoder, groups, output.splats, options);
+        const resolve = encoder.beginComputePass({
+            label: 'Caustic batch accumulation',
+            ...(options.querySet
+                ? {
+                    timestampWrites: {
+                        querySet: options.querySet,
+                        beginningOfPassWriteIndex: 4,
+                        endOfPassWriteIndex: 5
+                    }
+                }
+                : {})
+        });
+        resolve.setPipeline(this.accumulate);
+        resolve.setBindGroup(0, output.resolveGroup);
+        const workgroups = Math.ceil((width * height) / 64);
+        const columns = Math.min(workgroups, this.device.limits.maxComputeWorkgroupsPerDimension);
+        resolve.dispatchWorkgroups(columns, Math.ceil(workgroups / columns));
+        resolve.end();
+    }
+    emit(encoder, groups, storage, options) {
+        if (!this.pipeline)
+            return;
+        const data = packCausticLightUniform({
+            ...options,
+            experiments: (+!!causticDiagnostics.photonPerCasterRadius) | (+!!causticDiagnostics.causticViewImportance << 1),
+            casterCount: this.casterCount,
+            choiceCount: this.choiceCount
+        });
+        this.device.queue.writeBuffer(this.uniform, 0, data);
+        const pass = encoder.beginComputePass({
+            label: 'Caustic photons',
+            ...(options.querySet
+                ? {
+                    timestampWrites: {
+                        querySet: options.querySet,
+                        beginningOfPassWriteIndex: options.photonMapping ? 6 : 2,
+                        endOfPassWriteIndex: options.photonMapping ? 7 : 3
+                    }
+                }
+                : {})
+        });
+        pass.setPipeline(this.pipeline);
+        if (options.resourceTable)
+            setResourceTable(pass, options.resourceTable);
+        groups.forEach((g, i) => pass.setBindGroup(i, g));
+        let group = this.emissionGroups.get(storage);
+        if (!group) {
+            group = this.device.createBindGroup({
+                layout: this.layout,
+                entries: [
+                    { binding: 0, resource: { buffer: this.uniform } },
+                    {
+                        binding: 1,
+                        resource: this.photonMapping
+                            ? storage.createView()
+                            : { buffer: storage }
+                    },
+                    { binding: 2, resource: this.distribution.createView() },
+                    ...(this.photonMapping ? [{ binding: 3, resource: options.photonDirections.createView() }] : [])
+                ]
+            });
+            this.emissionGroups.set(storage, group);
+        }
+        pass.setBindGroup(groups.length, group);
+        const groupsCount = Math.ceil(options.photons / 64);
+        pass.dispatchWorkgroups(Math.min(groupsCount, 65535), Math.ceil(groupsCount / 65535));
+        pass.end();
+    }
+    dispose() {
+        for (const target of this.outputs.keys())
+            this.release(target);
+        this.uniform.destroy();
+        this.distribution?.destroy();
+    }
+}
+//# sourceMappingURL=WGPUCausticLightPass.js.map

package/lib/renderer/WGPUCausticLightPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WGPUCausticLightPass.js","sourceRoot":"","sources":["../../src/renderer/WGPUCausticLightPass.ts"],"names":[],"mappings":"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","sourcesContent":["import {causticDiagnostics} from './causticDiagnostics.js';\nimport {packCausticLightUniform} from './causticUniform.js';\nexport {packCausticLightUniform} from './causticUniform.js';\nimport {resourceTableLayout, setResourceTable, type ResourceTable} from './wgpuBindless.js';\nimport type {CasterSphere} from './caustics.js';\nimport {CAUSTIC_UNIFORM_BYTES, causticAccumulateCompute} from './wgsl/causticLight.compute.js';\n\ninterface Output {\n  splats: GPUBuffer;\n  accumulation: GPUBuffer;\n  resolveGroup: GPUBindGroup;\n}\n/** Per-target photon splats and independent floating-point batch accumulation. */\nexport class WGPUCausticLightPass {\n  private distribution?: GPUTexture;\n  private emissionGroups = new WeakMap<GPUBuffer | GPUTexture, GPUBindGroup>();\n  private casterCount = 0;\n  private choiceCount = 0;\n  private pipeline?: GPUComputePipeline;\n  private readonly outputs = new Map<object, Output>();\n  private readonly uniform: GPUBuffer;\n  private readonly layout: GPUBindGroupLayout;\n  private readonly accumulate: GPUComputePipeline;\n  constructor(\n    private readonly device: GPUDevice,\n    private readonly photonMapping = false\n  ) {\n    this.uniform = device.createBuffer({\n      label: 'Caustic light uniforms',\n      size: CAUSTIC_UNIFORM_BYTES,\n      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST\n    });\n    this.layout = device.createBindGroupLayout({\n      entries: [\n        {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: {type: 'uniform'}},\n        {\n          binding: 1,\n          visibility: GPUShaderStage.COMPUTE,\n          ...(photonMapping\n            ? {storageTexture: {access: 'write-only' as const, format: 'rgba32uint' as const}}\n            : {buffer: {type: 'storage' as const}})\n        },\n        {binding: 2, visibility: GPUShaderStage.COMPUTE, texture: {sampleType: 'unfilterable-float'}},\n        ...(photonMapping\n          ? [\n              {\n                binding: 3,\n                visibility: GPUShaderStage.COMPUTE,\n                storageTexture: {access: 'write-only' as const, format: 'r32uint' as const}\n              }\n            ]\n          : [])\n      ]\n    });\n    this.accumulate = device.createComputePipeline({\n      label: 'Caustic batch accumulation',\n      layout: 'auto',\n      compute: {module: device.createShaderModule({code: causticAccumulateCompute}), entryPoint: 'main'}\n    });\n  }\n  /** Compiles an emitter for one trace pipeline's layouts; select it with use(). */\n  async prepare(source: string, groups: GPUBindGroupLayout[], bindless = false) {\n    const module = this.device.createShaderModule({label: 'Caustic light tracing', code: source});\n    const info = await module.getCompilationInfo();\n    const errors = info.messages.filter((m) => m.type === 'error');\n    if (errors.length)\n      throw Error(errors.map((m) => `Caustic WGSL ${m.lineNum}:${m.linePos} ${m.message}`).join('\\n'));\n    return this.device.createComputePipelineAsync({\n      label: 'Caustic light tracing',\n      layout: this.device.createPipelineLayout(\n        bindless\n          ? resourceTableLayout({bindGroupLayouts: [...groups, this.layout]})\n          : {bindGroupLayouts: [...groups, this.layout]}\n      ),\n      compute: {module, entryPoint: 'main'}\n    });\n  }\n  use(pipeline: GPUComputePipeline) {\n    this.pipeline = pipeline;\n  }\n  setDistribution(spheres: readonly CasterSphere[], lights: {data: Float32Array; count: number}) {\n    this.choiceCount = lights.count;\n    this.casterCount = spheres.length;\n    this.distribution?.destroy();\n    this.emissionGroups = new WeakMap();\n    const texels = Math.max(1, spheres.length + lights.count * 2),\n      width = Math.min(texels, this.device.limits.maxTextureDimension2D),\n      height = Math.ceil(texels / width);\n    this.distribution = this.device.createTexture({\n      label: 'Caustic emission distribution',\n      size: [width, height],\n      format: 'rgba32float',\n      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST\n    });\n    const data = new Float32Array(width * height * 4);\n    spheres.forEach((sphere, i) => data.set(sphere, i * 4));\n    data.set(lights.data, spheres.length * 4);\n    this.device.queue.writeTexture({texture: this.distribution}, data, {bytesPerRow: width * 16}, [\n      width,\n      height\n    ]);\n  }\n  get(target: object) {\n    return this.outputs.get(target)?.accumulation;\n  }\n  bytes(target: object) {\n    const o = this.outputs.get(target);\n    return o ? o.splats.size + o.accumulation.size : 0;\n  }\n  release(target: object) {\n    const o = this.outputs.get(target);\n    o?.splats.destroy();\n    o?.accumulation.destroy();\n    this.outputs.delete(target);\n  }\n  encode(\n    encoder: GPUCommandEncoder,\n    groups: GPUBindGroup[],\n    target: object,\n    options: {\n      photonMapping?: boolean;\n      photonDirections?: GPUTexture;\n      querySet?: GPUQuerySet;\n      resourceTable?: ResourceTable;\n      width: number;\n      height: number;\n      clear: boolean;\n      run: boolean;\n      photons: number;\n      batch: number;\n      viewProjection: Float32Array | Float64Array | number[];\n      casterSphere: readonly number[];\n      cameraScale: number;\n      casterCount?: number;\n      choiceCount?: number;\n      orthographic?: boolean;\n    }\n  ) {\n    const {width, height} = options;\n    let output = this.outputs.get(target);\n    if (output && output.accumulation.size !== width * height * 16) {\n      this.release(target);\n      output = undefined;\n    }\n    if (!output) {\n      output = {\n        splats: this.device.createBuffer({\n          label: 'Caustic floating-point splats',\n          size: width * height * 12,\n          usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST\n        }),\n        resolveGroup: undefined as unknown as GPUBindGroup,\n        accumulation: this.device.createBuffer({\n          label: 'Caustic batch accumulation',\n          size: width * height * 16,\n          usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST\n        })\n      };\n      output.resolveGroup = this.device.createBindGroup({\n        layout: this.accumulate.getBindGroupLayout(0),\n        entries: [\n          {binding: 0, resource: {buffer: output.splats}},\n          {binding: 1, resource: {buffer: output.accumulation}}\n        ]\n      });\n      this.outputs.set(target, output);\n    }\n    if (options.clear) encoder.clearBuffer(output.accumulation);\n    if (!options.run || !this.pipeline) return;\n    encoder.clearBuffer(output.splats);\n    this.emit(encoder, groups, output.splats, options);\n    const resolve = encoder.beginComputePass({\n      label: 'Caustic batch accumulation',\n      ...(options.querySet\n        ? {\n            timestampWrites: {\n              querySet: options.querySet,\n              beginningOfPassWriteIndex: 4,\n              endOfPassWriteIndex: 5\n            }\n          }\n        : {})\n    });\n    resolve.setPipeline(this.accumulate);\n    resolve.setBindGroup(0, output.resolveGroup);\n    const workgroups = Math.ceil((width * height) / 64);\n    const columns = Math.min(workgroups, this.device.limits.maxComputeWorkgroupsPerDimension);\n    resolve.dispatchWorkgroups(columns, Math.ceil(workgroups / columns));\n    resolve.end();\n  }\n  emit(\n    encoder: GPUCommandEncoder,\n    groups: GPUBindGroup[],\n    storage: GPUBuffer | GPUTexture,\n    options: Parameters<WGPUCausticLightPass['encode']>[3]\n  ) {\n    if (!this.pipeline) return;\n    const data = packCausticLightUniform({\n      ...options,\n      experiments: (+!!causticDiagnostics.photonPerCasterRadius) | (+!!causticDiagnostics.causticViewImportance << 1),\n      casterCount: this.casterCount,\n      choiceCount: this.choiceCount\n    });\n    this.device.queue.writeBuffer(this.uniform, 0, data);\n    const pass = encoder.beginComputePass({\n      label: 'Caustic photons',\n      ...(options.querySet\n        ? {\n            timestampWrites: {\n              querySet: options.querySet,\n              beginningOfPassWriteIndex: options.photonMapping ? 6 : 2,\n              endOfPassWriteIndex: options.photonMapping ? 7 : 3\n            }\n          }\n        : {})\n    });\n    pass.setPipeline(this.pipeline);\n    if (options.resourceTable) setResourceTable(pass, options.resourceTable);\n    groups.forEach((g, i) => pass.setBindGroup(i, g));\n    let group = this.emissionGroups.get(storage);\n    if (!group) {\n      group = this.device.createBindGroup({\n        layout: this.layout,\n        entries: [\n          {binding: 0, resource: {buffer: this.uniform}},\n          {\n            binding: 1,\n            resource: this.photonMapping\n              ? (storage as GPUTexture).createView()\n              : {buffer: storage as GPUBuffer}\n          },\n          {binding: 2, resource: this.distribution!.createView()},\n          ...(this.photonMapping ? [{binding: 3, resource: options.photonDirections!.createView()}] : [])\n        ]\n      });\n      this.emissionGroups.set(storage, group);\n    }\n    pass.setBindGroup(groups.length, group);\n    const groupsCount = Math.ceil(options.photons / 64);\n    pass.dispatchWorkgroups(Math.min(groupsCount, 65535), Math.ceil(groupsCount / 65535));\n    pass.end();\n  }\n  dispose() {\n    for (const target of this.outputs.keys()) this.release(target);\n    this.uniform.destroy();\n    this.distribution?.destroy();\n  }\n}\n"]}

package/lib/renderer/WGPUEnvMapDistribution.js

@@ -5,27 +5,27 @@ const distributionWGSL = /* wgsl */ `
 @group(0) @binding(2) var<storage, read_write> rows: array<vec2f>;
 @group(0) @binding(3) var output: texture_storage_2d<rg32float, write>;
 var<workgroup> scan: array<f32, 256>;
-var<workgroup> tw: f32;
+var<workgroup> uZ: f32;
 
-fn rl(pZ: u32) {
+fn jA(nZ: u32) {
 workgroupBarrier();
 for (var offset = 1u; offset < 256u; offset *= 2u) {
 var previous = 0.0;
-if (pZ >= offset) { previous = scan[pZ - offset]; }
+if (nZ >= offset) { previous = scan[nZ - offset]; }
 workgroupBarrier();
-scan[pZ] += previous;
+scan[nZ] += previous;
 workgroupBarrier();
 }
 }
 
 @compute @workgroup_size(256)
-fn scanRows(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) pZ: u32) {
+fn scanRows(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) nZ: u32) {
 let size = textureDimensions(radiance);
 let y = group.x;
-if (pZ == 0u) { tw = 0.0; }
+if (nZ == 0u) { uZ = 0.0; }
 workgroupBarrier();
 for (var start = 0u; start < size.x; start += 256u) {
-let x = start + pZ;
+let x = start + nZ;
 var weight = 0.0;
 if (x < size.x) {
 
@@ -38,30 +38,30 @@ maximum = max(maximum, dot(textureLoad(radiance, p, 0).rgb, vec3f(0.2126, 0.7152
 }
 weight = max(maximum, 1e-12) * sin(3.141592653589793 * (f32(y) + 0.5) / f32(size.y));
 }
-scan[pZ] = weight / f32(size.x);
-rl(pZ);
-if (x < size.x) { pixels[y * size.x + x] = vec2f(tw + scan[pZ], weight); }
+scan[nZ] = weight / f32(size.x);
+jA(nZ);
+if (x < size.x) { pixels[y * size.x + x] = vec2f(uZ + scan[nZ], weight); }
 workgroupBarrier();
-if (pZ == 0u) { tw += scan[255]; }
+if (nZ == 0u) { uZ += scan[255]; }
 workgroupBarrier();
 }
-if (pZ == 0u) { rows[y] = vec2f(0.0, tw); }
+if (nZ == 0u) { rows[y] = vec2f(0.0, uZ); }
 }
 
 @compute @workgroup_size(256)
-fn scanMarginal(@builtin(local_invocation_index) pZ: u32) {
+fn scanMarginal(@builtin(local_invocation_index) nZ: u32) {
 let height = textureDimensions(radiance).y;
-if (pZ == 0u) { tw = 0.0; }
+if (nZ == 0u) { uZ = 0.0; }
 workgroupBarrier();
 for (var start = 0u; start < height; start += 256u) {
-let y = start + pZ;
+let y = start + nZ;
 var integral = 0.0;
 if (y < height) { integral = rows[y].y; }
-scan[pZ] = integral / f32(height);
-rl(pZ);
-if (y < height) { rows[y].x = tw + scan[pZ]; }
+scan[nZ] = integral / f32(height);
+jA(nZ);
+if (y < height) { rows[y].x = uZ + scan[nZ]; }
 workgroupBarrier();
-if (pZ == 0u) { tw += scan[255]; }
+if (nZ == 0u) { uZ += scan[255]; }
 workgroupBarrier();
 }
 }

package/lib/renderer/WGPUFullQuadPass.js

@@ -274,7 +274,7 @@ ${hasInputs
 ${this._uniforms
             .map((uniform, idx) => `@group(${hasInputs ? 1 : 0}) @binding(${idx}) var<uniform> ${uniform.label}: ${uniform.type};`)
             .join('\n')}
-struct qa {
+struct qZ {
 ${this._outputs
             .map((name, idx) => `@location(${idx}) ${name}: vec4f,`)
             .join('\n')}
@@ -284,10 +284,10 @@ ${this._fsDefine ?? ''}
 @fragment
 fn main(
 @builtin(position) coord: vec4f
-) -> qa {
+) -> qZ {
 let uv = vec2i(floor(coord.xy));
 let uv2 = coord.xy / viewportSize;
-var output: qa;
+var output: qZ;
 ${this._fsMain}
 return output;
 }

package/lib/renderer/WGPUPhotonMap.d.ts

@@ -0,0 +1,37 @@
+import { WGPUCausticLightPass } from './WGPUCausticLightPass.js';
+export { photonRadius } from './wgsl/photonMap.compute.js';
+interface Batch {
+    grid: GPUBuffer;
+    uniform: GPUBuffer;
+    data: GPUTexture;
+    headers: GPUTexture;
+    count: number;
+    buckets: number;
+    perCasterRadius: boolean;
+    group: GPUBindGroup;
+}
+/** Batch-local spatial hash; accumulated estimates live in the camera path target. */
+export declare class WGPUPhotonMap {
+    private readonly device;
+    readonly placeholder: GPUTexture;
+    readonly emission: WGPUCausticLightPass;
+    private readonly targets;
+    private readonly layout;
+    private readonly pipelines;
+    constructor(device: GPUDevice);
+    ensure(target: object, requested: number): Batch;
+    get(target: object): Batch | undefined;
+    encode(encoder: GPUCommandEncoder, groups: GPUBindGroup[], target: object, radius: number, options: Parameters<WGPUCausticLightPass['encode']>[3] & {
+        progressiveBatch?: number;
+    }): void;
+    release(target: object): void;
+    bytes(target: object): number;
+    dispose(): void;
+}
+/** Typical first-receiver footprint at the caster center; query disks stay exact. */
+export declare function photonVisibleRadius(radius: number, options: {
+    viewProjection: ArrayLike<number>;
+    casterSphere: readonly number[];
+    width: number;
+    orthographic?: boolean;
+}, screenPixels?: number): number;

package/lib/renderer/WGPUPhotonMap.js

@@ -0,0 +1,191 @@
+import { causticDiagnostics } from './causticDiagnostics.js';
+import { WGPUCausticLightPass } from './WGPUCausticLightPass.js';
+import { PHOTON_BYTES, PHOTON_GRID_SIZE, photonLayout, photonGridCompute } from './wgsl/photonMap.compute.js';
+export { photonRadius } from './wgsl/photonMap.compute.js';
+/** Batch-local spatial hash; accumulated estimates live in the camera path target. */
+export class WGPUPhotonMap {
+    device;
+    placeholder;
+    emission;
+    targets = new Map();
+    layout;
+    pipelines;
+    constructor(device) {
+        this.device = device;
+        this.placeholder = device.createTexture({
+            label: 'Inactive photon binding',
+            size: [1, 1],
+            format: 'r32uint',
+            usage: GPUTextureUsage.TEXTURE_BINDING
+        });
+        this.emission = new WGPUCausticLightPass(device, true);
+        this.layout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: 4, texture: { sampleType: 'uint' } },
+                { binding: 1, visibility: 4, buffer: { type: 'storage' } },
+                { binding: 2, visibility: 4, buffer: { type: 'uniform' } },
+                { binding: 4, visibility: 4, storageTexture: { access: 'write-only', format: 'r32uint' } }
+            ]
+        });
+        const module = device.createShaderModule({ label: 'Photon hash grid', code: photonGridCompute }), layout = device.createPipelineLayout({ bindGroupLayouts: [this.layout] });
+        this.pipelines = ['count', 'scanBlocks', 'scanSums', 'scatter'].map((entryPoint) => device.createComputePipeline({ label: 'Photon ' + entryPoint, layout, compute: { module, entryPoint } }));
+    }
+    ensure(target, requested) {
+        const device = this.device, limit = device.limits.maxTextureDimension2D;
+        const budget = causticDiagnostics.photonBudgetBytes ?? 128 * 1024 * 1024;
+        const perCasterRadius = !!causticDiagnostics.photonPerCasterRadius;
+        const bytesPerPhoton = perCasterRadius ? 32 : 28;
+        let count = Math.max(1, Math.min(Math.round(requested), Math.floor(device.limits.maxStorageBufferBindingSize / PHOTON_BYTES), Math.floor((limit * limit - PHOTON_GRID_SIZE * 4 - 8) / (perCasterRadius ? 4 : 3)), Math.floor(((causticDiagnostics.photonBudgetBytes ?? 128 * 1024 * 1024) - 13 * 1024 * 1024) / bytesPerPhoton)));
+        // Include row padding instead of assuming every texture is tightly packed.
+        const allocationBytes = (n) => {
+            const { buckets, texels } = photonLayout(n, perCasterRadius);
+            const capacity = (texels) => Math.min(texels, limit) * Math.ceil(texels / limit);
+            return (buckets + buckets / 256) * 32 + capacity(n) * 16 + capacity(texels) * 4 + 32;
+        };
+        while (count > 1 && allocationBytes(count) > budget) {
+            count = Math.max(1, count - Math.ceil((allocationBytes(count) - budget) / bytesPerPhoton));
+        }
+        const existing = this.targets.get(target);
+        if (existing?.count === count && existing.perCasterRadius === perCasterRadius)
+            return existing;
+        this.release(target);
+        const { buckets, texels: headerTexels } = photonLayout(count, perCasterRadius), texels = count, width = Math.min(texels, limit), height = Math.ceil(texels / width);
+        // One rgba32uint texel holds position and flux. Direction words live after
+        // both sorted indices in the integer grid texture: 20 B payload + 8 B indices.
+        const batch = {
+            count,
+            buckets,
+            perCasterRadius,
+            grid: device.createBuffer({
+                label: 'Photon hash buckets',
+                size: (buckets + buckets / 256) * 32,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+            }),
+            uniform: device.createBuffer({
+                label: 'Photon grid parameters',
+                size: 32,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+            }),
+            data: device.createTexture({
+                label: 'Packed photon positions and flux',
+                size: [width, height],
+                format: 'rgba32uint',
+                usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+            }),
+            headers: device.createTexture({
+                label: 'Photon grid headers',
+                size: [
+                    Math.min(headerTexels, limit),
+                    Math.ceil((headerTexels) / limit)
+                ],
+                format: 'r32uint',
+                usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+            })
+        };
+        batch.group = this.device.createBindGroup({
+            layout: this.layout,
+            entries: [
+                { binding: 0, resource: batch.data.createView() },
+                { binding: 1, resource: { buffer: batch.grid } },
+                { binding: 2, resource: { buffer: batch.uniform } },
+                { binding: 4, resource: batch.headers.createView() }
+            ]
+        });
+        this.targets.set(target, batch);
+        return batch;
+    }
+    get(target) {
+        return this.targets.get(target);
+    }
+    encode(encoder, groups, target, radius, options) {
+        const batch = this.targets.get(target);
+        if (causticDiagnostics.capturePhotons)
+            causticDiagnostics.photonBatch = {
+                device: this.device,
+                data: batch.headers,
+                emitted: batch.count,
+                packed: true
+            };
+        encoder.clearBuffer(batch.grid);
+        this.emission.emit(encoder, groups, batch.data, {
+            ...options,
+            photons: batch.count,
+            photonMapping: true,
+            photonDirections: batch.headers
+        });
+        const bytes = new ArrayBuffer(32);
+        new Float32Array(bytes)[0] = radius;
+        new Uint32Array(bytes)[1] = batch.count;
+        new Float32Array(bytes)[2] = causticDiagnostics.photonScreenRadius === false ? 0 : 2;
+        new Float32Array(bytes)[3] = causticDiagnostics.photonSkipQuery
+            ? 1
+            : causticDiagnostics.photonSkipVisible
+                ? 2
+                : 0;
+        new Uint32Array(bytes)[4] = batch.buckets;
+        new Float32Array(bytes)[5] = photonVisibleRadius(radius, options, new Float32Array(bytes)[2]);
+        new Uint32Array(bytes)[6] = (+batch.perCasterRadius) |
+            (Math.min(65535, Math.max(0, Math.round(causticDiagnostics.photonDeepScreenPixels ?? 0))) << 8);
+        this.device.queue.writeBuffer(batch.uniform, 0, bytes);
+        const group = batch.group;
+        // Dispatch boundaries synchronize storage accesses. Offline batches share one
+        // compute pass; timestamp profiling keeps separate passes for stage timings.
+        const combined = options.querySet ? undefined : encoder.beginComputePass({ label: 'Photon grid' });
+        this.pipelines.forEach((pipeline, index) => {
+            const pass = combined ??
+                encoder.beginComputePass({
+                    label: ['Photon count', 'Photon scan blocks', 'Photon scan sums', 'Photon scatter'][index],
+                    timestampWrites: {
+                        querySet: options.querySet,
+                        beginningOfPassWriteIndex: 8 + index * 2,
+                        endOfPassWriteIndex: 9 + index * 2
+                    }
+                });
+            pass.setPipeline(pipeline);
+            pass.setBindGroup(0, group);
+            const groups = index === 1
+                ? batch.buckets / 256
+                : index === 2
+                    ? 1
+                    : Math.ceil((index === 3 ? Math.max(batch.count, batch.buckets) : batch.count) / 64);
+            pass.dispatchWorkgroups(Math.min(groups, 65535), index === 1 || index === 2 ? 2 : Math.ceil(groups / 65535));
+            if (!combined)
+                pass.end();
+        });
+        combined?.end();
+    }
+    release(target) {
+        const b = this.targets.get(target);
+        if (!b)
+            return;
+        b.grid.destroy();
+        b.uniform.destroy();
+        b.data.destroy();
+        b.headers.destroy();
+        this.targets.delete(target);
+    }
+    bytes(target) {
+        const b = this.targets.get(target);
+        return b
+            ? b.grid.size +
+                b.uniform.size +
+                b.data.width * b.data.height * 16 +
+                b.headers.width * b.headers.height * 4
+            : 0;
+    }
+    dispose() {
+        for (const target of this.targets.keys())
+            this.release(target);
+        this.emission.dispose();
+        this.placeholder.destroy();
+    }
+}
+/** Typical first-receiver footprint at the caster center; query disks stay exact. */
+export function photonVisibleRadius(radius, options, screenPixels = 2) {
+    const m = options.viewProjection, p = options.casterSphere;
+    const depth = options.orthographic ? 1 : Math.abs(m[3] * p[0] + m[7] * p[1] + m[11] * p[2] + m[15]);
+    const projection = Math.hypot(m[0], m[4], m[8]);
+    const footprint = 2 * depth / (options.width * projection) * screenPixels;
+    return screenPixels > 0 && Number.isFinite(footprint) && footprint > 0 ? Math.min(radius, Math.max(1e-8, footprint)) : radius;
+}
+//# sourceMappingURL=WGPUPhotonMap.js.map