@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/wgsl/chunks/intersect.wgsl.js

@@ -1,42 +1,42 @@
 // 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 { uvProjectionConstants } from '../../MaterialTable.js';
+import { uvProjectionConstants } from '../../materialConstants.js';
 import { INSTANCE_VEC4_STRIDE } from '../../bvhAccel.js';
 import pdm_displacementWgsl from './pdm_displacement.wgsl.js';
 import { createIntersectionAlphaWgsl } from './intersectionAlpha.wgsl.js';
 const displacementWgsl = pdm_displacementWgsl;
 const flatIntersectCode = function () {
     return /* wgsl */ `
-let hit = fM(o, d, tri, ey, gQ, tMax);
+let hit = fM(o, d, tri, dZ, gH, tMax);
 if (hit.t > 0.0) {
 let e1 = tri.p1 - tri.p0;
 let e2 = tri.p2 - tri.p0;
-eD = normalize(cross(e1, e2));
-let kk = i32(ae(bitcast<i32>(ot.z)).x);
-let iN = materialsBuffer[kk].doubleSided > 0.5;
-if (!doubleSided && !iN && dot(eD, d) > 0.0) {
-eD = vec3f(0.0);
+ex = normalize(cross(e1, e2));
+let ku = i32(af(bitcast<i32>(oX.z)).x);
+let iL = materialsBuffer[ku].doubleSided > 0.5;
+if (!doubleSided && !iL && dot(ex, d) > 0.0) {
+ex = vec3f(0.0);
 continue;
 }
 
 tMax = hit.t;
-rb = true;
-ow = true;
-eY = o + tMax * d;
-aB = hit.barycentric;
+sd = true;
+pa = true;
+eS = o + tMax * d;
+aw = hit.barycentric;
 }
 `;
 };
 function getPDMDisplacmentCode(anyHit) {
     return /*wgsl */ `
-let kX = pc(
+let ll = pS(
 o, d, tMax,
 tri.p0, tri.p1, tri.p2,
 n0, n1, n2,
 uv0, uv1, uv2,
 displacementMapIndex,
-kJ(displacementMapIndex),
+jv(displacementMapIndex),
 minH, maxH,
 hScale,
 matData.displacementBias,
@@ -44,17 +44,17 @@ matData.displacementStepSize,
 i32(matData.displacementUvProjection),
 displacementUvProjectionScale,
 ${anyHit ? 'true' : 'false'},
-lC
+jg
 );
 `;
 }
 const displacementIntersectCode = function (anyHit, hasAnisotropyDirections) {
     return /* wgsl */ `
 
-let hScale = ot.w;
-let tA = bitcast<i32>(r3.w);
+let hScale = oX.w;
+let uW = bitcast<i32>(r3.w);
 
-let materialIndex = i32(ae(bitcast<i32>(ot.z)).x);
+let materialIndex = i32(af(bitcast<i32>(oX.z)).x);
 let matData = materialsBuffer[materialIndex];
 let n0 = normalize(attrBuffers[index.x * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
 let n1 = normalize(attrBuffers[index.y * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
@@ -64,9 +64,9 @@ tri.p0 += n0 * matData.displacementBias;
 tri.p1 += n1 * matData.displacementBias;
 tri.p2 += n2 * matData.displacementBias;
 }
-if (abs(hScale) > 0.0 && tA > 0) {
-let minH = f32(tA >> 8) / 255.0;
-let maxH = f32(tA & 0xff) / 255.0;
+if (abs(hScale) > 0.0 && uW > 0) {
+let minH = f32(uW >> 8) / 255.0;
+let maxH = f32(uW & 0xff) / 255.0;
 let displacementUvProjectionScale = vec2f(matData.displacementUvProjectionScale);
 let displacementMapIndex = i32(matData.displacementMapIndex);
 
@@ -77,18 +77,18 @@ var uv2 = attrBuffers[index.z * ATTR_STRIDE + UV_OFF].xy;
 
 ${getPDMDisplacmentCode(anyHit)}
 
-if (kX.t < tMax) {
-eD = kX.normal;
+if (ll.t < tMax) {
+ex = ll.normal;
 
 
-tMax = kX.t;
+tMax = ll.t;
 
-aB = kX.barycentric;
-eY = o + tMax * d;
+aw = ll.barycentric;
+eS = o + tMax * d;
 
-bU = true;
-rb = true;
-ow = true;
+bP = true;
+sd = true;
+pa = true;
 }
 }
 else {
@@ -97,7 +97,7 @@ ${flatIntersectCode()}
 `;
 };
 const cwbvhTraversalWgsl = /* wgsl */ `
-fn bp(value: u32) -> vec4f {
+fn bm(value: u32) -> vec4f {
 return vec4f(
 f32(value & 0xffu),
 f32((value >> 8u) & 0xffu),
@@ -112,118 +112,118 @@ f32(value >> 24u)
 
 
 
-fn kx(value: u32) -> u32 {
+fn kI(value: u32) -> u32 {
 return (bitcast<u32>(f32(value)) >> 23u) - 127u;
 }
 
-fn nY(value: u32) -> u32 {
+fn oJ(value: u32) -> u32 {
 return (bitcast<u32>(f32(value)) >> 23u) - 127u;
 }
 
-fn ou(
+fn oY(
 node: i32,
-tk: i32,
+uN: i32,
 n0: vec4f,
 o: vec3f,
-gE: vec3f,
+gb: vec3f,
 tMax: f32
 ) -> u32 {
-let i = node + tk;
+let i = node + uN;
 let n2 = bvhBuffer[i + 2];
 let n3 = bvhBuffer[i + 3];
 let n4 = bvhBuffer[i + 4];
 let header = bitcast<u32>(n0.w);
-let rG = bitcast<i32>((header & 0xffu) << 24u) >> 24;
-let rH = bitcast<i32>(((header >> 8u) & 0xffu) << 24u) >> 24;
-let rI = bitcast<i32>(((header >> 16u) & 0xffu) << 24u) >> 24;
-let hJ = vec3f(
-bitcast<f32>(u32(rG + 127) << 23u),
-bitcast<f32>(u32(rH + 127) << 23u),
-bitcast<f32>(u32(rI + 127) << 23u)
+let sD = bitcast<i32>((header & 0xffu) << 24u) >> 24;
+let sE = bitcast<i32>(((header >> 8u) & 0xffu) << 24u) >> 24;
+let sF = bitcast<i32>(((header >> 16u) & 0xffu) << 24u) >> 24;
+let hG = vec3f(
+bitcast<f32>(u32(sD + 127) << 23u),
+bitcast<f32>(u32(sE + 127) << 23u),
+bitcast<f32>(u32(sF + 127) << 23u)
 );
-let bJ = eZ(gE, o);
-let eI = (n0.xyz - o) * gE;
-let dc = hJ * gE;
-let wy = bp(bitcast<u32>(n2.x));
-let wB = bp(bitcast<u32>(n2.y));
-let wC = bp(bitcast<u32>(n2.z));
-let wE = bp(bitcast<u32>(n2.w));
-let wF = bp(bitcast<u32>(n3.x));
-let wG = bp(bitcast<u32>(n3.y));
-let ws = bp(bitcast<u32>(n3.z));
-let wt = bp(bitcast<u32>(n3.w));
-let wu = bp(bitcast<u32>(n4.x));
-let wv = bp(bitcast<u32>(n4.y));
-let ww = bp(bitcast<u32>(n4.z));
-let wx = bp(bitcast<u32>(n4.w));
-
-let vp = wy * dc.x + eI.x;
-let vs = wC * dc.y + eI.y;
-let vu = wF * dc.z + eI.z;
-let vj = ws * dc.x + eI.x;
-let vl = wu * dc.y + eI.y;
-let vn = ww * dc.z + eI.z;
-let wI = max(
-max((min(vp, vj) - vec4f(bJ.x)), (min(vs, vl) - vec4f(bJ.y))),
-(min(vu, vn) - vec4f(bJ.z))
+let padding = eU(gb, o);
+let eD = (n0.xyz - o) * gb;
+let cV = hG * gb;
+
+
+
+let vm = bitcast<vec4u>(n2);
+let vn = bitcast<vec4u>(n3);
+let vo = bitcast<vec4u>(n4);
+let negative = gb < vec3f(0.0);
+let wK = select(vm.xy, vn.zw, negative.x);
+let xX = select(vn.zw, vm.xy, negative.x);
+let wL = select(vm.zw, vo.xy, negative.y);
+let xY = select(vo.xy, vm.zw, negative.y);
+let wM = select(vn.xy, vo.zw, negative.z);
+let xZ = select(vo.zw, vn.xy, negative.z);
+
+let yL = max(
+max(
+bm(wK.x) * cV.x + eD.x - vec4f(padding.x),
+bm(wL.x) * cV.y + eD.y - vec4f(padding.y)
+),
+bm(wM.x) * cV.z + eD.z - vec4f(padding.z)
 );
-let wn = min(
-min((max(vp, vj) + vec4f(bJ.x)), (max(vs, vl) + vec4f(bJ.y))),
-(max(vu, vn) + vec4f(bJ.z))
+let yH = min(
+min(
+bm(xX.x) * cV.x + eD.x + vec4f(padding.x),
+bm(xY.x) * cV.y + eD.y + vec4f(padding.y)
+),
+bm(xZ.x) * cV.z + eD.z + vec4f(padding.z)
 );
-
-let vq = wB * dc.x + eI.x;
-let vt = wE * dc.y + eI.y;
-let vw = wG * dc.z + eI.z;
-let vk = wt * dc.x + eI.x;
-let vm = wv * dc.y + eI.y;
-let vo = wx * dc.z + eI.z;
-let wJ = max(
-max((min(vq, vk) - vec4f(bJ.x)), (min(vt, vm) - vec4f(bJ.y))),
-(min(vw, vo) - vec4f(bJ.z))
+let yM = max(
+max(
+bm(wK.y) * cV.x + eD.x - vec4f(padding.x),
+bm(wL.y) * cV.y + eD.y - vec4f(padding.y)
+),
+bm(wM.y) * cV.z + eD.z - vec4f(padding.z)
 );
-let wo = min(
-min((max(vq, vk) + vec4f(bJ.x)), (max(vt, vm) + vec4f(bJ.y))),
-(max(vw, vo) + vec4f(bJ.z))
+let yI = min(
+min(
+bm(xX.y) * cV.x + eD.x + vec4f(padding.x),
+bm(xY.y) * cV.y + eD.y + vec4f(padding.y)
+),
+bm(xZ.y) * cV.z + eD.z + vec4f(padding.z)
 );
 
-let uK = (wI <= min(wn, vec4f(tMax))) & (wn > vec4f(0.0));
-let uL = (wJ <= min(wo, vec4f(tMax))) & (wo > vec4f(0.0));
-return select(0u, 1u, uK.x)
-| select(0u, 2u, uK.y)
-| select(0u, 4u, uK.z)
-| select(0u, 8u, uK.w)
-| select(0u, 16u, uL.x)
-| select(0u, 32u, uL.y)
-| select(0u, 64u, uL.z)
-| select(0u, 128u, uL.w);
+let wI = (yL <= min(yH, vec4f(tMax))) & (yH > vec4f(0.0));
+let wJ = (yM <= min(yI, vec4f(tMax))) & (yI > vec4f(0.0));
+return select(0u, 1u, wI.x)
+| select(0u, 2u, wI.y)
+| select(0u, 4u, wI.z)
+| select(0u, 8u, wI.w)
+| select(0u, 16u, wJ.x)
+| select(0u, 32u, wJ.y)
+| select(0u, 64u, wJ.z)
+| select(0u, 128u, wJ.w);
 }
 
 `;
 function getBVHTraverseCode(handleHitCode, hasDisplacement, anyHit, blasLayoutMask, hasAnisotropyDirections, skipTriangleCode = '') {
     const intersectTriangles = /* wgsl */ `
-let ot = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
-let vertexOffset = vec3i(bitcast<i32>(ot.y));
-for (var k = 0; k < bh; k++) {
+let oX = instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE}];
+let vertexOffset = vec3i(bitcast<i32>(oX.y));
+for (var k = 0; k < primitiveCount; k++) {
 let triangleIndex = primitiveOffset + k;
 ${skipTriangleCode}
-if (bounces > 0 && triangleIndex == hO) {
+if (bounces > 0 && triangleIndex == fH && bK == fG) {
 continue;
 }
 
 let r3 = bvhBuffer[triangleIndex];
 let index = bitcast<vec3i>(r3.xyz) + vertexOffset;
-var tri = fB(
+var tri = fw(
 attrBuffers[index.x * ATTR_STRIDE + POSITION_OFF]${hasAnisotropyDirections ? '.xyz' : ''},
 attrBuffers[index.y * ATTR_STRIDE + POSITION_OFF]${hasAnisotropyDirections ? '.xyz' : ''},
 attrBuffers[index.z * ATTR_STRIDE + POSITION_OFF]${hasAnisotropyDirections ? '.xyz' : ''}
 );
-var ow = false;
+var pa = false;
 
 ${hasDisplacement
         ? displacementIntersectCode(anyHit, hasAnisotropyDirections)
         : flatIntersectCode()}
-if (ow) {
+if (pa) {
 ${handleHitCode}
 }
 }
@@ -231,285 +231,285 @@ ${handleHitCode}
     return /* wgsl */ `
 var d = ray.d;
 var o = ray.o;
-var lZ: array<i32, TLAS_STACK_SIZE>;
-var jh = -1;
-var gE = fb(d);
-var bU = false;
-var rb = false;
-var eY: vec3f;
-var eD: vec3f;
-var aB: vec3f;
-
-
-if (cM(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, gE, tMax) > 0.0) {
-jh = 0;
-lZ[0] = 0;
-}
-while (jh >= 0) {
-let sV = lZ[jh];
-jh--;
+var jk = -1;
+var gb = eW(d);
+var bP = false;
+var sd = false;
+var eS: vec3f;
+var ex: vec3f;
+var aw: vec3f;
+
+
+if (cH(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, gb, tMax) > 0.0) {
+jk = 0;
+mw[0] = 0;
+}
+while (jk >= 0) {
+let uo = mw[jk];
+jk--;
 o = ray.o;
 d = ray.d;
-gE = fb(d);
-
-let wf = bvhBuffer[sV];
-let eV = bitcast<i32>(wf.w);
-if (eV >= 0) {
-let left = sV + 2;
-let right = eV;
-let d0 = cM(
+gb = eW(d);
+
+let yw = bvhBuffer[uo];
+let eP = bitcast<i32>(yw.w);
+if (eP >= 0) {
+let left = uo + 2;
+let right = eP;
+let d0 = cH(
 o,
 bvhBuffer[left].xyz,
 bvhBuffer[left + 1].xyz,
-gE,
+gb,
 tMax
 );
-let d1 = cM(
+let d1 = cH(
 o,
 bvhBuffer[right].xyz,
 bvhBuffer[right + 1].xyz,
-gE,
+gb,
 tMax
 );
 
 if (d0 > d1) {
-if (d0 > 0.0) { jh++; lZ[jh] = left; }
-if (d1 > 0.0) { jh++; lZ[jh] = right; }
+if (d0 > 0.0) { jk++; mw[jk] = left; }
+if (d1 > 0.0) { jk++; mw[jk] = right; }
 }
 else {
-if (d1 > 0.0) { jh++; lZ[jh] = right; }
-if (d0 > 0.0) { jh++; lZ[jh] = left; }
+if (d1 > 0.0) { jk++; mw[jk] = right; }
+if (d0 > 0.0) { jk++; mw[jk] = left; }
 }
 }
 else {
-let qJ = -eV;
+let rN = -eP;
 
 
 for (
-var mw = qJ - 1;
-mw >= 0;
-mw--
+var mW = rN - 1;
+mW >= 0;
+mW--
 ) {
-let pI = bvhBuffer[sV + 2 + mw];
-let cf = bitcast<i32>(pI.x);
-let uU = bitcast<i32>(pI.y);
-let ot = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
+let qn = bvhBuffer[uo + 2 + mW];
+let bK = bitcast<i32>(qn.x);
+let xl = bitcast<i32>(qn.y);
+let oX = instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE}];
 let w2l = mat4x4<f32>(
-instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 1],
-instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 2],
-instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 3],
-instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 4]
+instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE} + 1],
+instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE} + 2],
+instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE} + 3],
+instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE} + 4]
 );
 o = (w2l * vec4f(ray.o, 1.0)).xyz;
 d = (w2l * vec4f(ray.d, 0.0)).xyz;
