@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/wgsl/bloom.wgsl.d.ts

@@ -0,0 +1,13 @@
+export declare const bloomBrightDefine = "\nfn median(a: vec4f, b: vec4f, c: vec4f) -> vec4f {\nreturn a + b + c - min(min(a, b), c) - max(max(a, b), c);\n}\n";
+export declare const bloomBrightMain = "\n\nlet d = vec3i(1, 1, 0);\n\nvar texel = load_colorTex(uv, 0);\nlet s1 = load_colorTex(uv - d.xz, 0);\nlet s2 = load_colorTex(uv + d.xz, 0);\nlet s3 = load_colorTex(uv - d.zy, 0);\nlet s4 = load_colorTex(uv + d.zy, 0);\ntexel = median(median(texel, s1, s2), s3, s4);\n\n// Premultiplied Alpha\nlet lum = dot(texel.rgb, vec3f(0.2125, 0.7154, 0.0721));\nvar color: vec4f;\nif (lum > threshold && texel.a > 0.0) {\n  color = vec4f(texel.rgb * scale, texel.a);\n} else {\n  // Bleed the alpha to avoid sharp edge when using alpha\n  color = vec4f(vec3(0.0), texel.a);\n}\noutput.color = color;\n";
+export declare const bloomDownDefine = "\nfn brightness(c: vec3f) -> f32 {\n  return max(max(c.r, c.g), c.b);\n}\n";
+export declare const bloomDownMain = "\nlet size = vec2f(colorTexRegion());\nlet d = vec4f(-1.0, -1.0, 1.0, 1.0) / size.xyxy;\n\noutput.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.zy) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.xw) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;\n";
+export declare const bloomBlurDefine = "\nconst kernel = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);\n";
+export declare const bloomBlurMain = "\nlet texSize = vec2f(colorTexRegion());\nlet off = direction / texSize * size;\n\nvar sum = vec4f(0.0);\nvar weightAll = 0.0;\nfor (var i = 0; i < 9; i++) {\n  let w = kernel[i];\n  sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;\n  weightAll += w;\n}\noutput.color = sum / max(weightAll, 0.01);\n";
+export declare const bloomBlendMain = "\nlet color1 = sample_colorTex1_linearSampler(uv2);\nlet color2 = sample_colorTex2_linearSampler(uv2);\noutput.color = mix(color1, color2, weight);\n";
+export declare const BLOOM_LEVELS = 6;
+export declare function bloomBlurSize(radius: number): number;
+export declare function bloomBlendWeight(radius: number): number;
+export type BloomStep = readonly [kind: number, a: number, b: number, target: number, dx: number, dy: number];
+export declare function createBloomPlan(levels: number): BloomStep[];
+export declare const BLOOM_PLAN: BloomStep[];

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

