@meimu/mutracer 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,927 @@
+import { MAX_PATH_EVENTS } from '../pathLimits.js';
+import shadowCatcherAccumulationWGSL from './chunks/shadowCatcherAccumulation.wgsl.js';
+import depthQueryWGSL from './depthQuery.wgsl.js';
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+import commonWgsl from './chunks/common.wgsl.js';
+import { WGPU_SCENE_FEATURE_BITS } from '../WGPUSceneFeatures.js';
+import rayTraceCoreWgsl from './chunks/rayTraceCore.wgsl.js';
+import { createMaterialBufferWgsl } from './chunks/materialBuffer.wgsl.js';
+import createIntersectionWgsl from './chunks/intersect.wgsl.js';
+import randomWgsl from './chunks/random.wgsl.js';
+import randWgsl from './chunks/rand.wgsl.js';
+import { createSampleMaterialWgsl } from './chunks/sampleMaterial.wgsl.js';
+import sampleLightWgsl from './chunks/sampleLight.wgsl.js';
+import { createOpenPbrBsdfWgsl } from './chunks/openPbrBsdf.wgsl.js';
+import samplingWgsl from './chunks/sampling.wgsl.js';
+import sampleShadowCatcherWgsl from './chunks/sampleShadowCatcher.wgsl.js';
+import envMapWgsl from './chunks/envMap.wgsl.js';
+import uvProjectionWgsl from './chunks/uvProjection.wgsl.js';
+export const WORKGROUP_SIZE = 8;
+/** Generates the WebGPU megakernel path tracing compute shader. */
+export default function rayTraceCompute({ hasDisplacement, hasAnisotropyDirections = false, hasCoatNormals = false, hasAlpha = true, hasSceneAlpha = true, blasLayoutMask = 1 }) {
+    hasAnisotropyDirections ||= hasCoatNormals;
+    const deterministicPrimaryAlpha = hasAlpha;
+    const source = /* wgsl */ `
+
+${commonWgsl}
+
+${rayTraceCoreWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}
+
+${uvProjectionWgsl}
+
+${createMaterialBufferWgsl({ hasSceneAlpha, hasAnisotropyDirections, hasCoatNormals })}
+
+${createIntersectionWgsl({ hasDisplacement, blasLayoutMask, hasAnisotropyDirections, hasCoatNormals })}
+${randWgsl}
+${randomWgsl}
+${envMapWgsl}
+
+${samplingWgsl}
+${createOpenPbrBsdfWgsl(hasAnisotropyDirections, hasCoatNormals)}
+${sampleLightWgsl}
+
+
+var<private> tw: u32 = 0u;
+
+
+
+fn jO() -> u32 {
+return u32(max(rtUniform.directLightCandidates, 1));
+}
+
+
+
+
+fn po(wy: u32) -> f32 {
+
+
+
+
+if (SAMPLING_PATTERN == 2) { _ = rand(); }
+let jU = bc.x + bc.y * u32(rtUniform.outputSize.x);
+let key = aq(aq(jU, bd), rtUniform.sequenceSeed);
+let dimension = aq(cE, wy) ^ 0xa511e9b3u;
+return f32(eg(key ^ dimension) >> 8u) * (1.0 / 16777216.0);
+}
+
+
+
+fn tk(fd: f32, scatteringPdf: f32) -> f32 {
+let aW = jO();
+if (aW <= 1u) {
+return aF(fd, scatteringPdf);
+}
+let iE = f32(aW) * fd;
+return iE /
+max(iE + scatteringPdf, 1e-20);
+}
+
+
+fn fS(scatteringPdf: f32, fd: f32) -> f32 {
+let aW = jO();
+if (aW <= 1u) {
+return aF(scatteringPdf, fd);
+}
+let iE = f32(aW) * fd;
+return scatteringPdf /
+max(scatteringPdf + iE, 1e-20);
+}
+
+${createSampleMaterialWgsl(hasAnisotropyDirections, hasCoatNormals)}
+${sampleShadowCatcherWgsl}
+
+
+@group(3) @binding(0) var<storage, read_write> outColor: array<vec4f>;
+@group(3) @binding(1) var<storage, read_write> outNormal: array<vec4f>;
+@group(3) @binding(2) var<storage, read_write> outAlbedo: array<vec4f>;
+
+${shadowCatcherAccumulationWGSL}
+@group(3) @binding(3) var<storage, read_write> outShadowCatcher: array<ShadowCatcherAccumulation>;
+
+
+fn hH(
+gZ: u32,
+vh: vec3f,
+normal: vec3f
+) {
+if (rtUniform.varianceMoments != 0) {
+let value = dot(vh, luminance);
+outNormal[gZ] += vec4f(value * value, 0.0, 0.0, 1.0);
+}
+else {
+outNormal[gZ] += vec4f(normal, 1.0);
+}
+}
+
+
+
+fn iM(gZ: u32, value: f32) {
+outShadowCatcher[gZ].moments += vec4f(value, value * value, 0.0, 0.0);
+}
+
+
+struct RayTraceAuxiliary {
+
+albedo: vec3f,
+isShadowCatcher: bool,
+normal: vec3f,
+isBlank: bool,
+}
+
+fn dq(sA: vec3f, height: f32, radius: f32) -> f32 {
+let fN = length(sA);
+if (fN < 0.00001) {
+return -radius;
+}
+
+let iC = radius * sA.y / fN;
+let ik = -1.5 * height;
+var ev: f32;
+if (iC >= 0.0) {
+ev = radius;
+}
+else if (iC < ik) {
+ev = -height * fN / sA.y;
+}
+else {
+let dW = 1.0
+- iC * iC / (3.0 * ik * ik);
+ev = radius * dW;
+}
+return fN - ev;
+}
+
+fn eQ(origin: vec3f, direction: vec3f) -> vec3f {
+if (!USE_GROUNDED_BACKGROUND) {
+return direction;
+}
+let params = rtUniform.groundedBackgroundParams;
+let bY = normalize(direction);
+let center = vec3f(
+rtUniform.groundedBackgroundCenter.x,
+params.z + params.x,
+rtUniform.groundedBackgroundCenter.y
+);
+let bB = origin - center;
+let eI = dot(bB, bY);
+let ej = eI * eI
+- dot(bB, bB) + params.y * params.y;
+if (
+ej <= 0.0
+|| dq(bB, params.x, params.y) > 0.0
+) {
+return direction;
+}
+
+var cB = -eI + sqrt(ej);
+if (cB <= 0.0) {
+return direction;
+}
+
+let nB = bB + bY * cB;
+if (nB.y >= 0.0) {
+return normalize(nB);
+}
+
+if (bY.y < -0.00001 && params.y > 1.5 * params.x) {
+let hQ = (-params.x - bB.y) / bY.y;
+let nk = bB + bY * hQ;
+let nZ = (2.0 / 3.0)
+* sqrt(params.y * params.y - 2.25 * params.x * params.x);
+if (hQ > 0.0 && length(nk.xz) <= nZ) {
+return normalize(nk);
+}
+}
+
+var cN = 0.0;
+for (var i = 0; i < 14; i++) {
+let fe = (cN + cB) * 0.5;
+let pp = bB + bY * fe;
+if (dq(pp, params.x, params.y) > 0.0) {
+cB = fe;
+}
+else {
+cN = fe;
+}
+}
+let hit = bB + bY * ((cN + cB) * 0.5);
+return normalize(hit);
+}
+
+fn hE(ray: Ray) -> vec4f {
+var bg = vec4f(0.0);
+if (USE_BACKGROUND_MAP) {
+let pP = eQ(ray.o, ray.d);
+bg = textureLinear(backgroundMap, aS(pP));
+}
+else if (USE_BACKGROUND) {
+bg = rtUniform.backgroundColor;
+}
+else if (USE_ENVMAP) {
+bg = textureLinear(envMap, aS(ray.d));
+}
+return bg;
+}
+
+fn cW(ray: Ray, wavelength: f32) -> vec4f {
+let bg = hE(ray);
+if (SPECTRAL) {
+return vec4f(ai(bg.rgb, wavelength), bg.a);
+}
+return bg;
+}
+
+fn bounce(uv: vec2f, aa: ptr<function, Path>, depth: ptr<function, i32>, si: ptr<function, ad>, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) {
+cE = u32(max(*depth, 0));
+let matType = (*ma).materialType;
+let isShadowCatcher = matType == SHADOW_CATCHER;
+if (isShadowCatcher) {
+if ((*aa).fromEye) {
+(*si).hit = false;
+}
+else {
+
+
+
+if (USE_ENVMAP) {
+if ((*aa).isNextRefraction) {
+
+
+let bg = cW(
+(*aa).ray,
+(*si).wavelength
+);
+let cT = select(fS((*aa).scatteringPdf,
+iv(aS((*aa).ray.d)) * rtUniform.envLightPmf),
+1.0, (*aa).scatteringIsDelta);
+(*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
+(*aa).alpha = max((*aa).alpha, bg.a);
+}
+else {
+let tE = aS((*aa).ray.d);
+var emission = textureLinear(envMap, tE).rgb;
+if (SPECTRAL) {
+emission = ai(emission, (*si).wavelength);
+}
+(*aa).li += (*aa).beta * emission *
+fS((*aa).scatteringPdf, iv(tE));
+}
+}
+else {
+let bg = cW(
+(*aa).ray,
+(*si).wavelength
+);
+(*aa).li += (*aa).beta * bg.rgb * bg.a;
+}
+(*aa).abort = true;
+return;
+}
+}
+if (!(*si).hit) {
+
+
+
+let bg = cW(
+(*aa).ray,
+(*si).wavelength
+);
+if ((*aa).fromEye) {
+
+(*aa).li = (*aa).beta * bg.rgb * bg.a;
+(*aa).alpha = bg.a;
+
+(*outAux).isBlank = bg.a < 0.001 ||
+(USE_BACKGROUND && !USE_BACKGROUND_MAP);
+}
+else {
+let cam = hz(uv);
+let mz = dot(cam.d, (*aa).ray.d) > 0.0;
+if (rtUniform.transmissiveOutputAlphaMin < 1.0) {
+if (mz) {
+(*aa).alpha = max((*aa).alpha, bg.a);
+} else {
+(*aa).alpha = 1.0;
+}
+}
+if (!USE_ENVMAP) {
+
+
+if (mz) {
+
+
+(*aa).li += (*aa).beta *
+fS((*aa).scatteringPdf, 1.0) * bg.rgb;
+}
+}
+}
+(*aa).abort = true;
+return;
+}
+
+var cG = false;
+if ((matType == STANDARD || matType == UNLIT)) {
+let alpha = clamp((*ma).alpha, 0.0, 1.0);
+
+if (alpha < 1.0) {
+
+
+if (alpha <= 0.0 || eo(3u) > alpha) {
+cG = true;
+}
+}
+if (!cG && rtUniform.transmissiveOutputAlphaMin < 1.0) {
+
+
+let tK = max(1.0 - (*ma).transmissionWeight, 1.0 - pow(1.0 - rtUniform.transmissiveOutputAlphaMin, f32(*depth)));
+(*aa).alpha = max(tK, (*aa).alpha);
+}
+if (!cG) {
+tw = u32(max(*depth, 0));
+lO(si, ma, aa);
+}
+else {
+
+
+(*aa).ray.o = (*si).position + (*aa).ray.d * EPS;
+}
+}
+
+if (!(*si).albedoSampled && !cG) {
+
+if ((matType == STANDARD || matType == UNLIT)) {
+if (!((*ma).transmissionWeight > 0.5 ||
+((*ma).specularRoughness <= 0.02 && (*ma).baseMetalness > 0.98))) {
+(*outAux).albedo = (*ma).baseColor;
+(*outAux).normal = select(
+(*si).normal,
+-(*si).normal,
+dot(
+(*si).normal,
+(*si).position - cameraUniform.viewInv[3].xyz
+) > 0.0
+);
+(*si).albedoSampled = true;
+}
+
+if (*depth > 4) {
+(*si).albedoSampled = true;
+}
+}
+}
+
+
+if (USE_RR) {
+if (*depth >= RR_MAX && !cG) {
+let ow = (*aa).beta;
+
+let oj = max(max(ow.x, ow.y), ow.z);
+let q: f32 = max(0.0, 1.0 - oj);
+if (dz(cv(RUSSIAN_ROULETTE)) < q) {
+
+
+(*aa).alpha = 1.0;
+(*aa).abort = true;
+}
+else {
+(*aa).beta /= 1.0 - q;
+}
+}
+}
+if ((*aa).abort) {
+return;
+}
+
+cY((*aa).ray, si, *depth, true, (*aa).isNextRefraction);
+eT(ma, (*si).materialIndex, (*si).uv, (*si).uv1, (*si).instanceIndex);
+
+if (SPECTRAL) {
+
+if ((*ma).transmissionWeight > 0.001) {
+(*ma).specularIor = eK(
+(*si).wavelength,
+(*ma).specularIor,
+(*ma).transmissionDispersionScale,
+(*ma).dispersionAbbeNumber
+);
+}
+}
+
+if (cG) {
+return;
+}
+
+
+var lightSample: LightSampleRec;
+let hu = eo(3u) < (*ma).alpha;
+for (var i = 0; i < rtUniform.lightsCount; i++) {
+
+let light: Light = analyticLights[i];
+let d = mk((*aa).ray, light, &lightSample);
+lightSample.pdf *= light.selectionPmf;
+let mp = (*si).hit && d > distance((*si).position, (*aa).ray.o);
+if (d != INF && !(mp && hu)) {
+let eW = fS((*aa).scatteringPdf, lightSample.pdf);
+if (SPECTRAL) {
+lightSample.emission = ai(lightSample.emission, (*si).wavelength);
+}
+(*aa).li += eW * (*aa).beta * lightSample.emission;
+(*aa).alpha = 1.0;
+(*aa).abort = true;
+}
+}
+
+if (USE_ENVMAP) {
+if (!((*si).hit && hu)) {
+if ((*aa).isNextRefraction) {
+
+
+
+let bg = cW(
+(*aa).ray,
+(*si).wavelength
+);
+let cT = select(fS((*aa).scatteringPdf,
+iv(aS((*aa).ray.d)) * rtUniform.envLightPmf),
+1.0, (*aa).scatteringIsDelta);
+(*aa).li += cT * (*aa).beta * bg.rgb * bg.a;
+(*aa).alpha = max((*aa).alpha, bg.a);
+(*aa).abort = true;
+return;
+}
+let _uv = aS((*aa).ray.d);
+var emission = textureLinear(envMap, _uv).rgb;
+let eW = fS(
+(*aa).scatteringPdf,
+iv(_uv) * rtUniform.envLightPmf
+);
+if (SPECTRAL) {
+emission = ai(emission, (*si).wavelength);
+}
+
+if (!USE_BACKGROUND) {
+(*aa).alpha = 1.0;
+}
+(*aa).li += (*aa).beta * emission * eW;
+(*aa).abort = true;
+}
+}
+
+*depth = *depth + 1;
+}
+
+fn hz(fD: vec2f) -> Ray {
+let origin = cameraUniform.viewProjectionInv * vec4f(fD * 2.0 - 1.0, -1.0, 1.0);
+let center = cameraUniform.viewProjectionInv * vec4f(fD * 2.0 - 1.0, 1.0, 1.0);
+var cam: Ray;
+iw(&cam, origin.xyz / origin.w, normalize(center.xyz * origin.w - origin.xyz * center.w));
+
+return cam;
+}
+
+
+fn kn(radius: f32, xi: f32) -> vec2f {
+var x = 0.25;
+for (var np = 0; np < 10; np++) {
+let x2 = x * x;
+let x3 = x2 * x;
+let kD = 1.0 - x;
+let value = 10.0 * x2 - 20.0 * x3 + 15.0 * x2 * x2 -
+4.0 * x2 * x3 - xi;
+let lV = 20.0 * x * kD * kD * kD;
+if (abs(value) < 1e-6 || lV == 0.0) { break; }
+x = clamp(x - value / lV, 0.0, 1.0);
+}
+let jh = x * radius;
+return vec2f(jh, sqrt(max(radius * radius - jh * jh, 0.0)));
+}
+
+fn iN(radius: f32, gr: f32) -> f32 {
+if (gr >= radius) { return 0.0; }
+let nS = radius - gr;
+return nS * nS * nS;
+}
+
+
+fn mf(source: ad, radius: f32) -> vec3f {
+var geometricNormal = source.faceNormal;
+if (dot(geometricNormal, source.vertexNormal) < 0.0) {
+geometricNormal = -geometricNormal;
+}
+var tangent: vec3f;
+var bitangent: vec3f;
+aK(geometricNormal, &tangent, &bitangent);
+var iB = vec3f(0.0);
+
+for (var ib = 0; ib < BEVEL_SAMPLES; ib++) {
+let oU = fk(CAMERA_BEVEL_BASE + u32(ib));
+var cz = oU.x;
+let ou = oU.y;
+var di = geometricNormal;
+var fE = tangent;
+var ek = bitangent;
+var fZ = 0.5;
+var hV = 0.25;
+var gy = 0.25;
+if (cz < 0.5) {
+cz *= 2.0;
+}
+else if (cz < 0.75) {
+let mx = di;
+di = fE;
+fE = mx;
+fZ = 0.25;
+hV = 0.5;
+cz = (cz - 0.5) * 4.0;
+}
+else {
+let mx = di;
+di = ek;
+ek = mx;
+fZ = 0.25;
+gy = 0.5;
+cz = (cz - 0.75) * 4.0;
+}
+
+let gO = kn(radius, ou);
+let phi = TWOPI * cz;
+let qj = gO.x *
+(cos(phi) * fE + sin(phi) * ek);
+var ray: Ray;
+iw(
+&ray,
+source.position + di * gO.y + qj,
+-di
+);
+var hit: ad;
+iG(
+ray,
+&hit,
+source.instanceIndex,
+max(2.0 * gO.y, EPS)
+);
+if (!hit.hit) { continue; }
+
+let kE = fZ * abs(dot(di, hit.faceNormal));
+let mt = hV * abs(dot(fE, hit.faceNormal));
+let jS = gy * abs(dot(ek, hit.faceNormal));
+var weight = kE / max(
+kE * kE + mt * mt +
+jS * jS,
+1e-8
+);
+weight *= iN(radius, distance(hit.position, source.position)) /
+max(iN(radius, gO.x), 1e-8);
+iB += weight * hit.vertexNormal;
+}
+
+if (dot(iB, iB) <= 1e-12) { return source.normal; }
+let jA = normalize(iB);
+let result = source.normal + jA - source.vertexNormal;
+if (dot(result, result) > 1e-12) { return normalize(result); }
+return source.normal;
+}
+
+fn bw(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+var aa: Path;
+aa.ray = ray;
+aa.li = vec3f(0.0);
+aa.alpha = select(1.0, 0.0, rtUniform.transmissiveOutputAlphaMin < 1.0);
+aa.beta = vec3f(1.0);
+aa.fromEye = true;
+aa.scatteringPdf = 0.0;
+aa.scatteringIsDelta = false;
+aa.isNextRefraction = false;
+aa.abort = false;
+
+let rt = (*ma).transmissionWeight < 0.001 && (*ma).subsurfaceWeight < 0.001 && (*ma).alpha > 0.99;
+let bounceLimit = max(rtUniform.bounces, 0);
+var depth = 0;
+
+for (var idx: i32 = 0; idx < min(bounceLimit * 3, ${MAX_PATH_EVENTS}); idx = idx + 1) {
+if (rt && idx > bounceLimit) {
+aa.abort = true;
+}
+if (aa.abort) {
+break;
+}
+bounce(uv, &aa, &depth, si, ma, outAux);
+}
+
+return vec4f(aa.li, aa.alpha);
+}
+
+fn iz(uv: vec2f, si: ptr<function, ad>, ray: Ray, ma: ptr<function, J>, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+${deterministicPrimaryAlpha ? /* wgsl */ `let coverage = clamp((*ma).alpha, 0.0, 1.0);
+if (!(*si).hit || ((*ma).materialType != STANDARD && (*ma).materialType != UNLIT) || coverage >= 1.0) {
+return bw(uv, si, ray, ma, outAux);
+}
+
+
+
+
+
+var nK = ray;
+nK.o = (*si).position + ray.d * (EPS * 0.02);
+var dU = *si;
+dU.albedoSampled = false;
+cY(nK, &dU, 0, false, false);
+var rd: J;
+eT(&rd, dU.materialIndex, dU.uv, dU.uv1, dU.instanceIndex);
+var gg = *outAux;
+if (dU.hit && rd.materialType == STANDARD) {
+gg.albedo = select(
+rd.baseColor,
+vec3f(1.0),
+rd.transmissionWeight > 0.5
+);
+gg.normal = select(
+dU.normal,
+-dU.normal,
+dot(
+dU.normal,
+dU.position - cameraUniform.viewInv[3].xyz
+) > 0.0
+);
+dU.albedoSampled = rd.transmissionWeight > 0.5;
+}
+let back = bw(
+uv, &dU, nK, &rd, &gg
+);
+if (coverage <= 0.0) {
+*outAux = gg;
+return back;
+}
+
+var te = *si;
+var ut = *ma;
+ut.alpha = 1.0;
+var iQ = *outAux;
+let qL = bw(
+uv, &te, ray, &ut, &iQ
+);
+(*outAux).albedo = mix(gg.albedo, iQ.albedo, coverage);
+let fR = mix(gg.normal, iQ.normal, coverage);
+(*outAux).normal = select(
+vec3f(0.0),
+normalize(fR),
+dot(fR, fR) > 1e-12
+);
+(*outAux).isBlank = gg.isBlank && iQ.isBlank;
+(*outAux).isShadowCatcher = gg.isShadowCatcher && iQ.isShadowCatcher;
+return mix(back, qL, coverage);` : /* wgsl */ `return bw(uv, si, ray, ma, outAux);`}
+}
+
+
+
+fn mj(uv: vec2f, ray: Ray, outAux: ptr<function, RayTraceAuxiliary>) -> vec4f {
+var si: ad;
+var ma: J;
+si.albedoSampled = false;
+si.mediumType = 0;
+si.mediumExtinction = vec3f(0.0);
+si.mediumScattering = vec3f(0.0);
+si.mediumAnisotropy = 0.0;
+si.barycentrics = vec2f(0.0);
+
+
+cY(ray, &si, 0, false, false);
+eT(&ma, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+
+if (ma.materialType == SHADOW_CATCHER) {
+(*outAux).isShadowCatcher = true;
+
+
+(*outAux).albedo = vec3f(1.0);
+(*outAux).normal = select(si.normal, -si.normal, dot(si.normal, ray.d) > 0.0);
+var aa: Path;
+aa.ray = ray;
+aa.fromEye = true;
+sampleShadowCatcher(si, 0, &aa);
+
+
+
+return vec4f(vec3f(1.0), aa.alpha);
+}
+else {
+if (HAS_BEVEL && rtUniform.bevel != 0) {
+if (ma.bevel > 0.0) {
+si.normal = mf(si, ma.bevel);
+}
+}
+
+
+
+if (si.hit && (ma.materialType == STANDARD || ma.materialType == UNLIT)) {
+(*outAux).albedo = select(ma.baseColor, vec3f(1.0), ma.transmissionWeight > 0.5);
+(*outAux).normal = select(
+si.normal,
+-si.normal,
+dot(si.normal, si.position - cameraUniform.viewInv[3].xyz) > 0.0
+);
+
+
+
+si.albedoSampled = ma.transmissionWeight > 0.5;
+}
+
+(*outAux).isShadowCatcher = false;
+
+if (SPECTRAL) {
+
+
+
+
+let sD = array<f32, 3>(650.0, 510.0, 475.0);
+var tC = vec3f(0.0);
+var alpha = 0.0;
+var jw = vec3f(0.0);
+var jx = vec3f(0.0);
+var rS = true;
+var si2 = si;
+var ma2 = ma;
+let qz = s0;
+let nG = em;
+let eh = rtUniform.dispersionWavelengths == 1;
+let jF = si.hit &&
+ma.transmissionWeight > 0.001 &&
+ma.transmissionDispersionScale > 0.001;
+let rR = select(3, 1, eh);
+var lC = 0;
+if (eh && jF) {
+
+
+lC = min(i32(floor(dz(CAMERA_WAVELENGTH) * 3.0)), 2);
+}
+for (var i = 0; i < rR; i++) {
+
+
+
+if (!eh) {
+s0 = qz;
+em = nG;
+cE = 0u;
+}
+si.wavelength = 0.0;
+if (!eh || jF) {
+si.wavelength = sD[select(i, lC, eh)];
+ma.specularIor = eK(
+si.wavelength,
+ma.specularIor,
+ma.transmissionDispersionScale,
+ma.dispersionAbbeNumber
+);
+}
+var dD: RayTraceAuxiliary;
+if (eh) {
+dD = *outAux;
+} else {
+dD.albedo = (*outAux).albedo;
+dD.normal = (*outAux).normal;
+dD.isBlank = false;
+dD.isShadowCatcher = false;
+}
+let res = iz(uv, &si, ray, &ma, &dD);
+if (eh) {
+*outAux = dD;
+let scale = select(1.0, 3.0, jF);
+return vec4f(res.rgb * scale, res.a);
+}
+tC += res.rgb;
+alpha = max(alpha, res.a);
+jw += dD.albedo;
+jx += dD.normal;
+rS = rS && dD.isBlank;
+si = si2;
+ma = ma2;
+}
+(*outAux).albedo = jw / 3.0;
+(*outAux).normal = jx / 3.0;
+(*outAux).isBlank = rS;
+return vec4f(tC, alpha);
+}
+else {
+return iz(uv, &si, ray, &ma, outAux);
+}
+}
+}
+
+fn oz(ip: vec2f) -> vec2f {
+let p = 2.0 * ip - 1.0;
+let greater = abs(p.x) > abs(p.y);
+let r = select(p.y, p.x, greater);
+let theta = select(PI * (0.5 - 0.25 * p.x / p.y), 0.25 * PI * p.y / p.x, greater);
+return r * vec2f(cos(theta), sin(theta));
+}
+
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) globalId: vec3u) {
+let outputSize = rtUniform.outputSize;
+let scaleOffset = rtUniform.scaleOffset;
+var jitter = rtUniform.jitter;
+
+let fD = globalId.xy * vec2u(scaleOffset.xy) + vec2u(scaleOffset.zw);
+if (fD.x >= u32(outputSize.x) || fD.y >= u32(outputSize.y)) {
+return;
+}
+let idx = fD.x + fD.y * u32(outputSize.x);
+
+if (
+rtUniform.adaptiveSampling != 0 &&
+outNormal[idx].a >= textureLoad(
+adaptiveSampleTargets,
+vec2i(fD),
+0
+).r
+) {
+return;
+}
+
+
+
+
+let uv = (vec2<f32>(f32(fD.x), f32(fD.y)) + vec2f(0.5)) / outputSize;
+
+bc = fD;
+bd = u32(outNormal[idx].a) + rtUniform.sampleSequenceOffset;
+cE = 0u; em = 0u;
+if (SAMPLING_PATTERN == 0 || SAMPLING_PATTERN == 1) {
+jitter = (fk(CAMERA_PIXEL) - 0.5) / outputSize;
+}
+jY(fD, i32(bd ^ eg(rtUniform.sequenceSeed)));
+var cam = hz(uv + jitter);
+
+if (cameraUniform.apertureRadius > 0.0) {
+
+let eye = cameraUniform.viewInv[3].xyz;
+let nV = -normalize(cameraUniform.viewInv[2].xyz);
+let qm = eye + cam.d * (cameraUniform.focusDistance / dot(cam.d, nV));
+let ru = cameraUniform.apertureRadius * oz(fk(CAMERA_LENS));
+let origin = (cameraUniform.viewInv * vec4f(ru, 0.0, 1.0)).xyz;
+let dir = normalize(qm - origin);
+iw(&cam, origin, dir);
+}
+
+var outAux: RayTraceAuxiliary;
+outAux.albedo = vec3f(0.0);
+outAux.normal = vec3f(0.0);
+outAux.isBlank = false;
+outAux.isShadowCatcher = false;
+var aN = mj(uv + jitter, cam, &outAux);
+
+
+
+if (rtUniform.clamping > 0.0) {
+let clamping = rtUniform.clamping;
+aN = vec4(clamp(aN.rgb, -vec3f(clamping), vec3f(clamping)), aN.a);
+}
+if (!(aN.x < INF && aN.x > -EPS)) {
+aN = vec4f(0.0, 0.0, 0.0, 1.0);
+}
+
+if (outAux.isShadowCatcher) {
+
+
+let dn = hE(cam);
+let pU = select(0.0, 1.0, dn.a >= 0.01);
+let jo = vec4f(dn.rgb * dn.a, dn.a);
+
+
+outShadowCatcher[idx].mask += vec4f(1.0, dn.a, pU, aN.a);
+outShadowCatcher[idx].background += jo;
+outColor[idx] += jo;
+outAlbedo[idx] += vec4f(outAux.albedo, pU);
+hH(idx, dn.rgb, outAux.normal);
+
+
+let visibility = 1.0 - aN.a;
+iM(idx, visibility * select(
+1.0, dot(dn.rgb, luminance), dn.a >= 0.01
+));
+}
+else {
+outColor[idx] += aN;
+outAlbedo[idx] += vec4f(outAux.albedo, select(1.0, 0.0, outAux.isBlank));
+hH(idx, aN.rgb, outAux.normal);
+iM(idx, dot(aN.rgb, luminance));
+}
+}
+`;
+    // The query entry point shares the exact BVH and material implementation.
+    // It has no effect on the beauty entry point or its bindings.
+    // Gate optional material layers on scene-level feature flags so drivers can
+    // skip the unused BSDF lobes.
+    let specializedSource = source + depthQueryWGSL;
+    const backgroundBits = {
+        USE_BACKGROUND: 1,
+        USE_BACKGROUND_MAP: 2,
+        USE_GROUNDED_BACKGROUND: 4
+    };
+    specializedSource = specializedSource.replace(/\b(?:USE_BACKGROUND|USE_BACKGROUND_MAP|USE_GROUNDED_BACKGROUND)\b/g, (name) => `((rtUniform.backgroundFlags & ${backgroundBits[name]}) != 0)`);
+    specializedSource = specializedSource.replace(new RegExp(`\\b(?:${Object.keys(WGPU_SCENE_FEATURE_BITS).join('|')})\\b`, 'g'), name => `((rtUniform.sceneFeatureFlags & ${WGPU_SCENE_FEATURE_BITS[name]}u) != 0u)`);
+    return specializedSource;
+}
+//# sourceMappingURL=rayTrace.compute.js.map