@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -8,35 +8,35 @@ import { createIntersectionAlphaWgsl } from './intersectionAlpha.wgsl.js';
 const displacementWgsl = pdm_displacementWgsl;
 const flatIntersectCode = function () {
     return /* wgsl */ `
-let hit = ga(o, d, tri, eq, gY, tMax);
+let hit = fY(o, d, tri, ei, gZ, tMax);
 if (hit.t > 0.0) {
 let e1 = tri.p1 - tri.p0;
 let e2 = tri.p2 - tri.p0;
-eL = normalize(cross(e1, e2));
-let kP = i32(ah(bitcast<i32>(pi.z)).x);
-let jd = materialsBuffer[kP].doubleSided > 0.5;
-if (!doubleSided && !jd && dot(eL, d) > 0.0) {
-eL = vec3f(0.0);
+hitNormal = normalize(cross(e1, e2));
+let lc = i32(af(bitcast<i32>(qf.z)).x);
+let jm = materialsBuffer[lc].doubleSided > 0.5;
+if (!doubleSided && !jm && dot(hitNormal, d) > 0.0) {
+hitNormal = vec3f(0.0);
 continue;
 }
 
 tMax = hit.t;
-sj = true;
-pl = true;
-fi = o + tMax * d;
-aC = hit.barycentric;
+tD = true;
+qi = true;
+fe = o + tMax * d;
+aw = hit.barycentric;
 }
 `;
 };
 function getPDMDisplacmentCode(anyHit) {
     return /*wgsl */ `
-let lH = pY(
+let mh = qW(
 o, d, tMax,
 tri.p0, tri.p1, tri.p2,
 n0, n1, n2,
 uv0, uv1, uv2,
 displacementMapIndex,
-jO(displacementMapIndex),
+getMapSize(displacementMapIndex),
 minH, maxH,
 hScale,
 matData.displacementBias,
@@ -44,51 +44,51 @@ matData.displacementStepSize,
 i32(matData.displacementUvProjection),
 displacementUvProjectionScale,
 ${anyHit ? 'true' : 'false'},
-jA
+jK
 );
 `;
 }
 const displacementIntersectCode = function (anyHit, hasAnisotropyDirections) {
     return /* wgsl */ `
 
-let hScale = pi.w;
-let uQ = bitcast<i32>(r3.w);
+let hScale = qf.w;
+let wK = bitcast<i32>(r3.w);
 
-let materialIndex = i32(ah(bitcast<i32>(pi.z)).x);
+let materialIndex = i32(af(bitcast<i32>(qf.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' : ''});
-let n2 = normalize(attrBuffers[index.z * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+let n0 = normalize(vertexNormal(index.x));
+let n1 = normalize(vertexNormal(index.y));
+let n2 = normalize(vertexNormal(index.z));
 if (matData.displacementMapIndex >= 0.0 && matData.displacementBias != 0.0) {
 tri.p0 += n0 * matData.displacementBias;
 tri.p1 += n1 * matData.displacementBias;
 tri.p2 += n2 * matData.displacementBias;
 }
-if (abs(hScale) > 0.0 && uQ > 0) {
-let minH = f32(uQ >> 8) / 255.0;
-let maxH = f32(uQ & 0xff) / 255.0;
+if (abs(hScale) > 0.0 && wK > 0) {
+let minH = f32(wK >> 8) / 255.0;
+let maxH = f32(wK & 0xff) / 255.0;
 let displacementUvProjectionScale = vec2f(matData.displacementUvProjectionScale);
 let displacementMapIndex = i32(matData.displacementMapIndex);
 
 
-var uv0 = attrBuffers[index.x * ATTR_STRIDE + UV_OFF].xy;
-var uv1 = attrBuffers[index.y * ATTR_STRIDE + UV_OFF].xy;
-var uv2 = attrBuffers[index.z * ATTR_STRIDE + UV_OFF].xy;
+var uv0 = hd(index.x);
+var uv1 = hd(index.y);
+var uv2 = hd(index.z);
 
 ${getPDMDisplacmentCode(anyHit)}
 
-if (lH.t < tMax) {
-eL = lH.normal;
+if (mh.t < tMax) {
+hitNormal = mh.normal;
 
 
-tMax = lH.t;
+tMax = mh.t;
 
-aC = lH.barycentric;
-fi = o + tMax * d;
+aw = mh.barycentric;
+fe = o + tMax * d;
 
-bZ = true;
-sj = true;
-pl = true;
+bQ = true;
+tD = true;
+qi = true;
 }
 }
 else {
@@ -97,7 +97,7 @@ ${flatIntersectCode()}
 `;
 };
 const cwbvhTraversalWgsl = /* wgsl */ `
-fn bA(value: u32) -> vec4f {
+fn bn(value: u32) -> vec4f {
 return vec4f(
 f32(value & 0xffu),
 f32((value >> 8u) & 0xffu),
@@ -112,118 +112,118 @@ f32(value >> 24u)
 
 
 
-fn lb(value: u32) -> u32 {
+fn lv(value: u32) -> u32 {
 return (bitcast<u32>(f32(value)) >> 23u) - 127u;
 }
 
-fn oT(value: u32) -> u32 {
+fn pR(value: u32) -> u32 {
 return (bitcast<u32>(f32(value)) >> 23u) - 127u;
 }
 
-fn pj(
+fn qg(
 node: i32,
-uJ: i32,
+ww: i32,
 n0: vec4f,
 o: vec3f,
-gr: vec3f,
+invD: vec3f,
 tMax: f32
 ) -> u32 {
-let i = node + uJ;
+let i = node + ww;
 let n2 = bvhBuffer[i + 2];
 let n3 = bvhBuffer[i + 3];
 let n4 = bvhBuffer[i + 4];
 let header = bitcast<u32>(n0.w);
-let sH = bitcast<i32>((header & 0xffu) << 24u) >> 24;
-let sI = bitcast<i32>(((header >> 8u) & 0xffu) << 24u) >> 24;
-let sJ = bitcast<i32>(((header >> 16u) & 0xffu) << 24u) >> 24;
-let hZ = vec3f(
-bitcast<f32>(u32(sH + 127) << 23u),
-bitcast<f32>(u32(sI + 127) << 23u),
-bitcast<f32>(u32(sJ + 127) << 23u)
+let uc = bitcast<i32>((header & 0xffu) << 24u) >> 24;
+let ud = bitcast<i32>(((header >> 8u) & 0xffu) << 24u) >> 24;
+let ue = bitcast<i32>(((header >> 16u) & 0xffu) << 24u) >> 24;
+let ih = vec3f(
+bitcast<f32>(u32(uc + 127) << 23u),
+bitcast<f32>(u32(ud + 127) << 23u),
+bitcast<f32>(u32(ue + 127) << 23u)
 );
-let padding = fk(gr, o);
-let eS = (n0.xyz - o) * gr;
-let dq = hZ * gr;
+let padding = ff(invD, o);
+let eM = (n0.xyz - o) * invD;
+let cW = ih * invD;
 
 
 
-let vc = bitcast<vec4u>(n2);
-let vd = bitcast<vec4u>(n3);
-let ve = bitcast<vec4u>(n4);
-let negative = gr < vec3f(0.0);
-let wn = select(vc.xy, vd.zw, negative.x);
-let xt = select(vd.zw, vc.xy, negative.x);
-let wo = select(vc.zw, ve.xy, negative.y);
-let xu = select(ve.xy, vc.zw, negative.y);
-let wp = select(vd.xy, ve.zw, negative.z);
-let xv = select(ve.zw, vd.xy, negative.z);
+let xd = bitcast<vec4u>(n2);
+let xe = bitcast<vec4u>(n3);
+let xf = bitcast<vec4u>(n4);
+let negative = invD < vec3f(0.0);
+let yK = select(xd.xy, xe.zw, negative.x);
+let zV = select(xe.zw, xd.xy, negative.x);
+let yL = select(xd.zw, xf.xy, negative.y);
+let zW = select(xf.xy, xd.zw, negative.y);
+let yM = select(xe.xy, xf.zw, negative.z);
+let zX = select(xf.zw, xe.xy, negative.z);
 
-let yl = max(
+let AL = max(
 max(
-bA(wn.x) * dq.x + eS.x - vec4f(padding.x),
-bA(wo.x) * dq.y + eS.y - vec4f(padding.y)
+bn(yK.x) * cW.x + eM.x - vec4f(padding.x),
+bn(yL.x) * cW.y + eM.y - vec4f(padding.y)
 ),
-bA(wp.x) * dq.z + eS.z - vec4f(padding.z)
+bn(yM.x) * cW.z + eM.z - vec4f(padding.z)
 );
-let yg = min(
+let AF = min(
 min(
-bA(xt.x) * dq.x + eS.x + vec4f(padding.x),
-bA(xu.x) * dq.y + eS.y + vec4f(padding.y)
+bn(zV.x) * cW.x + eM.x + vec4f(padding.x),
+bn(zW.x) * cW.y + eM.y + vec4f(padding.y)
 ),
-bA(xv.x) * dq.z + eS.z + vec4f(padding.z)
+bn(zX.x) * cW.z + eM.z + vec4f(padding.z)
 );
-let ym = max(
+let AM = max(
 max(
-bA(wn.y) * dq.x + eS.x - vec4f(padding.x),
-bA(wo.y) * dq.y + eS.y - vec4f(padding.y)
+bn(yK.y) * cW.x + eM.x - vec4f(padding.x),
+bn(yL.y) * cW.y + eM.y - vec4f(padding.y)
 ),
-bA(wp.y) * dq.z + eS.z - vec4f(padding.z)
+bn(yM.y) * cW.z + eM.z - vec4f(padding.z)
 );
-let yh = min(
+let AG = min(
 min(
-bA(xt.y) * dq.x + eS.x + vec4f(padding.x),
-bA(xu.y) * dq.y + eS.y + vec4f(padding.y)
+bn(zV.y) * cW.x + eM.x + vec4f(padding.x),
+bn(zW.y) * cW.y + eM.y + vec4f(padding.y)
 ),
-bA(xv.y) * dq.z + eS.z + vec4f(padding.z)
+bn(zX.y) * cW.z + eM.z + vec4f(padding.z)
 );
 
-let wl = (yl <= min(yg, vec4f(tMax))) & (yg > vec4f(0.0));
-let wm = (ym <= min(yh, vec4f(tMax))) & (yh > vec4f(0.0));
-return select(0u, 1u, wl.x)
-| select(0u, 2u, wl.y)
-| select(0u, 4u, wl.z)
-| select(0u, 8u, wl.w)
-| select(0u, 16u, wm.x)
-| select(0u, 32u, wm.y)
-| select(0u, 64u, wm.z)
-| select(0u, 128u, wm.w);
+let yG = (AL <= min(AF, vec4f(tMax))) & (AF > vec4f(0.0));
+let yH = (AM <= min(AG, vec4f(tMax))) & (AG > vec4f(0.0));
+return select(0u, 1u, yG.x)
+| select(0u, 2u, yG.y)
+| select(0u, 4u, yG.z)
+| select(0u, 8u, yG.w)
+| select(0u, 16u, yH.x)
+| select(0u, 32u, yH.y)
+| select(0u, 64u, yH.z)
+| select(0u, 128u, yH.w);
 }
 
 `;
