@meimu/mutracer 0.1.5 → 0.3.0

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 xu(yp:vec3i)->u32 {
+let p=bitcast<vec3u>(yp);
+return ((p.x*73856093u)^(p.y*19349663u)^(p.z*83492791u))&(parameters.buckets-1u);
+}
+fn tM(p:vec3f,layer:u32)->u32 {
+let radius=select(parameters.radius,parameters.fineRadius,layer==1u);
+let lv=select(radius,2.0*radius,layer==1u);
+return xu(vec3i(floor(p/lv)));
+}
+fn os(layer:u32)->u32 {
+return layer*(parameters.buckets+parameters.buckets/256u);
+}
+fn fm(i:u32,value:u32) {
+let width=textureDimensions(headers).x;
+textureStore(headers,vec2i(vec2u(i%width,i/width)),vec4u(value));
+}
+fn pi(i:u32)->vec4u {
+let width=textureDimensions(photons).x;
+return textureLoad(photons,vec2i(vec2u(i%width,i/width)),0);
+}
+fn qv(i:u32)->vec3f {
+return bitcast<vec3f>(pi(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(pi(index).w==0u) {
+return;
+}
+for(var layer=0u;layer<2u;layer++) {
+atomicAdd(&grid[os(layer)+tM(qv(index),layer)].count,1u);
+}
+}
+
+var<workgroup> scan:array<u32,256>;
+fn iU(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=os(group.y)+group.x*256u+local;
+let count=atomicLoad(&grid[index].count);
+let prefix=iU(local,count);
+grid[index].offset=prefix-count;
+if(local==255u) {
+atomicStore(&grid[os(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 xo=(blocks+255u)/256u;
+let first=local*xo;
+let start=os(group.y)+parameters.buckets;
+var count=0u;
+for(var i=first;i<min(first+xo,blocks);i++) {
+count+=atomicLoad(&grid[start+i].count);
+}
+let prefix=iU(local,count);
+var offset=prefix-count;
+for(var i=first;i<min(first+xo,blocks);i++) {
+grid[start+i].offset=offset;
+offset+=atomicLoad(&grid[start+i].count);
+}
+if(local==255u&&group.y==0u) {
+fm(0u,bitcast<u32>(parameters.radius));
+fm(1u,prefix);
+fm(2u,bitcast<u32>(parameters.screenPixels));
+fm(3u,bitcast<u32>(parameters.skipQuery));
+fm(4u,parameters.count);
+fm(5u,parameters.buckets);
+fm(6u,bitcast<u32>(parameters.fineRadius));
+fm(7u,parameters.experiments);
+}
+}
+@compute @workgroup_size(64)
+fn scatter(@builtin(global_invocation_id)id:vec3u) {
+let eA=id.x+id.y*4194240u;
+for(var layer=0u;layer<2u;layer++) {
+let start=os(layer);
+if(eA<parameters.buckets) {
+let offset=grid[start+eA].offset+grid[start+parameters.buckets+eA/256u].offset;
+fm(8u+layer*parameters.buckets*2u+eA*2u,offset);
+fm(9u+layer*parameters.buckets*2u+eA*2u,atomicLoad(&grid[start+eA].count));
+}
+if(eA<parameters.count&&pi(eA).w!=0u) {
+let su=tM(qv(eA),layer);
+let index=grid[start+su].offset+grid[start+parameters.buckets+su/256u].offset+atomicAdd(&grid[start+su].cursor,1u);
+fm(8u+parameters.buckets*4u+layer*parameters.count+index,eA);
+}
+}
+}
+`;
+/** Packed photon payload: position f32 x3, RGBE8 flux, two octahedral directions. */
+export const photonPackingWgsl = /* wgsl */ `
+fn rd(v:vec2f)->vec2f {
+return select(vec2f(-1.0),vec2f(1.0),v>=vec2f(0.0));
+}
+fn pN(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))*rd(p.xy),p.z<0.0);
+return uv*.5+.5;
+}
+fn pM(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))*rd(n.xy),n.z);
+}
+return normalize(n);
+}
+
+
+fn sS(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 wp(yp:vec3i)->u32 {
+let p=bitcast<vec3u>(yp);
+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 xe=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/xe,perspective);
+let cosine=abs(dot(si.faceNormal,normalize(si.position-eye)));
+return max(1e-8,footprint/sqrt(max(.0625,cosine)));
+}
+fn rI(si:SurfaceInteraction,prepared:OpenPbrPreparedBsdf,vb: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&&vb) {
+return vec3f(0.0);
+}
+let mn=bitcast<f32>(photonIndexWord(0u));
+let screenPixels=bitcast<f32>(photonIndexWord(2u));
+if(!(mn>0.0)||bitcast<f32>(photonIndexWord(3u))==1.0||(bitcast<f32>(photonIndexWord(3u))==2.0&&visible)) {
+return vec3f(0.0);
+}
+var radius=mn;
+let experiments=photonIndexWord(7u);
+let wa=f32(experiments>>8u);
+let tf=select(wa,screenPixels,visible);
+if(tf>0.0) {
+radius=min(radius,photonPixelFootprint(si)*tf);
+}
+let layer=select(0u,1u,visible&&screenPixels>0.0);
+let lv=select(mn,2.0*bitcast<f32>(photonIndexWord(6u)),layer==1u);
+let sG=vec3i(floor((si.position-vec3f(radius))/lv));
+let tS=vec3i(floor((si.position+vec3f(radius))/lv));
+let buckets=photonIndexWord(5u);
+let tb=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=sG.z;z<=tS.z;z++) {
+for(var y=sG.y;y<=tS.y;y++) {
+for(var x=sG.x;x<=tS.x;x++) {
+let sU=vec3i(x,y,z);
+
+
+let uP=vec3f(sU)*lv;
+let padding=max(vec3f(lv*1e-5),abs(uP)*1e-6);
+let xV=clamp(si.position,uP-padding,uP+vec3f(lv)+padding);
+if(distance(xV,si.position)>=radius) { continue; }
+let su=wp(sU);
+let offset=photonIndexWord(tb+su*2u);
+let count=photonIndexWord(tb+1u+su*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/lv))!=sU)||distance(position,si.position)>=radius) {
+continue;
+}
+var jY=radius;
+if((experiments&1u)!=0u) {
+let scale=bitcast<f32>(photonIndexWord(8u+buckets*4u+u32(emitted)*3u+index));
+jY=min(radius,mn*scale);
+if(!(jY>0.0)||distance(position,si.position)>=jY) { continue; }
+}
+let directions=photonIndexWord(8u+buckets*4u+u32(emitted)*2u+index);
+let normal=pM(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 hQ=pM(vec2f(f32((directions>>16u)&255u),f32(directions>>24u))/255.0);
+let cosine=abs(dot(si.faceNormal,hQ));
+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,hQ,&pdf);
+sum+=response*flux/cosine*(radius*radius)/(jY*jY);
+}
+}
+}
+}
+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 rL=ak(aC,rtUniform.sequenceSeed^0x91e10da5u);
+let vT=vec2u(cB(rL^0x68bc21ebu),cB(rL^0x967a889bu));
+let tj=aI+vT;
+let vS=(tj.x&1u)|((tj.y&1u)<<1u);
+var sum=vec3f(0.0);`)
+        .replace('let record=photonLoad(index);', `if(vb&&(ak(index,rL^0x02e5be93u)&3u)!=vS) { continue; }
+let record=photonLoad(index);`)
+        .replace('var flux=photonDecodeFlux(record.w)/emitted;', `var flux=photonDecodeFlux(record.w)/emitted;
+if(vb) { 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"]}

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

@@ -0,0 +1 @@
+export declare const proceduralSkyWGSL: string;

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

@@ -0,0 +1,198 @@
+import { TURBIDITY, GROUND_ALBEDO, ILLUMINANCE, REFERENCE_ILLUMINANCE } from '../skyModel.js';
+// Same atmosphere, quadrature and pass order as WebGLSkyBaker. Distances in km.
+export const proceduralSkyWGSL = /* wgsl */ `
+struct Params { sun: vec4f, sunWorld: vec4f, size: vec4f, scale: vec4f, ambient: vec4f }
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var transmittanceTable: texture_2d<f32>;
+@group(0) @binding(2) var multipleTable: texture_2d<f32>;
+@group(0) @binding(3) var skyTable: texture_2d<f32>;
+@group(0) @binding(4) var irradianceTable: texture_2d<f32>;
+@group(0) @binding(5) var output: texture_storage_2d<rgba32float, write>;
+const PI = 3.14159265358979;
+const R_GROUND = 6360.0;
+const R_TOP = 6460.0;
+const CAMERA_ALTITUDE = 0.2;
+const RAYLEIGH = vec3f(5.802e-3, 13.558e-3, 33.1e-3);
+const MIE_SCATTERING = 3.996e-3;
+const MIE_EXTINCTION = 4.44e-3;
+const MIE_G = 0.8;
+const OZONE = vec3f(0.65e-3, 1.881e-3, 0.085e-3);
+const ALBEDO = vec3f(${GROUND_ALBEDO.join(', ')});
+const T_SIZE = vec2u(256, 64);
+const MS_ALTITUDES = 32u;
+const SV_SIZE = vec2u(96, 192);
+
+fn bj(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }
+fn mV(r: f32, mu: f32) -> bool { return mu < 0.0 && bj(r, mu, R_GROUND) >= 0.0; }
+fn kT(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(bj(r, mu, R_GROUND), 0.0)), 0.0); }
+fn iS(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(bj(r, mu, R_TOP), 0.0)), 0.0); }
+fn oo(r: f32) -> vec3f {
+let h = max(r - R_GROUND, 0.0);
+return vec3f(exp(-h / 8.0), exp(-h / 1.2) * ${TURBIDITY}, max(0.0, 1.0 - abs(h - 25.0) / 15.0));
+}
+fn extinction(d: vec3f) -> vec3f { return RAYLEIGH * d.x + MIE_EXTINCTION * d.y + OZONE * d.z; }
+fn mB(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }
+fn hy(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }
+fn eR(table: texture_2d<f32>, p: vec2f) -> vec3f {
+let size = vec2i(textureDimensions(table));
+let q = clamp(p, vec2f(0.0), vec2f(size - 1));
+let i = min(vec2i(floor(q)), max(size - 2, vec2i(0)));
+let f = clamp(q - vec2f(i), vec2f(0.0), vec2f(1.0));
+let j = min(i + 1, size - 1);
+let a = textureLoad(table, i, 0).rgb;
+let b = textureLoad(table, vec2i(j.x, i.y), 0).rgb;
+let c = textureLoad(table, vec2i(i.x, j.y), 0).rgb;
+let d = textureLoad(table, j, 0).rgb;
+return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+fn fv(r: f32, mu: f32) -> vec3f {
+return eR(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), hy(r - R_GROUND) * f32(T_SIZE.y - 1u)));
+}
+fn mI(nu: f32) -> f32 {
+let g2 = MIE_G * MIE_G;
+return 3.0 / (8.0 * PI) * ((1.0 - g2) * (1.0 + nu * nu)) / ((2.0 + g2) * pow(1.0 + g2 - 2.0 * MIE_G * nu, 1.5));
+}
+struct yk { radiance: vec3f, throughput: vec3f }
+fn vG(origin: vec3f, dir: vec3f, steps: u32, full: bool, uD: vec3f) -> yk {
+let r = length(origin);
+let mu = dot(origin, dir) / r;
+let ground = mV(r, mu);
+var len = iS(r, mu);
+if (ground) { len = kT(r, mu); }
+let nu = dot(dir, params.sun.xyz);
+var ja = 1.0 / (4.0 * PI);
+var sh = ja;
+if (full) { ja = 3.0 / (16.0 * PI) * (1.0 + nu * nu); sh = mI(nu); }
+var result = yk(vec3f(0.0), vec3f(0.0));
+var view = vec3f(1.0);
+var previous = 0.0;
+for (var i = 0u; i < steps; i++) {
+let s = f32(i + 1u) / f32(steps);
+let next = len * s * s;
+let dt = next - previous;
+let p = origin + dir * (0.5 * (previous + next));
+previous = next;
+let pr = length(p);
+let d = oo(pr);
+let e = extinction(d);
+let vk = fv(pr, dot(p, params.sun.xyz) / pr);
+let np = RAYLEIGH * d.x;
+let nl = MIE_SCATTERING * d.y;
+var ms = vec3f(0.0);
+if (full) { ms = eR(multipleTable, vec2f(hy(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }
+let source = vk * (np * ja + nl * sh) + (np + nl) * ms;
+let segment = exp(-e * dt);
+let weight = (1.0 - segment) / max(e, vec3f(1e-9));
+result.radiance += view * source * weight;
+result.throughput += view * (np + nl) * weight;
+view *= segment;
+}
+if (ground) {
+let p = origin + dir * len;
+let pr = length(p);
+let tD = dot(p, params.sun.xyz) / pr;
+let irradiance = fv(pr, tD) * max(tD, 0.0) + uD;
+result.radiance += view * ALBEDO / PI * irradiance;
+}
+return result;
+}
+fn qd(row: f32) -> f32 {
+let x = row / f32(SV_SIZE.y - 1u) * 2.0 - 1.0;
+return sign(x) * x * x * (PI / 2.0);
+}
+fn hL(e: f32) -> f32 {
+let x = sign(e) * sqrt(abs(e) / (PI / 2.0));
+return clamp((x + 1.0) * 0.5, 0.0, 1.0) * f32(SV_SIZE.y - 1u);
+}
+@compute @workgroup_size(8, 8)
+fn transmittance(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= T_SIZE)) { return; }
+let mu = f32(id.x) / f32(T_SIZE.x - 1u) * 2.0 - 1.0;
+let r = R_GROUND + mB(f32(id.y) / f32(T_SIZE.y - 1u));
+if (mV(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }
+let len = iS(r, mu);
+var depth = vec3f(0.0);
+for (var i = 0u; i < 48u; i++) {
+let t = (f32(i) + 0.5) / 48.0 * len;
+depth += extinction(oo(sqrt(t * t + 2.0 * r * mu * t + r * r))) * (len / 48.0);
+}
+textureStore(output, vec2i(id.xy), vec4f(exp(-depth), 1.0));
+}
+@compute @workgroup_size(8, 8)
+fn multiple(@builtin(global_invocation_id) id: vec3u) {
+if (id.x >= MS_ALTITUDES || id.y > 0u) { return; }
+let r = R_GROUND + mB(f32(id.x) / f32(MS_ALTITUDES - 1u));
+var second = vec3f(0.0);
+var qC = vec3f(0.0);
+for (var i = 0u; i < 64u; i++) {
+let mu = 1.0 - 2.0 * (f32(i) + 0.5) / 64.0;
+let phi = f32(i) * PI * (3.0 - sqrt(5.0));
+let s = sqrt(1.0 - mu * mu);
+let result = vG(vec3f(0.0, r, 0.0), vec3f(s * cos(phi), mu, s * sin(phi)), 20u, false, vec3f(0.0));
+second += result.radiance / 64.0;
+qC += result.throughput / 64.0;
+}
+textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - qC), 1.0));
+}
+@compute @workgroup_size(8, 8)
+fn skyView(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= SV_SIZE)) { return; }
+let e = qd(f32(id.y));
+let phi = f32(id.x) / f32(SV_SIZE.x - 1u) * PI;
+var sky = vec3f(0.0);
+if (params.size.w > 0.0) { sky = textureLoad(irradianceTable, vec2i(0), 0).rgb; }
+let result = vG(vec3f(0.0, R_GROUND + CAMERA_ALTITUDE, 0.0), vec3f(cos(e) * cos(phi), sin(e), cos(e) * sin(phi)), 40u, true, sky);
+textureStore(output, vec2i(id.xy), vec4f(result.radiance, 1.0));
+}
+@compute @workgroup_size(8, 8)
+fn irradiance(@builtin(global_invocation_id) id: vec3u) {
+if (id.x >= 2u || id.y > 0u) { return; }
+var sky = vec3f(0.0);
+for (var i = 0u; i < 128u; i++) {
+let e = (f32(i) + 0.5) / 128.0 * (PI / 2.0);
+let weight = 2.0 * sin(e) * cos(e) * (PI / 2.0 / 128.0) * (PI / 48.0);
+for (var j = 0u; j < 48u; j++) {
+let phi = (f32(j) + 0.5) / 48.0 * PI;
+sky += eR(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), hL(e))) * weight;
+}
+}
+if (id.x == 0u) { textureStore(output, vec2i(id.xy), vec4f(sky, 1.0)); return; }
+let vk = fv(R_GROUND + CAMERA_ALTITUDE, params.sun.y);
+let xE = vec3f(0.2126, 0.7152, 0.0722);
+let horizontal = dot(sky, xE) + dot(vk, xE) * max(params.sun.y, 0.0);
+let scale = ${ILLUMINANCE} / sqrt(max(horizontal, ${REFERENCE_ILLUMINANCE} * 1e-3) * ${REFERENCE_ILLUMINANCE});
+textureStore(output, vec2i(id.xy), vec4f(vk, scale));
+}
+fn gU(cR: vec2f) -> vec3f {
+let theta = cR.y / params.size.y * PI;
+let phi = cR.x / params.size.x * 2.0 * PI;
+return vec3f(-sin(theta) * cos(phi), cos(theta), -sin(theta) * sin(phi));
+}
+@compute @workgroup_size(8, 8)
+fn map(@builtin(global_invocation_id) id: vec3u) {
+if (any(id.xy >= vec2u(params.size.xy))) { return; }
+let cR = vec2f(id.xy) + 0.5;
+let dir = gU(cR);
+let tg = abs(atan2(dir.z, dir.x) - params.sun.w);
+let wO = tg - floor(tg / (2.0 * PI)) * (2.0 * PI);
+let dU = min(wO, 2.0 * PI - wO);
+let e = asin(clamp(dir.y, -1.0, 1.0));
+var radiance = eR(skyTable, vec2f(dU / PI * f32(SV_SIZE.x - 1u), hL(e)));
+let sun = textureLoad(irradianceTable, vec2i(1, 0), 0);
+let radius = params.sunWorld.w;
+let rM = PI / params.size.y;
+if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * rM / max(sqrt(1.0 - dir.y * dir.y), 0.05)) {
+var coverage = 0.0;
+for (var y = 0u; y < 6u; y++) { for (var x = 0u; x < 6u; x++) {
+let d = gU(cR - 0.5 + (vec2f(f32(x), f32(y)) + 0.5) / 6.0);
+let angle = 2.0 * asin(min(length(d - params.sunWorld.xyz) * 0.5, 1.0));
+let t = angle / radius;
+if (t < 1.0) { coverage += 1.0 - 0.6 * (1.0 - sqrt(1.0 - t * t)); }
+} }
+let rK = 2.0 * PI * (1.0 - cos(radius));
+radiance += coverage / 36.0 / (rK * (1.0 - 0.6 / 3.0)) * sun.rgb;
+}
+textureStore(output, vec2i(id.xy), vec4f(radiance * sun.a * params.scale.xyz + params.ambient.xyz, 1.0));
+}
+`;
+//# sourceMappingURL=proceduralSky.compute.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proceduralSky.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/proceduralSky.compute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE9F,gFAAgF;AAChF,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;uBAiBrB,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;8CAWC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoIzC,WAAW,2BAA2B,qBAAqB,cAAc,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC7G,CAAC","sourcesContent":["import { TURBIDITY, GROUND_ALBEDO, ILLUMINANCE, REFERENCE_ILLUMINANCE } from '../skyModel.js';\n\n// Same atmosphere, quadrature and pass order as WebGLSkyBaker. Distances in km.\nexport const proceduralSkyWGSL = /* wgsl */ `\nstruct Params { sun: vec4f, sunWorld: vec4f, size: vec4f, scale: vec4f, ambient: vec4f }\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var transmittanceTable: texture_2d<f32>;\n@group(0) @binding(2) var multipleTable: texture_2d<f32>;\n@group(0) @binding(3) var skyTable: texture_2d<f32>;\n@group(0) @binding(4) var irradianceTable: texture_2d<f32>;\n@group(0) @binding(5) var output: texture_storage_2d<rgba32float, write>;\nconst PI = 3.14159265358979;\nconst R_GROUND = 6360.0;\nconst R_TOP = 6460.0;\nconst CAMERA_ALTITUDE = 0.2;\nconst RAYLEIGH = vec3f(5.802e-3, 13.558e-3, 33.1e-3);\nconst MIE_SCATTERING = 3.996e-3;\nconst MIE_EXTINCTION = 4.44e-3;\nconst MIE_G = 0.8;\nconst OZONE = vec3f(0.65e-3, 1.881e-3, 0.085e-3);\nconst ALBEDO = vec3f(${GROUND_ALBEDO.join(', ')});\nconst T_SIZE = vec2u(256, 64);\nconst MS_ALTITUDES = 32u;\nconst SV_SIZE = vec2u(96, 192);\n\nfn discriminant(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }\nfn hitsGround(r: f32, mu: f32) -> bool { return mu < 0.0 && discriminant(r, mu, R_GROUND) >= 0.0; }\nfn distanceToGround(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(discriminant(r, mu, R_GROUND), 0.0)), 0.0); }\nfn distanceToTop(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(discriminant(r, mu, R_TOP), 0.0)), 0.0); }\nfn densities(r: f32) -> vec3f {\n  let h = max(r - R_GROUND, 0.0);\n  return vec3f(exp(-h / 8.0), exp(-h / 1.2) * ${TURBIDITY}, max(0.0, 1.0 - abs(h - 25.0) / 15.0));\n}\nfn extinction(d: vec3f) -> vec3f { return RAYLEIGH * d.x + MIE_EXTINCTION * d.y + OZONE * d.z; }\nfn altitudeAt(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }\nfn altitudeCoord(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }\nfn fetchLinear(table: texture_2d<f32>, p: vec2f) -> vec3f {\n  let size = vec2i(textureDimensions(table));\n  let q = clamp(p, vec2f(0.0), vec2f(size - 1));\n  let i = min(vec2i(floor(q)), max(size - 2, vec2i(0)));\n  let f = clamp(q - vec2f(i), vec2f(0.0), vec2f(1.0));\n  let j = min(i + 1, size - 1);\n  let a = textureLoad(table, i, 0).rgb;\n  let b = textureLoad(table, vec2i(j.x, i.y), 0).rgb;\n  let c = textureLoad(table, vec2i(i.x, j.y), 0).rgb;\n  let d = textureLoad(table, j, 0).rgb;\n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\nfn transmittanceTo(r: f32, mu: f32) -> vec3f {\n  return fetchLinear(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), altitudeCoord(r - R_GROUND) * f32(T_SIZE.y - 1u)));\n}\nfn cornetteShanks(nu: f32) -> f32 {\n  let g2 = MIE_G * MIE_G;\n  return 3.0 / (8.0 * PI) * ((1.0 - g2) * (1.0 + nu * nu)) / ((2.0 + g2) * pow(1.0 + g2 - 2.0 * MIE_G * nu, 1.5));\n}\nstruct March { radiance: vec3f, throughput: vec3f }\nfn march(origin: vec3f, dir: vec3f, steps: u32, full: bool, skyIrradiance: vec3f) -> March {\n  let r = length(origin);\n  let mu = dot(origin, dir) / r;\n  let ground = hitsGround(r, mu);\n  var len = distanceToTop(r, mu);\n  if (ground) { len = distanceToGround(r, mu); }\n  let nu = dot(dir, params.sun.xyz);\n  var rayleighPhase = 1.0 / (4.0 * PI);\n  var miePhase = rayleighPhase;\n  if (full) { rayleighPhase = 3.0 / (16.0 * PI) * (1.0 + nu * nu); miePhase = cornetteShanks(nu); }\n  var result = March(vec3f(0.0), vec3f(0.0));\n  var view = vec3f(1.0);\n  var previous = 0.0;\n  for (var i = 0u; i < steps; i++) {\n    let s = f32(i + 1u) / f32(steps);\n    let next = len * s * s;\n    let dt = next - previous;\n    let p = origin + dir * (0.5 * (previous + next));\n    previous = next;\n    let pr = length(p);\n    let d = densities(pr);\n    let e = extinction(d);\n    let sunT = transmittanceTo(pr, dot(p, params.sun.xyz) / pr);\n    let scatterR = RAYLEIGH * d.x;\n    let scatterM = MIE_SCATTERING * d.y;\n    var ms = vec3f(0.0);\n    if (full) { ms = fetchLinear(multipleTable, vec2f(altitudeCoord(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }\n    let source = sunT * (scatterR * rayleighPhase + scatterM * miePhase) + (scatterR + scatterM) * ms;\n    let segment = exp(-e * dt);\n    let weight = (1.0 - segment) / max(e, vec3f(1e-9));\n    result.radiance += view * source * weight;\n    result.throughput += view * (scatterR + scatterM) * weight;\n    view *= segment;\n  }\n  if (ground) {\n    let p = origin + dir * len;\n    let pr = length(p);\n    let cosSun = dot(p, params.sun.xyz) / pr;\n    let irradiance = transmittanceTo(pr, cosSun) * max(cosSun, 0.0) + skyIrradiance;\n    result.radiance += view * ALBEDO / PI * irradiance;\n  }\n  return result;\n}\nfn elevationAt(row: f32) -> f32 {\n  let x = row / f32(SV_SIZE.y - 1u) * 2.0 - 1.0;\n  return sign(x) * x * x * (PI / 2.0);\n}\nfn elevationCoord(e: f32) -> f32 {\n  let x = sign(e) * sqrt(abs(e) / (PI / 2.0));\n  return clamp((x + 1.0) * 0.5, 0.0, 1.0) * f32(SV_SIZE.y - 1u);\n}\n@compute @workgroup_size(8, 8)\nfn transmittance(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= T_SIZE)) { return; }\n  let mu = f32(id.x) / f32(T_SIZE.x - 1u) * 2.0 - 1.0;\n  let r = R_GROUND + altitudeAt(f32(id.y) / f32(T_SIZE.y - 1u));\n  if (hitsGround(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }\n  let len = distanceToTop(r, mu);\n  var depth = vec3f(0.0);\n  for (var i = 0u; i < 48u; i++) {\n    let t = (f32(i) + 0.5) / 48.0 * len;\n    depth += extinction(densities(sqrt(t * t + 2.0 * r * mu * t + r * r))) * (len / 48.0);\n  }\n  textureStore(output, vec2i(id.xy), vec4f(exp(-depth), 1.0));\n}\n@compute @workgroup_size(8, 8)\nfn multiple(@builtin(global_invocation_id) id: vec3u) {\n  if (id.x >= MS_ALTITUDES || id.y > 0u) { return; }\n  let r = R_GROUND + altitudeAt(f32(id.x) / f32(MS_ALTITUDES - 1u));\n  var second = vec3f(0.0);\n  var transfer = vec3f(0.0);\n  for (var i = 0u; i < 64u; i++) {\n    let mu = 1.0 - 2.0 * (f32(i) + 0.5) / 64.0;\n    let phi = f32(i) * PI * (3.0 - sqrt(5.0));\n    let s = sqrt(1.0 - mu * mu);\n    let result = march(vec3f(0.0, r, 0.0), vec3f(s * cos(phi), mu, s * sin(phi)), 20u, false, vec3f(0.0));\n    second += result.radiance / 64.0;\n    transfer += result.throughput / 64.0;\n  }\n  textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - transfer), 1.0));\n}\n@compute @workgroup_size(8, 8)\nfn skyView(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= SV_SIZE)) { return; }\n  let e = elevationAt(f32(id.y));\n  let phi = f32(id.x) / f32(SV_SIZE.x - 1u) * PI;\n  var sky = vec3f(0.0);\n  if (params.size.w > 0.0) { sky = textureLoad(irradianceTable, vec2i(0), 0).rgb; }\n  let result = march(vec3f(0.0, R_GROUND + CAMERA_ALTITUDE, 0.0), vec3f(cos(e) * cos(phi), sin(e), cos(e) * sin(phi)), 40u, true, sky);\n  textureStore(output, vec2i(id.xy), vec4f(result.radiance, 1.0));\n}\n@compute @workgroup_size(8, 8)\nfn irradiance(@builtin(global_invocation_id) id: vec3u) {\n  if (id.x >= 2u || id.y > 0u) { return; }\n  var sky = vec3f(0.0);\n  for (var i = 0u; i < 128u; i++) {\n    let e = (f32(i) + 0.5) / 128.0 * (PI / 2.0);\n    let weight = 2.0 * sin(e) * cos(e) * (PI / 2.0 / 128.0) * (PI / 48.0);\n    for (var j = 0u; j < 48u; j++) {\n      let phi = (f32(j) + 0.5) / 48.0 * PI;\n      sky += fetchLinear(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), elevationCoord(e))) * weight;\n    }\n  }\n  if (id.x == 0u) { textureStore(output, vec2i(id.xy), vec4f(sky, 1.0)); return; }\n  let sunT = transmittanceTo(R_GROUND + CAMERA_ALTITUDE, params.sun.y);\n  let luma = vec3f(0.2126, 0.7152, 0.0722);\n  let horizontal = dot(sky, luma) + dot(sunT, luma) * max(params.sun.y, 0.0);\n  let scale = ${ILLUMINANCE} / sqrt(max(horizontal, ${REFERENCE_ILLUMINANCE} * 1e-3) * ${REFERENCE_ILLUMINANCE});\n  textureStore(output, vec2i(id.xy), vec4f(sunT, scale));\n}\nfn mapDirection(texel: vec2f) -> vec3f {\n  let theta = texel.y / params.size.y * PI;\n  let phi = texel.x / params.size.x * 2.0 * PI;\n  return vec3f(-sin(theta) * cos(phi), cos(theta), -sin(theta) * sin(phi));\n}\n@compute @workgroup_size(8, 8)\nfn map(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= vec2u(params.size.xy))) { return; }\n  let texel = vec2f(id.xy) + 0.5;\n  let dir = mapDirection(texel);\n  let rawRelative = abs(atan2(dir.z, dir.x) - params.sun.w);\n  let wrapped = rawRelative - floor(rawRelative / (2.0 * PI)) * (2.0 * PI);\n  let relative = min(wrapped, 2.0 * PI - wrapped);\n  let e = asin(clamp(dir.y, -1.0, 1.0));\n  var radiance = fetchLinear(skyTable, vec2f(relative / PI * f32(SV_SIZE.x - 1u), elevationCoord(e)));\n  let sun = textureLoad(irradianceTable, vec2i(1, 0), 0);\n  let radius = params.sunWorld.w;\n  let texelAngle = PI / params.size.y;\n  if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * texelAngle / max(sqrt(1.0 - dir.y * dir.y), 0.05)) {\n    var coverage = 0.0;\n    for (var y = 0u; y < 6u; y++) { for (var x = 0u; x < 6u; x++) {\n      let d = mapDirection(texel - 0.5 + (vec2f(f32(x), f32(y)) + 0.5) / 6.0);\n      let angle = 2.0 * asin(min(length(d - params.sunWorld.xyz) * 0.5, 1.0));\n      let t = angle / radius;\n      if (t < 1.0) { coverage += 1.0 - 0.6 * (1.0 - sqrt(1.0 - t * t)); }\n    } }\n    let solidAngle = 2.0 * PI * (1.0 - cos(radius));\n    radiance += coverage / 36.0 / (solidAngle * (1.0 - 0.6 / 3.0)) * sun.rgb;\n  }\n  textureStore(output, vec2i(id.xy), vec4f(radiance * sun.a * params.scale.xyz + params.ambient.xyz, 1.0));\n}\n`;\n"]}

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

@@ -1,6 +1,23 @@
 export declare const WORKGROUP_SIZE = 8;
+/** Native input instrumentation; omitted hooks preserve the production source. */
+export interface RayTraceInputHooks {
+    declarations: string;
+    begin: string;
+    primarySurface: string;
+    unclampedColor: string;
+    end: string;
+    uniformJitter: boolean;
+}
 export interface RayTraceShaderOptions {
     hasDisplacement: boolean;
+    debugGroup?: number;
+    /** Invocation block edge; the native host matches dispatch to this value. Default 8. */
+    workgroupSize?: number;
+    lightTracing?: boolean;
+    photonMapping?: boolean;
+    photonMaxDepth?: number;
+    /** Internal A/B override for directly visible PM receivers. Default true; ignored with light tracing. */
+    photonDirectSubset?: boolean;
     /** Include direction frames only when used, preserving the legacy shader arithmetic otherwise. */
     hasAnisotropyDirections?: boolean;
     /** Include independent coat normals only when a material uses that slot. */
@@ -11,6 +28,13 @@ export interface RayTraceShaderOptions {
     hasSceneAlpha?: boolean;
     /** Bit mask of the BLAS layouts present in the scene (bvh2, bvh4, bvh-gpu, cwbvh). */
     blasLayoutMask?: number;
+    /** Defined only when pipeline constants are baked into the source. */
+    spectral?: boolean;
+    sceneCapabilities?: number;
+    /** Retained environment support must still respect the current illumination state. */
+    dynamicEnvironment?: boolean;
+    materialCapabilities?: number;
+    lightCapabilities?: number;
 }
 /** Generates the WebGPU megakernel path tracing compute shader. */
-export default function rayTraceCompute({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, hasAlpha, hasSceneAlpha, blasLayoutMask }: RayTraceShaderOptions): string;
+export default function rayTraceCompute(options: RayTraceShaderOptions, sceneIntersections?: string, pathDiagnostic?: boolean, inputHooks?: RayTraceInputHooks): string;