@meimu/mutracer 0.2.0 → 0.3.1

package/lib/renderer/wgsl/bloom.wgsl.js

@@ -3,7 +3,7 @@
 // https://github.com/keijiro/KinoBloom/blob/master/Assets/Kino/Bloom/Shader/Bloom.cginc#L96
 // See THIRD_PARTY_NOTICES.md and LICENSES/KinoBloom-MIT.txt.
 export const bloomBrightDefine = /* wgsl */ `
-fn tS(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
+fn vE(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
 return a + b + c - min(min(a, b), c) - max(max(a, b), c);
 }
 `;
@@ -11,26 +11,26 @@ export const bloomBrightMain = /* wgsl */ `
 
 let d = vec3i(1, 1, 0);
 
-var dk = load_colorTex(uv, 0);
+var texel = load_colorTex(uv, 0);
 let s1 = load_colorTex(uv - d.xz, 0);
 let s2 = load_colorTex(uv + d.xz, 0);
 let s3 = load_colorTex(uv - d.zy, 0);
 let s4 = load_colorTex(uv + d.zy, 0);
-dk = tS(tS(dk, s1, s2), s3, s4);
+texel = vE(vE(texel, s1, s2), s3, s4);
 
 
-let lum = dot(dk.rgb, vec3f(0.2125, 0.7154, 0.0721));
+let lum = dot(texel.rgb, vec3f(0.2125, 0.7154, 0.0721));
 var color: vec4f;
-if (lum > threshold && dk.a > 0.0) {
-color = vec4f(dk.rgb * scale, dk.a);
+if (lum > threshold && texel.a > 0.0) {
+color = vec4f(texel.rgb * scale, texel.a);
 } else {
 
-color = vec4f(vec3(0.0), dk.a);
+color = vec4f(vec3(0.0), texel.a);
 }
 output.color = color;
 `;
 export const bloomDownDefine = /* wgsl */ `
-fn xP(c: vec3f) -> f32 {
+fn Am(c: vec3f) -> f32 {
 return max(max(c.r, c.g), c.b);
 }
 `;
@@ -44,25 +44,25 @@ output.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25
 + sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;
 `;
 export const bloomBlurDefine = /* wgsl */ `
-const xT = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);
+const Au = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);
 `;
 export const bloomBlurMain = /* wgsl */ `
-let xG = vec2f(colorTexRegion());
-let off = direction / xG * size;
+let Ae = vec2f(colorTexRegion());
+let off = direction / Ae * size;
 
 var sum = vec4f(0.0);
-var uE = 0.0;
+var wr = 0.0;
 for (var i = 0; i < 9; i++) {
-let w = xT[i];
+let w = Au[i];
 sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;
-uE += w;
+wr += w;
 }
-output.color = sum / max(uE, 0.01);
+output.color = sum / max(wr, 0.01);
 `;
 export const bloomBlendMain = /* wgsl */ `
