@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -25,18 +25,20 @@ return clamp((value-EPS)/(1.0-2.0*EPS),0.0,0.99999994);
 `;
 // Preserve the dormant R1 uniform slot and shader spelling for source parity.
 // Production packs zero; only an explicitly registered research adapter sets it.
-export function causticLightCompute(constants, blasLayoutMask, hasDisplacement, mode = 'lightTracing', sceneIntersections = '', fullEmissionRandom = true) {
+export function causticLightCompute(constants, blasLayoutMask, hasDisplacement, mode = 'lightTracing', sceneIntersections = '', fullEmissionRandom = true, perInstanceBounds = false, compactVertices = false, independentTextures = false) {
     const frames = !!constants.USE_ANISOTROPY_DIRECTIONS || !!constants.USE_COAT_NORMAL_FRAMES, coat = !!constants.USE_COAT_NORMAL_FRAMES;
-    return (wgpuShaderPreamble(constants, true) +
+    return ((independentTextures ? 'enable wgpu_binding_array;\n' : '') + wgpuShaderPreamble(constants, true) +
         /* wgsl */ `
 ${Object.keys(WGPU_SCENE_FEATURE_BITS)
             .map((name) => `const ${name} = ${!!constants[name]};`)
             .join('\n')}
 ${common}
-${core({ hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
+${core({ independentTextures, compactVertices, hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
 ${uv}
-${createMaterialBufferWgsl({ hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
+${createMaterialBufferWgsl({ independentTextures, hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
 ${intersect({
+            perInstanceBounds,
+            compactVertices,
             hasDisplacement,
             blasLayoutMask,
             hasAnisotropyDirections: frames,
@@ -75,7 +77,7 @@ fn photonStore(i:u32,value:vec4u) {
 let width=textureDimensions(photons).x;
 textureStore(photons,vec2i(vec2u(i%width,i/width)),value);
 }
-fn pU(i:u32,value:u32) {
+fn qX(i:u32,value:u32) {
 let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));
 let index=8u+buckets*4u+caustic.photonCount*2u+i;
 let width=textureDimensions(photonDirections).x;
@@ -86,29 +88,29 @@ textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(value)
 
 
 ${causticUnitRandomWgsl}
-fn fB(dim:u32)->f32{return ${fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'}
+fn fN(dim:u32)->f32{return ${fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'}
 ;
 }
-fn hE(dim:u32)->vec2f {
+fn ie(dim:u32)->vec2f {
 let value=sample2D(dim);
 return
 ${fullEmissionRandom ? 'vec2f(causticUnitRandom(value.x),causticUnitRandom(value.y))' : 'value'}
 ;
 }
-fn nH(i:u32)->vec4f {
+fn oF(i:u32)->vec4f {
 let width=textureDimensions(causticDistribution).x;
 return textureLoad(causticDistribution,vec2i(vec2u(i%width,i/width)),0);
 }
-fn ds(i:u32)->vec4f {
-return nH(i);
+fn dz(i:u32)->vec4f {
+return oF(i);
 }
 
 
 
-var<private> kH:vec3f;
+var<private> lu:vec3f;
 var<private> causticEmissionAreaPdf:f32;
-fn kL(origin:vec3f,position:vec3f,normal:vec3f,emission:vec3f,area:f32,pmf:f32,result:ptr<function,LightSampleRec>) {
-kH=position;
+fn lE(origin:vec3f,position:vec3f,normal:vec3f,emission:vec3f,area:f32,pmf:f32,result:ptr<function,LightSampleRec>) {
+lu=position;
 causticEmissionAreaPdf=pmf/max(area,1e-20);
 let offset=position-origin;
 (*result).dist=length(offset);
@@ -117,7 +119,7 @@ let offset=position-origin;
 (*result).emission=emission;
 (*result).pdf=pmf;
 }
-fn rn(origin:vec3f,rnd:vec3f,result:ptr<function,LightSampleRec>) {
+fn sE(origin:vec3f,rnd:vec3f,result:ptr<function,LightSampleRec>) {
 causticEmissionAreaPdf=0.0;
 (*result).pdf=0.0;
 (*result).sourceType=0u;
@@ -127,14 +129,14 @@ return;
 }
 let scaled=rnd.z*f32(caustic.choiceCount);
 let column=min(u32(scaled),caustic.choiceCount-1u);
-let entry=nH(caustic.casterCount+column*2u);
+let entry=oF(caustic.casterCount+column*2u);
 let selected=select(bitcast<u32>(entry.y),column,fract(scaled)<entry.x);
-let choice=bitcast<vec4u>(nH(caustic.casterCount+selected*2u));
-let pmf=nH(caustic.casterCount+selected*2u+1u).x;
+let choice=bitcast<vec4u>(oF(caustic.casterCount+selected*2u));
+let pmf=oF(caustic.casterCount+selected*2u+1u).x;
 (*result).sourceIndex=choice.w;
 if(choice.z==1u) {
 (*result).sourceType=0u;
-ig(rnd.xy,result);
+iM(rnd.xy,result);
 (*result).pdf*=pmf;
 }
 else if(choice.z==2u) {
@@ -143,15 +145,15 @@ var light=analyticLights[choice.w];
 let kind=i32(light.litType);
 if(kind==RECT_LIGHT) {
 let position=light.position+light.u*(rnd.x-.5)+light.v*(rnd.y-.5);
-kL(origin,position,normalize(cross(light.u,light.v)),light.emission,light.area,pmf,result);
+lE(origin,position,normalize(cross(light.u,light.v)),light.emission,light.area,pmf,result);
 (*result).isDelta=light.radiusOrSpread<=.001;
-bC(light,position,light.position-.5*(light.u+light.v),result);
+bD(light,position,light.position-.5*(light.u+light.v),result);
 }
 else if((kind==SPHERE_LIGHT||kind==SPOT_LIGHT)&&light.radiusOrSpread>0.0) {
 let z=1.0-2.0*rnd.x;
-let dr=sqrt(max(0.0,1.0-z*z));
-let normal=vec3f(dr*cos(TWOPI*rnd.y),dr*sin(TWOPI*rnd.y),z);
-kL(origin,light.position+light.radiusOrSpread*normal,normal,light.emission,light.area,pmf,result);
+let dw=sqrt(max(0.0,1.0-z*z));
+let normal=vec3f(dw*cos(TWOPI*rnd.y),dw*sin(TWOPI*rnd.y),z);
+lE(origin,light.position+light.radiusOrSpread*normal,normal,light.emission,light.area,pmf,result);
 }
 else {
 light.selectionPmf=1.0;
@@ -168,55 +170,55 @@ let position=bary.x*triangle.p0+bary.y*triangle.p1+bary.z*triangle.p2;
 let normal=normalize(cross(triangle.p1-triangle.p0,triangle.p2-triangle.p0));
 let uv=bary.x*triangle.uv0+bary.y*triangle.uv1+bary.z*triangle.uv2;
 let uv1=bary.x*triangle.secondaryUv0+bary.y*triangle.secondaryUv1+bary.z*triangle.secondaryUv2;
-kL(origin,position,normal,getMaterialEmission(i32(triangle.materialIndex),uv,uv1),triangle.area,pmf,result);
+lE(origin,position,normal,getMaterialEmission(i32(triangle.materialIndex),uv,uv1),triangle.area,pmf,result);
 }
 (*result).selectionPmf=pmf;
 }
-fn lj(s:vec4f,origin:vec3f)->f32 {
+fn mf(s:vec4f,origin:vec3f)->f32 {
 let bG=dot(s.xyz-origin,s.xyz-origin);
 return select(-1.0,sqrt(max(0.0,1.0-s.w*s.w/bG)),bG>s.w*s.w);
 }
 
 
-fn dN(s:vec4f)->f32 {
+fn dS(s:vec4f)->f32 {
 if((caustic.experiments&2u)==0u) { return 1.0; }
-let tB=caustic.viewProjection*vec4f(s.xyz,1.0);
+let vb=caustic.viewProjection*vec4f(s.xyz,1.0);
 let m=caustic.viewProjection;
 let extent=s.w*max(length(vec3f(m[0].x,m[1].x,m[2].x)),length(vec3f(m[0].y,m[1].y,m[2].y)));
-if(tB.w<=0.0||abs(tB.x)>tB.w+extent||abs(tB.y)>tB.w+extent) { return .05; }
-return .05+min(1.0,extent*extent/max(tB.w*tB.w,1e-20));
+if(vb.w<=0.0||abs(vb.x)>vb.w+extent||abs(vb.y)>vb.w+extent) { return .05; }
+return .05+min(1.0,extent*extent/max(vb.w*vb.w,1e-20));
 }
-fn sv(origin:vec3f,rnd:vec3f,pdf:ptr<function,f32>,ky:ptr<function,f32>)->vec3f {
+fn tV(origin:vec3f,rnd:vec3f,pdf:ptr<function,f32>,lh:ptr<function,f32>)->vec3f {
 var total=0.0;
 for(var i=0u;i<caustic.casterCount;i++) {
-total+=(1.0-lj(ds(i),origin))*dN(ds(i));
+total+=(1.0-mf(dz(i),origin))*dS(dz(i));
 }
 var choice=rnd.z*total;
-var selected=ds(0u);
+var selected=dz(0u);
 for(var i=0u;i<caustic.casterCount;i++) {
-let sphere=ds(i);
+let sphere=dz(i);
 selected=sphere;
-choice-=(1.0-lj(sphere,origin))*dN(sphere);
+choice-=(1.0-mf(sphere,origin))*dS(sphere);
 if(choice<=0.0) {
 break;
 }
 }
-*ky=selected.w;
+*lh=selected.w;
 let offset=selected.xyz-origin;
 let axis=normalize(select(vec3f(0.0,0.0,1.0),offset,dot(offset,offset)>1e-20));
-let cosine=mix(1.0,lj(selected,origin),rnd.x);
-let uC=sqrt(max(0.0,1.0-cosine*cosine));
+let cosine=mix(1.0,mf(selected,origin),rnd.x);
+let wk=sqrt(max(0.0,1.0-cosine*cosine));
 var t:vec3f;
 var b:vec3f;
 sampling_orthonormal_basis(axis,&t,&b);
-let direction=axis*cosine+(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y))*uC;
+let direction=axis*cosine+(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y))*wk;
 
 var overlaps=0.0;
 for(var i=0u;i<caustic.casterCount;i++) {
-let sphere=ds(i);
-let c=lj(sphere,origin);
+let sphere=dz(i);
+let c=mf(sphere,origin);
 if(c<0.0||dot(normalize(sphere.xyz-origin),direction)>=c) {
-overlaps+=dN(sphere);
+overlaps+=dS(sphere);
 }
 }
 *pdf=overlaps/max(TWOPI*total,1e-20);
@@ -224,26 +226,26 @@ return direction;
 }
 ${mode === 'lightTracing'
             ? /* wgsl */ `${atomic}
-fn causticCameraConnect(si: SurfaceInteraction, material: OpenPbrResolvedMaterial, hQ: Ray, flux: vec3f, extinction: vec3f) {
+fn causticCameraConnect(si: SurfaceInteraction, material: OpenPbrResolvedMaterial, iA: Ray, flux: vec3f, extinction: vec3f) {
 let eye=cameraUniform.viewInv[3].xyz;
 let forward=-normalize(cameraUniform.viewInv[2].xyz);
-let rB=hE(causticDim(68u));
-let radius=cameraUniform.apertureRadius*sqrt(rB.x);
-var uV=eye+radius*(cos(TWOPI*rB.y)*cameraUniform.viewInv[0].xyz+sin(TWOPI*rB.y)*cameraUniform.viewInv[1].xyz);
+let sQ=ie(causticDim(68u));
+let radius=cameraUniform.apertureRadius*sqrt(sQ.x);
+var wJ=eye+radius*(cos(TWOPI*sQ.y)*cameraUniform.viewInv[0].xyz+sin(TWOPI*sQ.y)*cameraUniform.viewInv[1].xyz);
 if(caustic.orthographic!=0u) {
-uV=si.position-forward*dot(si.position-eye,forward);
-}
-let xM=uV-si.position;
-let bG=dot(xM,xM);
-let direction=normalize(xM);
-let wf=uV+(si.position-uV)*cameraUniform.focusDistance/max(dot(si.position-uV,forward),1e-12);
-let qO=select(wf,si.position,caustic.orthographic!=0u);
-let tB=caustic.viewProjection*vec4f(qO,1.0);
-if(tB.w<=0.0||dot(si.position-eye,forward)<=0.0) {
+wJ=si.position-forward*dot(si.position-eye,forward);
+}
+let zJ=wJ-si.position;
+let bG=dot(zJ,zJ);
+let direction=normalize(zJ);
+let ye=wJ+(si.position-wJ)*cameraUniform.focusDistance/max(dot(si.position-wJ,forward),1e-12);
+let sc=select(ye,si.position,caustic.orthographic!=0u);
+let vb=caustic.viewProjection*vec4f(sc,1.0);
+if(vb.w<=0.0||dot(si.position-eye,forward)<=0.0) {
 return;
 }
-let wY=tB.xy/tB.w*0.5+0.5;
-if(any(wY<vec2f(0.0))||any(wY>=vec2f(1.0))) {
+let yY=vb.xy/vb.w*0.5+0.5;
+if(any(yY<vec2f(0.0))||any(yY>=vec2f(1.0))) {
 return;
 }
 var shadow:Ray;
@@ -252,31 +254,31 @@ if(intersectSceneShadow(shadow,sqrt(bG)-2.0*EPS,si.triangleIndex,si.instanceInde
 return;
 }
 var m=material;
-let normal=select(-si.normal,si.normal,dot(si.normal,-hQ.d)>=0.0);
-m.inside=dot(si.faceNormal,-hQ.d)<0.0;
+let normal=select(-si.normal,si.normal,dot(si.normal,-iA.d)>=0.0);
+m.inside=dot(si.faceNormal,-iA.d)<0.0;
 m.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);
 ${frames
                 ? /* wgsl */ `  m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`
                 : ''}
 ${coat
-                ? /* wgsl */ `  m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,-hQ.d)>=0.0);`
+                ? /* wgsl */ `  m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,-iA.d)>=0.0);`
                 : ''}
-let prepared=bV(si.tangent,m,-hQ.d,normal);
+let prepared=bX(si.tangent,m,-iA.d,normal);
 var pdf:f32;
 let response=openpbr_eval_prepared(prepared,direction,&pdf);
-let mj=dot(-direction,-normalize(cameraUniform.viewInv[2].xyz));
-if(mj<=0.0) {
+let ne=dot(-direction,-normalize(cameraUniform.viewInv[2].xyz));
+if(ne<=0.0) {
 return;
 }
-let wg=caustic.cameraScale*rtUniform.outputSize.x*rtUniform.outputSize.y /
-select(max(bG*mj*mj*mj,1e-12),1.0,caustic.orthographic!=0u);
+let yf=caustic.cameraScale*rtUniform.outputSize.x*rtUniform.outputSize.y /
+select(max(bG*ne*ne*ne,1e-12),1.0,caustic.orthographic!=0u);
 let transmittance=exp(-extinction*sqrt(bG));
-let value=flux*transmittance*response*causticAdjoint(-hQ.d,direction,normal,si.faceNormal)*wg/f32(caustic.photonCount);
-let pixel=vec2u(wY*rtUniform.outputSize);
+let value=flux*transmittance*response*causticAdjoint(-iA.d,direction,normal,si.faceNormal)*yf/f32(caustic.photonCount);
+let pixel=vec2u(yY*rtUniform.outputSize);
 let index=(pixel.x+pixel.y*u32(rtUniform.outputSize.x))*3u;
-kM(index,value.x);
-kM(index+1u,value.y);
-kM(index+2u,value.z);
+lF(index,value.x);
+lF(index+1u,value.y);
+lF(index+2u,value.z);
 }
 `
             : ''}
@@ -287,18 +289,18 @@ if(photonIndex>=caustic.photonCount) {
 return;
 }
 ${mode === 'photonMapping' ? 'photonStore(photonIndex,vec4u(0u));' : ''}
-aI=vec2u(photonIndex%u32(rtUniform.outputSize.x),photonIndex/u32(rtUniform.outputSize.x));
+aJ=vec2u(photonIndex%u32(rtUniform.outputSize.x),photonIndex/u32(rtUniform.outputSize.x));
 aC=caustic.batch;
 samplingBounce=0u;
-ca=0u;
-fi(aI,i32(ak(caustic.batch,rtUniform.sequenceSeed)));
+hashedCounter=0u;
+fA(aJ,i32(ak(caustic.batch,rtUniform.sequenceSeed)));
 var wavelength=0.0;
 var wavelengthPdf=1.0;
 if(SPECTRAL) {
-wavelength=spectrumSample(${SPECTRUM_PHOTON_DISTRIBUTION}u,fB(causticDim(69u)),&wavelengthPdf);
+wavelength=spectrumSample(${SPECTRUM_PHOTON_DISTRIBUTION}u,fN(causticDim(69u)),&wavelengthPdf);
 }
 var ls:LightSampleRec;
-rn(caustic.casterSphere.xyz,vec3f(hE(causticDim(60u)),fB(causticDim(61u))),&ls);
+sE(caustic.casterSphere.xyz,vec3f(ie(causticDim(60u)),fN(causticDim(61u))),&ls);
 if(ls.pdf<=0.0) {
 return;
 }
@@ -307,41 +309,41 @@ if(ls.sourceType==2u) {
 infinite=i32(analyticLights[ls.sourceIndex].litType)==DIRECTIONAL_LIGHT;
 }
 var origin=caustic.casterSphere.xyz+ls.direction*ls.dist;
-if(causticEmissionAreaPdf>0.0) { origin=kH; }
+if(causticEmissionAreaPdf>0.0) { origin=lu; }
 var direction:vec3f;
 var flux:vec3f;
-var ky=caustic.casterSphere.w;
+var lh=caustic.casterSphere.w;
 if(infinite) {
 direction=-ls.direction;
 
 var area=0.0;
 for(var i=0u;i<caustic.casterCount;i++) {
-let s=ds(i);
-area+=s.w*s.w*dN(s);
+let s=dz(i);
+area+=s.w*s.w*dS(s);
 }
-var choice=fB(causticDim(63u))*area;
-var sphere=ds(0u);
+var choice=fN(causticDim(63u))*area;
+var sphere=dz(0u);
 for(var i=0u;i<caustic.casterCount;i++) {
-sphere=ds(i);
-choice-=sphere.w*sphere.w*dN(sphere);
+sphere=dz(i);
+choice-=sphere.w*sphere.w*dS(sphere);
 if(choice<=0.0) {
 break;
 }
 }
-ky=sphere.w;
+lh=sphere.w;
 var t:vec3f;
 var b:vec3f;
 sampling_orthonormal_basis(direction,&t,&b);
-let rnd=hE(causticDim(62u));
+let rnd=ie(causticDim(62u));
 origin=sphere.xyz-direction*dot(sphere.xyz-caustic.casterSphere.xyz,direction)-direction*caustic.casterSphere.w;
 origin+=sphere.w*sqrt(rnd.x)*(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y));
 var overlaps=0.0;
 for(var i=0u;i<caustic.casterCount;i++) {
-let s=ds(i);
+let s=dz(i);
 let offset=origin-s.xyz;
-let qO=offset-direction*dot(offset,direction);
-if(dot(qO,qO)<=s.w*s.w) {
-overlaps+=dN(s);
+let sc=offset-direction*dot(offset,direction);
+if(dot(sc,sc)<=s.w*s.w) {
+overlaps+=dS(s);
 }
 }
 let diskPdf=overlaps/max(PI*area,1e-20);
@@ -362,9 +364,9 @@ if(areaPdf<=0.0) {
 return;
 }
 var directionPdf:f32;
-direction=sv(origin,vec3f(hE(causticDim(62u)),fB(causticDim(63u))),&directionPdf,&ky);
+direction=tV(origin,vec3f(ie(causticDim(62u)),fN(causticDim(63u))),&directionPdf,&lh);
 var emission=ls.emission;
-var mL=max(0.0,dot(ls.normal,direction));
+var nN=max(0.0,dot(ls.normal,direction));
 if(ls.sourceType==2u) {
 let source=analyticLights[ls.sourceIndex];
 emission=source.emission;
@@ -372,27 +374,27 @@ if(i32(source.litType)==SPOT_LIGHT) {
 emission*=evaluateSpotEmissionMultiplier(source,direction);
 }
 if(ls.isDelta) {
-mL=1.0;
+nN=1.0;
 }
-if(i32(source.litType)==RECT_LIGHT&&mL<cos(0.5*PI*source.radiusOrSpread)) {
+if(i32(source.litType)==RECT_LIGHT&&nN<cos(0.5*PI*source.radiusOrSpread)) {
 return;
 }
 if(i32(source.litType)==RECT_LIGHT) {
-var un:LightSampleRec;
-un.emission=emission;
-bC(source,origin,source.position-0.5*(source.u+source.v),&un);
-emission=un.emission;
+var vX:LightSampleRec;
+vX.emission=emission;
+bD(source,origin,source.position-0.5*(source.u+source.v),&vX);
+emission=vX.emission;
 }
 }
-flux=emission*mL/(areaPdf*directionPdf);
+flux=emission*nN/(areaPdf*directionPdf);
 }
 if(SPECTRAL) {
 flux*=spectrumRgb(wavelength)/(wavelengthPdf*${SPECTRUM_WAVELENGTH_RANGE}.0);
 }
 var ray:Ray;
 initRay(&ray,origin+EPS*direction,direction);
-var vt=0u;
-var wN=false;
+var xk=0u;
+var yN=false;
 var extinction=vec3f(0.0);
 var scattering=vec3f(0.0);
 var si:SurfaceInteraction;
@@ -408,7 +410,7 @@ return;
 }
 var m:OpenPbrResolvedMaterial;
 getMaterial(&m,si.materialIndex,si.uv,si.uv1,si.instanceIndex,si.vertexColor);
-if(m.alpha<1.0&&fB(causticDim(79u))>=m.alpha) {
+if(m.alpha<1.0&&fN(causticDim(79u))>=m.alpha) {
 initRay(&ray,si.position+EPS*ray.d,ray.d);
 continue;
 }
@@ -416,9 +418,9 @@ if(m.materialType==SHADOW_CATCHER) {
 return;
 }
 let segment=distance(ray.o,si.position);
-let channel=min(u32(sample1D(bE(MEDIUM_CHANNEL))*3.0),2u);
+let channel=min(u32(sample1D(aX(MEDIUM_CHANNEL))*3.0),2u);
 if(extinction[channel]>0.0&&any(scattering>vec3f(0.0))) {
-let sampled=-log(max(sample1D(bE(MEDIUM_DISTANCE)),1e-7))/extinction[channel];
+let sampled=-log(max(sample1D(aX(MEDIUM_DISTANCE)),1e-7))/extinction[channel];
 
 
 if(sampled<segment) {
@@ -426,31 +428,31 @@ return;
 }
 }
 let transmittance=exp(-extinction*segment);
-let xK=(transmittance.x+transmittance.y+transmittance.z)/3.0;
-flux*=transmittance/select(1.0,max(xK,1e-20),any(scattering>vec3f(0.0)));
+let oq=(transmittance.x+transmittance.y+transmittance.z)/3.0;
+flux*=transmittance/select(1.0,max(oq,1e-20),any(scattering>vec3f(0.0)));
 if(SPECTRAL) {
 m.specularIor=sampling_cauchy_ior(spectrumIorWavelength(wavelength),m.specularIor,m.transmissionDispersionScale,m.dispersionAbbeNumber);
 }
 if(!isCausticSpecular(m)) {
-let wj=ls.sourceType!=0u;
-let r1=wj&&vt==1u&&wN&&m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0&&m.subsurfaceWeight==0.0;
-if(vt>0u
+let yi=ls.sourceType!=0u;
+let r1=yi&&xk==1u&&yN&&m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0&&m.subsurfaceWeight==0.0;
+if(xk>0u
 ${mode === 'lightTracing' ? '&&!(caustic.mnee!=0u&&r1)' : ''}){${mode === 'lightTracing'
             ? 'causticCameraConnect(si,m,ray,flux,extinction);'
             : /* wgsl */ `
 let position=bitcast<vec3u>(si.position);
-photonStore(photonIndex,vec4u(position,sS(flux)));
+photonStore(photonIndex,vec4u(position,us(flux)));
 if((caustic.experiments&1u)!=0u) {
 var maximum=1e-8;
-for(var i=0u;i<caustic.casterCount;i++) { maximum=max(maximum,ds(i).w); }
+for(var i=0u;i<caustic.casterCount;i++) { maximum=max(maximum,dz(i).w); }
 let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));
 let index=8u+buckets*4u+caustic.photonCount*3u+photonIndex;
 let width=textureDimensions(photonDirections).x;
-textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(bitcast<u32>(ky/maximum)));
+textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(bitcast<u32>(lh/maximum)));
 }
-let hQ=vec2u(round(pN(-ray.d)*255.0));
-let normal=vec2u(round(pN(si.faceNormal)*vec2f(255.0,127.0)));
-pU(photonIndex,normal.x|(normal.y<<8u)|(select(0u,1u,r1)<<15u)|(hQ.x<<16u)|(hQ.y<<24u));
+let iA=vec2u(round(qR(-ray.d)*255.0));
+let normal=vec2u(round(qR(si.faceNormal)*vec2f(255.0,127.0)));
+qX(photonIndex,normal.x|(normal.y<<8u)|(select(0u,1u,r1)<<15u)|(iA.x<<16u)|(iA.y<<24u));
 `}
 }
 return;
@@ -465,7 +467,7 @@ ${frames
 ${coat
             ? /* wgsl */ `    m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,view)>=0.0);`
             : ''}
-let prepared=bV(si.tangent,m,view,normal);
+let prepared=bX(si.tangent,m,view,normal);
 var next:vec3f;
 var pdf:f32;
 var transmission:bool;
@@ -475,14 +477,14 @@ var diffuse:bool;
 var lobe:u32;
 var marginal:f32;
 var full:vec3f;
-let response=dl(prepared,vec3f(sample2D(bE(BSDF_DIRECTION)),sample1D(bE(BSDF_LOBE))),&next,&pdf,&transmission,&roughness,&specular,&diffuse,&lobe,&marginal,&full);
+let response=dr(prepared,vec3f(sample2D(aX(BSDF_DIRECTION)),sample1D(aX(BSDF_LOBE))),&next,&pdf,&transmission,&roughness,&specular,&diffuse,&lobe,&marginal,&full);
 if(!(pdf>0.0)) {
 return;
 }
-if(vt==0u&&ls.sourceType==0u&&transmission) {
+if(xk==0u&&ls.sourceType==0u&&transmission) {
 var reverse:Ray;
 initRay(&reverse,si.position,-ray.d);
-let bg=ft(reverse);
+let bg=fI(reverse);
 flux*=bg.rgb*bg.a/max(ls.emission,vec3f(1e-20));
 }
 flux*=response/pdf*causticAdjoint(view,next,normal,si.faceNormal);
@@ -496,8 +498,8 @@ if(transmission&&!m.thinWalled&&m.mediumType>0) {
 extinction=select(m.mediumExtinction,vec3f(0.0),m.inside);
 scattering=select(m.mediumScattering,vec3f(0.0),m.inside);
 }
-vt++;
-wN=vt==1u&&((isCausticT(m)&&transmission)||(isCausticR(m)&&!transmission));
+xk++;
+yN=xk==1u&&((isCausticT(m)&&transmission)||(isCausticR(m)&&!transmission));
 initRay(&ray,si.position+EPS*next,next);
 }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"causticLight.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/causticLight.compute.ts"],"names":[],"mappings":"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","sourcesContent":["import {PHOTON_GRID_SIZE, photonPackingWgsl} from './photonMap.compute.js';\nimport {SPECTRUM_PHOTON_DISTRIBUTION, SPECTRUM_WAVELENGTH_RANGE, spectrumWgsl} from '../spectrum.js';\nimport background from './chunks/background.wgsl.js';\nimport atomic from './chunks/causticAtomic.wgsl.js';\nimport adjoint from './chunks/causticAdjoint.wgsl.js';\nimport common from './chunks/common.wgsl.js';\nimport core from './chunks/rayTraceCore.wgsl.js';\nimport {createMaterialBufferWgsl} from './chunks/materialBuffer.wgsl.js';\nimport intersect from './chunks/intersect.wgsl.js';\nimport rand from './chunks/rand.wgsl.js';\nimport random from './chunks/random.wgsl.js';\nimport env from './chunks/envMap.wgsl.js';\nimport sampling from './chunks/sampling.wgsl.js';\nimport {createOpenPbrBsdfWgsl} from './chunks/openPbrBsdf.wgsl.js';\nimport light from './chunks/sampleLight.wgsl.js';\nimport uv from './chunks/uvProjection.wgsl.js';\nimport {causticPartitionWGSL} from './chunks/caustics.wgsl.js';\nimport {wgpuShaderPreamble} from '../wgpuShaderSource.js';\nimport {WGPU_SCENE_FEATURE_BITS} from '../WGPUSceneFeatures.js';\n\nexport const CAUSTIC_UNIFORM_BYTES = 112;\nexport const causticUnitRandomWgsl = /* wgsl */ `\n  fn causticUnitRandom(value:f32)->f32 {\n    return clamp((value-EPS)/(1.0-2.0*EPS),0.0,0.99999994);\n  }\n`;\n\n// Preserve the dormant R1 uniform slot and shader spelling for source parity.\n// Production packs zero; only an explicitly registered research adapter sets it.\nexport function causticLightCompute(\n  constants: Record<string, boolean | number>,\n  blasLayoutMask: number,\n  hasDisplacement: boolean,\n  mode: 'lightTracing' | 'photonMapping' = 'lightTracing',\n  sceneIntersections = '',\n  fullEmissionRandom = true\n) {\n  const frames = !!constants.USE_ANISOTROPY_DIRECTIONS || !!constants.USE_COAT_NORMAL_FRAMES,\n    coat = !!constants.USE_COAT_NORMAL_FRAMES;\n  return (\n    wgpuShaderPreamble(constants, true) +\n    /* wgsl */ `\n${Object.keys(WGPU_SCENE_FEATURE_BITS)\n  .map((name) => `const ${name} = ${!!constants[name]};`)\n  .join('\\n')}\n${common}\n${core({hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true})}\n${uv}\n${createMaterialBufferWgsl({hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true})}\n${intersect({\n  hasDisplacement,\n  blasLayoutMask,\n  hasAnisotropyDirections: frames,\n  hasCoatNormals: coat,\n  sceneIntersections\n})}\n${rand}\n${random}\n${env}\n${sampling}\n${spectrumWgsl}\n${createOpenPbrBsdfWgsl(frames, coat)}\n${light}\n${background.replace(\n  /\\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\\b/g,\n  (name) =>\n    `((rtUniform.backgroundFlags & ${\n      {USE_BACKGROUND: 1, USE_BACKGROUND_MAP: 2, USE_GROUNDED_BACKGROUND: 4}[name]\n    }) != 0)`\n)}\n${causticPartitionWGSL(false, false)}\n${adjoint}\n  struct CausticLightUniform {\n    casterSphere: vec4f,\n    viewProjection: mat4x4f,\n    photonCount: u32,\n    batch: u32,\n    mnee: u32,\n    cameraScale: f32,\n    casterCount: u32,\n    choiceCount: u32,\n    orthographic: u32,\n    experiments: u32,\n  }\n  @group(3) @binding(0) var<uniform> caustic: CausticLightUniform;\n${\n  mode === 'lightTracing'\n    ? '@group(3) @binding(1) var<storage,read_write> splats: array<atomic<u32>>;'\n    : `${photonPackingWgsl}\n  @group(3)@binding(1)var photons:texture_storage_2d<rgba32uint,write>;\n  @group(3)@binding(3)var photonDirections:texture_storage_2d<r32uint,write>;\n  fn photonStore(i:u32,value:vec4u) {\n    let width=textureDimensions(photons).x;\n    textureStore(photons,vec2i(vec2u(i%width,i/width)),value);\n  }\n  fn photonStoreDirections(i:u32,value:u32) {\n    let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));\n    let index=8u+buckets*4u+caustic.photonCount*2u+i;\n    let width=textureDimensions(photonDirections).x;\n    textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(value));\n  }\n`\n}\n  @group(3) @binding(2) var causticDistribution:texture_2d<f32>;\n  // Geometric emission PDFs assume the full disk/cone/area support. The generic\n  // BSDF sampler contracts randoms by EPS; undo that contraction for these warps.\n${causticUnitRandomWgsl}\nfn causticEmission1D(dim:u32)->f32{return ${\n      fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'\n    }\n  ;\n}\nfn causticEmission2D(dim:u32)->vec2f {\n  let value=sample2D(dim);\n  return\n${fullEmissionRandom ? 'vec2f(causticUnitRandom(value.x),causticUnitRandom(value.y))' : 'value'}\n  ;\n}\nfn causticLoad(i:u32)->vec4f {\n  let width=textureDimensions(causticDistribution).x;\n  return textureLoad(causticDistribution,vec2i(vec2u(i%width,i/width)),0);\n}\nfn causticSphere(i:u32)->vec4f {\n  return causticLoad(i);\n}\n// Photon emission samples a source surface, independently of any receiver.\n// A NEE sample viewed from the aggregate caster center can reject an emitter\n// which still illuminates another caster, or sample only part of a sphere.\nvar<private> causticEmissionOrigin:vec3f;\nvar<private> causticEmissionAreaPdf:f32;\nfn causticAreaLight(origin:vec3f,position:vec3f,normal:vec3f,emission:vec3f,area:f32,pmf:f32,result:ptr<function,LightSampleRec>) {\n  causticEmissionOrigin=position;\n  causticEmissionAreaPdf=pmf/max(area,1e-20);\n  let offset=position-origin;\n  (*result).dist=length(offset);\n  (*result).direction=offset/max((*result).dist,1e-20);\n  (*result).normal=normal;\n  (*result).emission=emission;\n  (*result).pdf=pmf;\n}\nfn causticSampleLight(origin:vec3f,rnd:vec3f,result:ptr<function,LightSampleRec>) {\n  causticEmissionAreaPdf=0.0;\n  (*result).pdf=0.0;\n  (*result).sourceType=0u;\n  (*result).isDelta=false;\n  if(caustic.choiceCount==0u) {\n    return;\n  }\n  let scaled=rnd.z*f32(caustic.choiceCount);\n  let column=min(u32(scaled),caustic.choiceCount-1u);\n  let entry=causticLoad(caustic.casterCount+column*2u);\n  let selected=select(bitcast<u32>(entry.y),column,fract(scaled)<entry.x);\n  let choice=bitcast<vec4u>(causticLoad(caustic.casterCount+selected*2u));\n  let pmf=causticLoad(caustic.casterCount+selected*2u+1u).x;\n  (*result).sourceIndex=choice.w;\n  if(choice.z==1u) {\n    (*result).sourceType=0u;\n    sampleEnvLight(rnd.xy,result);\n    (*result).pdf*=pmf;\n  }\n  else if(choice.z==2u) {\n    (*result).sourceType=2u;\n    var light=analyticLights[choice.w];\n    let kind=i32(light.litType);\n    if(kind==RECT_LIGHT) {\n      let position=light.position+light.u*(rnd.x-.5)+light.v*(rnd.y-.5);\n      causticAreaLight(origin,position,normalize(cross(light.u,light.v)),light.emission,light.area,pmf,result);\n      (*result).isDelta=light.radiusOrSpread<=.001;\n      light_apply_rect_texture(light,position,light.position-.5*(light.u+light.v),result);\n    }\n    else if((kind==SPHERE_LIGHT||kind==SPOT_LIGHT)&&light.radiusOrSpread>0.0) {\n      let z=1.0-2.0*rnd.x;\n      let radial=sqrt(max(0.0,1.0-z*z));\n      let normal=vec3f(radial*cos(TWOPI*rnd.y),radial*sin(TWOPI*rnd.y),z);\n      causticAreaLight(origin,light.position+light.radiusOrSpread*normal,normal,light.emission,light.area,pmf,result);\n    }\n    else {\n      light.selectionPmf=1.0;\n      sampleAnalyticLight(light,origin,rnd.xy,result);\n      (*result).pdf*=pmf;\n    }\n  }\n  else {\n    (*result).sourceType=1u;\n    let triangle=getEmissiveTriangle(i32(choice.w));\n    let u=sqrt(rnd.x);\n    let bary=vec3f(1.0-u,u*(1.0-rnd.y),u*rnd.y);\n    let position=bary.x*triangle.p0+bary.y*triangle.p1+bary.z*triangle.p2;\n    let normal=normalize(cross(triangle.p1-triangle.p0,triangle.p2-triangle.p0));\n    let uv=bary.x*triangle.uv0+bary.y*triangle.uv1+bary.z*triangle.uv2;\n    let uv1=bary.x*triangle.secondaryUv0+bary.y*triangle.secondaryUv1+bary.z*triangle.secondaryUv2;\n    causticAreaLight(origin,position,normal,getMaterialEmission(i32(triangle.materialIndex),uv,uv1),triangle.area,pmf,result);\n  }\n  (*result).selectionPmf=pmf;\n}\nfn causticCosMax(s:vec4f,origin:vec3f)->f32 {\n  let distanceSquared=dot(s.xyz-origin,s.xyz-origin);\n  return select(-1.0,sqrt(max(0.0,1.0-s.w*s.w/distanceSquared)),distanceSquared>s.w*s.w);\n}\n// A positive floor retains paths from offscreen or occluded casters. The\n// complete weighted mixture PDF below, including overlaps, compensates selection.\nfn causticTargetWeight(s:vec4f)->f32 {\n  if((caustic.experiments&2u)==0u) { return 1.0; }\n  let clip=caustic.viewProjection*vec4f(s.xyz,1.0);\n  let m=caustic.viewProjection;\n  let extent=s.w*max(length(vec3f(m[0].x,m[1].x,m[2].x)),length(vec3f(m[0].y,m[1].y,m[2].y)));\n  if(clip.w<=0.0||abs(clip.x)>clip.w+extent||abs(clip.y)>clip.w+extent) { return .05; }\n  return .05+min(1.0,extent*extent/max(clip.w*clip.w,1e-20));\n}\nfn causticDirection(origin:vec3f,rnd:vec3f,pdf:ptr<function,f32>,targetRadius:ptr<function,f32>)->vec3f {\n  var total=0.0;\n  for(var i=0u;i<caustic.casterCount;i++) {\n    total+=(1.0-causticCosMax(causticSphere(i),origin))*causticTargetWeight(causticSphere(i));\n  }\n  var choice=rnd.z*total;\n  var selected=causticSphere(0u);\n  for(var i=0u;i<caustic.casterCount;i++) {\n    let sphere=causticSphere(i);\n    selected=sphere;\n    choice-=(1.0-causticCosMax(sphere,origin))*causticTargetWeight(sphere);\n    if(choice<=0.0) {\n      break;\n    }\n  }\n  *targetRadius=selected.w;\n  let offset=selected.xyz-origin;\n  let axis=normalize(select(vec3f(0.0,0.0,1.0),offset,dot(offset,offset)>1e-20));\n  let cosine=mix(1.0,causticCosMax(selected,origin),rnd.x);\n  let sine=sqrt(max(0.0,1.0-cosine*cosine));\n  var t:vec3f;\n  var b:vec3f;\n  sampling_orthonormal_basis(axis,&t,&b);\n  let direction=axis*cosine+(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y))*sine;\n  // Evaluate the entire mixture, since intersecting bounding cones overlap.\n  var overlaps=0.0;\n  for(var i=0u;i<caustic.casterCount;i++) {\n    let sphere=causticSphere(i);\n    let c=causticCosMax(sphere,origin);\n    if(c<0.0||dot(normalize(sphere.xyz-origin),direction)>=c) {\n      overlaps+=causticTargetWeight(sphere);\n    }\n  }\n  *pdf=overlaps/max(TWOPI*total,1e-20);\n  return direction;\n}\n${\n  mode === 'lightTracing'\n    ? /* wgsl */ `${atomic}\n  fn causticCameraConnect(si: SurfaceInteraction, material: OpenPbrResolvedMaterial, incoming: Ray, flux: vec3f, extinction: vec3f) {\n    let eye=cameraUniform.viewInv[3].xyz;\n    let forward=-normalize(cameraUniform.viewInv[2].xyz);\n    let lensSample=causticEmission2D(causticDim(68u));\n    let radius=cameraUniform.apertureRadius*sqrt(lensSample.x);\n    var lens=eye+radius*(cos(TWOPI*lensSample.y)*cameraUniform.viewInv[0].xyz+sin(TWOPI*lensSample.y)*cameraUniform.viewInv[1].xyz);\n    if(caustic.orthographic!=0u) {\n      lens=si.position-forward*dot(si.position-eye,forward);\n    }\n    let toEye=lens-si.position;\n    let distanceSquared=dot(toEye,toEye);\n    let direction=normalize(toEye);\n    let focalPoint=lens+(si.position-lens)*cameraUniform.focusDistance/max(dot(si.position-lens,forward),1e-12);\n    let projected=select(focalPoint,si.position,caustic.orthographic!=0u);\n    let clip=caustic.viewProjection*vec4f(projected,1.0);\n    if(clip.w<=0.0||dot(si.position-eye,forward)<=0.0) {\n      return;\n    }\n    let film=clip.xy/clip.w*0.5+0.5;\n    if(any(film<vec2f(0.0))||any(film>=vec2f(1.0))) {\n      return;\n    }\n    var shadow:Ray;\n    initRay(&shadow,si.position+EPS*direction,direction);\n    if(intersectSceneShadow(shadow,sqrt(distanceSquared)-2.0*EPS,si.triangleIndex,si.instanceIndex)) {\n      return;\n    }\n    var m=material;\n    let normal=select(-si.normal,si.normal,dot(si.normal,-incoming.d)>=0.0);\n    m.inside=dot(si.faceNormal,-incoming.d)<0.0;\n    m.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);\n${\n  frames\n    ? /* wgsl */ `  m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`\n    : ''\n}\n${\n  coat\n    ? /* wgsl */ `  m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,-incoming.d)>=0.0);`\n    : ''\n}\n  let prepared=openpbr_prepare(si.tangent,m,-incoming.d,normal);\n  var pdf:f32;\n  let response=openpbr_eval_prepared(prepared,direction,&pdf);\n  let cameraCosine=dot(-direction,-normalize(cameraUniform.viewInv[2].xyz));\n  if(cameraCosine<=0.0) {\n    return;\n  }\n  let importance=caustic.cameraScale*rtUniform.outputSize.x*rtUniform.outputSize.y /\n  select(max(distanceSquared*cameraCosine*cameraCosine*cameraCosine,1e-12),1.0,caustic.orthographic!=0u);\n  let transmittance=exp(-extinction*sqrt(distanceSquared));\n  let value=flux*transmittance*response*causticAdjoint(-incoming.d,direction,normal,si.faceNormal)*importance/f32(caustic.photonCount);\n  let pixel=vec2u(film*rtUniform.outputSize);\n  let index=(pixel.x+pixel.y*u32(rtUniform.outputSize.x))*3u;\n  causticAtomicAdd(index,value.x);\n  causticAtomicAdd(index+1u,value.y);\n  causticAtomicAdd(index+2u,value.z);\n}\n`\n    : ''\n}\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u) {\n    let photonIndex=id.x+id.y*4194240u;\n    if(photonIndex>=caustic.photonCount) {\n      return;\n    }\n${mode === 'photonMapping' ? 'photonStore(photonIndex,vec4u(0u));' : ''}\n  samplingPixel=vec2u(photonIndex%u32(rtUniform.outputSize.x),photonIndex/u32(rtUniform.outputSize.x));\n  pixelSampleIndex=caustic.batch;\n  samplingBounce=0u;\n  hashedCounter=0u;\n  rng_initialize(samplingPixel,i32(sampleSeed(caustic.batch,rtUniform.sequenceSeed)));\n  var wavelength=0.0;\n  var wavelengthPdf=1.0;\n  if(SPECTRAL) {\n    wavelength=spectrumSample(${SPECTRUM_PHOTON_DISTRIBUTION}u,causticEmission1D(causticDim(69u)),&wavelengthPdf);\n  }\n  var ls:LightSampleRec;\n  causticSampleLight(caustic.casterSphere.xyz,vec3f(causticEmission2D(causticDim(60u)),causticEmission1D(causticDim(61u))),&ls);\n  if(ls.pdf<=0.0) {\n    return;\n  }\n  var infinite=ls.sourceType==0u;\n  if(ls.sourceType==2u) {\n    infinite=i32(analyticLights[ls.sourceIndex].litType)==DIRECTIONAL_LIGHT;\n  }\n  var origin=caustic.casterSphere.xyz+ls.direction*ls.dist;\n  if(causticEmissionAreaPdf>0.0) { origin=causticEmissionOrigin; }\n  var direction:vec3f;\n  var flux:vec3f;\n  var targetRadius=caustic.casterSphere.w;\n  if(infinite) {\n    direction=-ls.direction;\n    // Mixture of projected caster disks. Every overlap contributes to the PDF.\n    var area=0.0;\n    for(var i=0u;i<caustic.casterCount;i++) {\n      let s=causticSphere(i);\n      area+=s.w*s.w*causticTargetWeight(s);\n    }\n    var choice=causticEmission1D(causticDim(63u))*area;\n    var sphere=causticSphere(0u);\n    for(var i=0u;i<caustic.casterCount;i++) {\n      sphere=causticSphere(i);\n      choice-=sphere.w*sphere.w*causticTargetWeight(sphere);\n      if(choice<=0.0) {\n        break;\n      }\n    }\n    targetRadius=sphere.w;\n    var t:vec3f;\n    var b:vec3f;\n    sampling_orthonormal_basis(direction,&t,&b);\n    let rnd=causticEmission2D(causticDim(62u));\n    origin=sphere.xyz-direction*dot(sphere.xyz-caustic.casterSphere.xyz,direction)-direction*caustic.casterSphere.w;\n    origin+=sphere.w*sqrt(rnd.x)*(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y));\n    var overlaps=0.0;\n    for(var i=0u;i<caustic.casterCount;i++) {\n      let s=causticSphere(i);\n      let offset=origin-s.xyz;\n      let projected=offset-direction*dot(offset,direction);\n      if(dot(projected,projected)<=s.w*s.w) {\n        overlaps+=causticTargetWeight(s);\n      }\n    }\n    let diskPdf=overlaps/max(PI*area,1e-20);\n    flux=ls.emission/(ls.pdf*diskPdf);\n  }\n  else if(ls.sourceType==2u&&i32(analyticLights[ls.sourceIndex].litType)==RECT_LIGHT&&ls.isDelta) {\n    // A zero-spread rectangle is a collimated beam, matching PT's delta source.\n    direction=ls.normal;\n    flux=ls.emission/causticEmissionAreaPdf;\n  }\n  else {\n    var areaPdf=ls.pdf*abs(dot(ls.normal,-ls.direction))/max(ls.dist*ls.dist,1e-20);\n    if(causticEmissionAreaPdf>0.0) { areaPdf=causticEmissionAreaPdf; }\n    if(ls.isDelta) {\n      areaPdf=ls.selectionPmf;\n    }\n    if(areaPdf<=0.0) {\n      return;\n    }\n    var directionPdf:f32;\n    direction=causticDirection(origin,vec3f(causticEmission2D(causticDim(62u)),causticEmission1D(causticDim(63u))),&directionPdf,&targetRadius);\n    var emission=ls.emission;\n    var emissionCosine=max(0.0,dot(ls.normal,direction));\n    if(ls.sourceType==2u) {\n      let source=analyticLights[ls.sourceIndex];\n      emission=source.emission;\n      if(i32(source.litType)==SPOT_LIGHT) {\n        emission*=evaluateSpotEmissionMultiplier(source,direction);\n      }\n      if(ls.isDelta) {\n        emissionCosine=1.0;\n      }\n      if(i32(source.litType)==RECT_LIGHT&&emissionCosine<cos(0.5*PI*source.radiusOrSpread)) {\n        return;\n      }\n      if(i32(source.litType)==RECT_LIGHT) {\n        var textured:LightSampleRec;\n        textured.emission=emission;\n        light_apply_rect_texture(source,origin,source.position-0.5*(source.u+source.v),&textured);\n        emission=textured.emission;\n      }\n    }\n    flux=emission*emissionCosine/(areaPdf*directionPdf);\n  }\n  if(SPECTRAL) {\n    flux*=spectrumRgb(wavelength)/(wavelengthPdf*${SPECTRUM_WAVELENGTH_RANGE}.0);\n  }\n  var ray:Ray;\n  initRay(&ray,origin+EPS*direction,direction);\n  var chain=0u;\n  var singleT=false;\n  var extinction=vec3f(0.0);\n  var scattering=vec3f(0.0);\n  var si:SurfaceInteraction;\n  for(var depth=0;\n${mode === 'photonMapping' ? 'depth<=max(rtUniform.bounces,0)' : 'depth<20'}\n  ;\n  depth++) {\n    samplingBounce=u32(depth);\n    si.triangleIndex=-1;\n    intersectScene(ray,&si,0,true,depth>0);\n    if(!si.hit) {\n      return;\n    }\n    var m:OpenPbrResolvedMaterial;\n    getMaterial(&m,si.materialIndex,si.uv,si.uv1,si.instanceIndex,si.vertexColor);\n    if(m.alpha<1.0&&causticEmission1D(causticDim(79u))>=m.alpha) {\n      initRay(&ray,si.position+EPS*ray.d,ray.d);\n      continue;\n    }\n    if(m.materialType==SHADOW_CATCHER) {\n      return;\n    }\n    let segment=distance(ray.o,si.position);\n    let channel=min(u32(sample1D(bounceDim(MEDIUM_CHANNEL))*3.0),2u);\n    if(extinction[channel]>0.0&&any(scattering>vec3f(0.0))) {\n      let sampled=-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)),1e-7))/extinction[channel];\n      // A volume event belongs to PT's R3. Surface-reaching photons use the\n      // same RGB survival mixture as PT, retaining absorption and scattering.\n      if(sampled<segment) {\n        return;\n      }\n    }\n    let transmittance=exp(-extinction*segment);\n    let survival=(transmittance.x+transmittance.y+transmittance.z)/3.0;\n    flux*=transmittance/select(1.0,max(survival,1e-20),any(scattering>vec3f(0.0)));\n    if(SPECTRAL) {\n      m.specularIor=sampling_cauchy_ior(spectrumIorWavelength(wavelength),m.specularIor,m.transmissionDispersionScale,m.dispersionAbbeNumber);\n    }\n    if(!isCausticSpecular(m)) {\n      let mneeSource=ls.sourceType!=0u;\n      let r1=mneeSource&&chain==1u&&singleT&&m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0&&m.subsurfaceWeight==0.0;\n      if(chain>0u\n${mode === 'lightTracing' ? '&&!(caustic.mnee!=0u&&r1)' : ''}){${\n      mode === 'lightTracing'\n        ? 'causticCameraConnect(si,m,ray,flux,extinction);'\n        : /* wgsl */ `\n  let position=bitcast<vec3u>(si.position);\n  photonStore(photonIndex,vec4u(position,photonEncodeFlux(flux)));\n  if((caustic.experiments&1u)!=0u) {\n    var maximum=1e-8;\n    for(var i=0u;i<caustic.casterCount;i++) { maximum=max(maximum,causticSphere(i).w); }\n    let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));\n    let index=8u+buckets*4u+caustic.photonCount*3u+photonIndex;\n    let width=textureDimensions(photonDirections).x;\n    textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(bitcast<u32>(targetRadius/maximum)));\n  }\n  let incoming=vec2u(round(photonEncodeOct(-ray.d)*255.0));\n  let normal=vec2u(round(photonEncodeOct(si.faceNormal)*vec2f(255.0,127.0)));\n  photonStoreDirections(photonIndex,normal.x|(normal.y<<8u)|(select(0u,1u,r1)<<15u)|(incoming.x<<16u)|(incoming.y<<24u));\n`\n    }\n}\nreturn;\n}\nlet view=-ray.d;\nlet normal=select(-si.normal,si.normal,dot(si.normal,view)>=0.0);\nm.inside=dot(si.faceNormal,view)<0.0;\nm.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);\n${\n  frames\n    ? /* wgsl */ `    m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`\n    : ''\n}\n${\n  coat\n    ? /* wgsl */ `    m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,view)>=0.0);`\n    : ''\n}\n  let prepared=openpbr_prepare(si.tangent,m,view,normal);\n  var next:vec3f;\n  var pdf:f32;\n  var transmission:bool;\n  var roughness:f32;\n  var specular:bool;\n  var diffuse:bool;\n  var lobe:u32;\n  var marginal:f32;\n  var full:vec3f;\n  let response=openpbr_sample_prepared(prepared,vec3f(sample2D(bounceDim(BSDF_DIRECTION)),sample1D(bounceDim(BSDF_LOBE))),&next,&pdf,&transmission,&roughness,&specular,&diffuse,&lobe,&marginal,&full);\n  if(!(pdf>0.0)) {\n    return;\n  }\n  if(chain==0u&&ls.sourceType==0u&&transmission) {\n    var reverse:Ray;\n    initRay(&reverse,si.position,-ray.d);\n    let bg=sampleSceneBackground(reverse);\n    flux*=bg.rgb*bg.a/max(ls.emission,vec3f(1e-20));\n  }\n  flux*=response/pdf*causticAdjoint(view,next,normal,si.faceNormal);\n  // The shared BSDF is a radiance sampler. Cancel its eta_i/eta_t squared\n  // factor for adjoint (light-to-camera) propagation.\n  if(transmission&&!m.thinWalled) {\n    flux/=m.relativeIor*m.relativeIor;\n  }\n  // Match PT: a clear solid interface does not replace the active medium.\n  if(transmission&&!m.thinWalled&&m.mediumType>0) {\n    extinction=select(m.mediumExtinction,vec3f(0.0),m.inside);\n    scattering=select(m.mediumScattering,vec3f(0.0),m.inside);\n  }\n  chain++;\n  singleT=chain==1u&&((isCausticT(m)&&transmission)||(isCausticR(m)&&!transmission));\n  initRay(&ray,si.position+EPS*next,next);\n}\n}\n`\n  );\n}\n\nexport const causticAccumulateCompute = /* wgsl */ `\n  @group(0) @binding(0) var<storage,read_write> splats:array<atomic<u32>>;\n  @group(0) @binding(1) var<storage,read_write> accumulation:array<vec4f>;\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u, @builtin(num_workgroups) groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&accumulation)) {\n      return;\n    }\n    let i=pixel*3u;\n    accumulation[pixel]+=vec4f(vec3f(bitcast<f32>(atomicLoad(&splats[i])),bitcast<f32>(atomicLoad(&splats[i+1u])),bitcast<f32>(atomicLoad(&splats[i+2u]))),1.0);\n  }\n`;\n\n/** Native buffer resolve has the same independent batch normalization as web. */\nexport const causticBufferCompositeCompute = /* wgsl */ `\n  @group(0)@binding(0)var<storage,read>pt:array<vec4f>;\n  @group(0)@binding(1)var<storage,read>caustics:array<vec4f>;\n  @group(0)@binding(2)var<storage,read>normal:array<vec4f>;\n  @group(0)@binding(3)var<storage,read_write>output:array<vec4f>;\n  @compute @workgroup_size(64)fn main(@builtin(global_invocation_id)id:vec3u,@builtin(num_workgroups)groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&output)) {\n      return;\n    }\n    let c=caustics[pixel];\n    let p=pt[pixel];\n    output[pixel]=vec4f(p.rgb+c.rgb/max(c.a,1.0)*normal[pixel].a,p.a);\n  }\n`;\n"]}
+{"version":3,"file":"causticLight.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/causticLight.compute.ts"],"names":[],"mappings":"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","sourcesContent":["import {PHOTON_GRID_SIZE, photonPackingWgsl} from './photonMap.compute.js';\nimport {SPECTRUM_PHOTON_DISTRIBUTION, SPECTRUM_WAVELENGTH_RANGE, spectrumWgsl} from '../spectrum.js';\nimport background from './chunks/background.wgsl.js';\nimport atomic from './chunks/causticAtomic.wgsl.js';\nimport adjoint from './chunks/causticAdjoint.wgsl.js';\nimport common from './chunks/common.wgsl.js';\nimport core from './chunks/rayTraceCore.wgsl.js';\nimport {createMaterialBufferWgsl} from './chunks/materialBuffer.wgsl.js';\nimport intersect from './chunks/intersect.wgsl.js';\nimport rand from './chunks/rand.wgsl.js';\nimport random from './chunks/random.wgsl.js';\nimport env from './chunks/envMap.wgsl.js';\nimport sampling from './chunks/sampling.wgsl.js';\nimport {createOpenPbrBsdfWgsl} from './chunks/openPbrBsdf.wgsl.js';\nimport light from './chunks/sampleLight.wgsl.js';\nimport uv from './chunks/uvProjection.wgsl.js';\nimport {causticPartitionWGSL} from './chunks/caustics.wgsl.js';\nimport {wgpuShaderPreamble} from '../wgpuShaderSource.js';\nimport {WGPU_SCENE_FEATURE_BITS} from '../WGPUSceneFeatures.js';\n\nexport const CAUSTIC_UNIFORM_BYTES = 112;\nexport const causticUnitRandomWgsl = /* wgsl */ `\n  fn causticUnitRandom(value:f32)->f32 {\n    return clamp((value-EPS)/(1.0-2.0*EPS),0.0,0.99999994);\n  }\n`;\n\n// Preserve the dormant R1 uniform slot and shader spelling for source parity.\n// Production packs zero; only an explicitly registered research adapter sets it.\nexport function causticLightCompute(\n  constants: Record<string, boolean | number>,\n  blasLayoutMask: number,\n  hasDisplacement: boolean,\n  mode: 'lightTracing' | 'photonMapping' = 'lightTracing',\n  sceneIntersections = '',\n  fullEmissionRandom = true,\n  perInstanceBounds = false,\n  compactVertices = false,\n  independentTextures = false\n) {\n  const frames = !!constants.USE_ANISOTROPY_DIRECTIONS || !!constants.USE_COAT_NORMAL_FRAMES,\n    coat = !!constants.USE_COAT_NORMAL_FRAMES;\n  return (\n    (independentTextures ? 'enable wgpu_binding_array;\\n' : '') + wgpuShaderPreamble(constants, true) +\n    /* wgsl */ `\n${Object.keys(WGPU_SCENE_FEATURE_BITS)\n  .map((name) => `const ${name} = ${!!constants[name]};`)\n  .join('\\n')}\n${common}\n${core({independentTextures, compactVertices, hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true})}\n${uv}\n${createMaterialBufferWgsl({independentTextures, hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true})}\n${intersect({\n  perInstanceBounds,\n  compactVertices,\n  hasDisplacement,\n  blasLayoutMask,\n  hasAnisotropyDirections: frames,\n  hasCoatNormals: coat,\n  sceneIntersections\n})}\n${rand}\n${random}\n${env}\n${sampling}\n${spectrumWgsl}\n${createOpenPbrBsdfWgsl(frames, coat)}\n${light}\n${background.replace(\n  /\\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\\b/g,\n  (name) =>\n    `((rtUniform.backgroundFlags & ${\n      {USE_BACKGROUND: 1, USE_BACKGROUND_MAP: 2, USE_GROUNDED_BACKGROUND: 4}[name]\n    }) != 0)`\n)}\n${causticPartitionWGSL(false, false)}\n${adjoint}\n  struct CausticLightUniform {\n    casterSphere: vec4f,\n    viewProjection: mat4x4f,\n    photonCount: u32,\n    batch: u32,\n    mnee: u32,\n    cameraScale: f32,\n    casterCount: u32,\n    choiceCount: u32,\n    orthographic: u32,\n    experiments: u32,\n  }\n  @group(3) @binding(0) var<uniform> caustic: CausticLightUniform;\n${\n  mode === 'lightTracing'\n    ? '@group(3) @binding(1) var<storage,read_write> splats: array<atomic<u32>>;'\n    : `${photonPackingWgsl}\n  @group(3)@binding(1)var photons:texture_storage_2d<rgba32uint,write>;\n  @group(3)@binding(3)var photonDirections:texture_storage_2d<r32uint,write>;\n  fn photonStore(i:u32,value:vec4u) {\n    let width=textureDimensions(photons).x;\n    textureStore(photons,vec2i(vec2u(i%width,i/width)),value);\n  }\n  fn photonStoreDirections(i:u32,value:u32) {\n    let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));\n    let index=8u+buckets*4u+caustic.photonCount*2u+i;\n    let width=textureDimensions(photonDirections).x;\n    textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(value));\n  }\n`\n}\n  @group(3) @binding(2) var causticDistribution:texture_2d<f32>;\n  // Geometric emission PDFs assume the full disk/cone/area support. The generic\n  // BSDF sampler contracts randoms by EPS; undo that contraction for these warps.\n${causticUnitRandomWgsl}\nfn causticEmission1D(dim:u32)->f32{return ${\n      fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'\n    }\n  ;\n}\nfn causticEmission2D(dim:u32)->vec2f {\n  let value=sample2D(dim);\n  return\n${fullEmissionRandom ? 'vec2f(causticUnitRandom(value.x),causticUnitRandom(value.y))' : 'value'}\n  ;\n}\nfn causticLoad(i:u32)->vec4f {\n  let width=textureDimensions(causticDistribution).x;\n  return textureLoad(causticDistribution,vec2i(vec2u(i%width,i/width)),0);\n}\nfn causticSphere(i:u32)->vec4f {\n  return causticLoad(i);\n}\n// Photon emission samples a source surface, independently of any receiver.\n// A NEE sample viewed from the aggregate caster center can reject an emitter\n// which still illuminates another caster, or sample only part of a sphere.\nvar<private> causticEmissionOrigin:vec3f;\nvar<private> causticEmissionAreaPdf:f32;\nfn causticAreaLight(origin:vec3f,position:vec3f,normal:vec3f,emission:vec3f,area:f32,pmf:f32,result:ptr<function,LightSampleRec>) {\n  causticEmissionOrigin=position;\n  causticEmissionAreaPdf=pmf/max(area,1e-20);\n  let offset=position-origin;\n  (*result).dist=length(offset);\n  (*result).direction=offset/max((*result).dist,1e-20);\n  (*result).normal=normal;\n  (*result).emission=emission;\n  (*result).pdf=pmf;\n}\nfn causticSampleLight(origin:vec3f,rnd:vec3f,result:ptr<function,LightSampleRec>) {\n  causticEmissionAreaPdf=0.0;\n  (*result).pdf=0.0;\n  (*result).sourceType=0u;\n  (*result).isDelta=false;\n  if(caustic.choiceCount==0u) {\n    return;\n  }\n  let scaled=rnd.z*f32(caustic.choiceCount);\n  let column=min(u32(scaled),caustic.choiceCount-1u);\n  let entry=causticLoad(caustic.casterCount+column*2u);\n  let selected=select(bitcast<u32>(entry.y),column,fract(scaled)<entry.x);\n  let choice=bitcast<vec4u>(causticLoad(caustic.casterCount+selected*2u));\n  let pmf=causticLoad(caustic.casterCount+selected*2u+1u).x;\n  (*result).sourceIndex=choice.w;\n  if(choice.z==1u) {\n    (*result).sourceType=0u;\n    sampleEnvLight(rnd.xy,result);\n    (*result).pdf*=pmf;\n  }\n  else if(choice.z==2u) {\n    (*result).sourceType=2u;\n    var light=analyticLights[choice.w];\n    let kind=i32(light.litType);\n    if(kind==RECT_LIGHT) {\n      let position=light.position+light.u*(rnd.x-.5)+light.v*(rnd.y-.5);\n      causticAreaLight(origin,position,normalize(cross(light.u,light.v)),light.emission,light.area,pmf,result);\n      (*result).isDelta=light.radiusOrSpread<=.001;\n      light_apply_rect_texture(light,position,light.position-.5*(light.u+light.v),result);\n    }\n    else if((kind==SPHERE_LIGHT||kind==SPOT_LIGHT)&&light.radiusOrSpread>0.0) {\n      let z=1.0-2.0*rnd.x;\n      let radial=sqrt(max(0.0,1.0-z*z));\n      let normal=vec3f(radial*cos(TWOPI*rnd.y),radial*sin(TWOPI*rnd.y),z);\n      causticAreaLight(origin,light.position+light.radiusOrSpread*normal,normal,light.emission,light.area,pmf,result);\n    }\n    else {\n      light.selectionPmf=1.0;\n      sampleAnalyticLight(light,origin,rnd.xy,result);\n      (*result).pdf*=pmf;\n    }\n  }\n  else {\n    (*result).sourceType=1u;\n    let triangle=getEmissiveTriangle(i32(choice.w));\n    let u=sqrt(rnd.x);\n    let bary=vec3f(1.0-u,u*(1.0-rnd.y),u*rnd.y);\n    let position=bary.x*triangle.p0+bary.y*triangle.p1+bary.z*triangle.p2;\n    let normal=normalize(cross(triangle.p1-triangle.p0,triangle.p2-triangle.p0));\n    let uv=bary.x*triangle.uv0+bary.y*triangle.uv1+bary.z*triangle.uv2;\n    let uv1=bary.x*triangle.secondaryUv0+bary.y*triangle.secondaryUv1+bary.z*triangle.secondaryUv2;\n    causticAreaLight(origin,position,normal,getMaterialEmission(i32(triangle.materialIndex),uv,uv1),triangle.area,pmf,result);\n  }\n  (*result).selectionPmf=pmf;\n}\nfn causticCosMax(s:vec4f,origin:vec3f)->f32 {\n  let distanceSquared=dot(s.xyz-origin,s.xyz-origin);\n  return select(-1.0,sqrt(max(0.0,1.0-s.w*s.w/distanceSquared)),distanceSquared>s.w*s.w);\n}\n// A positive floor retains paths from offscreen or occluded casters. The\n// complete weighted mixture PDF below, including overlaps, compensates selection.\nfn causticTargetWeight(s:vec4f)->f32 {\n  if((caustic.experiments&2u)==0u) { return 1.0; }\n  let clip=caustic.viewProjection*vec4f(s.xyz,1.0);\n  let m=caustic.viewProjection;\n  let extent=s.w*max(length(vec3f(m[0].x,m[1].x,m[2].x)),length(vec3f(m[0].y,m[1].y,m[2].y)));\n  if(clip.w<=0.0||abs(clip.x)>clip.w+extent||abs(clip.y)>clip.w+extent) { return .05; }\n  return .05+min(1.0,extent*extent/max(clip.w*clip.w,1e-20));\n}\nfn causticDirection(origin:vec3f,rnd:vec3f,pdf:ptr<function,f32>,targetRadius:ptr<function,f32>)->vec3f {\n  var total=0.0;\n  for(var i=0u;i<caustic.casterCount;i++) {\n    total+=(1.0-causticCosMax(causticSphere(i),origin))*causticTargetWeight(causticSphere(i));\n  }\n  var choice=rnd.z*total;\n  var selected=causticSphere(0u);\n  for(var i=0u;i<caustic.casterCount;i++) {\n    let sphere=causticSphere(i);\n    selected=sphere;\n    choice-=(1.0-causticCosMax(sphere,origin))*causticTargetWeight(sphere);\n    if(choice<=0.0) {\n      break;\n    }\n  }\n  *targetRadius=selected.w;\n  let offset=selected.xyz-origin;\n  let axis=normalize(select(vec3f(0.0,0.0,1.0),offset,dot(offset,offset)>1e-20));\n  let cosine=mix(1.0,causticCosMax(selected,origin),rnd.x);\n  let sine=sqrt(max(0.0,1.0-cosine*cosine));\n  var t:vec3f;\n  var b:vec3f;\n  sampling_orthonormal_basis(axis,&t,&b);\n  let direction=axis*cosine+(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y))*sine;\n  // Evaluate the entire mixture, since intersecting bounding cones overlap.\n  var overlaps=0.0;\n  for(var i=0u;i<caustic.casterCount;i++) {\n    let sphere=causticSphere(i);\n    let c=causticCosMax(sphere,origin);\n    if(c<0.0||dot(normalize(sphere.xyz-origin),direction)>=c) {\n      overlaps+=causticTargetWeight(sphere);\n    }\n  }\n  *pdf=overlaps/max(TWOPI*total,1e-20);\n  return direction;\n}\n${\n  mode === 'lightTracing'\n    ? /* wgsl */ `${atomic}\n  fn causticCameraConnect(si: SurfaceInteraction, material: OpenPbrResolvedMaterial, incoming: Ray, flux: vec3f, extinction: vec3f) {\n    let eye=cameraUniform.viewInv[3].xyz;\n    let forward=-normalize(cameraUniform.viewInv[2].xyz);\n    let lensSample=causticEmission2D(causticDim(68u));\n    let radius=cameraUniform.apertureRadius*sqrt(lensSample.x);\n    var lens=eye+radius*(cos(TWOPI*lensSample.y)*cameraUniform.viewInv[0].xyz+sin(TWOPI*lensSample.y)*cameraUniform.viewInv[1].xyz);\n    if(caustic.orthographic!=0u) {\n      lens=si.position-forward*dot(si.position-eye,forward);\n    }\n    let toEye=lens-si.position;\n    let distanceSquared=dot(toEye,toEye);\n    let direction=normalize(toEye);\n    let focalPoint=lens+(si.position-lens)*cameraUniform.focusDistance/max(dot(si.position-lens,forward),1e-12);\n    let projected=select(focalPoint,si.position,caustic.orthographic!=0u);\n    let clip=caustic.viewProjection*vec4f(projected,1.0);\n    if(clip.w<=0.0||dot(si.position-eye,forward)<=0.0) {\n      return;\n    }\n    let film=clip.xy/clip.w*0.5+0.5;\n    if(any(film<vec2f(0.0))||any(film>=vec2f(1.0))) {\n      return;\n    }\n    var shadow:Ray;\n    initRay(&shadow,si.position+EPS*direction,direction);\n    if(intersectSceneShadow(shadow,sqrt(distanceSquared)-2.0*EPS,si.triangleIndex,si.instanceIndex)) {\n      return;\n    }\n    var m=material;\n    let normal=select(-si.normal,si.normal,dot(si.normal,-incoming.d)>=0.0);\n    m.inside=dot(si.faceNormal,-incoming.d)<0.0;\n    m.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);\n${\n  frames\n    ? /* wgsl */ `  m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`\n    : ''\n}\n${\n  coat\n    ? /* wgsl */ `  m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,-incoming.d)>=0.0);`\n    : ''\n}\n  let prepared=openpbr_prepare(si.tangent,m,-incoming.d,normal);\n  var pdf:f32;\n  let response=openpbr_eval_prepared(prepared,direction,&pdf);\n  let cameraCosine=dot(-direction,-normalize(cameraUniform.viewInv[2].xyz));\n  if(cameraCosine<=0.0) {\n    return;\n  }\n  let importance=caustic.cameraScale*rtUniform.outputSize.x*rtUniform.outputSize.y /\n  select(max(distanceSquared*cameraCosine*cameraCosine*cameraCosine,1e-12),1.0,caustic.orthographic!=0u);\n  let transmittance=exp(-extinction*sqrt(distanceSquared));\n  let value=flux*transmittance*response*causticAdjoint(-incoming.d,direction,normal,si.faceNormal)*importance/f32(caustic.photonCount);\n  let pixel=vec2u(film*rtUniform.outputSize);\n  let index=(pixel.x+pixel.y*u32(rtUniform.outputSize.x))*3u;\n  causticAtomicAdd(index,value.x);\n  causticAtomicAdd(index+1u,value.y);\n  causticAtomicAdd(index+2u,value.z);\n}\n`\n    : ''\n}\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u) {\n    let photonIndex=id.x+id.y*4194240u;\n    if(photonIndex>=caustic.photonCount) {\n      return;\n    }\n${mode === 'photonMapping' ? 'photonStore(photonIndex,vec4u(0u));' : ''}\n  samplingPixel=vec2u(photonIndex%u32(rtUniform.outputSize.x),photonIndex/u32(rtUniform.outputSize.x));\n  pixelSampleIndex=caustic.batch;\n  samplingBounce=0u;\n  hashedCounter=0u;\n  rng_initialize(samplingPixel,i32(sampleSeed(caustic.batch,rtUniform.sequenceSeed)));\n  var wavelength=0.0;\n  var wavelengthPdf=1.0;\n  if(SPECTRAL) {\n    wavelength=spectrumSample(${SPECTRUM_PHOTON_DISTRIBUTION}u,causticEmission1D(causticDim(69u)),&wavelengthPdf);\n  }\n  var ls:LightSampleRec;\n  causticSampleLight(caustic.casterSphere.xyz,vec3f(causticEmission2D(causticDim(60u)),causticEmission1D(causticDim(61u))),&ls);\n  if(ls.pdf<=0.0) {\n    return;\n  }\n  var infinite=ls.sourceType==0u;\n  if(ls.sourceType==2u) {\n    infinite=i32(analyticLights[ls.sourceIndex].litType)==DIRECTIONAL_LIGHT;\n  }\n  var origin=caustic.casterSphere.xyz+ls.direction*ls.dist;\n  if(causticEmissionAreaPdf>0.0) { origin=causticEmissionOrigin; }\n  var direction:vec3f;\n  var flux:vec3f;\n  var targetRadius=caustic.casterSphere.w;\n  if(infinite) {\n    direction=-ls.direction;\n    // Mixture of projected caster disks. Every overlap contributes to the PDF.\n    var area=0.0;\n    for(var i=0u;i<caustic.casterCount;i++) {\n      let s=causticSphere(i);\n      area+=s.w*s.w*causticTargetWeight(s);\n    }\n    var choice=causticEmission1D(causticDim(63u))*area;\n    var sphere=causticSphere(0u);\n    for(var i=0u;i<caustic.casterCount;i++) {\n      sphere=causticSphere(i);\n      choice-=sphere.w*sphere.w*causticTargetWeight(sphere);\n      if(choice<=0.0) {\n        break;\n      }\n    }\n    targetRadius=sphere.w;\n    var t:vec3f;\n    var b:vec3f;\n    sampling_orthonormal_basis(direction,&t,&b);\n    let rnd=causticEmission2D(causticDim(62u));\n    origin=sphere.xyz-direction*dot(sphere.xyz-caustic.casterSphere.xyz,direction)-direction*caustic.casterSphere.w;\n    origin+=sphere.w*sqrt(rnd.x)*(t*cos(TWOPI*rnd.y)+b*sin(TWOPI*rnd.y));\n    var overlaps=0.0;\n    for(var i=0u;i<caustic.casterCount;i++) {\n      let s=causticSphere(i);\n      let offset=origin-s.xyz;\n      let projected=offset-direction*dot(offset,direction);\n      if(dot(projected,projected)<=s.w*s.w) {\n        overlaps+=causticTargetWeight(s);\n      }\n    }\n    let diskPdf=overlaps/max(PI*area,1e-20);\n    flux=ls.emission/(ls.pdf*diskPdf);\n  }\n  else if(ls.sourceType==2u&&i32(analyticLights[ls.sourceIndex].litType)==RECT_LIGHT&&ls.isDelta) {\n    // A zero-spread rectangle is a collimated beam, matching PT's delta source.\n    direction=ls.normal;\n    flux=ls.emission/causticEmissionAreaPdf;\n  }\n  else {\n    var areaPdf=ls.pdf*abs(dot(ls.normal,-ls.direction))/max(ls.dist*ls.dist,1e-20);\n    if(causticEmissionAreaPdf>0.0) { areaPdf=causticEmissionAreaPdf; }\n    if(ls.isDelta) {\n      areaPdf=ls.selectionPmf;\n    }\n    if(areaPdf<=0.0) {\n      return;\n    }\n    var directionPdf:f32;\n    direction=causticDirection(origin,vec3f(causticEmission2D(causticDim(62u)),causticEmission1D(causticDim(63u))),&directionPdf,&targetRadius);\n    var emission=ls.emission;\n    var emissionCosine=max(0.0,dot(ls.normal,direction));\n    if(ls.sourceType==2u) {\n      let source=analyticLights[ls.sourceIndex];\n      emission=source.emission;\n      if(i32(source.litType)==SPOT_LIGHT) {\n        emission*=evaluateSpotEmissionMultiplier(source,direction);\n      }\n      if(ls.isDelta) {\n        emissionCosine=1.0;\n      }\n      if(i32(source.litType)==RECT_LIGHT&&emissionCosine<cos(0.5*PI*source.radiusOrSpread)) {\n        return;\n      }\n      if(i32(source.litType)==RECT_LIGHT) {\n        var textured:LightSampleRec;\n        textured.emission=emission;\n        light_apply_rect_texture(source,origin,source.position-0.5*(source.u+source.v),&textured);\n        emission=textured.emission;\n      }\n    }\n    flux=emission*emissionCosine/(areaPdf*directionPdf);\n  }\n  if(SPECTRAL) {\n    flux*=spectrumRgb(wavelength)/(wavelengthPdf*${SPECTRUM_WAVELENGTH_RANGE}.0);\n  }\n  var ray:Ray;\n  initRay(&ray,origin+EPS*direction,direction);\n  var chain=0u;\n  var singleT=false;\n  var extinction=vec3f(0.0);\n  var scattering=vec3f(0.0);\n  var si:SurfaceInteraction;\n  for(var depth=0;\n${mode === 'photonMapping' ? 'depth<=max(rtUniform.bounces,0)' : 'depth<20'}\n  ;\n  depth++) {\n    samplingBounce=u32(depth);\n    si.triangleIndex=-1;\n    intersectScene(ray,&si,0,true,depth>0);\n    if(!si.hit) {\n      return;\n    }\n    var m:OpenPbrResolvedMaterial;\n    getMaterial(&m,si.materialIndex,si.uv,si.uv1,si.instanceIndex,si.vertexColor);\n    if(m.alpha<1.0&&causticEmission1D(causticDim(79u))>=m.alpha) {\n      initRay(&ray,si.position+EPS*ray.d,ray.d);\n      continue;\n    }\n    if(m.materialType==SHADOW_CATCHER) {\n      return;\n    }\n    let segment=distance(ray.o,si.position);\n    let channel=min(u32(sample1D(bounceDim(MEDIUM_CHANNEL))*3.0),2u);\n    if(extinction[channel]>0.0&&any(scattering>vec3f(0.0))) {\n      let sampled=-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)),1e-7))/extinction[channel];\n      // A volume event belongs to PT's R3. Surface-reaching photons use the\n      // same RGB survival mixture as PT, retaining absorption and scattering.\n      if(sampled<segment) {\n        return;\n      }\n    }\n    let transmittance=exp(-extinction*segment);\n    let survival=(transmittance.x+transmittance.y+transmittance.z)/3.0;\n    flux*=transmittance/select(1.0,max(survival,1e-20),any(scattering>vec3f(0.0)));\n    if(SPECTRAL) {\n      m.specularIor=sampling_cauchy_ior(spectrumIorWavelength(wavelength),m.specularIor,m.transmissionDispersionScale,m.dispersionAbbeNumber);\n    }\n    if(!isCausticSpecular(m)) {\n      let mneeSource=ls.sourceType!=0u;\n      let r1=mneeSource&&chain==1u&&singleT&&m.baseWeight*(1.0-m.baseMetalness)*(1.0-m.transmissionWeight)>0.0&&m.subsurfaceWeight==0.0;\n      if(chain>0u\n${mode === 'lightTracing' ? '&&!(caustic.mnee!=0u&&r1)' : ''}){${\n      mode === 'lightTracing'\n        ? 'causticCameraConnect(si,m,ray,flux,extinction);'\n        : /* wgsl */ `\n  let position=bitcast<vec3u>(si.position);\n  photonStore(photonIndex,vec4u(position,photonEncodeFlux(flux)));\n  if((caustic.experiments&1u)!=0u) {\n    var maximum=1e-8;\n    for(var i=0u;i<caustic.casterCount;i++) { maximum=max(maximum,causticSphere(i).w); }\n    let buckets=min(${PHOTON_GRID_SIZE}u,1u<<(32u-countLeadingZeros(max(256u,caustic.photonCount*2u)-1u)));\n    let index=8u+buckets*4u+caustic.photonCount*3u+photonIndex;\n    let width=textureDimensions(photonDirections).x;\n    textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(bitcast<u32>(targetRadius/maximum)));\n  }\n  let incoming=vec2u(round(photonEncodeOct(-ray.d)*255.0));\n  let normal=vec2u(round(photonEncodeOct(si.faceNormal)*vec2f(255.0,127.0)));\n  photonStoreDirections(photonIndex,normal.x|(normal.y<<8u)|(select(0u,1u,r1)<<15u)|(incoming.x<<16u)|(incoming.y<<24u));\n`\n    }\n}\nreturn;\n}\nlet view=-ray.d;\nlet normal=select(-si.normal,si.normal,dot(si.normal,view)>=0.0);\nm.inside=dot(si.faceNormal,view)<0.0;\nm.relativeIor=select(1.0/m.specularIor,m.specularIor,m.inside);\n${\n  frames\n    ? /* wgsl */ `    m.directionTangent=si.directionTangent;m.directionBitangent=si.directionBitangent;m.geometryTangent=si.geometryTangent;m.geometryBitangent=si.geometryBitangent;`\n    : ''\n}\n${\n  coat\n    ? /* wgsl */ `    m.coatNormal=normal;m.geometricNormal=select(-si.faceNormal,si.faceNormal,dot(si.faceNormal,view)>=0.0);`\n    : ''\n}\n  let prepared=openpbr_prepare(si.tangent,m,view,normal);\n  var next:vec3f;\n  var pdf:f32;\n  var transmission:bool;\n  var roughness:f32;\n  var specular:bool;\n  var diffuse:bool;\n  var lobe:u32;\n  var marginal:f32;\n  var full:vec3f;\n  let response=openpbr_sample_prepared(prepared,vec3f(sample2D(bounceDim(BSDF_DIRECTION)),sample1D(bounceDim(BSDF_LOBE))),&next,&pdf,&transmission,&roughness,&specular,&diffuse,&lobe,&marginal,&full);\n  if(!(pdf>0.0)) {\n    return;\n  }\n  if(chain==0u&&ls.sourceType==0u&&transmission) {\n    var reverse:Ray;\n    initRay(&reverse,si.position,-ray.d);\n    let bg=sampleSceneBackground(reverse);\n    flux*=bg.rgb*bg.a/max(ls.emission,vec3f(1e-20));\n  }\n  flux*=response/pdf*causticAdjoint(view,next,normal,si.faceNormal);\n  // The shared BSDF is a radiance sampler. Cancel its eta_i/eta_t squared\n  // factor for adjoint (light-to-camera) propagation.\n  if(transmission&&!m.thinWalled) {\n    flux/=m.relativeIor*m.relativeIor;\n  }\n  // Match PT: a clear solid interface does not replace the active medium.\n  if(transmission&&!m.thinWalled&&m.mediumType>0) {\n    extinction=select(m.mediumExtinction,vec3f(0.0),m.inside);\n    scattering=select(m.mediumScattering,vec3f(0.0),m.inside);\n  }\n  chain++;\n  singleT=chain==1u&&((isCausticT(m)&&transmission)||(isCausticR(m)&&!transmission));\n  initRay(&ray,si.position+EPS*next,next);\n}\n}\n`\n  );\n}\n\nexport const causticAccumulateCompute = /* wgsl */ `\n  @group(0) @binding(0) var<storage,read_write> splats:array<atomic<u32>>;\n  @group(0) @binding(1) var<storage,read_write> accumulation:array<vec4f>;\n  @compute @workgroup_size(64)\n  fn main(@builtin(global_invocation_id) id:vec3u, @builtin(num_workgroups) groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&accumulation)) {\n      return;\n    }\n    let i=pixel*3u;\n    accumulation[pixel]+=vec4f(vec3f(bitcast<f32>(atomicLoad(&splats[i])),bitcast<f32>(atomicLoad(&splats[i+1u])),bitcast<f32>(atomicLoad(&splats[i+2u]))),1.0);\n  }\n`;\n\n/** Native buffer resolve has the same independent batch normalization as web. */\nexport const causticBufferCompositeCompute = /* wgsl */ `\n  @group(0)@binding(0)var<storage,read>pt:array<vec4f>;\n  @group(0)@binding(1)var<storage,read>caustics:array<vec4f>;\n  @group(0)@binding(2)var<storage,read>normal:array<vec4f>;\n  @group(0)@binding(3)var<storage,read_write>output:array<vec4f>;\n  @compute @workgroup_size(64)fn main(@builtin(global_invocation_id)id:vec3u,@builtin(num_workgroups)groups:vec3u) {\n    // Large images exceed one dispatch row; preserve the linear pixel order.\n    let pixel=id.x+id.y*groups.x*64u;\n    if(pixel>=arrayLength(&output)) {\n      return;\n    }\n    let c=caustics[pixel];\n    let p=pt[pixel];\n    output[pixel]=vec4f(p.rgb+c.rgb/max(c.a,1.0)*normal[pixel].a,p.a);\n  }\n`;\n"]}