-function getBVHTraverseCode(handleHitCode, hasDisplacement, anyHit, blasLayoutMask, hasAnisotropyDirections, skipTriangleCode = '') {
+function getBVHTraverseCode(handleHitCode, hasDisplacement, anyHit, blasLayoutMask, hasAnisotropyDirections, skipTriangleCode = '', perInstanceBounds = false) {
     const intersectTriangles = /* wgsl */ `
-let pi = instancesBuffer[bY * ${INSTANCE_VEC4_STRIDE}];
-let vertexOffset = vec3i(bitcast<i32>(pi.y));
+let qf = instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE}];
+let vertexOffset = vec3i(bitcast<i32>(qf.y));
 for (var k = 0; k < primitiveCount; k++) {
 let triangleIndex = primitiveOffset + k;
 ${skipTriangleCode}
-if (bounces > 0 && triangleIndex == fV) {
+if (bounces > 0 && triangleIndex == fT && bK == fS) {
 continue;
 }
 
 let r3 = bvhBuffer[triangleIndex];
 let index = bitcast<vec3i>(r3.xyz) + vertexOffset;
-var tri = fP(
-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 tri = fL(
+vertexPosition(index.x),
+vertexPosition(index.y),
+vertexPosition(index.z)
 );
-var pl = false;
+var qi = false;
 
 ${hasDisplacement
         ? displacementIntersectCode(anyHit, hasAnisotropyDirections)
         : flatIntersectCode()}
-if (pl) {
+if (qi) {
 ${handleHitCode}
 }
 }
@@ -231,285 +231,291 @@ ${handleHitCode}
     return /* wgsl */ `
 var d = ray.d;
 var o = ray.o;
-var jE = -1;
-var gr = fo(d);
-var bZ = false;
-var sj = false;
-var fi: vec3f;
-var eL: vec3f;
-var aC: vec3f;
-
-
-if (cU(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, gr, tMax) > 0.0) {
-jE = 0;
-mK[0] = 0;
-}
-while (jE >= 0) {
-let ul = mK[jE];
-jE--;
+var jO = -1;
+${perInstanceBounds ? 'let worldInvD = traversalInverse(ray.d);\nvar invD = worldInvD;' : 'var invD = traversalInverse(d);'}
+var bQ = false;
+var tD = false;
+var fe: vec3f;
+var hitNormal: vec3f;
+var aw: vec3f;
+
+
+if (bP(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, invD, tMax) > 0.0) {
+jO = 0;
+nA[0] = 0;
+}
+while (jO >= 0) {
+let vY = nA[jO];
+jO--;
 o = ray.o;
 d = ray.d;
-gr = fo(d);
-
-let xW = bvhBuffer[ul];
-let ff = bitcast<i32>(xW.w);
-if (ff >= 0) {
-let left = ul + 2;
-let right = ff;
-let d0 = cU(
+invD = traversalInverse(d);
+
+let Ax = bvhBuffer[vY];
+let eZ = bitcast<i32>(Ax.w);
+if (eZ >= 0) {
+let left = vY + 2;
+let right = eZ;
+let d0 = bP(
 o,
 bvhBuffer[left].xyz,
 bvhBuffer[left + 1].xyz,
-gr,
+invD,
 tMax
 );
-let d1 = cU(
+let d1 = bP(
 o,
 bvhBuffer[right].xyz,
 bvhBuffer[right + 1].xyz,
-gr,
+invD,
 tMax
 );
 
 if (d0 > d1) {
-if (d0 > 0.0) { jE++; mK[jE] = left; }
-if (d1 > 0.0) { jE++; mK[jE] = right; }
+if (d0 > 0.0) { jO++; nA[jO] = left; }
+if (d1 > 0.0) { jO++; nA[jO] = right; }
 }
 else {
-if (d1 > 0.0) { jE++; mK[jE] = right; }
-if (d0 > 0.0) { jE++; mK[jE] = left; }
+if (d1 > 0.0) { jO++; nA[jO] = right; }
+if (d0 > 0.0) { jO++; nA[jO] = left; }
 }
 }
 else {
-let rQ = -ff;
+let td = -eZ;
 
 
 for (
-var nq = rQ - 1;
-nq >= 0;
-nq--
+var nX = td - 1;
+nX >= 0;
+nX--
 ) {
-let qv = bvhBuffer[ul + 2 + nq];
-let bY = bitcast<i32>(qv.x);
-let wL = bitcast<i32>(qv.y);
-let pi = instancesBuffer[bY * ${INSTANCE_VEC4_STRIDE}];
+let nY = bvhBuffer[vY + 2 + nX];
+let bK = bitcast<i32>(nY.x);
+${perInstanceBounds ? /* wgsl */ `      
+
+let box = bitcast<i32>(nY.w);
+if (bP(ray.o, bvhBuffer[box].xyz, bvhBuffer[box + 1].xyz, worldInvD, tMax) <= 0.0) {
+continue;
+}
+` : ''}      let zn = bitcast<i32>(nY.y);
+let qf = instancesBuffer[bK * ${INSTANCE_VEC4_STRIDE}];
 let w2l = mat4x4<f32>(
-instancesBuffer[bY * ${INSTANCE_VEC4_STRIDE} + 1],
-instancesBuffer[bY * ${INSTANCE_VEC4_STRIDE} + 2],
-instancesBuffer[bY * ${INSTANCE_VEC4_STRIDE} + 3],
-instancesBuffer[bY * ${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;
-gr = fo(d);
-eq = maxDimension(abs(d));
-gY = nk(d, eq);
+invD = traversalInverse(d);
+ei = maxDimension(abs(d));
+gZ = nV(d, ei);
 
-let fY = bitcast<u32>(pi.x);
-let he = fY >> 30u;
-let blasOffset = i32(fY & 0x3fffffffu);
-let bw = rtUniform.blasOffset;
+let fW = bitcast<u32>(qf.x);
+let hj = fW >> 30u;
+let blasOffset = i32(fW & 0x3fffffffu);
+let bufferOff = rtUniform.blasOffset;
 
 ${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `
-if (he == 3u) {
+if (hj == 3u) {
 
 
 
 
-var qj = -1;
-var td = 0u;
-var lJ = 0u;
+var rk = -1;
+var uD = 0u;
+var mj = 0u;
 
-var eD = 0x80000000u;
-let vU = select(0u, 4u, d.x < 0.0)
+var eu = 0x80000000u;
+let yl = select(0u, 4u, d.x < 0.0)
 | select(0u, 2u, d.y < 0.0)
 | select(0u, 1u, d.z < 0.0);
-let rn = 7u - vU;
+let su = 7u - yl;
 
 
 
 
-while (td < 4096u) {
-td++;
+while (uD < 4096u) {
+uD++;
 
-let internalMask = eD & 0xffu;
-let ri =
-lb(eD >> 24u) + 24u;
-eD &= ~(1u << ri);
-if ((eD & 0xff000000u) != 0u) {
-qj++;
+let internalMask = eu & 0xffu;
+let sp =
+lv(eu >> 24u) + 24u;
+eu &= ~(1u << sp);
+if ((eu & 0xff000000u) != 0u) {
+rk++;
 
-tD[qj] = vec2u(lJ, eD);
+ve[rk] = vec2u(mj, eu);
 }
 
-let slot = (ri - 24u) ^ rn;
-let om = (1u << slot) - 1u;
-let relativeIndex = countOneBits(internalMask & om);
-let tA = lJ + relativeIndex;
-let node = blasOffset + i32(tA * 5u);
-let jZ = bvhBuffer[node + bw];
-let vG = pj(
-node, bw, jZ, o, gr, tMax
+let slot = (sp - 24u) ^ su;
+let oZ = (1u << slot) - 1u;
+let relativeIndex = countOneBits(internalMask & oZ);
+let va = mj + relativeIndex;
+let node = blasOffset + i32(va * 5u);
+let kj = bvhBuffer[node + bufferOff];
+let xK = qg(
+node, bufferOff, kj, o, invD, tMax
 );
 
 
-eD = 0u;
-if (vG != 0u) {
-let fU = bvhBuffer[node + bw + 1];
-let sP = bitcast<u32>(jZ.w) >> 24u;
-var uO = 0u;
-var kM = vG;
-while (kM != 0u) {
-let sC = lb(kM);
-kM &= ~(1u << sC);
-let tT = select(
-bitcast<u32>(fU.z),
-bitcast<u32>(fU.w),
-sC >= 4u
+eu = 0u;
+if (xK != 0u) {
+let fR = bvhBuffer[node + bufferOff + 1];
+let ul = bitcast<u32>(kj.w) >> 24u;
+var wG = 0u;
+var kW = xK;
+while (kW != 0u) {
+let tW = lv(kW);
+kW &= ~(1u << tW);
+let vF = select(
+bitcast<u32>(fR.z),
+bitcast<u32>(fR.w),
+tW >= 4u
 );
-let uB =
-(tT >> ((sC & 3u) * 8u)) & 0xffu;
-let kb = uB & 0x1fu;
-let wK = select(
-kb,
-kb ^ rn,
-kb >= 24u
+let wn =
+(vF >> ((tW & 3u) * 8u)) & 0xffu;
+let kl = wn & 0x1fu;
+let zm = select(
+kl,
+kl ^ su,
+kl >= 24u
 );
-let wt = (uB >> 5u) & 0x7u;
-uO |= wt << wK;
+let yR = (wn >> 5u) & 0x7u;
+wG |= yR << zm;
 }
 
-lJ = bitcast<u32>(fU.x);
-eD = (uO & 0xff000000u) | sP;
-let pM = bitcast<u32>(fU.y);
-var pN = uO & 0x00ffffffu;
-while (pN != 0u) {
-let oO = oT(pN);
-pN &= ~(1u << oO);
+mj = bitcast<u32>(fR.x);
+eu = (wG & 0xff000000u) | ul;
+let qE = bitcast<u32>(fR.y);
+var qF = wG & 0x00ffffffu;
+while (qF != 0u) {
+let pI = pR(qF);
+qF &= ~(1u << pI);
 let primitiveCount = 1;
-let primitiveOffset = bw + blasOffset
-+ i32(pM + oO);
+let primitiveOffset = bufferOff + blasOffset
++ i32(qE + pI);
 ${intersectTriangles}
 }
 }
 
-if ((eD & 0xff000000u) != 0u) { continue; }
-if (qj >= 0) {
-let ro = tD[qj];
-lJ = ro.x;
-eD = ro.y;
-qj--;
+if ((eu & 0xff000000u) != 0u) { continue; }
+if (rk >= 0) {
+let sw = ve[rk];
+mj = sw.x;
+eu = sw.y;
+rk--;
 }
 else { break; }
 }
 }
 ` : ''}
 
-var eh = -1;
-if (he != 3u) {
-eh = 0;
+var dX = -1;
+if (hj != 3u) {
+dX = 0;
 
-gJ[0] = wL;
+gL[0] = zn;
 }
 
-while (eh >= 0) {
+while (dX >= 0) {
 
-let node = gJ[eh];
-eh--;
+let node = gL[dX];
+dX--;
 var primitiveCount = 0;
 var primitiveOffset = 0;
 
 ${(blasLayoutMask & 4) !== 0 ? /* wgsl */ `
-if (he == 2u) {
-let i = node + bw;
-let wP = bvhBuffer[i];
-let wQ = bvhBuffer[i + 1];
-let wR = bvhBuffer[i + 2];
-let wS = bvhBuffer[i + 3];
-primitiveCount = i32(bitcast<u32>(wR.w));
+if (hj == 2u) {
+let i = node + bufferOff;
+let zr = bvhBuffer[i];
+let zs = bvhBuffer[i + 1];
+let zt = bvhBuffer[i + 2];
+let zu = bvhBuffer[i + 3];
+primitiveCount = i32(bitcast<u32>(zt.w));
 if (primitiveCount > 0) {
-primitiveOffset = bw + blasOffset
-+ i32(bitcast<u32>(wS.w));
+primitiveOffset = bufferOff + blasOffset
++ i32(bitcast<u32>(zu.w));
 }
 else {
-let left = blasOffset + i32(bitcast<u32>(wP.w) * 4u);
-let right = blasOffset + i32(bitcast<u32>(wQ.w) * 4u);
-let pm = cU(
-o, wP.xyz, wQ.xyz, gr, tMax
+let left = blasOffset + i32(bitcast<u32>(zr.w) * 4u);
+let right = blasOffset + i32(bitcast<u32>(zs.w) * 4u);
+let qj = bP(
+o, zr.xyz, zs.xyz, invD, tMax
 );
-let oq = cU(
-o, wR.xyz, wS.xyz, gr, tMax
+let pb = bP(
+o, zt.xyz, zu.xyz, invD, tMax
 );
-if (pm > oq) {
-if (pm > 0.0) {
-eh++; gJ[eh] = left;
+if (qj > pb) {
+if (qj > 0.0) {
+dX++; gL[dX] = left;
 }
-if (oq > 0.0) {
-eh++; gJ[eh] = right;
+if (pb > 0.0) {
+dX++; gL[dX] = right;
 }
 }
 else {
-if (oq > 0.0) {
-eh++; gJ[eh] = right;
+if (pb > 0.0) {
+dX++; gL[dX] = right;
 }
-if (pm > 0.0) {
-eh++; gJ[eh] = left;
+if (qj > 0.0) {
+dX++; gL[dX] = left;
 }
 }
 }
 }
 ` : ''}
 ${(blasLayoutMask & 2) !== 0 ? /* wgsl */ `
-if (he == 1u) {
-let iw = bitcast<u32>(node);
-if ((iw & 0x80000000u) != 0u) {
-primitiveCount = i32((iw >> 23u) & 0xffu);
-primitiveOffset = bw + blasOffset
-+ i32(iw & 0x007fffffu);
+if (hj == 1u) {
+let iE = bitcast<u32>(node);
+if ((iE & 0x80000000u) != 0u) {
+primitiveCount = i32((iE >> 23u) & 0xffu);
+primitiveOffset = bufferOff + blasOffset
++ i32(iE & 0x007fffffu);
 }
 else {
-let i = node + bw;
-let vJ = bvhBuffer[i];
-let sz = bvhBuffer[i + 1];
-let qR = bvhBuffer[i + 2];
-let oQ = bvhBuffer[i + 3];
-let nodeMin = vJ.xyz;
-let er = vec3f(vJ.w, sz.x, sz.y);
-let mT = array<u32, 4>(
-bitcast<u32>(sz.z), bitcast<u32>(sz.w),
-bitcast<u32>(qR.x), bitcast<u32>(qR.y)
+let i = node + bufferOff;
+let xS = bvhBuffer[i];
+let tR = bvhBuffer[i + 1];
+let rW = bvhBuffer[i + 2];
+let pL = bvhBuffer[i + 3];
+let nodeMin = xS.xyz;
+let ej = vec3f(xS.w, tR.x, tR.y);
+let nH = array<u32, 4>(
+bitcast<u32>(tR.z), bitcast<u32>(tR.w),
+bitcast<u32>(rW.x), bitcast<u32>(rW.y)
 );
 
 
-let negative = gr < vec3f(0.0);
-let wn = unpack4x8unorm(bitcast<u32>(select(qR.z, oQ.y, negative.x)));
-let xt = unpack4x8unorm(bitcast<u32>(select(oQ.y, qR.z, negative.x)));
-let wo = unpack4x8unorm(bitcast<u32>(select(qR.w, oQ.z, negative.y)));
-let xu = unpack4x8unorm(bitcast<u32>(select(oQ.z, qR.w, negative.y)));
-let wp = unpack4x8unorm(bitcast<u32>(select(oQ.x, oQ.w, negative.z)));
-let xv = unpack4x8unorm(bitcast<u32>(select(oQ.w, oQ.x, negative.z)));
-let padding = fk(gr, o);
-let nJ = max(
+let negative = invD < vec3f(0.0);
+let yK = unpack4x8unorm(bitcast<u32>(select(rW.z, pL.y, negative.x)));
+let zV = unpack4x8unorm(bitcast<u32>(select(pL.y, rW.z, negative.x)));
+let yL = unpack4x8unorm(bitcast<u32>(select(rW.w, pL.z, negative.y)));
+let zW = unpack4x8unorm(bitcast<u32>(select(pL.z, rW.w, negative.y)));
+let yM = unpack4x8unorm(bitcast<u32>(select(pL.x, pL.w, negative.z)));
+let zX = unpack4x8unorm(bitcast<u32>(select(pL.w, pL.x, negative.z)));
+let padding = ff(invD, o);
+let ot = max(
 max(
-(nodeMin.x + wn * er.x - o.x) * gr.x - vec4f(padding.x),
-(nodeMin.y + wo * er.y - o.y) * gr.y - vec4f(padding.y)
+(nodeMin.x + yK * ej.x - o.x) * invD.x - vec4f(padding.x),
+(nodeMin.y + yL * ej.y - o.y) * invD.y - vec4f(padding.y)
 ),
-(nodeMin.z + wp * er.z - o.z) * gr.z - vec4f(padding.z)
+(nodeMin.z + yM * ej.z - o.z) * invD.z - vec4f(padding.z)
 );
-let sY = min(
+let uA = min(
 min(
-(nodeMin.x + xt * er.x - o.x) * gr.x + vec4f(padding.x),
-(nodeMin.y + xu * er.y - o.y) * gr.y + vec4f(padding.y)
+(nodeMin.x + zV * ej.x - o.x) * invD.x + vec4f(padding.x),
+(nodeMin.y + zW * ej.y - o.y) * invD.y + vec4f(padding.y)
 ),
-(nodeMin.z + xv * er.z - o.z) * gr.z + vec4f(padding.z)
+(nodeMin.z + zX * ej.z - o.z) * invD.z + vec4f(padding.z)
 );
-var distance = select(sY, nJ, nJ > vec4f(0.0));
+var distance = select(uA, ot, ot > vec4f(0.0));
 distance = select(
 distance,
 vec4f(-1.0),
-nJ > min(sY, vec4f(tMax))
+ot > min(uA, vec4f(tMax))
 );
-var fq = array<f32, 4>(
+var fi = array<f32, 4>(
 distance.x,
 distance.y,
 distance.z,
@@ -518,78 +524,78 @@ distance.w
 
 
 for (var order = 0; order < 4; order++) {
-var em = -1.0;
-var eB = -1;
+var ee = -1.0;
+var eq = -1;
 for (var child = 0; child < 4; child++) {
 if (
-mT[child] != 0u &&
-fq[child] > em
+nH[child] != 0u &&
+fi[child] > ee
 ) {
-em = fq[child];
-eB = child;
+ee = fi[child];
+eq = child;
 }
 }
-if (eB >= 0 && em > 0.0) {
-let oy = mT[eB];
-var ki = bitcast<i32>(oy);
-if ((oy & 0x80000000u) == 0u) {
-ki += blasOffset;
+if (eq >= 0 && ee > 0.0) {
+let ph = nH[eq];
+var kv = bitcast<i32>(ph);
+if ((ph & 0x80000000u) == 0u) {
+kv += blasOffset;
 }
-eh++;
-gJ[eh] = ki;
-fq[eB] = -1.0;
+dX++;
+gL[dX] = kv;
+fi[eq] = -1.0;
 }
 }
 }
 }
 ` : ''}
 ${(blasLayoutMask & 1) !== 0 ? /* wgsl */ `
-if (he == 0u) {
-let i = node + bw;
+if (hj == 0u) {
+let i = node + bufferOff;
 let r1 = bvhBuffer[i];
-let bl = bitcast<i32>(r1.w);
+let bh = bitcast<i32>(r1.w);
 
-if (bl >= 0) {
+if (bh >= 0) {
 let left = node + 2;
-let right = bl + blasOffset;
-let d0 = cU(
+let right = bh + blasOffset;
+let d0 = bP(
 o,
-bvhBuffer[left + bw].xyz,
-bvhBuffer[left + 1 + bw].xyz,
-gr,
+bvhBuffer[left + bufferOff].xyz,
+bvhBuffer[left + 1 + bufferOff].xyz,
+invD,
 tMax
 );
-let d1 = cU(
+let d1 = bP(
 o,
-bvhBuffer[right + bw].xyz,
-bvhBuffer[right + 1 + bw].xyz,
-gr,
+bvhBuffer[right + bufferOff].xyz,
+bvhBuffer[right + 1 + bufferOff].xyz,
+invD,
 tMax
 );
 
 if (d0 > d1) {
 if (d0 > 0.0) {
-eh++; gJ[eh] = left;
+dX++; gL[dX] = left;
 
 }
 if (d1 > 0.0) {
-eh++; gJ[eh] = right;
+dX++; gL[dX] = right;
 
 }
 }
 else {
 if (d1 > 0.0) {
-eh++; gJ[eh] = right;
+dX++; gL[dX] = right;
 
 }
 if (d0 > 0.0) {
-eh++; gJ[eh] = left;
+dX++; gL[dX] = left;
 
 }
 }
 }
 else {
-primitiveCount = -bl;
+primitiveCount = -bh;
 primitiveOffset = i + 2;
 }
 }
@@ -608,31 +614,32 @@ ${intersectTriangles}
 // triangle tests without surface completion or any integrator/alpha sampling.
 export function createSceneHitQueryWgsl(hasAnisotropyDirections = false) {
     return /* wgsl */ `
-struct rd {
+struct sl {
 hit: bool, instance: i32, record: i32, t: f32, barycentric: vec3f,
 }
-fn vW(ray: Ray) -> rd {
-var result: rd;
+fn yn(ray: Ray) -> sl {
+var result: sl;
 result.instance = -1; result.record = -1; result.t = RAY_MAX_DISTANCE;
 if (rtUniform.isEmpty > 0) { return result; }
 let bounces = 0;
 let doubleSided = false;
-let jA = false;
-let fV = -1;
+let jK = false;
+let fT = -1;
+let fS = -1;
 var tMax = RAY_MAX_DISTANCE;
-var eq: i32;
-var gY: vec3f;
+var ei: i32;
+var gZ: vec3f;
 ${getBVHTraverseCode(`
-result.hit = true; result.instance = bY; result.record = triangleIndex;
-result.t = tMax; result.barycentric = aC;
+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 = '' }) {
+export function createSceneIntersectionsWgsl({ perInstanceBounds = false, compactVertices = false, 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, jA: bool) {
+fn ${closestName}(ray: Ray, si: ptr<function, SurfaceInteraction>, bounces: i32, doubleSided: bool, jK: bool) {
 
 (*si).hit = false;
 
@@ -641,31 +648,32 @@ return;
 }
 
 var tMax = RAY_MAX_DISTANCE;
-var eq: i32;
-var gY: vec3f;
+var ei: i32;
+var gZ: vec3f;
 
-var hK: vec3i;
-var mk: fP;
-var ap: i32;
-var fV: i32 = (*si).triangleIndex;
+var hL: vec3i;
+var mL: fL;
+var am: i32;
+var fT: i32 = (*si).triangleIndex;
+let fS = (*si).instanceIndex;
 
 ${getBVHTraverseCode(`
 (*si).triangleIndex = triangleIndex;
-mk = tri;
-hK = index;
-ap = bY;
-`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections)}
+mL = tri;
+hL = index;
+am = bK;
+`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections, '', perInstanceBounds)}
 
-${closestHitHook}  if (sj) {
-mV(
+${closestHitHook}  if (tD) {
+nJ(
 si,
-mk,
-aC,
-hK,
-bZ,
-ap,
-eL,
-fi,
+mL,
+aw,
+hL,
+bQ,
+am,
+hitNormal,
+fe,
 -1
 );
 }
@@ -681,58 +689,59 @@ return;
 
 let bounces = 0;
 let doubleSided = true;
-let jA = false;
+let jK = false;
 var tMax = maxDistance;
-var eq: i32;
-var gY: vec3f;
-var hK: vec3i;
-var mk: fP;
-var ap: i32;
-var fV: i32 = -1;
+var ei: i32;
+var gZ: vec3f;
+var hL: vec3i;
+var mL: fL;
+var am: i32;
+var fT: i32 = -1;
+let fS = instanceIndex;
 
 ${getBVHTraverseCode(`
 (*si).triangleIndex = triangleIndex;
-mk = tri;
-hK = index;
-ap = bY;
+mL = tri;
+hL = index;
+am = bK;
 `, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections, `
-if (bY != instanceIndex) {
+if (bK != instanceIndex) {
 continue;
 }
-`)}
+`, perInstanceBounds)}
 
-if (sj) {
-(*si).instanceIndex = ap;
-(*si).normal = eL;
-(*si).position = fi;
-(*si).materialIndex = i32(ah(bitcast<i32>(instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE}].z)).x);
-hH(
+if (tD) {
+(*si).instanceIndex = am;
+(*si).normal = hitNormal;
+(*si).position = fe;
+(*si).materialIndex = i32(af(bitcast<i32>(instancesBuffer[am * ${INSTANCE_VEC4_STRIDE}].z)).x);
+hI(
 si,
-mk,
-aC,
-hK,
-bZ,
+mL,
+aw,
+hL,
+bQ,
 -1
 );
 
 let l2w = mat4x4<f32>(
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 5],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 6],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 7],
-instancesBuffer[ap * ${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[ap * ${INSTANCE_VEC4_STRIDE} + 1],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 2],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 3],
-instancesBuffer[ap * ${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 aH = transpose(mat3x3<f32>(
 w2l[0].xyz,
 w2l[1].xyz,
 w2l[2].xyz
 ));
-(*si).faceNormal = normalize(aH * eL);
+(*si).faceNormal = normalize(aH * hitNormal);
 (*si).vertexNormal = normalize(aH * (*si).vertexNormal);
 (*si).normal = normalize(aH * (*si).normal);
 ${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aH * (*si).coatNormal);` : ''}
@@ -750,75 +759,76 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 }
 }
 
-fn ${shadowName}(ray: Ray, lightDistance: f32, kn: i32) -> bool {
+fn ${shadowName}(ray: Ray, lightDistance: f32, kx: i32, tm:i32) -> bool {
 if (rtUniform.isEmpty > 0) {
 return false;
 }
 
 let doubleSided = true;
-let rq = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-var tMax = rq;
-var eq: i32;
-var gY: vec3f;
+let sA = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
+var tMax = sA;
+var ei: i32;
+var gZ: vec3f;
 
 let bounces = 1;
-var jA = false;
-var fV: i32 = kn;
+var jK = false;
+var fT: i32 = kx;
+let fS = tm;
 
 ${getBVHTraverseCode(
     /*wgsl */ `
 
 
 
-var jS = true;
+var kc = true;
 
-if (jS) {
+if (kc) {
 if (HAS_ALPHA) {
-let materialIndex = i32(ah(bitcast<i32>(pi.z)).x);
-if (!oC(
+let materialIndex = i32(af(bitcast<i32>(qf.z)).x);
+if (!po(
 materialIndex,
 index,
-aC,
-fi,
-eL
+aw,
+fe,
+hitNormal${compactVertices ? ', triangleIndex' : ''}
 )) {
 
-tMax = rq;
-jS = false;
+tMax = sA;
+kc = false;
 }
 }
 }
-if (jS) {
+if (kc) {
 return true;
 }
-`, hasDisplacement, true, blasLayoutMask, hasAnisotropyDirections)}
+`, hasDisplacement, true, blasLayoutMask, hasAnisotropyDirections, '', perInstanceBounds)}
 
 return false;
 }
 
 `;
 }
-export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections = true, hasCoatNormals = false, blasLayoutMask = 1, sceneIntersections = '' }) {
+export default function getIntersectCode({ perInstanceBounds = false, compactVertices = false, hasDisplacement, hasAnisotropyDirections = true, hasCoatNormals = false, blasLayoutMask = 1, sceneIntersections = '' }) {
     return /*wgsl*/ `
 
 
 
 
 
-var<private> mK: array<i32, TLAS_STACK_SIZE>;
-var<private> gJ: array<i32, BLAS_STACK_SIZE>;
-${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `var<private> tD: array<vec2u, BLAS_STACK_SIZE>;` : ''}
+var<private> nA: array<i32, TLAS_STACK_SIZE>;
+var<private> gL: array<i32, BLAS_STACK_SIZE>;
+${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `var<private> ve: array<vec2u, BLAS_STACK_SIZE>;` : ''}
 
 ${hasDisplacement ? displacementWgsl : ''}
 ${(blasLayoutMask & 8) !== 0 ? cwbvhTraversalWgsl : ''}
 
-struct fP {
+struct fL {
 p0: vec3f,
 p1: vec3f,
 p2: vec3f,
 };
 
-fn hL(rad: f32, pos: vec3f, r: Ray) -> f32 {
+fn hM(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);
@@ -841,7 +851,7 @@ return t2;
 return INF;
 }
 
-fn og(pos: vec3f, u: vec3f, v: vec3f, n: vec3f, r: Ray) -> f32 {
+fn oU(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;
 
@@ -861,14 +871,16 @@ return INF;
 }
 
 fn sphereSolidAnglePdf(origin: vec3f, center: vec3f, radius: f32) -> f32 {
-let ak = distance(origin, center);
-if (ak <= radius) { return INV4PI; }
-let jV = min(1.0, radius * radius / (ak * ak));
-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 nr(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
+fn iB(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
 
 
 var d: f32 = INF;
@@ -880,9 +892,9 @@ var d: f32 = INF;
 (*lightSample).isDelta = false;
 var u = light.u;
 var v = light.v;
-var ec = i32(light.litType);
+var dU = i32(light.litType);
 
-if (HAS_SCENE_RECT_LIGHT && ec == RECT_LIGHT) {
+if (HAS_SCENE_RECT_LIGHT && dU == RECT_LIGHT) {
 
 var pos = light.position - u * 0.5 - v * 0.5;
 var normal = normalize(cross(u, v));
@@ -890,18 +902,18 @@ if (dot(normal, r.d) > 0.0) {
 return INF;
 }
 
-d = og(pos, u, v, normal, r);
+d = oU(pos, u, v, normal, r);
 if (d < 0.0) {
 d = INF;
 }
 else {
-var ci: f32 = dot(-r.d, normal);
+var cv: f32 = dot(-r.d, normal);
 let spread = light.radiusOrSpread;
-if (ci >= cos(spread * PI / 2.0)) {
+if (cv >= cos(spread * PI / 2.0)) {
 (*lightSample).direction = r.d;
 (*lightSample).normal = normal;
 (*lightSample).dist = d;
-(*lightSample).pdf = (d * d) / (light.area * ci);
+(*lightSample).pdf = (d * d) / (light.area * cv);
 (*lightSample).emission = light.emission;
 (*lightSample).isDelta = false;
 }
@@ -911,12 +923,12 @@ d = INF;
 }
 }
 
-else if (HAS_SCENE_SPHERE_LIGHT && ec == SPHERE_LIGHT) {
+else if (HAS_SCENE_SPHERE_LIGHT && dU == SPHERE_LIGHT) {
 if (light.radiusOrSpread <= 0.0) {
-let kT = light.position - r.o;
-let projection = dot(kT, r.d);
-let bk = kT - projection * r.d;
-if (projection <= EPS || dot(bk, bk) > 1e-8) {
+let lj = light.position - r.o;
+let projection = dot(lj, r.d);
+let bf = lj - projection * r.d;
+if (projection <= EPS || dot(bf, bf) > 1e-8) {
 return INF;
 }
 d = projection;
@@ -927,7 +939,7 @@ d = projection;
 (*lightSample).isDelta = true;
 }
 else {
-d = hL(light.radiusOrSpread, light.position, r);
+d = hM(light.radiusOrSpread, light.position, r);
 (*lightSample).isDelta = false;
 if (d > 0.0 && d != INF) {
 (*lightSample).direction = r.d;
@@ -956,12 +968,12 @@ light.radiusOrSpread <= 0.0
 }
 }
 
-else if (HAS_SCENE_SPOT_LIGHT && ec == SPOT_LIGHT) {
+else if (HAS_SCENE_SPOT_LIGHT && dU == SPOT_LIGHT) {
 if (light.radiusOrSpread <= 0.0) {
-let kT = light.position - r.o;
-let projection = dot(kT, r.d);
-let bk = kT - projection * r.d;
-if (projection <= EPS || dot(bk, bk) > 1e-8) {
+let lj = light.position - r.o;
+let projection = dot(lj, r.d);
+let bf = lj - projection * r.d;
+if (projection <= EPS || dot(bf, bf) > 1e-8) {
 return INF;
 }
 d = projection;
@@ -972,13 +984,13 @@ d = projection;
 (*lightSample).isDelta = true;
 }
 else {
-d = hL(light.radiusOrSpread, light.position, r);
+d = hM(light.radiusOrSpread, light.position, r);
 (*lightSample).isDelta = false;
 }
 if (d != INF) {
-let wW = r.o + d * r.d;
-let nv = bP(light, normalize(r.o - wW));
-if (nv <= 0.0) { return INF; }
+let zA = r.o + d * r.d;
+let od = evaluateSpotEmissionMultiplier(light, normalize(r.o - zA));
+if (od <= 0.0) { return INF; }
 if (light.radiusOrSpread > 0.0) {
 (*lightSample).direction = r.d;
 (*lightSample).dist = d;
@@ -987,7 +999,7 @@ r.o + r.d * d - light.position
 );
 (*lightSample).pdf = sphereSolidAnglePdf(r.o, light.position, light.radiusOrSpread);
 }
-(*lightSample).emission = light.emission * nv * select(
+(*lightSample).emission = light.emission * od * select(
 1.0,
 1.0 / max(d * d, 1e-8),
 light.radiusOrSpread <= 0.0
@@ -995,7 +1007,7 @@ light.radiusOrSpread <= 0.0
 }
 }
 
-else if (ec != RECT_LIGHT && ec != SPHERE_LIGHT && ec != SPOT_LIGHT) {
+else if (dU != RECT_LIGHT && dU != SPHERE_LIGHT && dU != SPOT_LIGHT) {
 
 d = INF;
 }
@@ -1003,111 +1015,113 @@ d = INF;
 return d;
 }
 
-fn fF(m0: vec3i, m1: vec3i, m2: vec3i, eU: vec3f) -> i32 {
-let m00 = ah(m0.x);
-let m01 = ah(m0.y);
-let m02 = ah(m0.z);
-let m10 = ah(m1.x);
-let m11 = ah(m1.y);
-let m12 = ah(m1.z);
-let m20 = ah(m2.x);
-let m21 = ah(m2.y);
-let m22 = ah(m2.z);
-var w00 = m00.y * eU.x;
-var w01 = m01.y * eU.x;
-var w02 = m02.y * eU.x;
-var w10 = m10.y * eU.y;
-var w11 = m11.y * eU.y;
-var w12 = m12.y * eU.y;
-var w20 = m20.y * eU.z;
-var w21 = m21.y * eU.z;
-var w22 = m22.y * eU.z;
-
-var hy = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
-
-w00 = w00 / hy;
-w01 = w01 / hy + w00;
-w02 = w02 / hy + w01;
-w10 = w10 / hy + w02;
-w11 = w11 / hy + w10;
-w12 = w12 / hy + w11;
-w20 = w20 / hy + w12;
-w21 = w21 / hy + w20;
-w22 = w22 / hy + w21;
-
-let rand = eC(0u);
-var oh: f32;
+fn fv(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 hB = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
+
+w00 = w00 / hB;
+w01 = w01 / hB + w00;
+w02 = w02 / hB + w01;
+w10 = w10 / hB + w02;
+w11 = w11 / hB + w10;
+w12 = w12 / hB + w11;
+w20 = w20 / hB + w12;
+w21 = w21 / hB + w20;
+w22 = w22 / hB + w21;
+
+let rand = cm(0u);
+var oV: f32;
 if (rand < w00) {
-oh = m00.x;
+oV = m00.x;
 } else if (rand < w01) {
-oh = m01.x;
+oV = m01.x;
 } else if (rand < w02) {
-oh = m02.x;
+oV = m02.x;
 } else if (rand < w10) {
-oh = m10.x;
+oV = m10.x;
 } else if (rand < w11) {
-oh = m11.x;
+oV = m11.x;
 } else if (rand < w12) {
-oh = m12.x;
+oV = m12.x;
 } else if (rand < w20) {
-oh = m20.x;
+oV = m20.x;
 } else if (rand < w21) {
-oh = m21.x;
+oV = m21.x;
 } else {
-oh = m22.x;
+oV = m22.x;
 }
-return i32(oh);
+return i32(oV);
 }
 
-fn mF(
-pW: i32,
+fn nl(
+lw: i32,
 index: vec3i,
-eU: vec3f
+bary: vec3f${compactVertices ? ', record: i32' : ''}
 ) -> i32 {
+${compactVertices ? /* wgsl */ `return pJ(lw, record);` : /* wgsl */ `
 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 fF(m0, m1, m2, eU);
+return fv(m0, m1, m2, bary);
 }
-return pW;
+return lw;
+`}
 }
 
 
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-fn eP(normal: vec3f, dp1: vec3f, dp2: vec3f, oW: vec2f, oX: vec2f, input: vec4f) -> mat2x3f {
-let determinant = oW.x * oX.y - oW.y * oX.x;
+fn eI(normal: vec3f, dp1: vec3f, dp2: vec3f, pU: vec2f, pV: vec2f, input: vec4f) -> mat2x3f {
+let determinant = pU.x * pV.y - pU.y * pV.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 * oX.y - dp2 * oW.y) / determinant;
-let db = (dp2 * oW.x - dp1 * oX.x) / determinant;
+let dt = (dp1 * pV.y - dp2 * pU.y) / determinant;
+let db = (dp2 * pU.x - dp1 * pV.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 iI = select(-1.0, 1.0, normal.z >= 0.0);
-let cL = -1.0 / (iI + normal.z);
-let xy = normal.x * normal.y * cL;
-t = vec3f(1.0 + iI * normal.x * normal.x * cL, iI * xy, -iI * normal.x);
-b = vec3f(xy, iI + normal.y * normal.y * cL, -normal.y);
+let iP = select(-1.0, 1.0, normal.z >= 0.0);
+let cA = -1.0 / (iP + normal.z);
+let xy = normal.x * normal.y * cA;
+t = vec3f(1.0 + iP * normal.x * normal.x * cA, iP * xy, -iP * normal.x);
+b = vec3f(xy, iP + normal.y * normal.y * cA, -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 hH(
+fn hI(
 si: ptr<function, SurfaceInteraction>,
-tri: fP,
-eU: vec3f,
+tri: fL,
+bary: vec3f,
 index: vec3i,
-bZ: bool,
-fM: i32
+bQ: bool,
+fH: i32
 ) {
 (*si).hit = true;
 
@@ -1119,26 +1133,26 @@ let i1 = index.y;
 let i2 = index.z;
 (*si).vertexColor = vec3f(1.0);
 if (USE_VERTEX_COLOR) {
-(*si).vertexColor = eU.x * attrBuffers[i0 * ATTR_STRIDE + COLOR_OFF].xyz
-+ eU.y * attrBuffers[i1 * ATTR_STRIDE + COLOR_OFF].xyz
-+ eU.z * attrBuffers[i2 * ATTR_STRIDE + COLOR_OFF].xyz;
+(*si).vertexColor = bary.x * vertexColor(i0)
++ bary.y * vertexColor(i1)
++ bary.z * vertexColor(i2);
 }
-let pU = uvProjection == ${uvProjectionConstants.spherical};
+let qP = uvProjection == ${uvProjectionConstants.spherical};
 
 var normal: vec3f = (*si).normal;
-var hq: vec3f;
+var hu: vec3f;
 var n0 = vec3f(0.0);
 var n1 = vec3f(0.0);
 var n2 = vec3f(0.0);
 
 
-if (!bZ || pU) {
-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' : ''};
-hq = normalize(eU.x * n0 + eU.y * n1 + eU.z * n2);
-if (!bZ) {
-normal = hq;
+if (!bQ || qP) {
+n0 = vertexNormal(i0);
+n1 = vertexNormal(i1);
+n2 = vertexNormal(i2);
+hu = normalize(bary.x * n0 + bary.y * n1 + bary.z * n2);
+if (!bQ) {
+normal = hu;
 }
 }
 
@@ -1146,48 +1160,48 @@ var uv: vec2f;
 var uv0: vec2f;
 var uv1: vec2f;
 var uv2: vec2f;
-var dj = vec2f(0.0);
+var cT = 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 = eU.x * uv0 + eU.y * uv1 + eU.z * uv2;
+uv0 = hd(i0);
+uv1 = hd(i1);
+uv2 = hd(i2);
+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;
-dj = eU.x * secondaryUv0
-+ eU.y * secondaryUv1
-+ eU.z * secondaryUv2;
+let secondaryUv0 = hV(i0);
+let secondaryUv1 = hV(i1);
+let secondaryUv2 = hV(i2);
+cT = bary.x * secondaryUv0
++ bary.y * secondaryUv1
++ bary.z * secondaryUv2;
 }
 }
 
 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(eU.x * t0 + eU.y * t1 + eU.z * t2);
+let t0 = gC(i0).xyz;
+let t1 = gC(i1).xyz;
+let t2 = gC(i2).xyz;
+(*si).tangent = normalize(bary.x * t0 + bary.y * t1 + bary.z * t2);
 }
 
-if (fM >= 0) {
-(*si).materialIndex = fM;
+if (fH >= 0) {
+(*si).materialIndex = fH;
 }
 else {
-(*si).materialIndex = mF(
+(*si).materialIndex = nl(
 (*si).materialIndex,
 index,
-eU
+bary${compactVertices ? ', (*si).triangleIndex' : ''}
 );
 }
 
 if (uvProjection > 0) {
 
-uv = gU(uvProjection, (*si).position, select(normal, hq, pU));
-dj = uv;
+uv = gW(uvProjection, (*si).position, select(normal, hu, qP));
+cT = uv;
 }
 
 uv = uv * material.uvScale;
-dj = dj * material.uvScale;
+cT = cT * material.uvScale;
 
 
 if (uvProjection == ${uvProjectionConstants.triplanar}) {
@@ -1200,41 +1214,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 aX = vec4f(0.0);
+var aT = vec4f(0.0);
 if (USE_TANGENT) {
-aX = eU.x * attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]
-+ eU.y * attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]
-+ eU.z * attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF];
-}
-let fc = eP(normal, dp1, dp2, uv0-uv2, uv1-uv2, aX);
-(*si).geometryTangent = fc[0];
-(*si).geometryBitangent = fc[1];
-var gm = fc;
+aT = bary.x * gC(i0)
++ bary.y * gC(i1)
++ bary.z * gC(i2);
+}
+let eV = eI(normal, dp1, dp2, uv0-uv2, uv1-uv2, aT);
+(*si).geometryTangent = eV[0];
+(*si).geometryBitangent = eV[1];
+var gp = eV;
 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;
-gm = eP(normal, dp1, dp2, a-c, b-c, select(aX, vec4f(0.0), aX.w == 0.0));
+let a = hV(i0);
+let b = hV(i1);
+let c = hV(i2);
+gp = eI(normal, dp1, dp2, a-c, b-c, select(aT, vec4f(0.0), aT.w == 0.0));
 }
-(*si).directionTangent = gm[0];
-(*si).directionBitangent = gm[1];
+(*si).directionTangent = gp[0];
+(*si).directionBitangent = gp[1];
 ${hasCoatNormals ? /* wgsl */ `
 if (USE_COAT_NORMAL_MAPS && directionMaterial.coatNormalMapIndex >= 0.0) {
-let lg = i32(directionMaterial.coatNormalMapIndex);
-var mU = fc;
-if (USE_UV1 && mapInfo[lg + 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;
-mU = eP(normal, dp1, dp2, a-c, b-c,
-select(aX, vec4f(0.0), aX.w == 0.0));
+let lI = i32(directionMaterial.coatNormalMapIndex);
+var nI = eV;
+if (USE_UV1 && mapInfo[lI + NUM_MAPS * 2].x > 0.5) {
+let a = hV(i0);
+let b = hV(i1);
+let c = hV(i2);
+nI = eI(normal, dp1, dp2, a-c, b-c,
+select(aT, vec4f(0.0), aT.w == 0.0));
 }
 
 
-let decoded = sampleMap(lg, getMapUvSet(lg, uv,
-select(dj, uv, uvProjection > 0))).rgb * 2.0 - 1.0;
-let mapped = mU[0] * decoded.x * directionMaterial.coatNormalScale.x
-+ mU[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
+let decoded = sampleMap(lI, getMapUvSet(lI, uv,
+select(cT, uv, uvProjection > 0))).rgb * 2.0 - 1.0;
+let mapped = nI[0] * decoded.x * directionMaterial.coatNormalScale.x
++ nI[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { (*si).coatNormal = normalize(mapped); }
 }
 ` : ''}
@@ -1244,19 +1258,19 @@ if (dot(mapped, mapped) > 1e-12) { (*si).coatNormal = normalize(mapped); }
 (*si).normal = normal;
 (*si).vertexNormal = normal;
 (*si).shadowOffset = vec3f(0.0);
-if (!bZ) {
+if (!bQ) {
 
 
 
 let geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-let kR = eU.x * n0 + eU.y * n1 + eU.z * n2;
+let le = 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 * eU.x * (eU.x - 1.0)
-+ (a + b + c) * eU.x * eU.y
-+ b * eU.y * (eU.y - 1.0);
-if (dot(kR, 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(le, 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);
@@ -1274,22 +1288,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 = kR * h;
+(*si).shadowOffset = le * h;
 }
 (*si).uv = uv;
-(*si).uv1 = dj;
+(*si).uv1 = cT;
 if (USE_NORMAL_MAPS) {
 let dp1 = tri.p0 - tri.p2;
 let dp2 = tri.p1 - tri.p2;
-let oW = uv0 - uv2;
-let oX = uv1 - uv2;
-(*si).normal = pd(
-(*si).materialIndex, uv, normal, dp1, dp2, oW, oX
+let pU = uv0 - uv2;
+let pV = uv1 - uv2;
+(*si).normal = qa(
+(*si).materialIndex, uv, normal, dp1, dp2, pU, pV
 );
 }
 }
 
-struct eK {
+struct eF {
 t: f32,
 barycentric: vec3f,
 };
@@ -1298,8 +1312,8 @@ barycentric: vec3f,
 
 
 
-fn ga(o: vec3f, d: vec3f, tri: fP, eq: i32, gY: vec3f, tMax: f32) -> eK {
-var ti: eK;
+fn fY(o: vec3f, d: vec3f, tri: fL, ei: i32, gZ: vec3f, tMax: f32) -> eF {
+var ti: eF;
 
 
 var p0t = tri.p0 - o;
@@ -1307,11 +1321,11 @@ var p1t = tri.p1 - o;
 var p2t = tri.p2 - o;
 
 
-if (eq == 0) {
+if (ei == 0) {
 p0t = p0t.yzx;
 p1t = p1t.yzx;
 p2t = p2t.yzx;
-} else if (eq == 1) {
+} else if (ei == 1) {
 p0t = p0t.zxy;
 p1t = p1t.zxy;
 p2t = p2t.zxy;
@@ -1319,9 +1333,9 @@ p2t = p2t.zxy;
 
 
 
-p0t = vec3f(p0t.xy + gY.xy * p0t.z, p0t.z);
-p1t = vec3f(p1t.xy + gY.xy * p1t.z, p1t.z);
-p2t = vec3f(p2t.xy + gY.xy * p2t.z, p2t.z);
+p0t = vec3f(p0t.xy + gZ.xy * p0t.z, p0t.z);
+p1t = vec3f(p1t.xy + gZ.xy * p1t.z, p1t.z);
+p2t = vec3f(p2t.xy + gZ.xy * p2t.z, p2t.z);
 
 
 var e = vec3f(
@@ -1333,9 +1347,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 if (DEPTH_QUERY_MODE) {
 
 
-let sF = abs(vec3f(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+let ua = 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) <= sF * 1e-6);
+e = select(e, vec3f(0.0), abs(e) <= ua * 1e-6);
 }
 
 
@@ -1346,19 +1360,19 @@ return ti;
 let det = e.x + e.y + e.z;
 if (DEPTH_QUERY_MODE && det == 0.0) { return ti; }
 
-p0t.z *= gY.z;
-p1t.z *= gY.z;
-p2t.z *= gY.z;
-let sw = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+p0t.z *= gZ.z;
+p1t.z *= gZ.z;
+p2t.z *= gZ.z;
+let tQ = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
 
 
-if (abs(sw) > abs(tMax * det)) {
+if (abs(tQ) > abs(tMax * det)) {
 return ti;
 }
 
-let tN = 1. / det;
-ti.t = sw * tN;
-ti.barycentric = e * tN;
+let vu = 1. / det;
+ti.t = tQ * vu;
+ti.barycentric = e * vu;
 
 return ti;
 }
@@ -1368,26 +1382,26 @@ return ti;
 
 override DEPTH_QUERY_MODE: bool = false;
 
-fn fo(d: vec3f) -> vec3f {
+fn traversalInverse(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 fk(gr: vec3f, o: vec3f) -> vec3f {
+fn ff(invD: vec3f, o: vec3f) -> vec3f {
 if (!DEPTH_QUERY_MODE) { return vec3f(0.0); }
-return abs(gr) * max(vec3f(1.0), abs(o)) * 1e-6;
+return abs(invD) * max(vec3f(1.0), abs(o)) * 1e-6;
 }
 
 
 
-fn cU(o: vec3f, xq: vec3f, xp: vec3f, gr: vec3f, tMax: f32) -> f32 {
-let wG = (xq - o) * gr;
-let wI = (xp - o) * gr;
-let padding = fk(gr, o);
-let nJ = min(wG, wI) - padding;
-let sY = max(wG, wI) + padding;
-let t0 = max(nJ.x, max(nJ.y, nJ.z));
-let t1 = min(sY.x, min(sY.y, sY.z));
+fn bP(o: vec3f, zT: vec3f, zS: vec3f, invD: vec3f, tMax: f32) -> f32 {
+let zi = (zT - o) * invD;
+let zj = (zS - o) * invD;
+let padding = ff(invD, o);
+let ot = min(zi, zj) - padding;
+let uA = max(zi, zj) + padding;
+let t0 = max(ot.x, max(ot.y, ot.z));
+let t1 = min(uA.x, min(uA.y, uA.z));
 return select(select(t1, t0, t0 > 0.0), -1.0, (t0 > t1 || t0 > tMax));
 }
 
@@ -1395,58 +1409,58 @@ 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 nk(d: vec3f, eq: i32) -> vec3f {
+fn nV(d: vec3f, ei: i32) -> vec3f {
 
 
-if (eq == 0) {
+if (ei == 0) {
 return vec3f(-d.y, -d.z, 1.0) / d.x;
-} else if (eq == 1) {
+} else if (ei == 1) {
 return vec3f(-d.z, -d.x, 1.0) / d.y;
 } else {
 return vec3f(-d.x, -d.y, 1.0) / d.z;
 }
 }
 
-fn mV(
+fn nJ(
 si: ptr<function, SurfaceInteraction>,
-mk: fP,
-aC: vec3f,
-hK: vec3i,
-bZ: bool,
-ap: i32,
-eL: vec3f,
-fi: vec3f,
-fM: i32
+mL: fL,
+aw: vec3f,
+hL: vec3i,
+bQ: bool,
+am: i32,
+hitNormal: vec3f,
+fe: vec3f,
+fH: i32
 ) {
-(*si).instanceIndex = ap;
-(*si).barycentrics = aC.xy;
-(*si).normal = eL;
-(*si).position = fi;
-(*si).materialIndex = i32(ah(
-bitcast<i32>(instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE}].z)
+(*si).instanceIndex = am;
+(*si).barycentrics = aw.xy;
+(*si).normal = hitNormal;
+(*si).position = fe;
+(*si).materialIndex = i32(af(
+bitcast<i32>(instancesBuffer[am * ${INSTANCE_VEC4_STRIDE}].z)
 ).x);
 
 
-hH(
+hI(
 si,
-mk,
-aC,
-hK,
-bZ,
-fM
+mL,
+aw,
+hL,
+bQ,
+fH
 );
 
 let l2w = mat4x4<f32>(
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 5],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 6],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 7],
-instancesBuffer[ap * ${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[ap * ${INSTANCE_VEC4_STRIDE} + 1],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 2],
-instancesBuffer[ap * ${INSTANCE_VEC4_STRIDE} + 3],
-instancesBuffer[ap * ${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 aH = transpose(mat3x3<f32>(
 w2l[0].xyz,
@@ -1454,7 +1468,7 @@ w2l[1].xyz,
 w2l[2].xyz
 ));
 
-(*si).faceNormal = normalize(aH * eL);
+(*si).faceNormal = normalize(aH * hitNormal);
 (*si).vertexNormal = normalize(aH * (*si).vertexNormal);
 (*si).normal = normalize(aH * (*si).normal);
 ${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aH * (*si).coatNormal);` : ''}
@@ -1472,10 +1486,10 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 }
 
 
-${createIntersectionAlphaWgsl(hasAnisotropyDirections)}
+${createIntersectionAlphaWgsl(hasAnisotropyDirections, compactVertices)}
 
 
 
-${sceneIntersections || createSceneIntersectionsWgsl({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask })}`;
+${sceneIntersections || createSceneIntersectionsWgsl({ perInstanceBounds, compactVertices, hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask })}`;
 }
 //# sourceMappingURL=intersect.wgsl.js.map