@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -0,0 +1,537 @@
+import { PHOTON_GRID_SIZE, photonPackingWgsl } from './photonMap.compute.js';
+import { SPECTRUM_PHOTON_DISTRIBUTION, SPECTRUM_WAVELENGTH_RANGE, spectrumWgsl } from '../spectrum.js';
+import background from './chunks/background.wgsl.js';
+import atomic from './chunks/causticAtomic.wgsl.js';
+import adjoint from './chunks/causticAdjoint.wgsl.js';
+import common from './chunks/common.wgsl.js';
+import core from './chunks/rayTraceCore.wgsl.js';
+import { createMaterialBufferWgsl } from './chunks/materialBuffer.wgsl.js';
+import intersect from './chunks/intersect.wgsl.js';
+import rand from './chunks/rand.wgsl.js';
+import random from './chunks/random.wgsl.js';
+import env from './chunks/envMap.wgsl.js';
+import sampling from './chunks/sampling.wgsl.js';
+import { createOpenPbrBsdfWgsl } from './chunks/openPbrBsdf.wgsl.js';
+import light from './chunks/sampleLight.wgsl.js';
+import uv from './chunks/uvProjection.wgsl.js';
+import { causticPartitionWGSL } from './chunks/caustics.wgsl.js';
+import { wgpuShaderPreamble } from '../wgpuShaderSource.js';
+import { WGPU_SCENE_FEATURE_BITS } from '../WGPUSceneFeatures.js';
+export const CAUSTIC_UNIFORM_BYTES = 112;
+export const causticUnitRandomWgsl = /* wgsl */ `
+fn causticUnitRandom(value:f32)->f32 {
+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) {
+    const frames = !!constants.USE_ANISOTROPY_DIRECTIONS || !!constants.USE_COAT_NORMAL_FRAMES, coat = !!constants.USE_COAT_NORMAL_FRAMES;
+    return (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 })}
+${uv}
+${createMaterialBufferWgsl({ hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
+${intersect({
+            hasDisplacement,
+            blasLayoutMask,
+            hasAnisotropyDirections: frames,
+            hasCoatNormals: coat,
+            sceneIntersections
+        })}
+${rand}
+${random}
+${env}
+${sampling}
+${spectrumWgsl}
+${createOpenPbrBsdfWgsl(frames, coat)}
+${light}
+${background.replace(/\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\b/g, (name) => `((rtUniform.backgroundFlags & ${{ USE_BACKGROUND: 1, USE_BACKGROUND_MAP: 2, USE_GROUNDED_BACKGROUND: 4 }[name]}) != 0)`)}
+${causticPartitionWGSL(false, false)}
+${adjoint}
+struct CausticLightUniform {
+casterSphere: vec4f,
+viewProjection: mat4x4f,
+photonCount: u32,
+batch: u32,
+mnee: u32,
+cameraScale: f32,
+casterCount: u32,
+choiceCount: u32,
+orthographic: u32,
+experiments: u32,
+}
+@group(3) @binding(0) var<uniform> caustic: CausticLightUniform;
+${mode === 'lightTracing'
+            ? '@group(3) @binding(1) var<storage,read_write> splats: array<atomic<u32>>;'
+            : `${photonPackingWgsl}
+@group(3)@binding(1)var photons:texture_storage_2d<rgba32uint,write>;
+@group(3)@binding(3)var photonDirections:texture_storage_2d<r32uint,write>;
+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) {
+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;
+textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(value));
+}
+`}
+@group(3) @binding(2) var causticDistribution:texture_2d<f32>;
+
+
+${causticUnitRandomWgsl}
+fn fB(dim:u32)->f32{return ${fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'}
+;
+}
+fn hE(dim:u32)->vec2f {
+let value=sample2D(dim);
+return
+${fullEmissionRandom ? 'vec2f(causticUnitRandom(value.x),causticUnitRandom(value.y))' : 'value'}
+;
+}
+fn nH(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);
+}
+
+
+
+var<private> kH: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;
+causticEmissionAreaPdf=pmf/max(area,1e-20);
+let offset=position-origin;
+(*result).dist=length(offset);
+(*result).direction=offset/max((*result).dist,1e-20);
+(*result).normal=normal;
+(*result).emission=emission;
+(*result).pdf=pmf;
+}
+fn rn(origin:vec3f,rnd:vec3f,result:ptr<function,LightSampleRec>) {
+causticEmissionAreaPdf=0.0;
+(*result).pdf=0.0;
+(*result).sourceType=0u;
+(*result).isDelta=false;
+if(caustic.choiceCount==0u) {
+return;
+}
+let scaled=rnd.z*f32(caustic.choiceCount);
+let column=min(u32(scaled),caustic.choiceCount-1u);
+let entry=nH(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;
+(*result).sourceIndex=choice.w;
+if(choice.z==1u) {
+(*result).sourceType=0u;
+ig(rnd.xy,result);
+(*result).pdf*=pmf;
+}
+else if(choice.z==2u) {
+(*result).sourceType=2u;
+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);
+(*result).isDelta=light.radiusOrSpread<=.001;
+bC(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);
+}
+else {
+light.selectionPmf=1.0;
+sampleAnalyticLight(light,origin,rnd.xy,result);
+(*result).pdf*=pmf;
+}
+}
+else {
+(*result).sourceType=1u;
+let triangle=getEmissiveTriangle(i32(choice.w));
+let u=sqrt(rnd.x);
+let bary=vec3f(1.0-u,u*(1.0-rnd.y),u*rnd.y);
+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);
+}
+(*result).selectionPmf=pmf;
+}
+fn lj(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 {
+if((caustic.experiments&2u)==0u) { return 1.0; }
+let tB=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));
+}
+fn sv(origin:vec3f,rnd:vec3f,pdf:ptr<function,f32>,ky: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));
+}
+var choice=rnd.z*total;
+var selected=ds(0u);
+for(var i=0u;i<caustic.casterCount;i++) {
+let sphere=ds(i);
+selected=sphere;
+choice-=(1.0-lj(sphere,origin))*dN(sphere);
+if(choice<=0.0) {
+break;
+}
+}
+*ky=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));
+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;
+
+var overlaps=0.0;
+for(var i=0u;i<caustic.casterCount;i++) {
+let sphere=ds(i);
+let c=lj(sphere,origin);
+if(c<0.0||dot(normalize(sphere.xyz-origin),direction)>=c) {
+overlaps+=dN(sphere);
+}
+}
+*pdf=overlaps/max(TWOPI*total,1e-20);
+return direction;
+}
+${mode === 'lightTracing'
+            ? /* wgsl */ `${atomic}
+fn causticCameraConnect(si: SurfaceInteraction, material: OpenPbrResolvedMaterial, hQ: 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);
+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) {
+return;
+}
+let wY=tB.xy/tB.w*0.5+0.5;
+if(any(wY<vec2f(0.0))||any(wY>=vec2f(1.0))) {
+return;
+}
+var shadow:Ray;
+initRay(&shadow,si.position+EPS*direction,direction);
+if(intersectSceneShadow(shadow,sqrt(bG)-2.0*EPS,si.triangleIndex,si.instanceIndex)) {
+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;
+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);`
+                : ''}
+let prepared=bV(si.tangent,m,-hQ.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) {
+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 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 index=(pixel.x+pixel.y*u32(rtUniform.outputSize.x))*3u;
+kM(index,value.x);
+kM(index+1u,value.y);
+kM(index+2u,value.z);
+}
+`
+            : ''}
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id:vec3u) {
+let photonIndex=id.x+id.y*4194240u;
+if(photonIndex>=caustic.photonCount) {
+return;
+}
+${mode === 'photonMapping' ? 'photonStore(photonIndex,vec4u(0u));' : ''}
+aI=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)));
+var wavelength=0.0;
+var wavelengthPdf=1.0;
+if(SPECTRAL) {
+wavelength=spectrumSample(${SPECTRUM_PHOTON_DISTRIBUTION}u,fB(causticDim(69u)),&wavelengthPdf);
+}
+var ls:LightSampleRec;
+rn(caustic.casterSphere.xyz,vec3f(hE(causticDim(60u)),fB(causticDim(61u))),&ls);
+if(ls.pdf<=0.0) {
+return;
+}
+var infinite=ls.sourceType==0u;
+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; }
+var direction:vec3f;
+var flux:vec3f;
+var ky=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);
+}
+var choice=fB(causticDim(63u))*area;
+var sphere=ds(0u);
+for(var i=0u;i<caustic.casterCount;i++) {
+sphere=ds(i);
+choice-=sphere.w*sphere.w*dN(sphere);
+if(choice<=0.0) {
+break;
+}
+}
+ky=sphere.w;
+var t:vec3f;
+var b:vec3f;
+sampling_orthonormal_basis(direction,&t,&b);
+let rnd=hE(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 offset=origin-s.xyz;
+let qO=offset-direction*dot(offset,direction);
+if(dot(qO,qO)<=s.w*s.w) {
+overlaps+=dN(s);
+}
+}
+let diskPdf=overlaps/max(PI*area,1e-20);
+flux=ls.emission/(ls.pdf*diskPdf);
+}
+else if(ls.sourceType==2u&&i32(analyticLights[ls.sourceIndex].litType)==RECT_LIGHT&&ls.isDelta) {
+
+direction=ls.normal;
+flux=ls.emission/causticEmissionAreaPdf;
+}
+else {
+var areaPdf=ls.pdf*abs(dot(ls.normal,-ls.direction))/max(ls.dist*ls.dist,1e-20);
+if(causticEmissionAreaPdf>0.0) { areaPdf=causticEmissionAreaPdf; }
+if(ls.isDelta) {
+areaPdf=ls.selectionPmf;
+}
+if(areaPdf<=0.0) {
+return;
+}
+var directionPdf:f32;
+direction=sv(origin,vec3f(hE(causticDim(62u)),fB(causticDim(63u))),&directionPdf,&ky);
+var emission=ls.emission;
+var mL=max(0.0,dot(ls.normal,direction));
+if(ls.sourceType==2u) {
+let source=analyticLights[ls.sourceIndex];
+emission=source.emission;
+if(i32(source.litType)==SPOT_LIGHT) {
+emission*=evaluateSpotEmissionMultiplier(source,direction);
+}
+if(ls.isDelta) {
+mL=1.0;
+}
+if(i32(source.litType)==RECT_LIGHT&&mL<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;
+}
+}
+flux=emission*mL/(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 extinction=vec3f(0.0);
+var scattering=vec3f(0.0);
+var si:SurfaceInteraction;
+for(var depth=0;
+${mode === 'photonMapping' ? 'depth<=max(rtUniform.bounces,0)' : 'depth<20'}
+;
+depth++) {
+samplingBounce=u32(depth);
+si.triangleIndex=-1;
+intersectScene(ray,&si,0,true,depth>0);
+if(!si.hit) {
+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) {
+initRay(&ray,si.position+EPS*ray.d,ray.d);
+continue;
+}
+if(m.materialType==SHADOW_CATCHER) {
+return;
+}
+let segment=distance(ray.o,si.position);
+let channel=min(u32(sample1D(bE(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];
+
+
+if(sampled<segment) {
+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)));
+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
+${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)));
+if((caustic.experiments&1u)!=0u) {
+var maximum=1e-8;
+for(var i=0u;i<caustic.casterCount;i++) { maximum=max(maximum,ds(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)));
+}
+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));
+`}
+}
+return;
+}
+let view=-ray.d;
+let normal=select(-si.normal,si.normal,dot(si.normal,view)>=0.0);
+m.inside=dot(si.faceNormal,view)<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,view)>=0.0);`
+            : ''}
+let prepared=bV(si.tangent,m,view,normal);
+var next:vec3f;
+var pdf:f32;
+var transmission:bool;
+var roughness:f32;
+var specular:bool;
+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);
+if(!(pdf>0.0)) {
+return;
+}
+if(vt==0u&&ls.sourceType==0u&&transmission) {
+var reverse:Ray;
+initRay(&reverse,si.position,-ray.d);
+let bg=ft(reverse);
+flux*=bg.rgb*bg.a/max(ls.emission,vec3f(1e-20));
+}
+flux*=response/pdf*causticAdjoint(view,next,normal,si.faceNormal);
+
+
+if(transmission&&!m.thinWalled) {
+flux/=m.relativeIor*m.relativeIor;
+}
+
+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));
+initRay(&ray,si.position+EPS*next,next);
+}
+}
+`);
+}
+export const causticAccumulateCompute = /* wgsl */ `
+@group(0) @binding(0) var<storage,read_write> splats:array<atomic<u32>>;
+@group(0) @binding(1) var<storage,read_write> accumulation:array<vec4f>;
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id:vec3u, @builtin(num_workgroups) groups:vec3u) {
+
+let pixel=id.x+id.y*groups.x*64u;
+if(pixel>=arrayLength(&accumulation)) {
+return;
+}
+let i=pixel*3u;
+accumulation[pixel]+=vec4f(vec3f(bitcast<f32>(atomicLoad(&splats[i])),bitcast<f32>(atomicLoad(&splats[i+1u])),bitcast<f32>(atomicLoad(&splats[i+2u]))),1.0);
+}
+`;
+/** Native buffer resolve has the same independent batch normalization as web. */
+export const causticBufferCompositeCompute = /* wgsl */ `
+@group(0)@binding(0)var<storage,read>pt:array<vec4f>;
+@group(0)@binding(1)var<storage,read>caustics:array<vec4f>;
+@group(0)@binding(2)var<storage,read>normal:array<vec4f>;
+@group(0)@binding(3)var<storage,read_write>output:array<vec4f>;
+@compute @workgroup_size(64)fn main(@builtin(global_invocation_id)id:vec3u,@builtin(num_workgroups)groups:vec3u) {
+
+let pixel=id.x+id.y*groups.x*64u;
+if(pixel>=arrayLength(&output)) {
+return;
+}
+let c=caustics[pixel];
+let p=pt[pixel];
+output[pixel]=vec4f(p.rgb+c.rgb/max(c.a,1.0)*normal[pixel].a,p.a);
+}
+`;
+//# sourceMappingURL=causticLight.compute.js.map

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

@@ -0,0 +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"]}

package/lib/renderer/wgsl/chunks/background.wgsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "fn groundedSurfaceDistance(point: vec3f, height: f32, radius: f32) -> f32 {\n  let pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  let originalY = radius * point.y / pointLength;\n  let transitionY = -1.5 * height;\n  var surfaceRadius: f32;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  }\n  else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  }\n  else {\n    let factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nfn groundedBackgroundDirection(origin: vec3f, direction: vec3f) -> vec3f {\n  if (!USE_GROUNDED_BACKGROUND) {\n    return direction;\n  }\n  let params = rtUniform.groundedBackgroundParams;\n  let rayDirection = normalize(direction);\n  let center = vec3f(\n    rtUniform.groundedBackgroundCenter.x,\n    params.z + params.x,\n    rtUniform.groundedBackgroundCenter.y\n  );\n  let localOrigin = origin - center;\n  let projectedOrigin = dot(localOrigin, rayDirection);\n  let discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + params.y * params.y;\n  if (\n    discriminant <= 0.0\n    || groundedSurfaceDistance(localOrigin, params.x, params.y) > 0.0\n  ) {\n    return direction;\n  }\n\n  var farDistance = -projectedOrigin + sqrt(discriminant);\n  if (farDistance <= 0.0) {\n    return direction;\n  }\n\n  let sphereHit = localOrigin + rayDirection * farDistance;\n  if (sphereHit.y >= 0.0) {\n    return normalize(sphereHit);\n  }\n\n  if (rayDirection.y < -0.00001 && params.y > 1.5 * params.x) {\n    let groundDistance = (-params.x - localOrigin.y) / rayDirection.y;\n    let groundHit = localOrigin + rayDirection * groundDistance;\n    let groundRadius = (2.0 / 3.0)\n      * sqrt(params.y * params.y - 2.25 * params.x * params.x);\n    if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n      return normalize(groundHit);\n    }\n  }\n\n  var nearDistance = 0.0;\n  for (var i = 0; i < 14; i++) {\n    let middleDistance = (nearDistance + farDistance) * 0.5;\n    let middlePoint = localOrigin + rayDirection * middleDistance;\n    if (groundedSurfaceDistance(middlePoint, params.x, params.y) > 0.0) {\n      farDistance = middleDistance;\n    }\n    else {\n      nearDistance = middleDistance;\n    }\n  }\n  let hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n  return normalize(hit);\n}\n\nfn sampleSceneBackground(ray: Ray) -> vec4f {\n  var bg = vec4f(0.0);\n  if (USE_BACKGROUND_MAP) {\n    let d = groundedBackgroundDirection(ray.o, ray.d);\n    let t = rtUniform.backgroundMapTransform;\n    let backgroundDirection = vec3f(t.x * d.x - t.y * d.z, d.y, t.y * d.x + t.x * d.z);\n    let rotation = rtUniform.backgroundMapRotation;\n    let mapDirection = transpose(mat3x3f(rotation[0].xyz, rotation[1].xyz, rotation[2].xyz)) * backgroundDirection;\n    let backgroundSample = textureLinear(backgroundMap, cartesianToEquirect(mapDirection));\n    bg = vec4f(backgroundSample.rgb * t.z, backgroundSample.a);\n  }\n  else if (USE_BACKGROUND) {\n    bg = rtUniform.backgroundColor;\n  }\n  else if (USE_ENVMAP) {\n    bg = textureLinear(envMap, environmentUv(ray.d));\n  }\n  return bg;\n}\n\n";
+export default _default;