@@ -0,0 +1,92 @@
+// Shared pass bodies; each host supplies texture access and the entry point.
+// Median bright pass adapted from KinoBloom (MIT), Keijiro Takahashi:
+// 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 tV(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
+return a + b + c - min(min(a, b), c) - max(max(a, b), c);
+}
+`;
+export const bloomBrightMain = /* wgsl */ `
+
+let d = vec3i(1, 1, 0);
+
+var cR = 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);
+cR = tV(tV(cR, s1, s2), s3, s4);
+
+
+let lum = dot(cR.rgb, vec3f(0.2125, 0.7154, 0.0721));
+var color: vec4f;
+if (lum > threshold && cR.a > 0.0) {
+color = vec4f(cR.rgb * scale, cR.a);
+} else {
+
+color = vec4f(vec3(0.0), cR.a);
+}
+output.color = color;
+`;
+export const bloomDownDefine = /* wgsl */ `
+fn yo(c: vec3f) -> f32 {
+return max(max(c.r, c.g), c.b);
+}
+`;
+export const bloomDownMain = /* wgsl */ `
+let size = vec2f(colorTexRegion());
+let d = vec4f(-1.0, -1.0, 1.0, 1.0) / size.xyxy;
+
+output.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25
++ sample_colorTex_linearSampler(uv2 + d.zy) * 0.25
++ sample_colorTex_linearSampler(uv2 + d.xw) * 0.25
++ sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;
+`;
+export const bloomBlurDefine = /* wgsl */ `
+const yu = 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 yh = vec2f(colorTexRegion());
+let off = direction / yh * size;
+
+var sum = vec4f(0.0);
+var uI = 0.0;
+for (var i = 0; i < 9; i++) {
+let w = yu[i];
+sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;
+uI += w;
+}
+output.color = sum / max(uI, 0.01);
+`;
+export const bloomBlendMain = /* wgsl */ `
+let yq = sample_colorTex1_linearSampler(uv2);
+let yr = sample_colorTex2_linearSampler(uv2);
+output.color = mix(yq, yr, weight);
+`;
+export const BLOOM_LEVELS = 6;
+export function bloomBlurSize(radius) {
+    return Math.max(Math.min(radius * 2, 1), 0.2);
+}
+export function bloomBlendWeight(radius) {
+    return 1 - Math.max(Math.min(radius ** 0.3 * 0.8, 0.8), 0);
+}
+export function createBloomPlan(levels) {
+    const down = 1, h = down + levels, v = h + levels, blend = v + levels;
+    const input = blend + levels - 1;
+    const steps = [[0, input, input, 0, 0, 0]];
+    for (let i = 0; i < levels; i++) {
+        const source = i === 0 ? 0 : down + i - 1;
+        steps.push([1, source, source, down + i, 0, 0]);
+    }
+    for (let i = levels - 1; i >= 0; i--) {
+        steps.push([2, down + i, down + i, h + i, 1, 0]);
+        steps.push([2, h + i, h + i, v + i, 0, 1]);
+    }
+    for (let i = levels - 2; i >= 0; i--) {
+        steps.push([3, i === levels - 2 ? v + levels - 1 : blend + i + 1, v + i, blend + i, 0, 0]);
+    }
+    return steps;
+}
+export const BLOOM_PLAN = createBloomPlan(BLOOM_LEVELS);
+//# sourceMappingURL=bloom.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.wgsl.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/bloom.wgsl.ts"],"names":[],"mappings":"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","sourcesContent":["// Shared pass bodies; each host supplies texture access and the entry point.\n// Median bright pass adapted from KinoBloom (MIT), Keijiro Takahashi:\n// https://github.com/keijiro/KinoBloom/blob/master/Assets/Kino/Bloom/Shader/Bloom.cginc#L96\n// See THIRD_PARTY_NOTICES.md and LICENSES/KinoBloom-MIT.txt.\nexport const bloomBrightDefine = /* wgsl */ `\nfn median(a: vec4f, b: vec4f, c: vec4f) -> vec4f {\nreturn a + b + c - min(min(a, b), c) - max(max(a, b), c);\n}\n`;\nexport const bloomBrightMain = /* wgsl */ `\n\nlet d = vec3i(1, 1, 0);\n\nvar texel = load_colorTex(uv, 0);\nlet s1 = load_colorTex(uv - d.xz, 0);\nlet s2 = load_colorTex(uv + d.xz, 0);\nlet s3 = load_colorTex(uv - d.zy, 0);\nlet s4 = load_colorTex(uv + d.zy, 0);\ntexel = median(median(texel, s1, s2), s3, s4);\n\n// Premultiplied Alpha\nlet lum = dot(texel.rgb, vec3f(0.2125, 0.7154, 0.0721));\nvar color: vec4f;\nif (lum > threshold && texel.a > 0.0) {\n  color = vec4f(texel.rgb * scale, texel.a);\n} else {\n  // Bleed the alpha to avoid sharp edge when using alpha\n  color = vec4f(vec3(0.0), texel.a);\n}\noutput.color = color;\n`;\nexport const bloomDownDefine = /* wgsl */ `\nfn brightness(c: vec3f) -> f32 {\n  return max(max(c.r, c.g), c.b);\n}\n`;\nexport const bloomDownMain = /* wgsl */ `\nlet size = vec2f(colorTexRegion());\nlet d = vec4f(-1.0, -1.0, 1.0, 1.0) / size.xyxy;\n\noutput.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.zy) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.xw) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;\n`;\nexport const bloomBlurDefine = /* wgsl */ `\nconst kernel = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);\n`;\nexport const bloomBlurMain = /* wgsl */ `\nlet texSize = vec2f(colorTexRegion());\nlet off = direction / texSize * size;\n\nvar sum = vec4f(0.0);\nvar weightAll = 0.0;\nfor (var i = 0; i < 9; i++) {\n  let w = kernel[i];\n  sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;\n  weightAll += w;\n}\noutput.color = sum / max(weightAll, 0.01);\n`;\nexport const bloomBlendMain = /* wgsl */ `\nlet color1 = sample_colorTex1_linearSampler(uv2);\nlet color2 = sample_colorTex2_linearSampler(uv2);\noutput.color = mix(color1, color2, weight);\n`;\n\nexport const BLOOM_LEVELS = 6;\nexport function bloomBlurSize(radius: number): number {\n  return Math.max(Math.min(radius * 2, 1), 0.2);\n}\nexport function bloomBlendWeight(radius: number): number {\n  return 1 - Math.max(Math.min(radius ** 0.3 * 0.8, 0.8), 0);\n}\n\n// Slots: bright, down[], horizontal[], vertical[], blend[], external input.\n// Kind selects bright/down/blur/blend. Hosts only bind their own pass resources.\nexport type BloomStep = readonly [kind: number, a: number, b: number, target: number, dx: number, dy: number];\nexport function createBloomPlan(levels: number): BloomStep[] {\n  const down = 1, h = down + levels, v = h + levels, blend = v + levels;\n  const input = blend + levels - 1;\n  const steps: BloomStep[] = [[0, input, input, 0, 0, 0]];\n  for (let i = 0; i < levels; i++) {\n    const source = i === 0 ? 0 : down + i - 1;\n    steps.push([1, source, source, down + i, 0, 0]);\n  }\n  for (let i = levels - 1; i >= 0; i--) {\n    steps.push([2, down + i, down + i, h + i, 1, 0]);\n    steps.push([2, h + i, h + i, v + i, 0, 1]);\n  }\n  for (let i = levels - 2; i >= 0; i--) {\n    steps.push([3, i === levels - 2 ? v + levels - 1 : blend + i + 1, v + i, blend + i, 0, 0]);\n  }\n  return steps;\n}\nexport const BLOOM_PLAN = createBloomPlan(BLOOM_LEVELS);\n"]}

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): 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,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