@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -7,7 +7,7 @@ function guideBinding(guides, binding, name) {
         : `@group(0) @binding(${binding}) var<storage, read> ${name}: array<vec4f>;`;
 }
 function loadGuide(guides, name, position) {
-    return guides === 'textures' ? `textureLoad(${name}, ${position}, 0)` : `${name}[gv(${position})]`;
+    return guides === 'textures' ? `textureLoad(${name}, ${position}, 0)` : `${name}[gf(${position})]`;
 }
 // Shared uniform packing also fixes sensitivity and dilation for native callers.
 export function packJNLMParameters(width, height, strength, pass) {
@@ -43,9 +43,9 @@ ${shadowCatcherAccumulationWGSL}
 fn main(@builtin(global_invocation_id) id: vec3u) {
 let size = params.size;
 if (id.x >= size.x || id.y >= size.y) { return; }
-let qE = id.x + (size.y - 1u - id.y) * size.x;
-let n = normalBuffer[qE].a;
-let moments = accumulation[qE].moments;
+let qw = id.x + (size.y - 1u - id.y) * size.x;
+let n = normalBuffer[qw].a;
+let moments = accumulation[qw].moments;
 let mean = moments.x / max(n, 1.0);
 
 var variance = -1.0;
@@ -69,28 +69,28 @@ fn main(@builtin(global_invocation_id) id: vec3u) {
 let size = params.size;
 if (id.x >= size.x || id.y >= size.y) { return; }
 let center = rawGuide[id.x + id.y * size.x];
-var mf = 0.0;
-var jx = 0.0;
-var nW = 0.0;
-var jp = 0.0;
+var lM = 0.0;
+var je = 0.0;
+var nM = 0.0;
+var iV = 0.0;
 for (var dy = -1; dy <= 1; dy++) {
 for (var dx = -1; dx <= 1; dx++) {
 let q = clamp(vec2i(id.xy) + vec2i(dx, dy), vec2i(0), vec2i(size) - 1);
 let value = rawGuide[u32(q.x) + u32(q.y) * size.x];
-nW += value.x;
-jp += value.x * value.x;
+nM += value.x;
+iV += value.x * value.x;
 if (value.y >= 0.0) {
-mf += value.y;
-jx += 1.0;
+lM += value.y;
+je += 1.0;
 }
 }
 }
 var variance: f32;
 if (center.y >= 0.0) {
-variance = mf / jx;
+variance = lM / je;
 } else {
-let me = nW / 9.0;
-variance = max(jp / 9.0 - me * me, 0.0) * 9.0 / 8.0;
+let lL = nM / 9.0;
+variance = max(iV / 9.0 - lL * lL, 0.0) * 9.0 / 8.0;
 }
 guide[id.x + id.y * size.x] = vec2f(center.x, variance);
 }
@@ -114,11 +114,11 @@ fn main(@builtin(global_invocation_id) id: vec3u) {
 if (id.x >= params.size.x || id.y >= params.size.y) { return; }
 outColor[id.x + id.y * params.size.x] = textureLoad(colorTex, vec2i(id.xy), 0);
 ${guides === 'buffers' ? `  let index = id.x + id.y * params.size.x;
-let qE = id.x + (params.size.y - 1u - id.y) * params.size.x;
-let n = normalAccumulation[qE];
+let qw = id.x + (params.size.y - 1u - id.y) * params.size.x;
+let n = normalAccumulation[qw];
 let samples = max(n.a, 1.0);
 normal[index] = vec4f(n.rgb / samples * 0.5 + 0.5, select(0.0, 1.0, dot(n.rgb, n.rgb) > 0.1));
-shadow[index] = shadowAccumulation[qE].mask / samples;
+shadow[index] = shadowAccumulation[qw].mask / samples;
 albedo[index] = textureLoad(albedoTex, vec2i(id.xy), 0);` : ''}
 }
 `;
@@ -155,23 +155,23 @@ const INV_NORMAL_BANDWIDTH2 = ${(1 / normalBandwidth ** 2).toFixed(6)};
 
 const CENTER_WEIGHT_MIN = 0.01;
 
-fn gv(p: vec2i) -> u32 {
+fn gf(p: vec2i) -> u32 {
 let q = clamp(p, vec2i(0), vec2i(params.size) - 1);
 return u32(q.x) + u32(q.y) * params.size.x;
 }
 
-fn mi(q: vec2i, bC: vec4f, hg: vec3f) -> f32 {
+fn lP(q: vec2i, bo: vec4f, gO: vec3f) -> f32 {
 let albedo = ${loadGuide(guides, 'albedoTex', 'q')};
 
 
-let qd = max((albedo.rgb + bC.rgb) * 0.5, vec3f(${JNLM_ALBEDO_FLOOR}));
-let lN = (albedo.rgb - bC.rgb) / qd;
-let jk = albedo.a - bC.a;
-let lX = ${loadGuide(guides, 'normalTex', 'q')}.rgb - hg;
+let pY = max((albedo.rgb + bo.rgb) * 0.5, vec3f(${JNLM_ALBEDO_FLOOR}));
+let lu = (albedo.rgb - bo.rgb) / pY;
+let iQ = albedo.a - bo.a;
+let lG = ${loadGuide(guides, 'normalTex', 'q')}.rgb - gO;
 return max(
-dot(lN, lN) * INV_ALBEDO_BANDWIDTH2
-+ jk * jk * INV_COVERAGE_BANDWIDTH2,
-dot(lX, lX) * INV_NORMAL_BANDWIDTH2
+dot(lu, lu) * INV_ALBEDO_BANDWIDTH2
++ iQ * iQ * INV_COVERAGE_BANDWIDTH2,
+dot(lG, lG) * INV_NORMAL_BANDWIDTH2
 );
 }
 
@@ -185,37 +185,37 @@ let size = vec2i(params.size);
 let p = vec2i(id.xy);
 if (p.x >= size.x || p.y >= size.y) { return; }
 let step = i32(params.dilation);
-let bC = ${loadGuide(guides, 'albedoTex', 'p')};
-let fR = ${loadGuide(guides, 'normalTex', 'p')};
-let hg = fR.rgb;
-let index = gv(p);
+let bo = ${loadGuide(guides, 'albedoTex', 'p')};
+let fC = ${loadGuide(guides, 'normalTex', 'p')};
+let gO = fC.rgb;
+let index = gf(p);
 
 
-if (fR.a <= 0.0 && ${loadGuide(guides, 'shadowCatcherTex', 'p')}.r <= 0.0) {
+if (fC.a <= 0.0 && ${loadGuide(guides, 'shadowCatcherTex', 'p')}.r <= 0.0) {
 outColor[index] = color[index];
 outGuide[index] = guide[index];
 return;
 }
 
-var lP: array<vec2f, PATCH_SIZE>;
+var lA: array<vec2f, PATCH_SIZE>;
 var k = 0;
 for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-lP[k] = guide[gv(p + vec2i(dx, dy) * step)];
+lA[k] = guide[gf(p + vec2i(dx, dy) * step)];
 k++;
 }
 }
 let k2 = params.colorSensitivity * params.colorSensitivity;
 
 var sum = vec4f(0.0);
-let hk = max(bC.rgb, vec3f(${JNLM_ALBEDO_FLOOR}));
-var ng = vec3f(0.0);
-var gN = vec3f(0.0);
-var hG = vec3f(0.0);
-var qp = 0.0;
-var gP = 0.0;
-var oP = 0.0;
-var lt = 0.0;
+let gR = max(bo.rgb, vec3f(${JNLM_ALBEDO_FLOOR}));
+var mQ = vec3f(0.0);
+var gv = vec3f(0.0);
+var hm = vec3f(0.0);
+var qf = 0.0;
+var gx = 0.0;
+var oE = 0.0;
+var kX = 0.0;
 for (var sy = -SEARCH_RADIUS; sy <= SEARCH_RADIUS; sy++) {
 for (var sx = -SEARCH_RADIUS; sx <= SEARCH_RADIUS; sx++) {
 let q = p + vec2i(sx, sy) * step;
@@ -224,63 +224,63 @@ if (
 q.x < 0 || q.y < 0 || q.x >= size.x || q.y >= size.y
 ) { continue; }
 
-let features = mi(q, bC, hg);
+let features = lP(q, bo, gO);
 if (features > 16.0) { continue; }
 
-var gk = 0.0;
+var fW = 0.0;
 k = 0;
 for (var dy = -PATCH_RADIUS; dy <= PATCH_RADIUS; dy++) {
 for (var dx = -PATCH_RADIUS; dx <= PATCH_RADIUS; dx++) {
-let a = lP[k];
-let b = guide[gv(q + vec2i(dx, dy) * step)];
-let rZ = a.x - b.x;
-gk += (rZ * rZ
+let a = lA[k];
+let b = guide[gf(q + vec2i(dx, dy) * step)];
+let rV = a.x - b.x;
+fW += (rV * rV
 - VARIANCE_CANCELLATION * (a.y + min(a.y, b.y)))
 / (1e-10 + k2 * (a.y + b.y));
 k++;
 }
 }
-gk /= f32(PATCH_SIZE);
+fW /= f32(PATCH_SIZE);
 
-let weight = exp(-max(max(gk, 0.0), features));
-let index = gv(q);
+let weight = exp(-max(max(fW, 0.0), features));
+let index = gf(q);
 let c = color[index];
 let g = guide[index];
 
-let a = (${loadGuide(guides, 'albedoTex', 'q')}.rgb - bC.rgb) / hk;
+let a = (${loadGuide(guides, 'albedoTex', 'q')}.rgb - bo.rgb) / gR;
 let value = premultiplied(c);
 sum += value * weight;
-ng += a * weight;
-gN += a * a * weight;
-hG += a * value.rgb * weight;
-qp += g.x * weight;
-gP += g.y * weight * weight;
-oP += weight;
-lt = max(lt, weight);
+mQ += a * weight;
+gv += a * a * weight;
+hm += a * value.rgb * weight;
+qf += g.x * weight;
+gx += g.y * weight * weight;
+oE += weight;
+kX = max(kX, weight);
 }
 }
 
 
 
 let center = color[index];
-let lO = guide[index];
-let dR = max(lt, CENTER_WEIGHT_MIN);
-let totalWeight = oP + dR;
-let vj = premultiplied(center);
-let mean = (sum + vj * dR) / totalWeight;
+let lw = guide[index];
+let dE = max(kX, CENTER_WEIGHT_MIN);
+let totalWeight = oE + dE;
+let vs = premultiplied(center);
+let mean = (sum + vs * dE) / totalWeight;
 
 
-let eI = ng / totalWeight;
-let mj = max(gN / totalWeight - eI * eI, vec3f(0.0));
-let rv = hG / totalWeight - eI * mean.rgb;
+let er = mQ / totalWeight;
+let lQ = max(gv / totalWeight - er * er, vec3f(0.0));
+let rq = hm / totalWeight - er * mean.rgb;
 
 
 
-let rI = bC.rgb + eI * hk;
-let po = mean.rgb * hk / max(rI, vec3f(${JNLM_ALBEDO_FLOOR}));
-let xg = clamp(rv / (mj + vec3f(${JNLM_ALBEDO_REGULARIZATION})), vec3f(0.0), po);
-let sD = mean.rgb - xg * eI;
-let filtered = vec4f(max(sD, vec3f(0.0)), max(mean.a, 0.0));
+let rD = bo.rgb + er * gR;
+let pd = mean.rgb * gR / max(rD, vec3f(${JNLM_ALBEDO_FLOOR}));
+let xI = clamp(rq / (lQ + vec3f(${JNLM_ALBEDO_REGULARIZATION})), vec3f(0.0), pd);
+let sz = mean.rgb - xI * er;
+let filtered = vec4f(max(sz, vec3f(0.0)), max(mean.a, 0.0));
 let rgb = select(
 center.rgb,
 filtered.rgb / max(filtered.a, 1e-6),
@@ -288,8 +288,8 @@ filtered.a > 1e-6
 );
 outColor[index] = vec4f(rgb, filtered.a);
 outGuide[index] = vec2f(
-(qp + lO.x * dR) / totalWeight,
-(gP + lO.y * dR * dR)
+(qf + lw.x * dE) / totalWeight,
+(gx + lw.y * dE * dE)
 / (totalWeight * totalWeight)
 );
 }

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) eA: vec3u) {
+let tile = eA.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 ws = tileX * params.tileSize;
+let wt = tileY * params.tileSize;
+let yF = min(ws + params.tileSize, params.width);
+let yG = min(wt + params.tileSize, params.height);
+var nM = 0.0;
+var jh = 0.0;
 var count = 0u;
 
-for (var y = vZ; y < yf; y++) {
-for (var x = vY; x < ye; x++) {
+for (var y = wt; y < yG; y++) {
+for (var x = ws; x < yF; 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 vj = pilotMoments[offset] / samples;
+let qb = max(vj - mean * mean, 0.0);
+var variance = qb;
 if (samples > 1.0) {
-variance = qg * samples / (samples - 1.0);
+variance = qb * samples / (samples - 1.0);
 }
-nW += mean;
-jB = max(jB, variance);
+nM += mean;
+jh = max(jh, variance);
 count += 1u;
 }
 }
 
-let mean = nW / f32(max(count, 1u));
-var pT = 0.0;
+let mean = nM / f32(max(count, 1u));
+var pK = 0.0;
 if (params.hasPrevious != 0u) {
-pT = previousVariance[tile];
+pK = previousVariance[tile];
 }
-let tu = max(jB, pT);
-let uD = params.absoluteError + params.relativeError * abs(mean);
+let tu = max(jh, pK);
+let uH = params.absoluteError + params.relativeError * abs(mean);
 let required = ceil(
 params.confidence * params.confidence * tu /
-max(uD * uD, 1e-16)
+max(uH * uH, 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] = jh;
 tileTargets[tile] = targetSamples;
 
-for (var y = vZ; y < yf; y++) {
-for (var x = vY; x < ye; x++) {
+for (var y = wt; y < yG; y++) {
+for (var x = ws; x < yF; 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 sQ(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 sP(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 rG(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;