-let xQ = sample_colorTex1_linearSampler(uv2);
-let xR = sample_colorTex2_linearSampler(uv2);
-output.color = mix(xQ, xR, weight);
+let Ao = sample_colorTex1_linearSampler(uv2);
+let Ap = sample_colorTex2_linearSampler(uv2);
+output.color = mix(Ao, Ap, weight);
 `;
 export const BLOOM_LEVELS = 6;
 export function bloomBlurSize(radius) {

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

@@ -0,0 +1,6 @@
+export declare const CAUSTIC_UNIFORM_BYTES = 112;
+export declare const causticUnitRandomWgsl = "\n  fn causticUnitRandom(value:f32)->f32 {\n    return clamp((value-EPS)/(1.0-2.0*EPS),0.0,0.99999994);\n  }\n";
+export declare function causticLightCompute(constants: Record<string, boolean | number>, blasLayoutMask: number, hasDisplacement: boolean, mode?: 'lightTracing' | 'photonMapping', sceneIntersections?: string, fullEmissionRandom?: boolean, perInstanceBounds?: boolean, compactVertices?: boolean, independentTextures?: boolean): string;
+export declare const causticAccumulateCompute = "\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";
+/** Native buffer resolve has the same independent batch normalization as web. */
+export declare const causticBufferCompositeCompute = "\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";

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

@@ -0,0 +1,539 @@
+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, perInstanceBounds = false, compactVertices = false, independentTextures = false) {
+    const frames = !!constants.USE_ANISOTROPY_DIRECTIONS || !!constants.USE_COAT_NORMAL_FRAMES, coat = !!constants.USE_COAT_NORMAL_FRAMES;
+    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({ independentTextures, compactVertices, hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
+${uv}
+${createMaterialBufferWgsl({ independentTextures, hasAnisotropyDirections: frames, hasCoatNormals: coat, caustics: true })}
+${intersect({
+            perInstanceBounds,
+            compactVertices,
+            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 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;
+textureStore(photonDirections,vec2i(vec2u(index%width,index/width)),vec4u(value));
+}
+`}
+@group(3) @binding(2) var causticDistribution:texture_2d<f32>;
+
+
+${causticUnitRandomWgsl}
+fn fN(dim:u32)->f32{return ${fullEmissionRandom ? 'causticUnitRandom(sample1D(dim))' : 'sample1D(dim)'}
+;
+}
+fn ie(dim:u32)->vec2f {
+let value=sample2D(dim);
+return
+${fullEmissionRandom ? 'vec2f(causticUnitRandom(value.x),causticUnitRandom(value.y))' : 'value'}
+;
+}
+fn oF(i:u32)->vec4f {
+let width=textureDimensions(causticDistribution).x;
+return textureLoad(causticDistribution,vec2i(vec2u(i%width,i/width)),0);
+}
+fn dz(i:u32)->vec4f {
+return oF(i);
+}
+
+
+
+var<private> lu:vec3f;
+var<private> causticEmissionAreaPdf:f32;
+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);
+(*result).direction=offset/max((*result).dist,1e-20);
+(*result).normal=normal;
+(*result).emission=emission;
+(*result).pdf=pmf;
+}
+fn sE(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=oF(caustic.casterCount+column*2u);
+let selected=select(bitcast<u32>(entry.y),column,fract(scaled)<entry.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;
+iM(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);
+lE(origin,position,normalize(cross(light.u,light.v)),light.emission,light.area,pmf,result);
+(*result).isDelta=light.radiusOrSpread<=.001;
+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 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;
+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;
+lE(origin,position,normal,getMaterialEmission(i32(triangle.materialIndex),uv,uv1),triangle.area,pmf,result);
+}
+(*result).selectionPmf=pmf;
+}
+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 dS(s:vec4f)->f32 {
+if((caustic.experiments&2u)==0u) { return 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(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 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-mf(dz(i),origin))*dS(dz(i));
+}
+var choice=rnd.z*total;
+var selected=dz(0u);
+for(var i=0u;i<caustic.casterCount;i++) {
+let sphere=dz(i);
+selected=sphere;
+choice-=(1.0-mf(sphere,origin))*dS(sphere);
+if(choice<=0.0) {
+break;
+}
+}
+*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,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))*wk;
+
+var overlaps=0.0;
+for(var i=0u;i<caustic.casterCount;i++) {
+let sphere=dz(i);
+let c=mf(sphere,origin);
+if(c<0.0||dot(normalize(sphere.xyz-origin),direction)>=c) {
+overlaps+=dS(sphere);
+}
+}
+*pdf=overlaps/max(TWOPI*total,1e-20);
+return direction;
+}
+${mode === 'lightTracing'
+            ? /* wgsl */ `${atomic}
+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 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) {
+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 yY=vb.xy/vb.w*0.5+0.5;
+if(any(yY<vec2f(0.0))||any(yY>=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,-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,-iA.d)>=0.0);`
+                : ''}
+let prepared=bX(si.tangent,m,-iA.d,normal);
+var pdf:f32;
+let response=openpbr_eval_prepared(prepared,direction,&pdf);
+let ne=dot(-direction,-normalize(cameraUniform.viewInv[2].xyz));
+if(ne<=0.0) {
+return;
+}
+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(-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;
+lF(index,value.x);
+lF(index+1u,value.y);
+lF(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));' : ''}
+aJ=vec2u(photonIndex%u32(rtUniform.outputSize.x),photonIndex/u32(rtUniform.outputSize.x));
+aC=caustic.batch;
+samplingBounce=0u;
+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,fN(causticDim(69u)),&wavelengthPdf);
+}
+var ls:LightSampleRec;
+sE(caustic.casterSphere.xyz,vec3f(ie(causticDim(60u)),fN(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=lu; }
+var direction:vec3f;
+var flux:vec3f;
+var lh=caustic.casterSphere.w;
+if(infinite) {
+direction=-ls.direction;
+
+var area=0.0;
+for(var i=0u;i<caustic.casterCount;i++) {
+let s=dz(i);
+area+=s.w*s.w*dS(s);
+}
+var choice=fN(causticDim(63u))*area;
+var sphere=dz(0u);
+for(var i=0u;i<caustic.casterCount;i++) {
+sphere=dz(i);
+choice-=sphere.w*sphere.w*dS(sphere);
+if(choice<=0.0) {
+break;
+}
+}
+lh=sphere.w;
+var t:vec3f;
+var b:vec3f;
+sampling_orthonormal_basis(direction,&t,&b);
+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=dz(i);
+let offset=origin-s.xyz;
+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);
+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=tV(origin,vec3f(ie(causticDim(62u)),fN(causticDim(63u))),&directionPdf,&lh);
+var emission=ls.emission;
+var nN=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) {
+nN=1.0;
+}
+if(i32(source.litType)==RECT_LIGHT&&nN<cos(0.5*PI*source.radiusOrSpread)) {
+return;
+}
+if(i32(source.litType)==RECT_LIGHT) {
+var vX:LightSampleRec;
+vX.emission=emission;
+bD(source,origin,source.position-0.5*(source.u+source.v),&vX);
+emission=vX.emission;
+}
+}
+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 xk=0u;
+var yN=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&&fN(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(aX(MEDIUM_CHANNEL))*3.0),2u);
+if(extinction[channel]>0.0&&any(scattering>vec3f(0.0))) {
+let sampled=-log(max(sample1D(aX(MEDIUM_DISTANCE)),1e-7))/extinction[channel];
+
+
+if(sampled<segment) {
+return;
+}
+}
+let transmittance=exp(-extinction*segment);
+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 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,us(flux)));
+if((caustic.experiments&1u)!=0u) {
+var maximum=1e-8;
+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>(lh/maximum)));
+}
+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;
+}
+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=bX(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=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(xk==0u&&ls.sourceType==0u&&transmission) {
+var reverse:Ray;
+initRay(&reverse,si.position,-ray.d);
+let bg=fI(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);
+}
+xk++;
+yN=xk==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