-gE = fb(d);
-ey = maxDimension(abs(d));
-gQ = mu(d, ey);
+gb = eW(d);
+dZ = maxDimension(abs(d));
+gH = mU(d, dZ);
 
-let fK = bitcast<u32>(ot.x);
-let gS = fK >> 30u;
+let fK = bitcast<u32>(oX.x);
+let gN = fK >> 30u;
 let blasOffset = i32(fK & 0x3fffffffu);
-let bo = rtUniform.blasOffset;
+let bufferOff = rtUniform.blasOffset;
 
 ${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `
-if (gS == 3u) {
+if (gN == 3u) {
 
 
 
 
-var sm: array<vec2u, BLAS_STACK_SIZE>;
-var pn = -1;
-var rX = 0u;
-var kZ = 0u;
+var qc = -1;
+var ta = 0u;
+var ln = 0u;
 
-var ep = 0x80000000u;
-let ut = select(0u, 4u, d.x < 0.0)
+var el = 0x80000000u;
+let wm = select(0u, 4u, d.x < 0.0)
 | select(0u, 2u, d.y < 0.0)
 | select(0u, 1u, d.z < 0.0);
-let ql = 7u - ut;
+let rc = 7u - wm;
 
 
 
 
-while (rX < 4096u) {
-rX++;
+while (ta < 4096u) {
+ta++;
 
-let internalMask = ep & 0xffu;
-let qh =
-kx(ep >> 24u) + 24u;
-ep &= ~(1u << qh);
-if ((ep & 0xff000000u) != 0u) {
-pn++;
+let internalMask = el & 0xffu;
+let qY =
+kI(el >> 24u) + 24u;
+el &= ~(1u << qY);
+if ((el & 0xff000000u) != 0u) {
+qc++;
 
-sm[pn] = vec2u(kZ, ep);
+tE[qc] = vec2u(ln, el);
 }
 
-let slot = (qh - 24u) ^ ql;
-let nr = (1u << slot) - 1u;
-let relativeIndex = countOneBits(internalMask & nr);
-let sk = kZ + relativeIndex;
-let node = blasOffset + i32(sk * 5u);
-let jA = bvhBuffer[node + bo];
-let ue = ou(
-node, bo, jA, o, gE, tMax
+let slot = (qY - 24u) ^ rc;
+let oa = (1u << slot) - 1u;
+let relativeIndex = countOneBits(internalMask & oa);
+let tA = ln + relativeIndex;
+let node = blasOffset + i32(tA * 5u);
+let jF = bvhBuffer[node + bufferOff];
+let vQ = oY(
+node, bufferOff, jF, o, gb, tMax
 );
 
 
-ep = 0u;
-if (ue != 0u) {
-let fG = bvhBuffer[node + bo + 1];
-let rO = bitcast<u32>(jA.w) >> 24u;
-var tv = 0u;
-var kg = ue;
-while (kg != 0u) {
-let rC = kx(kg);
-kg &= ~(1u << rC);
-let sE = select(
-bitcast<u32>(fG.z),
-bitcast<u32>(fG.w),
-rC >= 4u
+el = 0u;
+if (vQ != 0u) {
+let fF = bvhBuffer[node + bufferOff + 1];
+let sM = bitcast<u32>(jF.w) >> 24u;
+var uT = 0u;
+var kp = vQ;
+while (kp != 0u) {
+let sw = kI(kp);
+kp &= ~(1u << sw);
+let tW = select(
+bitcast<u32>(fF.z),
+bitcast<u32>(fF.w),
+sw >= 4u
 );
-let td =
-(sE >> ((rC & 3u) * 8u)) & 0xffu;
-let jC = td & 0x1fu;
-let uT = select(
-jC,
-jC ^ ql,
-jC >= 24u
+let uF =
+(tW >> ((sw & 3u) * 8u)) & 0xffu;
+let jH = uF & 0x1fu;
+let xk = select(
+jH,
+jH ^ rc,
+jH >= 24u
 );
-let uO = (td >> 5u) & 0x7u;
-tv |= uO << uT;
-}
-
-kZ = bitcast<u32>(fG.x);
-ep = (tv & 0xff000000u) | rO;
-let oP = bitcast<u32>(fG.y);
-var oQ = tv & 0x00ffffffu;
-while (oQ != 0u) {
-let nS = nY(oQ);
-oQ &= ~(1u << nS);
-let bh = 1;
-let primitiveOffset = bo + blasOffset
-+ i32(oP + nS);
+let wQ = (uF >> 5u) & 0x7u;
+uT |= wQ << xk;
+}
+
+ln = bitcast<u32>(fF.x);
+el = (uT & 0xff000000u) | sM;
+let ps = bitcast<u32>(fF.y);
+var pv = uT & 0x00ffffffu;
+while (pv != 0u) {
+let oD = oJ(pv);
+pv &= ~(1u << oD);
+let primitiveCount = 1;
+let primitiveOffset = bufferOff + blasOffset
++ i32(ps + oD);
 ${intersectTriangles}
 }
 }
 
-if ((ep & 0xff000000u) != 0u) { continue; }
-if (pn >= 0) {
-let qm = sm[pn];
-kZ = qm.x;
-ep = qm.y;
-pn--;
+if ((el & 0xff000000u) != 0u) { continue; }
+if (qc >= 0) {
+let rf = tE[qc];
+ln = rf.x;
+el = rf.y;
+qc--;
 }
 else { break; }
 }
 }
 ` : ''}
 
