@meimu/mutracer 0.2.0 → 0.3.1

package/lib/renderer/wgsl/offlineAdaptive.compute.js

@@ -27,8 +27,8 @@ _padding: f32,
 const LUMINANCE = vec3f(0.2126, 0.7152, 0.0722);
 
 @compute @workgroup_size(64)
-fn main(@builtin(global_invocation_id) vQ: vec3u) {
-let tile = vQ.x;
+fn main(@builtin(global_invocation_id) eJ: vec3u) {
+let tile = eJ.x;
 let tileCount = params.columns * params.rows;
 if (tile >= tileCount) {
 return;
@@ -36,16 +36,16 @@ return;
 
 let tileX = tile % params.columns;
 let tileY = tile / params.columns;
-let vY = tileX * params.tileSize;
-let vZ = tileY * params.tileSize;
-let ye = min(vY + params.tileSize, params.width);
-let yf = min(vZ + params.tileSize, params.height);
-var nW = 0.0;
-var jB = 0.0;
+let yp = tileX * params.tileSize;
+let yq = tileY * params.tileSize;
+let AD = min(yp + params.tileSize, params.width);
+let AE = min(yq + params.tileSize, params.height);
+var oL = 0.0;
+var jL = 0.0;
 var count = 0u;
 
-for (var y = vZ; y < yf; y++) {
-for (var x = vY; x < ye; x++) {
+for (var y = yq; y < AE; y++) {
+for (var x = yp; x < AD; x++) {
 let pixel = y * params.width + x;
 let offset = pixel * 4u;
 let samples = pilotMoments[offset + 3u];
@@ -60,28 +60,28 @@ pilotColor[offset + 2u]
 ),
 LUMINANCE
 ) / samples;
-let va = pilotMoments[offset] / samples;
-let qg = max(va - mean * mean, 0.0);
-var variance = qg;
+let wX = pilotMoments[offset] / samples;
+let rj = max(wX - mean * mean, 0.0);
+var variance = rj;
 if (samples > 1.0) {
-variance = qg * samples / (samples - 1.0);
+variance = rj * samples / (samples - 1.0);
 }
-nW += mean;
-jB = max(jB, variance);
+oL += mean;
+jL = max(jL, variance);
 count += 1u;
 }
 }
 
-let mean = nW / f32(max(count, 1u));
-var pT = 0.0;
+let mean = oL / f32(max(count, 1u));
+var qO = 0.0;
 if (params.hasPrevious != 0u) {
-pT = previousVariance[tile];
+qO = previousVariance[tile];
 }
-let tu = max(jB, pT);
-let uD = params.absoluteError + params.relativeError * abs(mean);
+let uX = max(jL, qO);
+let sf = params.absoluteError + params.relativeError * abs(mean);
 let required = ceil(
-params.confidence * params.confidence * tu /
-max(uD * uD, 1e-16)
+params.confidence * params.confidence * uX /
+max(sf * sf, 1e-16)
 );
 let targetSamples = u32(min(
 f32(params.maxSamples),
@@ -91,11 +91,11 @@ max(f32(params.minSamples), required)
 tileMeans[tile] = mean;
 
 
-tileVariances[tile] = jB;
+tileVariances[tile] = jL;
 tileTargets[tile] = targetSamples;
 
-for (var y = vZ; y < yf; y++) {
-for (var x = vY; x < ye; x++) {
+for (var y = yq; y < AE; y++) {
+for (var x = yp; x < AD; x++) {
 textureStore(
 targetTexture,
 vec2i(i32(x), i32(y)),

package/lib/renderer/wgsl/oidnAuxiliary.wgsl.js

@@ -1,16 +1,16 @@
 // OIDN's LDR auxiliary networks use sRGB albedo and normals in [0,1].
 export const oidnAuxiliaryDefine = /* wgsl */ `
-fn sT(value: vec3f) -> vec3f {
+fn uq(value: vec3f) -> vec3f {
 let linear = clamp(value, vec3f(0.0), vec3f(1.0));
 return select(1.055 * pow(linear, vec3f(1.0 / 2.4)) - 0.055,
 12.92 * linear, linear <= vec3f(0.0031308));
 }
-fn sS(value: vec3f) -> vec3f {
+fn uo(value: vec3f) -> vec3f {
 let encoded = clamp(value, vec3f(0.0), vec3f(1.0));
 return select(pow((encoded + 0.055) / 1.055, vec3f(2.4)),
 encoded / 12.92, encoded <= vec3f(0.04045));
 }
-fn rL(value: vec3f) -> vec3f {
+fn sW(value: vec3f) -> vec3f {
 return clamp(value, vec3f(0.0), vec3f(1.0));
 }
 `;

package/lib/renderer/wgsl/photonMap.compute.d.ts

@@ -0,0 +1,29 @@
+export declare const PHOTON_BYTES = 20;
+export declare const PHOTON_GRID_SIZE = 262144;
+export declare const PHOTON_SCAN_BLOCK = 256;
+export declare const PHOTON_REFERENCE_COUNT: number;
+export type PhotonRadiusScaling = 'none' | 'ppm' | 'constant-count';
+/** Internal density A/B, with the same progressive schedule in all modes. */
+export declare function photonRadius(initial: number, batch: number, alpha?: number, photons?: number, scaling?: PhotonRadiusScaling): number;
+/** Default photon-map batch: pixel count / 4, capped at 2^18. */
+export declare function defaultPhotonMapPhotons(width: number, height: number, divisor?: number): number;
+/** Power-of-two hash capacity, bounded independently of large photon batches. */
+export declare function photonBucketCount(photons: number): number;
+/** Shared texture address contract; payload is stored once, indices twice. */
+export declare function photonLayout(count: number, perCasterRadius?: boolean): {
+    buckets: number;
+    coarseHeaders: number;
+    fineHeaders: number;
+    coarseIndices: number;
+    fineIndices: number;
+    directions: number;
+    texels: number;
+};
+/** Batch-local hash buckets: count, two-level parallel prefix sum, then parallel scatter. */
+export declare const photonGridCompute = "\n  struct Bucket {\n    count: atomic<u32>,\n    offset: u32,\n    cursor: atomic<u32>,\n    padding: u32,\n  }\n  struct Parameters {\n    radius: f32,\n    count: u32,\n    screenPixels: f32,\n    skipQuery: f32,\n    buckets: u32,\n    fineRadius: f32,\n    experiments: u32,\n    padding2: u32,\n  }\n  @group(0)@binding(0)var photons:texture_2d<u32>;\n  @group(0)@binding(1)var<storage,read_write>grid:array<Bucket>;\n  @group(0)@binding(2)var<uniform>parameters:Parameters;\n  @group(0)@binding(4)var headers:texture_storage_2d<r32uint,write>;\n  fn hashCell(cell:vec3i)->u32 {\n    let p=bitcast<vec3u>(cell);\n    return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(parameters.buckets-1u);\n  }\n  fn hashPhoton(p:vec3f,layer:u32)->u32 {\n    let radius=select(parameters.radius,parameters.fineRadius,layer==1u);\n    let cellSize=select(radius,2.0*radius,layer==1u);\n    return hashCell(vec3i(floor(p/cellSize)));\n  }\n  fn gridStart(layer:u32)->u32 {\n    return layer*(parameters.buckets+parameters.buckets/256u);\n  }\n  fn storeIndex(i:u32,value:u32) {\n    let width=textureDimensions(headers).x;\n    textureStore(headers,vec2i(vec2u(i%width,i/width)),vec4u(value));\n  }\n  fn photonRecord(i:u32)->vec4u {\n    let width=textureDimensions(photons).x;\n    return textureLoad(photons,vec2i(vec2u(i%width,i/width)),0);\n  }\n  fn photonPosition(i:u32)->vec3f {\n    return bitcast<vec3f>(photonRecord(i).xyz);\n  }\n  @compute @workgroup_size(64)\n  fn count(@builtin(global_invocation_id)id:vec3u) {\n    if(id.x+id.y*4194240u>=parameters.count) {\n      return;\n    }\n    let index=id.x+id.y*4194240u;\n    if(photonRecord(index).w==0u) {\n      return;\n    }\n    for(var layer=0u;layer<2u;layer++) {\n      atomicAdd(&grid[gridStart(layer)+hashPhoton(photonPosition(index),layer)].count,1u);\n    }\n  }\n  // Each block scans 256 buckets; the next workgroup scans chunks of block totals.\n  var<workgroup> scan:array<u32,256>;\n  fn inclusiveScan(local:u32,value:u32)->u32 {\n    scan[local]=value;\n    workgroupBarrier();\n    for(var stride=1u;stride<256u;stride*=2u) {\n      var previous=0u;\n      if(local>=stride) {\n        previous=scan[local-stride];\n      }\n      workgroupBarrier();\n      scan[local]+=previous;\n      workgroupBarrier();\n    }\n    return scan[local];\n  }\n  @compute @workgroup_size(256)\n  fn scanBlocks(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {\n    let index=gridStart(group.y)+group.x*256u+local;\n    let count=atomicLoad(&grid[index].count);\n    let prefix=inclusiveScan(local,count);\n    grid[index].offset=prefix-count;\n    if(local==255u) {\n      atomicStore(&grid[gridStart(group.y)+parameters.buckets+group.x].count,prefix);\n    }\n  }\n  @compute @workgroup_size(256)\n  fn scanSums(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {\n    let blocks=parameters.buckets/256u;\n    let chunk=(blocks+255u)/256u;\n    let first=local*chunk;\n    let start=gridStart(group.y)+parameters.buckets;\n    var count=0u;\n    for(var i=first;i<min(first+chunk,blocks);i++) {\n      count+=atomicLoad(&grid[start+i].count);\n    }\n    let prefix=inclusiveScan(local,count);\n    var offset=prefix-count;\n    for(var i=first;i<min(first+chunk,blocks);i++) {\n      grid[start+i].offset=offset;\n      offset+=atomicLoad(&grid[start+i].count);\n    }\n    if(local==255u&&group.y==0u) {\n      storeIndex(0u,bitcast<u32>(parameters.radius));\n      storeIndex(1u,prefix);\n      storeIndex(2u,bitcast<u32>(parameters.screenPixels));\n      storeIndex(3u,bitcast<u32>(parameters.skipQuery));\n      storeIndex(4u,parameters.count);\n      storeIndex(5u,parameters.buckets);\n      storeIndex(6u,bitcast<u32>(parameters.fineRadius));\n      storeIndex(7u,parameters.experiments);\n    }\n  }\n  @compute @workgroup_size(64)\n  fn scatter(@builtin(global_invocation_id)id:vec3u) {\n    let invocation=id.x+id.y*4194240u;\n    for(var layer=0u;layer<2u;layer++) {\n      let start=gridStart(layer);\n      if(invocation<parameters.buckets) {\n        let offset=grid[start+invocation].offset+grid[start+parameters.buckets+invocation/256u].offset;\n        storeIndex(8u+layer*parameters.buckets*2u+invocation*2u,offset);\n        storeIndex(9u+layer*parameters.buckets*2u+invocation*2u,atomicLoad(&grid[start+invocation].count));\n      }\n      if(invocation<parameters.count&&photonRecord(invocation).w!=0u) {\n        let bucket=hashPhoton(photonPosition(invocation),layer);\n        let index=grid[start+bucket].offset+grid[start+parameters.buckets+bucket/256u].offset+atomicAdd(&grid[start+bucket].cursor,1u);\n        storeIndex(8u+parameters.buckets*4u+layer*parameters.count+index,invocation);\n      }\n    }\n  }\n";
+/** Packed photon payload: position f32 x3, RGBE8 flux, two octahedral directions. */
+export declare const photonPackingWgsl = "\n  fn photonOctSign(v:vec2f)->vec2f {\n    return select(vec2f(-1.0),vec2f(1.0),v>=vec2f(0.0));\n  }\n  fn photonEncodeOct(n:vec3f)->vec2f {\n    let p=n/(abs(n.x)+abs(n.y)+abs(n.z));\n    let uv=select(p.xy,(vec2f(1.0)-abs(p.yx))*photonOctSign(p.xy),p.z<0.0);\n    return uv*.5+.5;\n  }\n  fn photonDecodeOct(uv:vec2f)->vec3f {\n    let p=uv*2.0-1.0;\n    var n=vec3f(p,1.0-abs(p.x)-abs(p.y));\n    if(n.z<0.0) {\n      n=vec3f((vec2f(1.0)-abs(n.yx))*photonOctSign(n.xy),n.z);\n    }\n    return normalize(n);\n  }\n  // An eight-bit exponent avoids RGB9E5's limited range for very dim/bright lights.\n  // Flux is stored before dividing by emitted count, preserving tiny large batches.\n  fn photonEncodeFlux(value:vec3f)->u32 {\n    let peak=max(max(value.x,value.y),value.z);\n    if(!(peak>0.0)) {\n      return 0u;\n    }\n    let exponent=clamp(i32(floor(log2(peak)))+1,-126,127);\n    let rgb=vec3u(clamp(round(value*exp2(-f32(exponent))*255.0),vec3f(0.0),vec3f(255.0)));\n    return rgb.x|(rgb.y<<8u)|(rgb.z<<16u)|(u32(exponent+127)<<24u);\n  }\n  fn photonDecodeFlux(value:u32)->vec3f {\n    if(value==0u) {\n      return vec3f(0.0);\n    }\n    return vec3f(f32(value&255u),f32((value>>8u)&255u),f32((value>>16u)&255u))*exp2(f32(i32(value>>24u)-127))/255.0;\n  }\n";
+export declare const photonQueryWgsl = "\n  fn photonOctSign(v:vec2f)->vec2f {\n    return select(vec2f(-1.0),vec2f(1.0),v>=vec2f(0.0));\n  }\n  fn photonEncodeOct(n:vec3f)->vec2f {\n    let p=n/(abs(n.x)+abs(n.y)+abs(n.z));\n    let uv=select(p.xy,(vec2f(1.0)-abs(p.yx))*photonOctSign(p.xy),p.z<0.0);\n    return uv*.5+.5;\n  }\n  fn photonDecodeOct(uv:vec2f)->vec3f {\n    let p=uv*2.0-1.0;\n    var n=vec3f(p,1.0-abs(p.x)-abs(p.y));\n    if(n.z<0.0) {\n      n=vec3f((vec2f(1.0)-abs(n.yx))*photonOctSign(n.xy),n.z);\n    }\n    return normalize(n);\n  }\n  // An eight-bit exponent avoids RGB9E5's limited range for very dim/bright lights.\n  // Flux is stored before dividing by emitted count, preserving tiny large batches.\n  fn photonEncodeFlux(value:vec3f)->u32 {\n    let peak=max(max(value.x,value.y),value.z);\n    if(!(peak>0.0)) {\n      return 0u;\n    }\n    let exponent=clamp(i32(floor(log2(peak)))+1,-126,127);\n    let rgb=vec3u(clamp(round(value*exp2(-f32(exponent))*255.0),vec3f(0.0),vec3f(255.0)));\n    return rgb.x|(rgb.y<<8u)|(rgb.z<<16u)|(u32(exponent+127)<<24u);\n  }\n  fn photonDecodeFlux(value:u32)->vec3f {\n    if(value==0u) {\n      return vec3f(0.0);\n    }\n    return vec3f(f32(value&255u),f32((value>>8u)&255u),f32((value>>16u)&255u))*exp2(f32(i32(value>>24u)-127))/255.0;\n  }\n\n  @group(1)@binding(11)var photonMapData:texture_2d<u32>;\n  @group(1)@binding(12)var photonMapGrid:texture_2d<u32>;\n  fn photonLoad(i:u32)->vec4u {\n    let width=textureDimensions(photonMapData).x;\n    return textureLoad(photonMapData,vec2i(vec2u(i%width,i/width)),0);\n  }\n  fn photonIndexWord(i:u32)->u32 {\n    let width=textureDimensions(photonMapGrid).x;\n    return textureLoad(photonMapGrid,vec2i(vec2u(i%width,i/width)),0).x;\n  }\n  fn photonHash(cell:vec3i)->u32 {\n    let p=bitcast<vec3u>(cell);\n    return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(photonIndexWord(5u)-1u);\n  }\n  // Approximate a specular prefix by the camera-space depth of its first diffuse\n  // receiver. Orthographic footprints do not grow with distance. Grazing surfaces\n  // expand the disk conservatively; the progressive world radius remains the cap.\n  fn photonPixelFootprint(si:SurfaceInteraction)->f32 {\n    let inverse=cameraUniform.viewProjectionInv;\n    let a=inverse*vec4f(0.0,0.0,-1.0,1.0);\n    let b=inverse*vec4f(2.0/rtUniform.outputSize.x,0.0,-1.0,1.0);\n    let origin=a.xyz/a.w;\n    let offset=b.xyz/b.w;\n    let eye=cameraUniform.viewInv[3].xyz;\n    let forward=normalize(cameraUniform.viewInv[2].xyz);\n    let depth=abs(dot(si.position-eye,forward));\n    let nearDepth=max(abs(dot(origin-eye,forward)),1e-8);\n    let perspective=abs(inverse[2].w)>1e-8;\n    let footprint=length(offset-origin)*select(1.0,depth/nearDepth,perspective);\n    let cosine=abs(dot(si.faceNormal,normalize(si.position-eye)));\n    return max(1e-8,footprint/sqrt(max(.0625,cosine)));\n  }\n  fn photonContribution(si:SurfaceInteraction,prepared:OpenPbrPreparedBsdf,primary:bool,visible:bool)->vec3f {\n    if(samplingBounce>CAUSTIC_PHOTON_MAX_DEPTH||isCausticSpecular(prepared.material)||prepared.material.materialType==SHADOW_CATCHER) {\n      return vec3f(0.0);\n    }\n    if(CAUSTIC_LIGHT_TRACING&&primary) {\n      return vec3f(0.0);\n    }\n    let globalRadius=bitcast<f32>(photonIndexWord(0u));\n    let screenPixels=bitcast<f32>(photonIndexWord(2u));\n    if(!(globalRadius>0.0)||bitcast<f32>(photonIndexWord(3u))==1.0||(bitcast<f32>(photonIndexWord(3u))==2.0&&visible)) {\n      return vec3f(0.0);\n    }\n    var radius=globalRadius;\n    let experiments=photonIndexWord(7u);\n    let deepPixels=f32(experiments>>8u);\n    let queryPixels=select(deepPixels,screenPixels,visible);\n    if(queryPixels>0.0) {\n      radius=min(radius,photonPixelFootprint(si)*queryPixels);\n    }\n    let layer=select(0u,1u,visible&&screenPixels>0.0);\n    let cellSize=select(globalRadius,2.0*bitcast<f32>(photonIndexWord(6u)),layer==1u);\n    let firstCell=vec3i(floor((si.position-vec3f(radius))/cellSize));\n    let lastCell=vec3i(floor((si.position+vec3f(radius))/cellSize));\n    let buckets=photonIndexWord(5u);\n    let headerStart=8u+layer*buckets*2u;\n    let indexStart=8u+buckets*4u+layer*photonIndexWord(4u);\n    let emitted=f32(photonIndexWord(4u));\n    var sum=vec3f(0.0);\n    for(var z=firstCell.z;z<=lastCell.z;z++) {\n      for(var y=firstCell.y;y<=lastCell.y;y++) {\n        for(var x=firstCell.x;x<=lastCell.x;x++) {\n          let queryCell=vec3i(x,y,z);\n          // Reject cube corners before loading their photon lists. Padding keeps\n          // the bound conservative when cell multiplication rounds in f32.\n          let cellMin=vec3f(queryCell)*cellSize;\n          let padding=max(vec3f(cellSize*1e-5),abs(cellMin)*1e-6);\n          let closest=clamp(si.position,cellMin-padding,cellMin+vec3f(cellSize)+padding);\n          if(distance(closest,si.position)>=radius) { continue; }\n          let bucket=photonHash(queryCell);\n          let offset=photonIndexWord(headerStart+bucket*2u);\n          let count=photonIndexWord(headerStart+1u+bucket*2u);\n          for(var i=offset;i<offset+count;i++) {\n            let index=photonIndexWord(indexStart+i);\n            let record=photonLoad(index);\n            let position=bitcast<vec3f>(record.xyz);\n            // Hash collisions and neighboring buckets never count a photon twice.\n            if(any(vec3i(floor(position/cellSize))!=queryCell)||distance(position,si.position)>=radius) {\n              continue;\n            }\n            var kernelRadius=radius;\n            if((experiments&1u)!=0u) {\n              let scale=bitcast<f32>(photonIndexWord(8u+buckets*4u+u32(emitted)*3u+index));\n              kernelRadius=min(radius,globalRadius*scale);\n              if(!(kernelRadius>0.0)||distance(position,si.position)>=kernelRadius) { continue; }\n            }\n            let directions=photonIndexWord(8u+buckets*4u+u32(emitted)*2u+index);\n            let normal=photonDecodeOct(vec2f(f32(directions&255u)/255.0,f32((directions>>8u)&127u)/127.0));\n            if(dot(normal,si.faceNormal)<0.9) {\n              continue;\n            }\n            if(CAUSTIC_MNEE&&samplingBounce<=CAUSTIC_MNEE_MAX_DEPTH&&(directions&32768u)!=0u&&prepared.material.baseWeight*(1.0-prepared.material.baseMetalness)*(1.0-prepared.material.transmissionWeight)>0.0&&prepared.material.subsurfaceWeight==0.0) {\n              continue;\n            }\n            let incoming=photonDecodeOct(vec2f(f32((directions>>16u)&255u),f32(directions>>24u))/255.0);\n            let cosine=abs(dot(si.faceNormal,incoming));\n            if(cosine<=0.0) {\n              continue;\n            }\n            var flux=photonDecodeFlux(record.w)/emitted;\n            if(SPECTRAL) {\n              flux=sampling_spectral_rgb_filter(flux,si.spectralChannel);\n            }\n            var pdf:f32;\n            let response=openpbr_eval_prepared(prepared,incoming,&pdf);\n            sum+=response*flux/cosine*(radius*radius)/(kernelRadius*kernelRadius);\n          }\n        }\n      }\n    }\n    return sum/(PI*radius*radius);\n  }\n";
+export declare function photonDirectQuerySource(enabled?: boolean): string;
+/** Evidence-only per-query counters; no extra bindings or public render options. */
+export declare function photonQuerySource(debugGroup?: number, directSubset?: boolean): string;

package/lib/renderer/wgsl/photonMap.compute.js

@@ -0,0 +1,352 @@
+export const PHOTON_BYTES = 20;
+export const PHOTON_GRID_SIZE = 262144;
+export const PHOTON_SCAN_BLOCK = 256;
+export const PHOTON_REFERENCE_COUNT = 2 ** 18;
+/** Internal density A/B, with the same progressive schedule in all modes. */
+export function photonRadius(initial, batch, alpha = 2 / 3, photons = PHOTON_REFERENCE_COUNT, scaling = 'none') {
+    const radius = initial * Math.pow(Math.max(1, batch), (alpha - 1) / 2);
+    if (scaling === 'none' || photons === PHOTON_REFERENCE_COUNT)
+        return radius;
+    const exponent = scaling === 'ppm' ? (alpha - 1) / 2 : -1 / 2;
+    return radius * Math.pow(Math.max(1, photons) / PHOTON_REFERENCE_COUNT, exponent);
+}
+/** Default photon-map batch: pixel count / 4, capped at 2^18. */
+export function defaultPhotonMapPhotons(width, height, divisor = 4) {
+    return Math.min(2 ** 18, Math.max(1, Math.round((width * height) / divisor)));
+}
+/** Power-of-two hash capacity, bounded independently of large photon batches. */
+export function photonBucketCount(photons) {
+    return Math.min(PHOTON_GRID_SIZE, 2 ** Math.ceil(Math.log2(Math.max(256, photons * 2))));
+}
+/** Shared texture address contract; payload is stored once, indices twice. */
+export function photonLayout(count, perCasterRadius = false) {
+    const buckets = photonBucketCount(count);
+    const coarseHeaders = 8;
+    const fineHeaders = coarseHeaders + buckets * 2;
+    const coarseIndices = fineHeaders + buckets * 2;
+    const fineIndices = coarseIndices + count;
+    const directions = fineIndices + count;
+    return { buckets, coarseHeaders, fineHeaders, coarseIndices, fineIndices, directions, texels: directions + count * (perCasterRadius ? 2 : 1) };
+}
+/** Batch-local hash buckets: count, two-level parallel prefix sum, then parallel scatter. */
+export const photonGridCompute = /* wgsl */ `
+struct Bucket {
+count: atomic<u32>,
+offset: u32,
+cursor: atomic<u32>,
+padding: u32,
+}
+struct Parameters {
+radius: f32,
+count: u32,
+screenPixels: f32,
+skipQuery: f32,
+buckets: u32,
+fineRadius: f32,
+experiments: u32,
+padding2: u32,
+}
+@group(0)@binding(0)var photons:texture_2d<u32>;
+@group(0)@binding(1)var<storage,read_write>grid:array<Bucket>;
+@group(0)@binding(2)var<uniform>parameters:Parameters;
+@group(0)@binding(4)var headers:texture_storage_2d<r32uint,write>;
+fn zv(sF:vec3i)->u32 {
+let p=bitcast<vec3u>(sF);
+return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(parameters.buckets-1u);
+}
+fn vq(p:vec3f,layer:u32)->u32 {
+let radius=select(parameters.radius,parameters.fineRadius,layer==1u);
+let mo=select(radius,2.0*radius,layer==1u);
+return zv(vec3i(floor(p/mo)));
+}
+fn pl(layer:u32)->u32 {
+return layer*(parameters.buckets+parameters.buckets/256u);
+}
+fn fE(i:u32,value:u32) {
+let width=textureDimensions(headers).x;
+textureStore(headers,vec2i(vec2u(i%width,i/width)),vec4u(value));
+}
+fn qs(i:u32)->vec4u {
+let width=textureDimensions(photons).x;
+return textureLoad(photons,vec2i(vec2u(i%width,i/width)),0);
+}
+fn rI(i:u32)->vec3f {
+return bitcast<vec3f>(qs(i).xyz);
+}
+@compute @workgroup_size(64)
+fn count(@builtin(global_invocation_id)id:vec3u) {
+if(id.x+id.y*4194240u>=parameters.count) {
+return;
+}
+let index=id.x+id.y*4194240u;
+if(qs(index).w==0u) {
+return;
+}
+for(var layer=0u;layer<2u;layer++) {
+atomicAdd(&grid[pl(layer)+vq(rI(index),layer)].count,1u);
+}
+}
+
+var<workgroup> scan:array<u32,256>;
+fn jA(local:u32,value:u32)->u32 {
+scan[local]=value;
+workgroupBarrier();
+for(var stride=1u;stride<256u;stride*=2u) {
+var previous=0u;
+if(local>=stride) {
+previous=scan[local-stride];
+}
+workgroupBarrier();
+scan[local]+=previous;
+workgroupBarrier();
+}
+return scan[local];
+}
+@compute @workgroup_size(256)
+fn scanBlocks(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {
+let index=pl(group.y)+group.x*256u+local;
+let count=atomicLoad(&grid[index].count);
+let prefix=jA(local,count);
+grid[index].offset=prefix-count;
+if(local==255u) {
+atomicStore(&grid[pl(group.y)+parameters.buckets+group.x].count,prefix);
+}
+}
+@compute @workgroup_size(256)
+fn scanSums(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {
+let blocks=parameters.buckets/256u;
+let chunk=(blocks+255u)/256u;
+let first=local*chunk;
+let start=pl(group.y)+parameters.buckets;
+var count=0u;
+for(var i=first;i<min(first+chunk,blocks);i++) {
+count+=atomicLoad(&grid[start+i].count);
+}
+let prefix=jA(local,count);
+var offset=prefix-count;
+for(var i=first;i<min(first+chunk,blocks);i++) {
+grid[start+i].offset=offset;
+offset+=atomicLoad(&grid[start+i].count);
+}
+if(local==255u&&group.y==0u) {
+fE(0u,bitcast<u32>(parameters.radius));
+fE(1u,prefix);
+fE(2u,bitcast<u32>(parameters.screenPixels));
+fE(3u,bitcast<u32>(parameters.skipQuery));
+fE(4u,parameters.count);
+fE(5u,parameters.buckets);
+fE(6u,bitcast<u32>(parameters.fineRadius));
+fE(7u,parameters.experiments);
+}
+}
+@compute @workgroup_size(64)
+fn scatter(@builtin(global_invocation_id)id:vec3u) {
+let eJ=id.x+id.y*4194240u;
+for(var layer=0u;layer<2u;layer++) {
+let start=pl(layer);
+if(eJ<parameters.buckets) {
+let offset=grid[start+eJ].offset+grid[start+parameters.buckets+eJ/256u].offset;
+fE(8u+layer*parameters.buckets*2u+eJ*2u,offset);
+fE(9u+layer*parameters.buckets*2u+eJ*2u,atomicLoad(&grid[start+eJ].count));
+}
+if(eJ<parameters.count&&qs(eJ).w!=0u) {
+let tU=vq(rI(eJ),layer);
+let index=grid[start+tU].offset+grid[start+parameters.buckets+tU/256u].offset+atomicAdd(&grid[start+tU].cursor,1u);
+fE(8u+parameters.buckets*4u+layer*parameters.count+index,eJ);
+}
+}
+}
+`;
+/** Packed photon payload: position f32 x3, RGBE8 flux, two octahedral directions. */
+export const photonPackingWgsl = /* wgsl */ `
+fn sv(v:vec2f)->vec2f {
+return select(vec2f(-1.0),vec2f(1.0),v>=vec2f(0.0));
+}
+fn qR(n:vec3f)->vec2f {
+let p=n/(abs(n.x)+abs(n.y)+abs(n.z));
+let uv=select(p.xy,(vec2f(1.0)-abs(p.yx))*sv(p.xy),p.z<0.0);
+return uv*.5+.5;
+}
+fn qQ(uv:vec2f)->vec3f {
+let p=uv*2.0-1.0;
+var n=vec3f(p,1.0-abs(p.x)-abs(p.y));
+if(n.z<0.0) {
+n=vec3f((vec2f(1.0)-abs(n.yx))*sv(n.xy),n.z);
+}
+return normalize(n);
+}
+
+
+fn us(value:vec3f)->u32 {
+let peak=max(max(value.x,value.y),value.z);
+if(!(peak>0.0)) {
+return 0u;
+}
+let exponent=clamp(i32(floor(log2(peak)))+1,-126,127);
+let rgb=vec3u(clamp(round(value*exp2(-f32(exponent))*255.0),vec3f(0.0),vec3f(255.0)));
+return rgb.x|(rgb.y<<8u)|(rgb.z<<16u)|(u32(exponent+127)<<24u);
+}
+fn photonDecodeFlux(value:u32)->vec3f {
+if(value==0u) {
+return vec3f(0.0);
+}
+return vec3f(f32(value&255u),f32((value>>8u)&255u),f32((value>>16u)&255u))*exp2(f32(i32(value>>24u)-127))/255.0;
+}
+`;
+export const photonQueryWgsl = /* wgsl */ `${photonPackingWgsl}
+@group(1)@binding(11)var photonMapData:texture_2d<u32>;
+@group(1)@binding(12)var photonMapGrid:texture_2d<u32>;
+fn photonLoad(i:u32)->vec4u {
+let width=textureDimensions(photonMapData).x;
+return textureLoad(photonMapData,vec2i(vec2u(i%width,i/width)),0);
+}
+fn photonIndexWord(i:u32)->u32 {
+let width=textureDimensions(photonMapGrid).x;
+return textureLoad(photonMapGrid,vec2i(vec2u(i%width,i/width)),0).x;
+}
+fn ym(sF:vec3i)->u32 {
+let p=bitcast<vec3u>(sF);
+return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(photonIndexWord(5u)-1u);
+}
+
+
+
+fn photonPixelFootprint(si:SurfaceInteraction)->f32 {
+let inverse=cameraUniform.viewProjectionInv;
+let a=inverse*vec4f(0.0,0.0,-1.0,1.0);
+let b=inverse*vec4f(2.0/rtUniform.outputSize.x,0.0,-1.0,1.0);
+let origin=a.xyz/a.w;
+let offset=b.xyz/b.w;
+let eye=cameraUniform.viewInv[3].xyz;
+let forward=normalize(cameraUniform.viewInv[2].xyz);
+let depth=abs(dot(si.position-eye,forward));
+let zg=max(abs(dot(origin-eye,forward)),1e-8);
+let perspective=abs(inverse[2].w)>1e-8;
+let footprint=length(offset-origin)*select(1.0,depth/zg,perspective);
+let cosine=abs(dot(si.faceNormal,normalize(si.position-eye)));
+return max(1e-8,footprint/sqrt(max(.0625,cosine)));
+}
+fn sY(si:SurfaceInteraction,prepared:OpenPbrPreparedBsdf,wP:bool,visible:bool)->vec3f {
+if(samplingBounce>CAUSTIC_PHOTON_MAX_DEPTH||isCausticSpecular(prepared.material)||prepared.material.materialType==SHADOW_CATCHER) {
+return vec3f(0.0);
+}
+if(CAUSTIC_LIGHT_TRACING&&wP) {
+return vec3f(0.0);
+}
+let ni=bitcast<f32>(photonIndexWord(0u));
+let screenPixels=bitcast<f32>(photonIndexWord(2u));
+if(!(ni>0.0)||bitcast<f32>(photonIndexWord(3u))==1.0||(bitcast<f32>(photonIndexWord(3u))==2.0&&visible)) {
+return vec3f(0.0);
+}
+var radius=ni;
+let experiments=photonIndexWord(7u);
+let xW=f32(experiments>>8u);
+let uI=select(xW,screenPixels,visible);
+if(uI>0.0) {
+radius=min(radius,photonPixelFootprint(si)*uI);
+}
+let layer=select(0u,1u,visible&&screenPixels>0.0);
+let mo=select(ni,2.0*bitcast<f32>(photonIndexWord(6u)),layer==1u);
+let uf=vec3i(floor((si.position-vec3f(radius))/mo));
+let vB=vec3i(floor((si.position+vec3f(radius))/mo));
+let buckets=photonIndexWord(5u);
+let uE=8u+layer*buckets*2u;
+let indexStart=8u+buckets*4u+layer*photonIndexWord(4u);
+let emitted=f32(photonIndexWord(4u));
+var sum=vec3f(0.0);
+for(var z=uf.z;z<=vB.z;z++) {
+for(var y=uf.y;y<=vB.y;y++) {
+for(var x=uf.x;x<=vB.x;x++) {
+let uw=vec3i(x,y,z);
+
+
+let wy=vec3f(uw)*mo;
+let padding=max(vec3f(mo*1e-5),abs(wy)*1e-6);
+let pQ=clamp(si.position,wy-padding,wy+vec3f(mo)+padding);
+if(distance(pQ,si.position)>=radius) { continue; }
+let tU=ym(uw);
+let offset=photonIndexWord(uE+tU*2u);
+let count=photonIndexWord(uE+1u+tU*2u);
+for(var i=offset;i<offset+count;i++) {
+let index=photonIndexWord(indexStart+i);
+let record=photonLoad(index);
+let position=bitcast<vec3f>(record.xyz);
+
+if(any(vec3i(floor(position/mo))!=uw)||distance(position,si.position)>=radius) {
+continue;
+}
+var kE=radius;
+if((experiments&1u)!=0u) {
+let scale=bitcast<f32>(photonIndexWord(8u+buckets*4u+u32(emitted)*3u+index));
+kE=min(radius,ni*scale);
+if(!(kE>0.0)||distance(position,si.position)>=kE) { continue; }
+}
+let directions=photonIndexWord(8u+buckets*4u+u32(emitted)*2u+index);
+let normal=qQ(vec2f(f32(directions&255u)/255.0,f32((directions>>8u)&127u)/127.0));
+if(dot(normal,si.faceNormal)<0.9) {
+continue;
+}
+if(CAUSTIC_MNEE&&samplingBounce<=CAUSTIC_MNEE_MAX_DEPTH&&(directions&32768u)!=0u&&prepared.material.baseWeight*(1.0-prepared.material.baseMetalness)*(1.0-prepared.material.transmissionWeight)>0.0&&prepared.material.subsurfaceWeight==0.0) {
+continue;
+}
+let iA=qQ(vec2f(f32((directions>>16u)&255u),f32(directions>>24u))/255.0);
+let cosine=abs(dot(si.faceNormal,iA));
+if(cosine<=0.0) {
+continue;
+}
+var flux=photonDecodeFlux(record.w)/emitted;
+if(SPECTRAL) {
+flux=sampling_spectral_rgb_filter(flux,si.spectralChannel);
+}
+var pdf:f32;
+let response=openpbr_eval_prepared(prepared,iA,&pdf);
+sum+=response*flux/cosine*(radius*radius)/(kE*kE);
+}
+}
+}
+}
+return sum/(PI*radius*radius);
+}
+`;
+// Each translated 2x2 tile assigns all four labels once. Conditional on any
+// stored photon, a uniform pixel label accepts it with probability 1/4; scaling
+// accepted flux by four preserves the original expected density estimate.
+// Only the first camera hit participates; specular prefixes and deeper queries
+// keep the original estimator. Disjoint salts consume no sampling dimensions.
+export function photonDirectQuerySource(enabled = false) {
+    if (!enabled)
+        return photonQueryWgsl;
+    return photonQueryWgsl
+        .replace('var sum=vec3f(0.0);', `let tb=ak(aC,rtUniform.sequenceSeed^0x91e10da5u);
+let xO=vec2u(cD(tb^0x68bc21ebu),cD(tb^0x967a889bu));
+let uL=aJ+xO;
+let xN=(uL.x&1u)|((uL.y&1u)<<1u);
+var sum=vec3f(0.0);`)
+        .replace('let record=photonLoad(index);', `if(wP&&(ak(index,tb^0x02e5be93u)&3u)!=xN) { continue; }
+let record=photonLoad(index);`)
+        .replace('var flux=photonDecodeFlux(record.w)/emitted;', `var flux=photonDecodeFlux(record.w)/emitted;
+if(wP) { flux*=4.0; }`);
+}
+/** Evidence-only per-query counters; no extra bindings or public render options. */
+export function photonQuerySource(debugGroup = -1, directSubset = false) {
+    const source = photonDirectQuerySource(directSubset);
+    if (debugGroup < 50)
+        return source;
+    // Offline union-of-photons audit. Each depth is replayed with the same seed;
+    // payloads are positions/normals rather than radiance, before path throughput.
+    if (debugGroup >= 80) {
+        const normal = debugGroup >= 130 || debugGroup === 81;
+        const visible = debugGroup < 100;
+        const depth = debugGroup - (normal ? 130 : 100);
+        const selected = visible ? 'visible' : `!visible&&samplingBounce==${depth}u`;
+        const payload = debugGroup === 82 ? 'vec3f(photonPixelFootprint(si),radius,1.0)' : normal ? 'si.faceNormal' : 'si.position';
+        return 'var<private> photonQueryStats:vec3f;\n' + source.replace('return sum/(PI*radius*radius);', `if(${selected}){photonQueryStats=${payload};}return sum/(PI*radius*radius);`);
+    }
+    const selected = debugGroup === 50 || debugGroup === 73 ? 'visible' : debugGroup === 72 ? '!visible' : `!visible&&samplingBounce==${debugGroup - 51}u`;
+    return 'var<private> photonQueryStats:vec3f;\n' + source
+        .replace('var sum=vec3f(0.0);', 'var sum=vec3f(0.0);var reads=0u;var passed=0u;')
+        .replace('let index=photonIndexWord(indexStart+i);', 'reads++;let index=photonIndexWord(indexStart+i);')
+        .replace(debugGroup === 73 ? 'var flux=photonDecodeFlux' : 'let directions=photonIndexWord', debugGroup === 73 ? 'passed++;var flux=photonDecodeFlux' : 'passed++;let directions=photonIndexWord')
+        .replace('return sum/(PI*radius*radius);', `if(${selected}){photonQueryStats${debugGroup === 72 ? '+' : ''}=vec3f(f32(reads),f32(passed),1.0);}return sum/(PI*radius*radius);`);
+}
+//# sourceMappingURL=photonMap.compute.js.map

package/lib/renderer/wgsl/photonMap.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"photonMap.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/photonMap.compute.ts"],"names":[],"mappings":"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","sourcesContent":["export const PHOTON_BYTES = 20;\nexport const PHOTON_GRID_SIZE = 262144;\nexport const PHOTON_SCAN_BLOCK = 256;\nexport const PHOTON_REFERENCE_COUNT = 2 ** 18;\nexport type PhotonRadiusScaling = 'none' | 'ppm' | 'constant-count';\n/** Internal density A/B, with the same progressive schedule in all modes. */\nexport function photonRadius(\n  initial: number,\n  batch: number,\n  alpha = 2 / 3,\n  photons = PHOTON_REFERENCE_COUNT,\n  scaling: PhotonRadiusScaling = 'none'\n) {\n  const radius = initial * Math.pow(Math.max(1, batch), (alpha - 1) / 2);\n  if (scaling === 'none' || photons === PHOTON_REFERENCE_COUNT) return radius;\n  const exponent = scaling === 'ppm' ? (alpha - 1) / 2 : -1 / 2;\n  return radius * Math.pow(Math.max(1, photons) / PHOTON_REFERENCE_COUNT, exponent);\n}\n/** Default photon-map batch: pixel count / 4, capped at 2^18. */\nexport function defaultPhotonMapPhotons(width: number, height: number, divisor = 4) {\n  return Math.min(2 ** 18, Math.max(1, Math.round((width * height) / divisor)));\n}\n/** Power-of-two hash capacity, bounded independently of large photon batches. */\nexport function photonBucketCount(photons: number) {\n  return Math.min(PHOTON_GRID_SIZE, 2 ** Math.ceil(Math.log2(Math.max(256, photons * 2))));\n}\n/** Shared texture address contract; payload is stored once, indices twice. */\nexport function photonLayout(count: number, perCasterRadius = false) {\n  const buckets = photonBucketCount(count);\n  const coarseHeaders = 8;\n  const fineHeaders = coarseHeaders + buckets * 2;\n  const coarseIndices = fineHeaders + buckets * 2;\n  const fineIndices = coarseIndices + count;\n  const directions = fineIndices + count;\n  return {buckets, coarseHeaders, fineHeaders, coarseIndices, fineIndices, directions, texels: directions + count * (perCasterRadius ? 2 : 1)};\n}\n/** Batch-local hash buckets: count, two-level parallel prefix sum, then parallel scatter. */\nexport const photonGridCompute = /* wgsl */ `\n  struct Bucket {\n    count: atomic<u32>,\n    offset: u32,\n    cursor: atomic<u32>,\n    padding: u32,\n  }\n  struct Parameters {\n    radius: f32,\n    count: u32,\n    screenPixels: f32,\n    skipQuery: f32,\n    buckets: u32,\n    fineRadius: f32,\n    experiments: u32,\n    padding2: u32,\n  }\n  @group(0)@binding(0)var photons:texture_2d<u32>;\n  @group(0)@binding(1)var<storage,read_write>grid:array<Bucket>;\n  @group(0)@binding(2)var<uniform>parameters:Parameters;\n  @group(0)@binding(4)var headers:texture_storage_2d<r32uint,write>;\n  fn hashCell(cell:vec3i)->u32 {\n    let p=bitcast<vec3u>(cell);\n    return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(parameters.buckets-1u);\n  }\n  fn hashPhoton(p:vec3f,layer:u32)->u32 {\n    let radius=select(parameters.radius,parameters.fineRadius,layer==1u);\n    let cellSize=select(radius,2.0*radius,layer==1u);\n    return hashCell(vec3i(floor(p/cellSize)));\n  }\n  fn gridStart(layer:u32)->u32 {\n    return layer*(parameters.buckets+parameters.buckets/256u);\n  }\n  fn storeIndex(i:u32,value:u32) {\n    let width=textureDimensions(headers).x;\n    textureStore(headers,vec2i(vec2u(i%width,i/width)),vec4u(value));\n  }\n  fn photonRecord(i:u32)->vec4u {\n    let width=textureDimensions(photons).x;\n    return textureLoad(photons,vec2i(vec2u(i%width,i/width)),0);\n  }\n  fn photonPosition(i:u32)->vec3f {\n    return bitcast<vec3f>(photonRecord(i).xyz);\n  }\n  @compute @workgroup_size(64)\n  fn count(@builtin(global_invocation_id)id:vec3u) {\n    if(id.x+id.y*4194240u>=parameters.count) {\n      return;\n    }\n    let index=id.x+id.y*4194240u;\n    if(photonRecord(index).w==0u) {\n      return;\n    }\n    for(var layer=0u;layer<2u;layer++) {\n      atomicAdd(&grid[gridStart(layer)+hashPhoton(photonPosition(index),layer)].count,1u);\n    }\n  }\n  // Each block scans 256 buckets; the next workgroup scans chunks of block totals.\n  var<workgroup> scan:array<u32,256>;\n  fn inclusiveScan(local:u32,value:u32)->u32 {\n    scan[local]=value;\n    workgroupBarrier();\n    for(var stride=1u;stride<256u;stride*=2u) {\n      var previous=0u;\n      if(local>=stride) {\n        previous=scan[local-stride];\n      }\n      workgroupBarrier();\n      scan[local]+=previous;\n      workgroupBarrier();\n    }\n    return scan[local];\n  }\n  @compute @workgroup_size(256)\n  fn scanBlocks(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {\n    let index=gridStart(group.y)+group.x*256u+local;\n    let count=atomicLoad(&grid[index].count);\n    let prefix=inclusiveScan(local,count);\n    grid[index].offset=prefix-count;\n    if(local==255u) {\n      atomicStore(&grid[gridStart(group.y)+parameters.buckets+group.x].count,prefix);\n    }\n  }\n  @compute @workgroup_size(256)\n  fn scanSums(@builtin(local_invocation_index)local:u32,@builtin(workgroup_id)group:vec3u) {\n    let blocks=parameters.buckets/256u;\n    let chunk=(blocks+255u)/256u;\n    let first=local*chunk;\n    let start=gridStart(group.y)+parameters.buckets;\n    var count=0u;\n    for(var i=first;i<min(first+chunk,blocks);i++) {\n      count+=atomicLoad(&grid[start+i].count);\n    }\n    let prefix=inclusiveScan(local,count);\n    var offset=prefix-count;\n    for(var i=first;i<min(first+chunk,blocks);i++) {\n      grid[start+i].offset=offset;\n      offset+=atomicLoad(&grid[start+i].count);\n    }\n    if(local==255u&&group.y==0u) {\n      storeIndex(0u,bitcast<u32>(parameters.radius));\n      storeIndex(1u,prefix);\n      storeIndex(2u,bitcast<u32>(parameters.screenPixels));\n      storeIndex(3u,bitcast<u32>(parameters.skipQuery));\n      storeIndex(4u,parameters.count);\n      storeIndex(5u,parameters.buckets);\n      storeIndex(6u,bitcast<u32>(parameters.fineRadius));\n      storeIndex(7u,parameters.experiments);\n    }\n  }\n  @compute @workgroup_size(64)\n  fn scatter(@builtin(global_invocation_id)id:vec3u) {\n    let invocation=id.x+id.y*4194240u;\n    for(var layer=0u;layer<2u;layer++) {\n      let start=gridStart(layer);\n      if(invocation<parameters.buckets) {\n        let offset=grid[start+invocation].offset+grid[start+parameters.buckets+invocation/256u].offset;\n        storeIndex(8u+layer*parameters.buckets*2u+invocation*2u,offset);\n        storeIndex(9u+layer*parameters.buckets*2u+invocation*2u,atomicLoad(&grid[start+invocation].count));\n      }\n      if(invocation<parameters.count&&photonRecord(invocation).w!=0u) {\n        let bucket=hashPhoton(photonPosition(invocation),layer);\n        let index=grid[start+bucket].offset+grid[start+parameters.buckets+bucket/256u].offset+atomicAdd(&grid[start+bucket].cursor,1u);\n        storeIndex(8u+parameters.buckets*4u+layer*parameters.count+index,invocation);\n      }\n    }\n  }\n`;\n/** Packed photon payload: position f32 x3, RGBE8 flux, two octahedral directions. */\nexport const photonPackingWgsl = /* wgsl */ `\n  fn photonOctSign(v:vec2f)->vec2f {\n    return select(vec2f(-1.0),vec2f(1.0),v>=vec2f(0.0));\n  }\n  fn photonEncodeOct(n:vec3f)->vec2f {\n    let p=n/(abs(n.x)+abs(n.y)+abs(n.z));\n    let uv=select(p.xy,(vec2f(1.0)-abs(p.yx))*photonOctSign(p.xy),p.z<0.0);\n    return uv*.5+.5;\n  }\n  fn photonDecodeOct(uv:vec2f)->vec3f {\n    let p=uv*2.0-1.0;\n    var n=vec3f(p,1.0-abs(p.x)-abs(p.y));\n    if(n.z<0.0) {\n      n=vec3f((vec2f(1.0)-abs(n.yx))*photonOctSign(n.xy),n.z);\n    }\n    return normalize(n);\n  }\n  // An eight-bit exponent avoids RGB9E5's limited range for very dim/bright lights.\n  // Flux is stored before dividing by emitted count, preserving tiny large batches.\n  fn photonEncodeFlux(value:vec3f)->u32 {\n    let peak=max(max(value.x,value.y),value.z);\n    if(!(peak>0.0)) {\n      return 0u;\n    }\n    let exponent=clamp(i32(floor(log2(peak)))+1,-126,127);\n    let rgb=vec3u(clamp(round(value*exp2(-f32(exponent))*255.0),vec3f(0.0),vec3f(255.0)));\n    return rgb.x|(rgb.y<<8u)|(rgb.z<<16u)|(u32(exponent+127)<<24u);\n  }\n  fn photonDecodeFlux(value:u32)->vec3f {\n    if(value==0u) {\n      return vec3f(0.0);\n    }\n    return vec3f(f32(value&255u),f32((value>>8u)&255u),f32((value>>16u)&255u))*exp2(f32(i32(value>>24u)-127))/255.0;\n  }\n`;\nexport const photonQueryWgsl = /* wgsl */ `${photonPackingWgsl}\n  @group(1)@binding(11)var photonMapData:texture_2d<u32>;\n  @group(1)@binding(12)var photonMapGrid:texture_2d<u32>;\n  fn photonLoad(i:u32)->vec4u {\n    let width=textureDimensions(photonMapData).x;\n    return textureLoad(photonMapData,vec2i(vec2u(i%width,i/width)),0);\n  }\n  fn photonIndexWord(i:u32)->u32 {\n    let width=textureDimensions(photonMapGrid).x;\n    return textureLoad(photonMapGrid,vec2i(vec2u(i%width,i/width)),0).x;\n  }\n  fn photonHash(cell:vec3i)->u32 {\n    let p=bitcast<vec3u>(cell);\n    return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(photonIndexWord(5u)-1u);\n  }\n  // Approximate a specular prefix by the camera-space depth of its first diffuse\n  // receiver. Orthographic footprints do not grow with distance. Grazing surfaces\n  // expand the disk conservatively; the progressive world radius remains the cap.\n  fn photonPixelFootprint(si:SurfaceInteraction)->f32 {\n    let inverse=cameraUniform.viewProjectionInv;\n    let a=inverse*vec4f(0.0,0.0,-1.0,1.0);\n    let b=inverse*vec4f(2.0/rtUniform.outputSize.x,0.0,-1.0,1.0);\n    let origin=a.xyz/a.w;\n    let offset=b.xyz/b.w;\n    let eye=cameraUniform.viewInv[3].xyz;\n    let forward=normalize(cameraUniform.viewInv[2].xyz);\n    let depth=abs(dot(si.position-eye,forward));\n    let nearDepth=max(abs(dot(origin-eye,forward)),1e-8);\n    let perspective=abs(inverse[2].w)>1e-8;\n    let footprint=length(offset-origin)*select(1.0,depth/nearDepth,perspective);\n    let cosine=abs(dot(si.faceNormal,normalize(si.position-eye)));\n    return max(1e-8,footprint/sqrt(max(.0625,cosine)));\n  }\n  fn photonContribution(si:SurfaceInteraction,prepared:OpenPbrPreparedBsdf,primary:bool,visible:bool)->vec3f {\n    if(samplingBounce>CAUSTIC_PHOTON_MAX_DEPTH||isCausticSpecular(prepared.material)||prepared.material.materialType==SHADOW_CATCHER) {\n      return vec3f(0.0);\n    }\n    if(CAUSTIC_LIGHT_TRACING&&primary) {\n      return vec3f(0.0);\n    }\n    let globalRadius=bitcast<f32>(photonIndexWord(0u));\n    let screenPixels=bitcast<f32>(photonIndexWord(2u));\n    if(!(globalRadius>0.0)||bitcast<f32>(photonIndexWord(3u))==1.0||(bitcast<f32>(photonIndexWord(3u))==2.0&&visible)) {\n      return vec3f(0.0);\n    }\n    var radius=globalRadius;\n    let experiments=photonIndexWord(7u);\n    let deepPixels=f32(experiments>>8u);\n    let queryPixels=select(deepPixels,screenPixels,visible);\n    if(queryPixels>0.0) {\n      radius=min(radius,photonPixelFootprint(si)*queryPixels);\n    }\n    let layer=select(0u,1u,visible&&screenPixels>0.0);\n    let cellSize=select(globalRadius,2.0*bitcast<f32>(photonIndexWord(6u)),layer==1u);\n    let firstCell=vec3i(floor((si.position-vec3f(radius))/cellSize));\n    let lastCell=vec3i(floor((si.position+vec3f(radius))/cellSize));\n    let buckets=photonIndexWord(5u);\n    let headerStart=8u+layer*buckets*2u;\n    let indexStart=8u+buckets*4u+layer*photonIndexWord(4u);\n    let emitted=f32(photonIndexWord(4u));\n    var sum=vec3f(0.0);\n    for(var z=firstCell.z;z<=lastCell.z;z++) {\n      for(var y=firstCell.y;y<=lastCell.y;y++) {\n        for(var x=firstCell.x;x<=lastCell.x;x++) {\n          let queryCell=vec3i(x,y,z);\n          // Reject cube corners before loading their photon lists. Padding keeps\n          // the bound conservative when cell multiplication rounds in f32.\n          let cellMin=vec3f(queryCell)*cellSize;\n          let padding=max(vec3f(cellSize*1e-5),abs(cellMin)*1e-6);\n          let closest=clamp(si.position,cellMin-padding,cellMin+vec3f(cellSize)+padding);\n          if(distance(closest,si.position)>=radius) { continue; }\n          let bucket=photonHash(queryCell);\n          let offset=photonIndexWord(headerStart+bucket*2u);\n          let count=photonIndexWord(headerStart+1u+bucket*2u);\n          for(var i=offset;i<offset+count;i++) {\n            let index=photonIndexWord(indexStart+i);\n            let record=photonLoad(index);\n            let position=bitcast<vec3f>(record.xyz);\n            // Hash collisions and neighboring buckets never count a photon twice.\n            if(any(vec3i(floor(position/cellSize))!=queryCell)||distance(position,si.position)>=radius) {\n              continue;\n            }\n            var kernelRadius=radius;\n            if((experiments&1u)!=0u) {\n              let scale=bitcast<f32>(photonIndexWord(8u+buckets*4u+u32(emitted)*3u+index));\n              kernelRadius=min(radius,globalRadius*scale);\n              if(!(kernelRadius>0.0)||distance(position,si.position)>=kernelRadius) { continue; }\n            }\n            let directions=photonIndexWord(8u+buckets*4u+u32(emitted)*2u+index);\n            let normal=photonDecodeOct(vec2f(f32(directions&255u)/255.0,f32((directions>>8u)&127u)/127.0));\n            if(dot(normal,si.faceNormal)<0.9) {\n              continue;\n            }\n            if(CAUSTIC_MNEE&&samplingBounce<=CAUSTIC_MNEE_MAX_DEPTH&&(directions&32768u)!=0u&&prepared.material.baseWeight*(1.0-prepared.material.baseMetalness)*(1.0-prepared.material.transmissionWeight)>0.0&&prepared.material.subsurfaceWeight==0.0) {\n              continue;\n            }\n            let incoming=photonDecodeOct(vec2f(f32((directions>>16u)&255u),f32(directions>>24u))/255.0);\n            let cosine=abs(dot(si.faceNormal,incoming));\n            if(cosine<=0.0) {\n              continue;\n            }\n            var flux=photonDecodeFlux(record.w)/emitted;\n            if(SPECTRAL) {\n              flux=sampling_spectral_rgb_filter(flux,si.spectralChannel);\n            }\n            var pdf:f32;\n            let response=openpbr_eval_prepared(prepared,incoming,&pdf);\n            sum+=response*flux/cosine*(radius*radius)/(kernelRadius*kernelRadius);\n          }\n        }\n      }\n    }\n    return sum/(PI*radius*radius);\n  }\n`;\n\n// Each translated 2x2 tile assigns all four labels once. Conditional on any\n// stored photon, a uniform pixel label accepts it with probability 1/4; scaling\n// accepted flux by four preserves the original expected density estimate.\n// Only the first camera hit participates; specular prefixes and deeper queries\n// keep the original estimator. Disjoint salts consume no sampling dimensions.\nexport function photonDirectQuerySource(enabled = false) {\n  if (!enabled) return photonQueryWgsl;\n  return photonQueryWgsl\n    .replace('var sum=vec3f(0.0);', `let subsetSeed=sampleSeed(pixelSampleIndex,rtUniform.sequenceSeed^0x91e10da5u);\n    let subsetShift=vec2u(sampleHash(subsetSeed^0x68bc21ebu),sampleHash(subsetSeed^0x967a889bu));\n    let subsetPixel=samplingPixel+subsetShift;\n    let subsetGroup=(subsetPixel.x&1u)|((subsetPixel.y&1u)<<1u);\n    var sum=vec3f(0.0);`)\n    .replace('let record=photonLoad(index);', `if(primary&&(sampleSeed(index,subsetSeed^0x02e5be93u)&3u)!=subsetGroup) { continue; }\n            let record=photonLoad(index);`)\n    .replace('var flux=photonDecodeFlux(record.w)/emitted;', `var flux=photonDecodeFlux(record.w)/emitted;\n            if(primary) { flux*=4.0; }`);\n}\n/** Evidence-only per-query counters; no extra bindings or public render options. */\nexport function photonQuerySource(debugGroup = -1, directSubset = false) {\n  const source = photonDirectQuerySource(directSubset);\n  if (debugGroup < 50) return source;\n  // Offline union-of-photons audit. Each depth is replayed with the same seed;\n  // payloads are positions/normals rather than radiance, before path throughput.\n  if (debugGroup >= 80) {\n    const normal = debugGroup >= 130 || debugGroup === 81;\n    const visible = debugGroup < 100;\n    const depth = debugGroup - (normal ? 130 : 100);\n    const selected = visible ? 'visible' : `!visible&&samplingBounce==${depth}u`;\n    const payload = debugGroup === 82 ? 'vec3f(photonPixelFootprint(si),radius,1.0)' : normal ? 'si.faceNormal' : 'si.position';\n    return 'var<private> photonQueryStats:vec3f;\\n' + source.replace('return sum/(PI*radius*radius);', `if(${selected}){photonQueryStats=${payload};}return sum/(PI*radius*radius);`);\n  }\n  const selected = debugGroup === 50 || debugGroup === 73 ? 'visible' : debugGroup === 72 ? '!visible' : `!visible&&samplingBounce==${debugGroup - 51}u`;\n  return 'var<private> photonQueryStats:vec3f;\\n' + source\n    .replace('var sum=vec3f(0.0);', 'var sum=vec3f(0.0);var reads=0u;var passed=0u;')\n    .replace('let index=photonIndexWord(indexStart+i);', 'reads++;let index=photonIndexWord(indexStart+i);')\n    .replace(debugGroup === 73 ? 'var flux=photonDecodeFlux' : 'let directions=photonIndexWord',\n      debugGroup === 73 ? 'passed++;var flux=photonDecodeFlux' : 'passed++;let directions=photonIndexWord')\n    .replace('return sum/(PI*radius*radius);', `if(${selected}){photonQueryStats${debugGroup === 72 ? '+' : ''}=vec3f(f32(reads),f32(passed),1.0);}return sum/(PI*radius*radius);`);\n}\n"]}