-var gu: array<i32, BLAS_STACK_SIZE>;
-var dS = -1;
-if (gS != 3u) {
-dS = 0;
+var dR = -1;
+if (gN != 3u) {
+dR = 0;
 
-gu[0] = uU;
+gs[0] = xl;
 }
 
-while (dS >= 0) {
+while (dR >= 0) {
 
-let node = gu[dS];
-dS--;
-var bh = 0;
+let node = gs[dR];
+dR--;
+var primitiveCount = 0;
 var primitiveOffset = 0;
 
 ${(blasLayoutMask & 4) !== 0 ? /* wgsl */ `
-if (gS == 2u) {
-let i = node + bo;
-let uY = bvhBuffer[i];
-let uZ = bvhBuffer[i + 1];
-let va = bvhBuffer[i + 2];
-let vb = bvhBuffer[i + 3];
-bh = i32(bitcast<u32>(va.w));
-if (bh > 0) {
-primitiveOffset = bo + blasOffset
-+ i32(bitcast<u32>(vb.w));
+if (gN == 2u) {
+let i = node + bufferOff;
+let xq = bvhBuffer[i];
+let xr = bvhBuffer[i + 1];
+let xs = bvhBuffer[i + 2];
+let xt = bvhBuffer[i + 3];
+primitiveCount = i32(bitcast<u32>(xs.w));
+if (primitiveCount > 0) {
+primitiveOffset = bufferOff + blasOffset
++ i32(bitcast<u32>(xt.w));
 }
 else {
-let left = blasOffset + i32(bitcast<u32>(uY.w) * 4u);
-let right = blasOffset + i32(bitcast<u32>(uZ.w) * 4u);
-let ox = cM(
-o, uY.xyz, uZ.xyz, gE, tMax
+let left = blasOffset + i32(bitcast<u32>(xq.w) * 4u);
+let right = blasOffset + i32(bitcast<u32>(xr.w) * 4u);
+let pb = cH(
+o, xq.xyz, xr.xyz, gb, tMax
 );
-let nt = cM(
-o, va.xyz, vb.xyz, gE, tMax
+let oc = cH(
+o, xs.xyz, xt.xyz, gb, tMax
 );
-if (ox > nt) {
-if (ox > 0.0) {
-dS++; gu[dS] = left;
+if (pb > oc) {
+if (pb > 0.0) {
+dR++; gs[dR] = left;
 }
-if (nt > 0.0) {
-dS++; gu[dS] = right;
+if (oc > 0.0) {
+dR++; gs[dR] = right;
 }
 }
 else {
-if (nt > 0.0) {
-dS++; gu[dS] = right;
+if (oc > 0.0) {
+dR++; gs[dR] = right;
 }
-if (ox > 0.0) {
-dS++; gu[dS] = left;
+if (pb > 0.0) {
+dR++; gs[dR] = left;
 }
 }
 }
 }
 ` : ''}
 ${(blasLayoutMask & 2) !== 0 ? /* wgsl */ `
-if (gS == 1u) {
-let hW = bitcast<u32>(node);
-if ((hW & 0x80000000u) != 0u) {
-bh = i32((hW >> 23u) & 0xffu);
-primitiveOffset = bo + blasOffset
-+ i32(hW & 0x007fffffu);
+if (gN == 1u) {
+let hT = bitcast<u32>(node);
+if ((hT & 0x80000000u) != 0u) {
+primitiveCount = i32((hT >> 23u) & 0xffu);
+primitiveOffset = bufferOff + blasOffset
++ i32(hT & 0x007fffffu);
 }
 else {
-let i = node + bo;
-let ui = bvhBuffer[i];
-let ro = bvhBuffer[i + 1];
-let rp = bvhBuffer[i + 2];
-let rq = bvhBuffer[i + 3];
-let nodeMin = ui.xyz;
-let ec = vec3f(ui.w, ro.x, ro.y);
-let mg = array<u32, 4>(
-bitcast<u32>(ro.z), bitcast<u32>(ro.w),
-bitcast<u32>(rp.x), bitcast<u32>(rp.y)
+let i = node + bufferOff;
+let vW = bvhBuffer[i];
+let sq = bvhBuffer[i + 1];
+let qI = bvhBuffer[i + 2];
+let oF = bvhBuffer[i + 3];
+let nodeMin = vW.xyz;
+let ea = vec3f(vW.w, sq.x, sq.y);
+let mF = array<u32, 4>(
+bitcast<u32>(sq.z), bitcast<u32>(sq.w),
+bitcast<u32>(qI.x), bitcast<u32>(qI.y)
 );
-let rw = unpack4x8unorm(bitcast<u32>(rp.z));
-let rA = unpack4x8unorm(bitcast<u32>(rp.w));
-let rB = unpack4x8unorm(bitcast<u32>(rq.x));
-let rt = unpack4x8unorm(bitcast<u32>(rq.y));
-let ru = unpack4x8unorm(bitcast<u32>(rq.z));
-let rv = unpack4x8unorm(bitcast<u32>(rq.w));
-let tx0 = (nodeMin.x + rw * ec.x - o.x) * gE.x;
-let tx1 = (nodeMin.x + rt * ec.x - o.x) * gE.x;
-let ty0 = (nodeMin.y + rA * ec.y - o.y) * gE.y;
-let ty1 = (nodeMin.y + ru * ec.y - o.y) * gE.y;
-let tz0 = (nodeMin.z + rB * ec.z - o.z) * gE.z;
-let tz1 = (nodeMin.z + rv * ec.z - o.z) * gE.z;
-let bJ = eZ(gE, o);
-let mK = max(
-max((min(tx0, tx1) - vec4f(bJ.x)), (min(ty0, ty1) - vec4f(bJ.y))),
-(min(tz0, tz1) - vec4f(bJ.z))
+
+
+let negative = gb < vec3f(0.0);
+let wK = unpack4x8unorm(bitcast<u32>(select(qI.z, oF.y, negative.x)));
+let xX = unpack4x8unorm(bitcast<u32>(select(oF.y, qI.z, negative.x)));
+let wL = unpack4x8unorm(bitcast<u32>(select(qI.w, oF.z, negative.y)));
+let xY = unpack4x8unorm(bitcast<u32>(select(oF.z, qI.w, negative.y)));
+let wM = unpack4x8unorm(bitcast<u32>(select(oF.x, oF.w, negative.z)));
+let xZ = unpack4x8unorm(bitcast<u32>(select(oF.w, oF.x, negative.z)));
+let padding = eU(gb, o);
+let ns = max(
+max(
+(nodeMin.x + wK * ea.x - o.x) * gb.x - vec4f(padding.x),
+(nodeMin.y + wL * ea.y - o.y) * gb.y - vec4f(padding.y)
+),
+(nodeMin.z + wM * ea.z - o.z) * gb.z - vec4f(padding.z)
 );
-let rU = min(
-min((max(tx0, tx1) + vec4f(bJ.x)), (max(ty0, ty1) + vec4f(bJ.y))),
-(max(tz0, tz1) + vec4f(bJ.z))
+let sW = min(
+min(
+(nodeMin.x + xX * ea.x - o.x) * gb.x + vec4f(padding.x),
+(nodeMin.y + xY * ea.y - o.y) * gb.y + vec4f(padding.y)
+),
+(nodeMin.z + xZ * ea.z - o.z) * gb.z + vec4f(padding.z)
 );
-var distance = select(rU, mK, mK > vec4f(0.0));
+var distance = select(sW, ns, ns > vec4f(0.0));
 distance = select(
 distance,
 vec4f(-1.0),
-mK > min(rU, vec4f(tMax))
+ns > min(sW, vec4f(tMax))
 );
-var fd = array<f32, 4>(
+var eY = array<f32, 4>(
 distance.x,
 distance.y,
 distance.z,
@@ -518,83 +518,83 @@ distance.w
 
 
 for (var order = 0; order < 4; order++) {
-var dX = -1.0;
-var el = -1;
+var dW = -1.0;
+var ej = -1;
 for (var child = 0; child < 4; child++) {
 if (
-mg[child] != 0u &&
-fd[child] > dX
+mF[child] != 0u &&
+eY[child] > dW
 ) {
-dX = fd[child];
-el = child;
+dW = eY[child];
+ej = child;
 }
 }
-if (el >= 0 && dX > 0.0) {
-let nC = mg[el];
-var jI = bitcast<i32>(nC);
-if ((nC & 0x80000000u) == 0u) {
-jI += blasOffset;
+if (ej >= 0 && dW > 0.0) {
+let ol = mF[ej];
+var jO = bitcast<i32>(ol);
+if ((ol & 0x80000000u) == 0u) {
+jO += blasOffset;
 }
-dS++;
-gu[dS] = jI;
-fd[el] = -1.0;
+dR++;
+gs[dR] = jO;
+eY[ej] = -1.0;
 }
 }
 }
 }
 ` : ''}
 ${(blasLayoutMask & 1) !== 0 ? /* wgsl */ `
-if (gS == 0u) {
-let i = node + bo;
+if (gN == 0u) {
+let i = node + bufferOff;
 let r1 = bvhBuffer[i];
-let bb = bitcast<i32>(r1.w);
+let bf = bitcast<i32>(r1.w);
 
-if (bb >= 0) {
+if (bf >= 0) {
 let left = node + 2;
-let right = bb + blasOffset;
-let d0 = cM(
+let right = bf + blasOffset;
+let d0 = cH(
 o,
-bvhBuffer[left + bo].xyz,
-bvhBuffer[left + 1 + bo].xyz,
-gE,
+bvhBuffer[left + bufferOff].xyz,
+bvhBuffer[left + 1 + bufferOff].xyz,
+gb,
 tMax
 );
-let d1 = cM(
+let d1 = cH(
 o,
-bvhBuffer[right + bo].xyz,
-bvhBuffer[right + 1 + bo].xyz,
-gE,
+bvhBuffer[right + bufferOff].xyz,
+bvhBuffer[right + 1 + bufferOff].xyz,
+gb,
 tMax
 );
 
 if (d0 > d1) {
 if (d0 > 0.0) {
-dS++; gu[dS] = left;
+dR++; gs[dR] = left;
 
 }
 if (d1 > 0.0) {
-dS++; gu[dS] = right;
+dR++; gs[dR] = right;
 
 }
 }
 else {
 if (d1 > 0.0) {
-dS++; gu[dS] = right;
+dR++; gs[dR] = right;
 
 }
 if (d0 > 0.0) {
-dS++; gu[dS] = left;
+dR++; gs[dR] = left;
 
 }
 }
 }
 else {
-bh = -bb;
+primitiveCount = -bf;
 primitiveOffset = i + 2;
 }
 }
 ` : ''}
-if (bh > 0) {
+if (primitiveCount > 0) {
 ${intersectTriangles}
 }
 }
@@ -604,19 +604,225 @@ ${intersectTriangles}
 
 `;
 }
-export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections = true, hasCoatNormals = false, blasLayoutMask = 1 }) {
+// Raw first-hit contract for native diagnostics. Reuse the same traversal and
+// triangle tests without surface completion or any integrator/alpha sampling.
+export function createSceneHitQueryWgsl(hasAnisotropyDirections = false) {
+    return /* wgsl */ `
+struct qV {
+hit: bool, instance: i32, record: i32, t: f32, barycentric: vec3f,
+}
+fn wq(ray: Ray) -> qV {
+var result: qV;
+result.instance = -1; result.record = -1; result.t = RAY_MAX_DISTANCE;
+if (rtUniform.isEmpty > 0) { return result; }
+let bounces = 0;
+let doubleSided = false;
+let jg = false;
+let fH = -1;
+let fG = -1;
+var tMax = RAY_MAX_DISTANCE;
+var dZ: i32;
+var gH: vec3f;
+${getBVHTraverseCode(`
+result.hit = true; result.instance = bK; result.record = triangleIndex;
+result.t = tMax; result.barycentric = aw;
+`, false, false, 1, hasAnisotropyDirections)}
+return result;
+}
+`;
+}
+export function createSceneIntersectionsWgsl({ hasDisplacement, hasAnisotropyDirections = true, hasCoatNormals = false, blasLayoutMask = 1, closestName = 'intersectScene', shadowName = 'intersectSceneShadow', bevelName = 'intersectSceneBevel', closestHitHook = '' }) {
+    return /* wgsl */ `
+fn ${closestName}(ray: Ray, si: ptr<function, SurfaceInteraction>, bounces: i32, doubleSided: bool, jg: bool) {
+
+(*si).hit = false;
+
+if (rtUniform.isEmpty > 0) {
+return;
+}
+
+var tMax = RAY_MAX_DISTANCE;
+var dZ: i32;
+var gH: vec3f;
+
+var hr: vec3i;
+var lR: fw;
+var am: i32;
+var fH: i32 = (*si).triangleIndex;
+let fG = (*si).instanceIndex;
+
+${getBVHTraverseCode(`
+(*si).triangleIndex = triangleIndex;
+lR = tri;
+hr = index;
+am = bK;
+`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections)}
+
+${closestHitHook}  if (sd) {
+mH(
+si,
+lR,
+aw,
+hr,
+bP,
+am,
+ex,
+eS,
+-1
+);
+}
+}
+
+
+fn ${bevelName}(ray: Ray, si: ptr<function, SurfaceInteraction>, instanceIndex: i32, maxDistance: f32) {
+(*si).hit = false;
+
+if (rtUniform.isEmpty > 0) {
+return;
+}
+
+let bounces = 0;
+let doubleSided = true;
+let jg = false;
+var tMax = maxDistance;
+var dZ: i32;
+var gH: vec3f;
+var hr: vec3i;
+var lR: fw;
+var am: i32;
+var fH: i32 = -1;
+let fG = instanceIndex;
+
+${getBVHTraverseCode(`
+(*si).triangleIndex = triangleIndex;
+lR = tri;
+hr = index;
+am = bK;
+`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections, `
+if (bK != instanceIndex) {
+continue;
+}
+`)}
+
+if (sd) {
+(*si).instanceIndex = am;
+(*si).normal = ex;
+(*si).position = eS;
+(*si).materialIndex = i32(af(bitcast<i32>(instancesBuffer[am * ${INSTANCE_VEC4_STRIDE}].z)).x);
+hn(
+si,
+lR,
+aw,
+hr,
+bP,
+-1
+);
+
+let l2w = mat4x4<f32>(
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 5],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 6],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 7],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 8]
+);
+let w2l = mat4x4<f32>(
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 1],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 2],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 3],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 4]
+);
+let aG = transpose(mat3x3<f32>(
+w2l[0].xyz,
+w2l[1].xyz,
+w2l[2].xyz
+));
+(*si).faceNormal = normalize(aG * ex);
+(*si).vertexNormal = normalize(aG * (*si).vertexNormal);
+(*si).normal = normalize(aG * (*si).normal);
+${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aG * (*si).coatNormal);` : ''}
+if (USE_TANGENT && dot((*si).tangent, (*si).tangent) > 0.0) {
+(*si).tangent = normalize((l2w * vec4f((*si).tangent, 0.0)).xyz);
+}
+${hasAnisotropyDirections ? /* wgsl */ `
+(*si).directionTangent = (l2w * vec4f((*si).directionTangent, 0.0)).xyz;
+(*si).directionBitangent = (l2w * vec4f((*si).directionBitangent, 0.0)).xyz;
+(*si).geometryTangent = (l2w * vec4f((*si).geometryTangent, 0.0)).xyz;
+(*si).geometryBitangent = (l2w * vec4f((*si).geometryBitangent, 0.0)).xyz;
+` : /* wgsl */ ``}
+(*si).shadowOffset = (l2w * vec4f((*si).shadowOffset, 0.0)).xyz;
+(*si).position = (l2w * vec4((*si).position, 1.0)).xyz;
+}
+}
+
+fn ${shadowName}(ray: Ray, lightDistance: f32, jR: i32, rU:i32) -> bool {
+if (rtUniform.isEmpty > 0) {
+return false;
+}
+
+let doubleSided = true;
+let rj = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
+var tMax = rj;
+var dZ: i32;
+var gH: vec3f;
+
+let bounces = 1;
+var jg = false;
+var fH: i32 = jR;
+let fG = rU;
+
+${getBVHTraverseCode(
+    /*wgsl */ `
+
+
+
+var jA = true;
+
+if (jA) {
+if (HAS_ALPHA) {
+let materialIndex = i32(af(bitcast<i32>(oX.z)).x);
+if (!ou(
+materialIndex,
+index,
+aw,
+eS,
+ex
+)) {
+
+tMax = rj;
+jA = false;
+}
+}
+}
+if (jA) {
+return true;
+}
+`, hasDisplacement, true, blasLayoutMask, hasAnisotropyDirections)}
+
+return false;
+}
+
+`;
+}
+export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections = true, hasCoatNormals = false, blasLayoutMask = 1, sceneIntersections = '' }) {
     return /*wgsl*/ `
 
+
+
+
+
+var<private> mw: array<i32, TLAS_STACK_SIZE>;
+var<private> gs: array<i32, BLAS_STACK_SIZE>;
+${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `var<private> tE: array<vec2u, BLAS_STACK_SIZE>;` : ''}
+
 ${hasDisplacement ? displacementWgsl : ''}
 ${(blasLayoutMask & 8) !== 0 ? cwbvhTraversalWgsl : ''}
 
-struct fB {
+struct fw {
 p0: vec3f,
 p1: vec3f,
 p2: vec3f,
 };
 
-fn hx(rad: f32, pos: vec3f, r: Ray) -> f32 {
+fn hs(rad: f32, pos: vec3f, r: Ray) -> f32 {
 let op: vec3f = pos - r.o;
 let eps: f32 = 0.001;
 let b: f32 = dot(op, r.d);
@@ -639,7 +845,7 @@ return t2;
 return INF;
 }
 
-fn nh(pos: vec3f, u: vec3f, v: vec3f, n: vec3f, r: Ray) -> f32 {
+fn nV(pos: vec3f, u: vec3f, v: vec3f, n: vec3f, r: Ray) -> f32 {
 let dt: f32 = dot(r.d, n);
 let t: f32 = (dot(n, pos) - dot(n, r.o)) / dt;
 
@@ -659,14 +865,16 @@ return INF;
 }
 
 fn sphereSolidAnglePdf(origin: vec3f, center: vec3f, radius: f32) -> f32 {
-let aj = distance(origin, center);
-if (aj <= radius) { return INV4PI; }
-let jv = min(1.0, radius * radius / (aj * aj));
-let cosThetaMax = sqrt(max(0.0, 1.0 - jv));
-return 1.0 / max(TWOPI * (1.0 - cosThetaMax), 1e-8);
+let ao = distance(origin, center);
+if (ao <= radius) { return INV4PI; }
+let sinThetaMaxSquared = min(1.0, radius * radius / (ao * ao));
+let cosThetaMax = sqrt(max(0.0, 1.0 - sinThetaMaxSquared));
+
+let oneMinusCosThetaMax = sinThetaMaxSquared / (1.0 + cosThetaMax);
+return 1.0 / max(TWOPI * oneMinusCosThetaMax, 1e-8);
 }
 
-fn my(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
+fn mX(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
 
 
 var d: f32 = INF;
@@ -678,9 +886,9 @@ var d: f32 = INF;
 (*lightSample).isDelta = false;
 var u = light.u;
 var v = light.v;
-var dP = i32(light.litType);
+var dO = i32(light.litType);
 
-if (dP == RECT_LIGHT) {
+if (HAS_SCENE_RECT_LIGHT && dO == RECT_LIGHT) {
 
 var pos = light.position - u * 0.5 - v * 0.5;
 var normal = normalize(cross(u, v));
@@ -688,18 +896,18 @@ if (dot(normal, r.d) > 0.0) {
 return INF;
 }
 
-d = nh(pos, u, v, normal, r);
+d = nV(pos, u, v, normal, r);
 if (d < 0.0) {
 d = INF;
 }
 else {
-var cc: f32 = dot(-r.d, normal);
+var ct: f32 = dot(-r.d, normal);
 let spread = light.radiusOrSpread;
-if (cc >= cos(spread * PI / 2.0)) {
+if (ct >= cos(spread * PI / 2.0)) {
 (*lightSample).direction = r.d;
 (*lightSample).normal = normal;
 (*lightSample).dist = d;
-(*lightSample).pdf = (d * d) / (light.area * cc);
+(*lightSample).pdf = (d * d) / (light.area * ct);
 (*lightSample).emission = light.emission;
 (*lightSample).isDelta = false;
 }
@@ -709,12 +917,12 @@ d = INF;
 }
 }
 
-else if (dP == SPHERE_LIGHT) {
+else if (HAS_SCENE_SPHERE_LIGHT && dO == SPHERE_LIGHT) {
 if (light.radiusOrSpread <= 0.0) {
-let ko = light.position - r.o;
-let projection = dot(ko, r.d);
-let ba = ko - projection * r.d;
-if (projection <= EPS || dot(ba, ba) > 1e-8) {
+let kz = light.position - r.o;
+let projection = dot(kz, r.d);
+let bd = kz - projection * r.d;
+if (projection <= EPS || dot(bd, bd) > 1e-8) {
 return INF;
 }
 d = projection;
@@ -725,7 +933,7 @@ d = projection;
 (*lightSample).isDelta = true;
 }
 else {
-d = hx(light.radiusOrSpread, light.position, r);
+d = hs(light.radiusOrSpread, light.position, r);
 (*lightSample).isDelta = false;
 if (d > 0.0 && d != INF) {
 (*lightSample).direction = r.d;
@@ -754,12 +962,12 @@ light.radiusOrSpread <= 0.0
 }
 }
 
-else if (dP == SPOT_LIGHT) {
+else if (HAS_SCENE_SPOT_LIGHT && dO == SPOT_LIGHT) {
 if (light.radiusOrSpread <= 0.0) {
-let ko = light.position - r.o;
-let projection = dot(ko, r.d);
-let ba = ko - projection * r.d;
-if (projection <= EPS || dot(ba, ba) > 1e-8) {
+let kz = light.position - r.o;
+let projection = dot(kz, r.d);
+let bd = kz - projection * r.d;
+if (projection <= EPS || dot(bd, bd) > 1e-8) {
 return INF;
 }
 d = projection;
@@ -770,13 +978,13 @@ d = projection;
 (*lightSample).isDelta = true;
 }
 else {
-d = hx(light.radiusOrSpread, light.position, r);
+d = hs(light.radiusOrSpread, light.position, r);
 (*lightSample).isDelta = false;
 }
 if (d != INF) {
-let ve = r.o + d * r.d;
-let mB = bL(light, normalize(r.o - ve));
-if (mB <= 0.0) { return INF; }
+let xv = r.o + d * r.d;
+let ne = evaluateSpotEmissionMultiplier(light, normalize(r.o - xv));
+if (ne <= 0.0) { return INF; }
 if (light.radiusOrSpread > 0.0) {
 (*lightSample).direction = r.d;
 (*lightSample).dist = d;
@@ -785,7 +993,7 @@ r.o + r.d * d - light.position
 );
 (*lightSample).pdf = sphereSolidAnglePdf(r.o, light.position, light.radiusOrSpread);
 }
-(*lightSample).emission = light.emission * mB * select(
+(*lightSample).emission = light.emission * ne * select(
 1.0,
 1.0 / max(d * d, 1e-8),
 light.radiusOrSpread <= 0.0
@@ -793,7 +1001,7 @@ light.radiusOrSpread <= 0.0
 }
 }
 
-else if (dP != RECT_LIGHT && dP != SPHERE_LIGHT && dP != SPOT_LIGHT) {
+else if (dO != RECT_LIGHT && dO != SPHERE_LIGHT && dO != SPOT_LIGHT) {
 
 d = INF;
 }
@@ -801,111 +1009,111 @@ d = INF;
 return d;
 }
 
-fn fm(m0: vec3i, m1: vec3i, m2: vec3i, eK: vec3f) -> i32 {
-let m00 = ae(m0.x);
-let m01 = ae(m0.y);
-let m02 = ae(m0.z);
-let m10 = ae(m1.x);
-let m11 = ae(m1.y);
-let m12 = ae(m1.z);
-let m20 = ae(m2.x);
-let m21 = ae(m2.y);
-let m22 = ae(m2.z);
-var w00 = m00.y * eK.x;
-var w01 = m01.y * eK.x;
-var w02 = m02.y * eK.x;
-var w10 = m10.y * eK.y;
-var w11 = m11.y * eK.y;
-var w12 = m12.y * eK.y;
-var w20 = m20.y * eK.z;
-var w21 = m21.y * eK.z;
-var w22 = m22.y * eK.z;
-
-var hk = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
-
-w00 = w00 / hk;
-w01 = w01 / hk + w00;
-w02 = w02 / hk + w01;
-w10 = w10 / hk + w02;
-w11 = w11 / hk + w10;
-w12 = w12 / hk + w11;
-w20 = w20 / hk + w12;
-w21 = w21 / hk + w20;
-w22 = w22 / hk + w21;
-
-let rand = eo(0u);
-var ni: f32;
+fn fh(m0: vec3i, m1: vec3i, m2: vec3i, bary: vec3f) -> i32 {
+let m00 = af(m0.x);
+let m01 = af(m0.y);
+let m02 = af(m0.z);
+let m10 = af(m1.x);
+let m11 = af(m1.y);
+let m12 = af(m1.z);
+let m20 = af(m2.x);
+let m21 = af(m2.y);
+let m22 = af(m2.z);
+var w00 = m00.y * bary.x;
+var w01 = m01.y * bary.x;
+var w02 = m02.y * bary.x;
+var w10 = m10.y * bary.y;
+var w11 = m11.y * bary.y;
+var w12 = m12.y * bary.y;
+var w20 = m20.y * bary.z;
+var w21 = m21.y * bary.z;
+var w22 = m22.y * bary.z;
+
+var hd = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
+
+w00 = w00 / hd;
+w01 = w01 / hd + w00;
+w02 = w02 / hd + w01;
+w10 = w10 / hd + w02;
+w11 = w11 / hd + w10;
+w12 = w12 / hd + w11;
+w20 = w20 / hd + w12;
+w21 = w21 / hd + w20;
+w22 = w22 / hd + w21;
+
+let rand = ek(0u);
+var nW: f32;
 if (rand < w00) {
-ni = m00.x;
+nW = m00.x;
 } else if (rand < w01) {
-ni = m01.x;
+nW = m01.x;
 } else if (rand < w02) {
-ni = m02.x;
+nW = m02.x;
 } else if (rand < w10) {
-ni = m10.x;
+nW = m10.x;
 } else if (rand < w11) {
-ni = m11.x;
+nW = m11.x;
 } else if (rand < w12) {
-ni = m12.x;
+nW = m12.x;
 } else if (rand < w20) {
-ni = m20.x;
+nW = m20.x;
 } else if (rand < w21) {
-ni = m21.x;
+nW = m21.x;
 } else {
-ni = m22.x;
+nW = m22.x;
 }
-return i32(ni);
+return i32(nW);
 }
 
-fn lV(
-pa: i32,
+fn mp(
+pQ: i32,
 index: vec3i,
-eK: vec3f
+bary: vec3f
 ) -> i32 {
 let m0 = vec3i(attrBuffers[index.x * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
 let m1 = vec3i(attrBuffers[index.y * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
 let m2 = vec3i(attrBuffers[index.z * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
 if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
-return fm(m0, m1, m2, eK);
+return fh(m0, m1, m2, bary);
 }
-return pa;
+return pQ;
 }
 
 
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-fn eE(normal: vec3f, dp1: vec3f, dp2: vec3f, oc: vec2f, od: vec2f, input: vec4f) -> mat2x3f {
-let determinant = oc.x * od.y - oc.y * od.x;
+fn ez(normal: vec3f, dp1: vec3f, dp2: vec3f, oM: vec2f, oN: vec2f, input: vec4f) -> mat2x3f {
+let determinant = oM.x * oN.y - oM.y * oN.x;
 var t = input.xyz;
 var b = vec3f(0.0);
 
 var sign = select(input.w, 0.0, abs(input.w) > 1.5);
 if (abs(determinant) > 1e-12) {
-let dt = (dp1 * od.y - dp2 * oc.y) / determinant;
-let db = (dp2 * oc.x - dp1 * od.x) / determinant;
+let dt = (dp1 * oN.y - dp2 * oM.y) / determinant;
+let db = (dp2 * oM.x - dp1 * oN.x) / determinant;
 if (dot(t, t) < 1e-8) { t = dt; }
 if (sign == 0.0) { sign = select(1.0, -1.0, dot(cross(normal, dt), db) < 0.0); }
 }
 t -= normal * dot(normal, t);
 if (dot(t, t) < 1e-8) {
 let ik = select(-1.0, 1.0, normal.z >= 0.0);
-let dW = -1.0 / (ik + normal.z);
-let xy = normal.x * normal.y * dW;
-t = vec3f(1.0 + ik * normal.x * normal.x * dW, ik * xy, -ik * normal.x);
-b = vec3f(xy, ik + normal.y * normal.y * dW, -normal.y);
+let cv = -1.0 / (ik + normal.z);
+let xy = normal.x * normal.y * cv;
+t = vec3f(1.0 + ik * normal.x * normal.x * cv, ik * xy, -ik * normal.x);
+b = vec3f(xy, ik + normal.y * normal.y * cv, -normal.y);
 }
 else { t = normalize(t); b = normalize(cross(normal, t)); }
 return mat2x3f(t, b * select(1.0, -1.0, sign < 0.0));
 }
 
 ` : /* wgsl */ ``}
-fn ht(
-si: ptr<function, ad>,
-tri: fB,
-eK: vec3f,
+fn hn(
+si: ptr<function, SurfaceInteraction>,
+tri: fw,
+bary: vec3f,
 index: vec3i,
-bU: bool,
-fw: i32
+bP: bool,
+fq: i32
 ) {
 (*si).hit = true;
 
@@ -917,26 +1125,26 @@ let i1 = index.y;
 let i2 = index.z;
 (*si).vertexColor = vec3f(1.0);
 if (USE_VERTEX_COLOR) {
-(*si).vertexColor = eK.x * attrBuffers[i0 * ATTR_STRIDE + COLOR_OFF].xyz
-+ eK.y * attrBuffers[i1 * ATTR_STRIDE + COLOR_OFF].xyz
-+ eK.z * attrBuffers[i2 * ATTR_STRIDE + COLOR_OFF].xyz;
+(*si).vertexColor = bary.x * attrBuffers[i0 * ATTR_STRIDE + COLOR_OFF].xyz
++ bary.y * attrBuffers[i1 * ATTR_STRIDE + COLOR_OFF].xyz
++ bary.z * attrBuffers[i2 * ATTR_STRIDE + COLOR_OFF].xyz;
 }
-let oY = uvProjection == ${uvProjectionConstants.spherical};
+let pL = uvProjection == ${uvProjectionConstants.spherical};
 
 var normal: vec3f = (*si).normal;
-var ha: vec3f;
+var gW: vec3f;
 var n0 = vec3f(0.0);
 var n1 = vec3f(0.0);
 var n2 = vec3f(0.0);
 
 
-if (!bU || oY) {
+if (!bP || pL) {
 n0 = attrBuffers[i0 * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
 n1 = attrBuffers[i1 * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
 n2 = attrBuffers[i2 * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
-ha = normalize(eK.x * n0 + eK.y * n1 + eK.z * n2);
-if (!bU) {
-normal = ha;
+gW = normalize(bary.x * n0 + bary.y * n1 + bary.z * n2);
+if (!bP) {
+normal = gW;
 }
 }
 
@@ -944,19 +1152,19 @@ var uv: vec2f;
 var uv0: vec2f;
 var uv1: vec2f;
 var uv2: vec2f;
-var cX = vec2f(0.0);
+var cQ = vec2f(0.0);
 if (USE_UV) {
 uv0 = attrBuffers[i0 * ATTR_STRIDE + UV_OFF].xy;
 uv1 = attrBuffers[i1 * ATTR_STRIDE + UV_OFF].xy;
 uv2 = attrBuffers[i2 * ATTR_STRIDE + UV_OFF].xy;
-uv = eK.x * uv0 + eK.y * uv1 + eK.z * uv2;
+uv = bary.x * uv0 + bary.y * uv1 + bary.z * uv2;
 if (USE_UV1) {
 let secondaryUv0 = attrBuffers[i0 * ATTR_STRIDE + UV1_OFF].xy;
 let secondaryUv1 = attrBuffers[i1 * ATTR_STRIDE + UV1_OFF].xy;
 let secondaryUv2 = attrBuffers[i2 * ATTR_STRIDE + UV1_OFF].xy;
-cX = eK.x * secondaryUv0
-+ eK.y * secondaryUv1
-+ eK.z * secondaryUv2;
+cQ = bary.x * secondaryUv0
++ bary.y * secondaryUv1
++ bary.z * secondaryUv2;
 }
 }
 
@@ -964,28 +1172,28 @@ if (USE_TANGENT) {
 let t0 = attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
 let t1 = attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
 let t2 = attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
-(*si).tangent = normalize(eK.x * t0 + eK.y * t1 + eK.z * t2);
+(*si).tangent = normalize(bary.x * t0 + bary.y * t1 + bary.z * t2);
 }
 
-if (fw >= 0) {
-(*si).materialIndex = fw;
+if (fq >= 0) {
+(*si).materialIndex = fq;
 }
 else {
-(*si).materialIndex = lV(
+(*si).materialIndex = mp(
 (*si).materialIndex,
 index,
-eK
+bary
 );
 }
 
 if (uvProjection > 0) {
 
-uv = gI(uvProjection, (*si).position, select(normal, ha, oY));
-cX = uv;
+uv = gE(uvProjection, (*si).position, select(normal, gW, pL));
+cQ = uv;
 }
 
 uv = uv * material.uvScale;
-cX = cX * material.uvScale;
+cQ = cQ * material.uvScale;
 
 
 if (uvProjection == ${uvProjectionConstants.triplanar}) {
@@ -998,41 +1206,41 @@ let directionMaterial = materialsBuffer[(*si).materialIndex];
 if (directionMaterial.anisotropyMapIndex >= 0.0 || directionMaterial.specularAnisotropyRotation != 0.0 || directionMaterial.coatAnisotropyRotation != 0.0${hasCoatNormals ? " || directionMaterial.coatWeight > 0.0" : ""}) {
 let dp1 = tri.p0 - tri.p2;
 let dp2 = tri.p1 - tri.p2;
-var aT = vec4f(0.0);
+var aS = vec4f(0.0);
 if (USE_TANGENT) {
-aT = eK.x * attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]
-+ eK.y * attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]
-+ eK.z * attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF];
-}
-let eS = eE(normal, dp1, dp2, uv0-uv2, uv1-uv2, aT);
-(*si).geometryTangent = eS[0];
-(*si).geometryBitangent = eS[1];
-var fZ = eS;
+aS = bary.x * attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]
++ bary.y * attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]
++ bary.z * attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF];
+}
+let eL = ez(normal, dp1, dp2, uv0-uv2, uv1-uv2, aS);
+(*si).geometryTangent = eL[0];
+(*si).geometryBitangent = eL[1];
+var fX = eL;
 if (USE_UV1 && directionMaterial.anisotropyMapIndex >= 0.0 && mapInfo[i32(directionMaterial.anisotropyMapIndex) + NUM_MAPS * 2].x > 0.5) {
 let a = attrBuffers[i0 * ATTR_STRIDE + UV1_OFF].xy;
 let b = attrBuffers[i1 * ATTR_STRIDE + UV1_OFF].xy;
 let c = attrBuffers[i2 * ATTR_STRIDE + UV1_OFF].xy;
-fZ = eE(normal, dp1, dp2, a-c, b-c, select(aT, vec4f(0.0), aT.w == 0.0));
+fX = ez(normal, dp1, dp2, a-c, b-c, select(aS, vec4f(0.0), aS.w == 0.0));
 }
-(*si).directionTangent = fZ[0];
-(*si).directionBitangent = fZ[1];
+(*si).directionTangent = fX[0];
+(*si).directionBitangent = fX[1];
 ${hasCoatNormals ? /* wgsl */ `
 if (USE_COAT_NORMAL_MAPS && directionMaterial.coatNormalMapIndex >= 0.0) {
-let kC = i32(directionMaterial.coatNormalMapIndex);
-var mh = eS;
-if (USE_UV1 && mapInfo[kC + NUM_MAPS * 2].x > 0.5) {
+let kP = i32(directionMaterial.coatNormalMapIndex);
+var mG = eL;
+if (USE_UV1 && mapInfo[kP + NUM_MAPS * 2].x > 0.5) {
 let a = attrBuffers[i0 * ATTR_STRIDE + UV1_OFF].xy;
 let b = attrBuffers[i1 * ATTR_STRIDE + UV1_OFF].xy;
 let c = attrBuffers[i2 * ATTR_STRIDE + UV1_OFF].xy;
-mh = eE(normal, dp1, dp2, a-c, b-c,
-select(aT, vec4f(0.0), aT.w == 0.0));
+mG = ez(normal, dp1, dp2, a-c, b-c,
+select(aS, vec4f(0.0), aS.w == 0.0));
 }
 
 
-let decoded = sampleMap(kC, getMapUvSet(kC, uv,
-select(cX, uv, uvProjection > 0))).rgb * 2.0 - 1.0;
-let mapped = mh[0] * decoded.x * directionMaterial.coatNormalScale.x
-+ mh[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
+let decoded = sampleMap(kP, getMapUvSet(kP, uv,
+select(cQ, uv, uvProjection > 0))).rgb * 2.0 - 1.0;
+let mapped = mG[0] * decoded.x * directionMaterial.coatNormalScale.x
++ mG[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { (*si).coatNormal = normalize(mapped); }
 }
 ` : ''}
@@ -1042,19 +1250,19 @@ if (dot(mapped, mapped) > 1e-12) { (*si).coatNormal = normalize(mapped); }
 (*si).normal = normal;
 (*si).vertexNormal = normal;
 (*si).shadowOffset = vec3f(0.0);
-if (!bU) {
+if (!bP) {
 
 
 
 let geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-let km = eK.x * n0 + eK.y * n1 + eK.z * n2;
+let kw = bary.x * n0 + bary.y * n1 + bary.z * n2;
 let a = dot(n2 - n0, tri.p0 - tri.p2);
 let b = dot(n2 - n1, tri.p1 - tri.p2);
 let c = dot(n1 - n0, tri.p1 - tri.p0);
-var h = a * eK.x * (eK.x - 1.0)
-+ (a + b + c) * eK.x * eK.y
-+ b * eK.y * (eK.y - 1.0);
-if (dot(km, geometricNormal) > 0.0) {
+var h = a * bary.x * (bary.x - 1.0)
++ (a + b + c) * bary.x * bary.y
++ b * bary.y * (bary.y - 1.0);
+if (dot(kw, geometricNormal) > 0.0) {
 var h0 = max(max(dot(tri.p1 - tri.p0, n0), dot(tri.p2 - tri.p0, n0)), 0.0);
 var h1 = max(max(dot(tri.p0 - tri.p1, n1), dot(tri.p2 - tri.p1, n1)), 0.0);
 var h2 = max(max(dot(tri.p0 - tri.p2, n2), dot(tri.p1 - tri.p2, n2)), 0.0);
@@ -1072,22 +1280,22 @@ h1 = max(dot((*si).position - tri.p1, n1) + h1, 0.0);
 h2 = max(dot((*si).position - tri.p2, n2) + h2, 0.0);
 h = min(-min(min(h0, h1), h2), h * 0.5);
 }
-(*si).shadowOffset = km * h;
+(*si).shadowOffset = kw * h;
 }
 (*si).uv = uv;
-(*si).uv1 = cX;
+(*si).uv1 = cQ;
 if (USE_NORMAL_MAPS) {
 let dp1 = tri.p0 - tri.p2;
 let dp2 = tri.p1 - tri.p2;
-let oc = uv0 - uv2;
-let od = uv1 - uv2;
-(*si).normal = ol(
-(*si).materialIndex, uv, normal, dp1, dp2, oc, od
+let oM = uv0 - uv2;
+let oN = uv1 - uv2;
+(*si).normal = oS(
+(*si).materialIndex, uv, normal, dp1, dp2, oM, oN
 );
 }
 }
 
-struct eC {
+struct ev {
 t: f32,
 barycentric: vec3f,
 };
@@ -1096,8 +1304,8 @@ barycentric: vec3f,
 
 
 
-fn fM(o: vec3f, d: vec3f, tri: fB, ey: i32, gQ: vec3f, tMax: f32) -> eC {
-var ti: eC;
+fn fM(o: vec3f, d: vec3f, tri: fw, dZ: i32, gH: vec3f, tMax: f32) -> ev {
+var ti: ev;
 
 
 var p0t = tri.p0 - o;
@@ -1105,11 +1313,11 @@ var p1t = tri.p1 - o;
 var p2t = tri.p2 - o;
 
 
-if (ey == 0) {
+if (dZ == 0) {
 p0t = p0t.yzx;
 p1t = p1t.yzx;
 p2t = p2t.yzx;
-} else if (ey == 1) {
+} else if (dZ == 1) {
 p0t = p0t.zxy;
 p1t = p1t.zxy;
 p2t = p2t.zxy;
@@ -1117,9 +1325,9 @@ p2t = p2t.zxy;
 
 
 
-p0t = vec3f(p0t.xy + gQ.xy * p0t.z, p0t.z);
-p1t = vec3f(p1t.xy + gQ.xy * p1t.z, p1t.z);
-p2t = vec3f(p2t.xy + gQ.xy * p2t.z, p2t.z);
+p0t = vec3f(p0t.xy + gH.xy * p0t.z, p0t.z);
+p1t = vec3f(p1t.xy + gH.xy * p1t.z, p1t.z);
+p2t = vec3f(p2t.xy + gH.xy * p2t.z, p2t.z);
 
 
 var e = vec3f(
@@ -1131,9 +1339,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 if (DEPTH_QUERY_MODE) {
 
 
-let rE = abs(vec3f(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+let sB = abs(vec3f(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
 + abs(vec3f(p1t.y * p2t.x, p2t.y * p0t.x, p0t.y * p1t.x));
-e = select(e, vec3f(0.0), abs(e) <= rE * 1e-6);
+e = select(e, vec3f(0.0), abs(e) <= sB * 1e-6);
 }
 
 
@@ -1144,19 +1352,19 @@ return ti;
 let det = e.x + e.y + e.z;
 if (DEPTH_QUERY_MODE && det == 0.0) { return ti; }
 
-p0t.z *= gQ.z;
-p1t.z *= gQ.z;
-p2t.z *= gQ.z;
-let rn = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+p0t.z *= gH.z;
+p1t.z *= gH.z;
+p2t.z *= gH.z;
+let sp = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
 
 
-if (abs(rn) > abs(tMax * det)) {
+if (abs(sp) > abs(tMax * det)) {
 return ti;
 }
 
-let sw = 1. / det;
-ti.t = rn * sw;
-ti.barycentric = e * sw;
+let tP = 1. / det;
+ti.t = sp * tP;
+ti.barycentric = e * tP;
 
 return ti;
 }
@@ -1166,26 +1374,26 @@ return ti;
 
 override DEPTH_QUERY_MODE: bool = false;
 
-fn fb(d: vec3f) -> vec3f {
+fn eW(d: vec3f) -> vec3f {
 if (!DEPTH_QUERY_MODE) { return 1.0 / d; }
 return 1.0 / select(d, select(vec3f(1e-20), vec3f(-1e-20), d < vec3f(0.0)), abs(d) < vec3f(1e-20));
 }
 
-fn eZ(gE: vec3f, o: vec3f) -> vec3f {
+fn eU(gb: vec3f, o: vec3f) -> vec3f {
 if (!DEPTH_QUERY_MODE) { return vec3f(0.0); }
-return abs(gE) * max(vec3f(1.0), abs(o)) * 1e-6;
+return abs(gb) * max(vec3f(1.0), abs(o)) * 1e-6;
 }
 
 
 
-fn cM(o: vec3f, vK: vec3f, vJ: vec3f, gE: vec3f, tMax: f32) -> f32 {
-let uR = (vK - o) * gE;
-let uS = (vJ - o) * gE;
-let bJ = eZ(gE, o);
-let mK = min(uR, uS) - bJ;
-let rU = max(uR, uS) + bJ;
-let t0 = max(mK.x, max(mK.y, mK.z));
-let t1 = min(rU.x, min(rU.y, rU.z));
+fn cH(o: vec3f, xU: vec3f, xT: vec3f, gb: vec3f, tMax: f32) -> f32 {
+let xg = (xU - o) * gb;
+let xh = (xT - o) * gb;
+let padding = eU(gb, o);
+let ns = min(xg, xh) - padding;
+let sW = max(xg, xh) + padding;
+let t0 = max(ns.x, max(ns.y, ns.z));
+let t1 = min(sW.x, min(sW.y, sW.z));
 return select(select(t1, t0, t0 > 0.0), -1.0, (t0 > t1 || t0 > tMax));
 }
 
@@ -1193,69 +1401,69 @@ fn maxDimension(v: vec3f) -> i32 {
 return select(select(2, 1, v.y > v.z), select(2, 0, v.x > v.z), v.x > v.y);
 }
 
-fn mu(d: vec3f, ey: i32) -> vec3f {
+fn mU(d: vec3f, dZ: i32) -> vec3f {
 
 
-if (ey == 0) {
+if (dZ == 0) {
 return vec3f(-d.y, -d.z, 1.0) / d.x;
-} else if (ey == 1) {
+} else if (dZ == 1) {
 return vec3f(-d.z, -d.x, 1.0) / d.y;
 } else {
 return vec3f(-d.x, -d.y, 1.0) / d.z;
 }
 }
 
-fn mi(
-si: ptr<function, ad>,
-lB: fB,
-aB: vec3f,
-hw: vec3i,
-bU: bool,
-ao: i32,
-eD: vec3f,
-eY: vec3f,
-fw: i32
+fn mH(
+si: ptr<function, SurfaceInteraction>,
+lR: fw,
+aw: vec3f,
+hr: vec3i,
+bP: bool,
+am: i32,
+ex: vec3f,
+eS: vec3f,
+fq: i32
 ) {
-(*si).instanceIndex = ao;
-(*si).barycentrics = aB.xy;
-(*si).normal = eD;
-(*si).position = eY;
-(*si).materialIndex = i32(ae(
-bitcast<i32>(instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE}].z)
+(*si).instanceIndex = am;
+(*si).barycentrics = aw.xy;
+(*si).normal = ex;
+(*si).position = eS;
+(*si).materialIndex = i32(af(
+bitcast<i32>(instancesBuffer[am * ${INSTANCE_VEC4_STRIDE}].z)
 ).x);
 
 
-ht(
+hn(
 si,
-lB,
-aB,
-hw,
-bU,
-fw
+lR,
+aw,
+hr,
+bP,
+fq
 );
 
 let l2w = mat4x4<f32>(
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 5],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 6],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 7],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 8]
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 5],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 6],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 7],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 8]
 );
 let w2l = mat4x4<f32>(
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 1],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 2],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 3],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 4]
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 1],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 2],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 3],
+instancesBuffer[am * ${INSTANCE_VEC4_STRIDE} + 4]
 );
-let aD = transpose(mat3x3<f32>(
+let aG = transpose(mat3x3<f32>(
 w2l[0].xyz,
 w2l[1].xyz,
 w2l[2].xyz
 ));
 
-(*si).faceNormal = normalize(aD * eD);
-(*si).vertexNormal = normalize(aD * (*si).vertexNormal);
-(*si).normal = normalize(aD * (*si).normal);
-${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aD * (*si).coatNormal);` : ''}
+(*si).faceNormal = normalize(aG * ex);
+(*si).vertexNormal = normalize(aG * (*si).vertexNormal);
+(*si).normal = normalize(aG * (*si).normal);
+${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aG * (*si).coatNormal);` : ''}
 if (USE_TANGENT && dot((*si).tangent, (*si).tangent) > 0.0) {
 (*si).tangent = normalize((l2w * vec4f((*si).tangent, 0.0)).xyz);
 }
@@ -1274,171 +1482,6 @@ ${createIntersectionAlphaWgsl(hasAnisotropyDirections)}
 
 
 
-
-fn cZ(ray: Ray, si: ptr<function, ad>, bounces: i32, doubleSided: bool, lC: bool) {
-
-(*si).hit = false;
-
-if (rtUniform.isEmpty > 0) {
-return;
-}
-
-var tMax = RAY_MAX_DISTANCE;
-var ey: i32;
-var gQ: vec3f;
-
-var hw: vec3i;
-var lB: fB;
-var ao: i32;
-var hO: i32 = (*si).triangleIndex;
-
-${getBVHTraverseCode(`
-(*si).triangleIndex = triangleIndex;
-lB = tri;
-hw = index;
-ao = cf;
-`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections)}
-
-if (rb) {
-mi(
-si,
-lB,
-aB,
-hw,
-bU,
-ao,
-eD,
-eY,
--1
-);
-}
-}
-
-
-fn iM(ray: Ray, si: ptr<function, ad>, instanceIndex: i32, maxDistance: f32) {
-(*si).hit = false;
-
-if (rtUniform.isEmpty > 0) {
-return;
-}
-
-let bounces = 0;
-let doubleSided = true;
-let lC = false;
-var tMax = maxDistance;
-var ey: i32;
-var gQ: vec3f;
-var hw: vec3i;
-var lB: fB;
-var ao: i32;
-var hO: i32 = -1;
-
-${getBVHTraverseCode(`
-(*si).triangleIndex = triangleIndex;
-lB = tri;
-hw = index;
-ao = cf;
-`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections, `
-if (cf != instanceIndex) {
-continue;
-}
-`)}
-
-if (rb) {
-(*si).instanceIndex = ao;
-(*si).normal = eD;
-(*si).position = eY;
-(*si).materialIndex = i32(ae(bitcast<i32>(instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE}].z)).x);
-ht(
-si,
-lB,
-aB,
-hw,
-bU,
--1
-);
-
-let l2w = mat4x4<f32>(
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 5],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 6],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 7],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 8]
-);
-let w2l = mat4x4<f32>(
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 1],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 2],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 3],
-instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 4]
-);
-let aD = transpose(mat3x3<f32>(
-w2l[0].xyz,
-w2l[1].xyz,
-w2l[2].xyz
-));
-(*si).faceNormal = normalize(aD * eD);
-(*si).vertexNormal = normalize(aD * (*si).vertexNormal);
-(*si).normal = normalize(aD * (*si).normal);
-${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aD * (*si).coatNormal);` : ''}
-if (USE_TANGENT && dot((*si).tangent, (*si).tangent) > 0.0) {
-(*si).tangent = normalize((l2w * vec4f((*si).tangent, 0.0)).xyz);
-}
-${hasAnisotropyDirections ? /* wgsl */ `
-(*si).directionTangent = (l2w * vec4f((*si).directionTangent, 0.0)).xyz;
-(*si).directionBitangent = (l2w * vec4f((*si).directionBitangent, 0.0)).xyz;
-(*si).geometryTangent = (l2w * vec4f((*si).geometryTangent, 0.0)).xyz;
-(*si).geometryBitangent = (l2w * vec4f((*si).geometryBitangent, 0.0)).xyz;
-` : /* wgsl */ ``}
-(*si).shadowOffset = (l2w * vec4f((*si).shadowOffset, 0.0)).xyz;
-(*si).position = (l2w * vec4((*si).position, 1.0)).xyz;
-}
-}
-
-fn ex(ray: Ray, lightDistance: f32, jL: i32) -> bool {
-if (rtUniform.isEmpty > 0) {
-return false;
-}
-
-let doubleSided = true;
-let qo = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-var tMax = qo;
-var ey: i32;
-var gQ: vec3f;
-
-let bounces = 1;
-var lC = false;
-var hO: i32 = jL;
-
-${getBVHTraverseCode(
-    /*wgsl */ `
-
-
-
-var jt = true;
-
-if (jt) {
-if (HAS_ALPHA) {
-let materialIndex = i32(ae(bitcast<i32>(ot.z)).x);
-if (!nF(
-materialIndex,
-index,
-aB,
-eY,
-eD
-)) {
-
-tMax = qo;
-jt = false;
-}
-}
-}
-if (jt) {
-return true;
-}
-`, hasDisplacement, true, blasLayoutMask, hasAnisotropyDirections)}
-
-return false;
-}
-
-`;
+${sceneIntersections || createSceneIntersectionsWgsl({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask })}`;
 }
 //# sourceMappingURL=intersect.wgsl.js.map