@meimu/mutracer 0.1.3 → 0.1.4

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 = fI(o, d, tri, ey, gL, tMax);
+let hit = fL(o, d, tri, ey, gP, tMax);
 if (hit.t > 0.0) {
 let e1 = tri.p1 - tri.p0;
 let e2 = tri.p2 - tri.p0;
-eC = normalize(cross(e1, e2));
-let kd = i32(ae(bitcast<i32>(oh.z)).x);
-let iI = materialsBuffer[kd].doubleSided > 0.5;
-if (!doubleSided && !iI && dot(eC, d) > 0.0) {
-eC = vec3f(0.0);
+eD = normalize(cross(e1, e2));
+let kk = i32(ae(bitcast<i32>(ou.z)).x);
+let iN = materialsBuffer[kk].doubleSided > 0.5;
+if (!doubleSided && !iN && dot(eD, d) > 0.0) {
+eD = vec3f(0.0);
 continue;
 }
 
 tMax = hit.t;
-qT = true;
-ol = true;
-eU = o + tMax * d;
+rb = true;
+ox = true;
+eY = o + tMax * d;
 aB = hit.barycentric;
 }
 `;
 };
 function getPDMDisplacmentCode(anyHit) {
     return /*wgsl */ `
-let kO = oT(
+let kX = pc(
 o, d, tMax,
 tri.p0, tri.p1, tri.p2,
 n0, n1, n2,
 uv0, uv1, uv2,
 displacementMapIndex,
-oa(displacementMapIndex),
+kJ(displacementMapIndex),
 minH, maxH,
 hScale,
 matData.displacementBias,
@@ -44,17 +44,17 @@ matData.displacementStepSize,
 i32(matData.displacementUvProjection),
 displacementUvProjectionScale,
 ${anyHit ? 'true' : 'false'},
-lq
+lD
 );
 `;
 }
 const displacementIntersectCode = function (anyHit, hasAnisotropyDirections) {
     return /* wgsl */ `
 
-let hScale = oh.w;
-let tn = bitcast<i32>(r3.w);
+let hScale = ou.w;
+let tA = bitcast<i32>(r3.w);
 
-let materialIndex = i32(ae(bitcast<i32>(oh.z)).x);
+let materialIndex = i32(ae(bitcast<i32>(ou.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 && tn > 0) {
-let minH = f32(tn >> 8) / 255.0;
-let maxH = f32(tn & 0xff) / 255.0;
+if (abs(hScale) > 0.0 && tA > 0) {
+let minH = f32(tA >> 8) / 255.0;
+let maxH = f32(tA & 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 (kO.t < tMax) {
-eC = kO.normal;
+if (kX.t < tMax) {
+eD = kX.normal;
 
 
-tMax = kO.t;
+tMax = kX.t;
 
-aB = kO.barycentric;
-eU = o + tMax * d;
+aB = kX.barycentric;
+eY = o + tMax * d;
 
 bU = true;
-qT = true;
-ol = true;
+rb = true;
+ox = true;
 }
 }
 else {
@@ -112,118 +112,118 @@ f32(value >> 24u)
 
 
 
-fn kn(value: u32) -> u32 {
+fn kx(value: u32) -> u32 {
 return (bitcast<u32>(f32(value)) >> 23u) - 127u;
 }
 
-fn nO(value: u32) -> u32 {
+fn nZ(value: u32) -> u32 {
 return (bitcast<u32>(f32(value)) >> 23u) - 127u;
 }
 
-fn oi(
+fn ov(
 node: i32,
-tc: i32,
+tk: i32,
 n0: vec4f,
 o: vec3f,
-gx: vec3f,
+gC: vec3f,
 tMax: f32
 ) -> u32 {
-let i = node + tc;
+let i = node + tk;
 let n2 = bvhBuffer[i + 2];
 let n3 = bvhBuffer[i + 3];
 let n4 = bvhBuffer[i + 4];
 let header = bitcast<u32>(n0.w);
-let rv = bitcast<i32>((header & 0xffu) << 24u) >> 24;
-let rw = bitcast<i32>(((header >> 8u) & 0xffu) << 24u) >> 24;
-let rA = bitcast<i32>(((header >> 16u) & 0xffu) << 24u) >> 24;
-let hF = vec3f(
-bitcast<f32>(u32(rv + 127) << 23u),
-bitcast<f32>(u32(rw + 127) << 23u),
-bitcast<f32>(u32(rA + 127) << 23u)
+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 bJ = eV(gx, o);
-let eH = (n0.xyz - o) * gx;
-let da = hF * gx;
-let wr = bp(bitcast<u32>(n2.x));
-let ws = bp(bitcast<u32>(n2.y));
-let wt = bp(bitcast<u32>(n2.z));
-let wu = bp(bitcast<u32>(n2.w));
-let wv = bp(bitcast<u32>(n3.x));
-let ww = bp(bitcast<u32>(n3.y));
-let wl = bp(bitcast<u32>(n3.z));
-let wm = bp(bitcast<u32>(n3.w));
-let wn = bp(bitcast<u32>(n4.x));
-let wo = bp(bitcast<u32>(n4.y));
-let wp = bp(bitcast<u32>(n4.z));
-let wq = bp(bitcast<u32>(n4.w));
-
-let vh = wr * da.x + eH.x;
-let vk = wt * da.y + eH.y;
-let vm = wv * da.z + eH.z;
-let va = wl * da.x + eH.x;
-let vc = wn * da.y + eH.y;
-let ve = wp * da.z + eH.z;
-let wx = max(
-max((min(vh, va) - vec4f(bJ.x)), (min(vk, vc) - vec4f(bJ.y))),
-(min(vm, ve) - vec4f(bJ.z))
+let bJ = eZ(gC, o);
+let eI = (n0.xyz - o) * gC;
+let dc = hJ * gC;
+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 wg = min(
-min((max(vh, va) + vec4f(bJ.x)), (max(vk, vc) + vec4f(bJ.y))),
-(max(vm, ve) + vec4f(bJ.z))
+let wn = min(
+min((max(vp, vj) + vec4f(bJ.x)), (max(vs, vl) + vec4f(bJ.y))),
+(max(vu, vn) + vec4f(bJ.z))
 );
 
-let vj = ws * da.x + eH.x;
-let vl = wu * da.y + eH.y;
-let vn = ww * da.z + eH.z;
-let vb = wm * da.x + eH.x;
-let vd = wo * da.y + eH.y;
-let vg = wq * da.z + eH.z;
-let wy = max(
-max((min(vj, vb) - vec4f(bJ.x)), (min(vl, vd) - vec4f(bJ.y))),
-(min(vn, vg) - vec4f(bJ.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 wh = min(
-min((max(vj, vb) + vec4f(bJ.x)), (max(vl, vd) + vec4f(bJ.y))),
-(max(vn, vg) + vec4f(bJ.z))
+let wo = min(
+min((max(vq, vk) + vec4f(bJ.x)), (max(vt, vm) + vec4f(bJ.y))),
+(max(vw, vo) + vec4f(bJ.z))
 );
 
-let uD = (wx <= min(wg, vec4f(tMax))) & (wg > vec4f(0.0));
-let uE = (wy <= min(wh, vec4f(tMax))) & (wh > vec4f(0.0));
-return select(0u, 1u, uD.x)
-| select(0u, 2u, uD.y)
-| select(0u, 4u, uD.z)
-| select(0u, 8u, uD.w)
-| select(0u, 16u, uE.x)
-| select(0u, 32u, uE.y)
-| select(0u, 64u, uE.z)
-| select(0u, 128u, uE.w);
+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);
 }
 
 `;
 function getBVHTraverseCode(handleHitCode, hasDisplacement, anyHit, blasLayoutMask, hasAnisotropyDirections, skipTriangleCode = '') {
     const intersectTriangles = /* wgsl */ `
-let oh = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
-let vertexOffset = vec3i(bitcast<i32>(oh.y));
+let ou = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
+let vertexOffset = vec3i(bitcast<i32>(ou.y));
 for (var k = 0; k < bh; k++) {
 let triangleIndex = primitiveOffset + k;
 ${skipTriangleCode}
-if (bounces > 0 && triangleIndex == hK) {
+if (bounces > 0 && triangleIndex == hO) {
 continue;
 }
 
 let r3 = bvhBuffer[triangleIndex];
 let index = bitcast<vec3i>(r3.xyz) + vertexOffset;
-var tri = fu(
+var tri = fA(
 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 ol = false;
+var ox = false;
 
 ${hasDisplacement
         ? displacementIntersectCode(anyHit, hasAnisotropyDirections)
         : flatIntersectCode()}
-if (ol) {
+if (ox) {
 ${handleHitCode}
 }
 }
@@ -231,69 +231,69 @@ ${handleHitCode}
     return /* wgsl */ `
 var d = ray.d;
 var o = ray.o;
-var lQ: array<i32, TLAS_STACK_SIZE>;
-var jd = -1;
-var gx = eX(d);
+var mb: array<i32, TLAS_STACK_SIZE>;
+var jh = -1;
+var gC = fb(d);
 var bU = false;
-var qT = false;
-var eU: vec3f;
-var eC: vec3f;
+var rb = false;
+var eY: vec3f;
+var eD: vec3f;
 var aB: vec3f;
 
 
-if (cM(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, gx, tMax) > 0.0) {
-jd = 0;
-lQ[0] = 0;
+if (cM(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, gC, tMax) > 0.0) {
+jh = 0;
+mb[0] = 0;
 }
-while (jd >= 0) {
-let sN = lQ[jd];
-jd--;
+while (jh >= 0) {
+let sV = mb[jh];
+jh--;
 o = ray.o;
 d = ray.d;
-gx = eX(d);
+gC = fb(d);
 
-let vX = bvhBuffer[sN];
-let eR = bitcast<i32>(vX.w);
-if (eR >= 0) {
-let left = sN + 2;
-let right = eR;
+let wf = bvhBuffer[sV];
+let eV = bitcast<i32>(wf.w);
+if (eV >= 0) {
+let left = sV + 2;
+let right = eV;
 let d0 = cM(
 o,
 bvhBuffer[left].xyz,
 bvhBuffer[left + 1].xyz,
-gx,
+gC,
 tMax
 );
 let d1 = cM(
 o,
 bvhBuffer[right].xyz,
 bvhBuffer[right + 1].xyz,
-gx,
+gC,
 tMax
 );
 
 if (d0 > d1) {
-if (d0 > 0.0) { jd++; lQ[jd] = left; }
-if (d1 > 0.0) { jd++; lQ[jd] = right; }
+if (d0 > 0.0) { jh++; mb[jh] = left; }
+if (d1 > 0.0) { jh++; mb[jh] = right; }
 }
 else {
-if (d1 > 0.0) { jd++; lQ[jd] = right; }
-if (d0 > 0.0) { jd++; lQ[jd] = left; }
+if (d1 > 0.0) { jh++; mb[jh] = right; }
+if (d0 > 0.0) { jh++; mb[jh] = left; }
 }
 }
 else {
-let qB = -eR;
+let qJ = -eV;
 
 
 for (
-var ml = qB - 1;
-ml >= 0;
-ml--
+var mx = qJ - 1;
+mx >= 0;
+mx--
 ) {
-let pq = bvhBuffer[sN + 2 + ml];
-let cf = bitcast<i32>(pq.x);
-let uN = bitcast<i32>(pq.y);
-let oh = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
+let pI = bvhBuffer[sV + 2 + mx];
+let cf = bitcast<i32>(pI.x);
+let uU = bitcast<i32>(pI.y);
+let ou = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
 let w2l = mat4x4<f32>(
 instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 1],
 instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 2],
@@ -302,214 +302,214 @@ instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 4]
 );
 o = (w2l * vec4f(ray.o, 1.0)).xyz;
 d = (w2l * vec4f(ray.d, 0.0)).xyz;
-gx = eX(d);
+gC = fb(d);
 ey = maxDimension(abs(d));
-gL = mj(d, ey);
+gP = mv(d, ey);
 
-let fG = bitcast<u32>(oh.x);
-let gN = fG >> 30u;
-let blasOffset = i32(fG & 0x3fffffffu);
+let fJ = bitcast<u32>(ou.x);
+let gR = fJ >> 30u;
+let blasOffset = i32(fJ & 0x3fffffffu);
 let bo = rtUniform.blasOffset;
 
 ${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `
-if (gN == 3u) {
+if (gR == 3u) {
 
 
 
 
-var sd: array<vec2u, BLAS_STACK_SIZE>;
-var pe = -1;
-var rP = 0u;
-var kQ = 0u;
+var sm: array<vec2u, BLAS_STACK_SIZE>;
+var pn = -1;
+var rX = 0u;
+var kZ = 0u;
 
 var ep = 0x80000000u;
-let ul = select(0u, 4u, d.x < 0.0)
+let ut = select(0u, 4u, d.x < 0.0)
 | select(0u, 2u, d.y < 0.0)
 | select(0u, 1u, d.z < 0.0);
-let qd = 7u - ul;
+let ql = 7u - ut;
 
 
 
 
-while (rP < 4096u) {
-rP++;
+while (rX < 4096u) {
+rX++;
 
 let internalMask = ep & 0xffu;
-let pZ =
-kn(ep >> 24u) + 24u;
-ep &= ~(1u << pZ);
+let qh =
+kx(ep >> 24u) + 24u;
+ep &= ~(1u << qh);
 if ((ep & 0xff000000u) != 0u) {
-pe++;
+pn++;
 
-sd[pe] = vec2u(kQ, ep);
+sm[pn] = vec2u(kZ, ep);
 }
 
-let slot = (pZ - 24u) ^ qd;
-let ne = (1u << slot) - 1u;
-let relativeIndex = countOneBits(internalMask & ne);
-let sb = kQ + relativeIndex;
-let node = blasOffset + i32(sb * 5u);
-let ju = bvhBuffer[node + bo];
-let tX = oi(
-node, bo, ju, o, gx, tMax
+let slot = (qh - 24u) ^ ql;
+let ns = (1u << slot) - 1u;
+let relativeIndex = countOneBits(internalMask & ns);
+let sk = kZ + relativeIndex;
+let node = blasOffset + i32(sk * 5u);
+let jA = bvhBuffer[node + bo];
+let ue = ov(
+node, bo, jA, o, gC, tMax
 );
 
 
 ep = 0u;
-if (tX != 0u) {
-let fC = bvhBuffer[node + bo + 1];
-let rG = bitcast<u32>(ju.w) >> 24u;
-var tl = 0u;
-var jZ = tX;
-while (jZ != 0u) {
-let rr = kn(jZ);
-jZ &= ~(1u << rr);
-let su = select(
-bitcast<u32>(fC.z),
-bitcast<u32>(fC.w),
-rr >= 4u
+if (ue != 0u) {
+let fF = 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>(fF.z),
+bitcast<u32>(fF.w),
+rC >= 4u
 );
-let sW =
-(su >> ((rr & 3u) * 8u)) & 0xffu;
-let jw = sW & 0x1fu;
-let uM = select(
-jw,
-jw ^ qd,
-jw >= 24u
+let td =
+(sE >> ((rC & 3u) * 8u)) & 0xffu;
+let jC = td & 0x1fu;
+let uT = select(
+jC,
+jC ^ ql,
+jC >= 24u
 );
-let uH = (sW >> 5u) & 0x7u;
-tl |= uH << uM;
+let uO = (td >> 5u) & 0x7u;
+tv |= uO << uT;
 }
 
-kQ = bitcast<u32>(fC.x);
-ep = (tl & 0xff000000u) | rG;
-let oH = bitcast<u32>(fC.y);
-var oI = tl & 0x00ffffffu;
-while (oI != 0u) {
-let nI = nO(oI);
-oI &= ~(1u << nI);
+kZ = bitcast<u32>(fF.x);
+ep = (tv & 0xff000000u) | rO;
+let oQ = bitcast<u32>(fF.y);
+var oR = tv & 0x00ffffffu;
+while (oR != 0u) {
+let nT = nZ(oR);
+oR &= ~(1u << nT);
 let bh = 1;
 let primitiveOffset = bo + blasOffset
-+ i32(oH + nI);
++ i32(oQ + nT);
 ${intersectTriangles}
 }
 }
 
 if ((ep & 0xff000000u) != 0u) { continue; }
-if (pe >= 0) {
-let qe = sd[pe];
-kQ = qe.x;
-ep = qe.y;
-pe--;
+if (pn >= 0) {
+let qm = sm[pn];
+kZ = qm.x;
+ep = qm.y;
+pn--;
 }
 else { break; }
 }
 }
 ` : ''}
 
-var gp: array<i32, BLAS_STACK_SIZE>;
-var dR = -1;
-if (gN != 3u) {
-dR = 0;
+var gt: array<i32, BLAS_STACK_SIZE>;
+var dS = -1;
+if (gR != 3u) {
+dS = 0;
 
-gp[0] = uN;
+gt[0] = uU;
 }
 
-while (dR >= 0) {
+while (dS >= 0) {
 
-let node = gp[dR];
-dR--;
+let node = gt[dS];
+dS--;
 var bh = 0;
 var primitiveOffset = 0;
 
 ${(blasLayoutMask & 4) !== 0 ? /* wgsl */ `
-if (gN == 2u) {
+if (gR == 2u) {
 let i = node + bo;
-let uR = bvhBuffer[i];
-let uS = bvhBuffer[i + 1];
-let uT = bvhBuffer[i + 2];
-let uU = bvhBuffer[i + 3];
-bh = i32(bitcast<u32>(uT.w));
+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>(uU.w));
++ i32(bitcast<u32>(vb.w));
 }
 else {
-let left = blasOffset + i32(bitcast<u32>(uR.w) * 4u);
-let right = blasOffset + i32(bitcast<u32>(uS.w) * 4u);
-let om = cM(
-o, uR.xyz, uS.xyz, gx, tMax
+let left = blasOffset + i32(bitcast<u32>(uY.w) * 4u);
+let right = blasOffset + i32(bitcast<u32>(uZ.w) * 4u);
+let oy = cM(
+o, uY.xyz, uZ.xyz, gC, tMax
 );
-let ng = cM(
-o, uT.xyz, uU.xyz, gx, tMax
+let nu = cM(
+o, va.xyz, vb.xyz, gC, tMax
 );
-if (om > ng) {
-if (om > 0.0) {
-dR++; gp[dR] = left;
+if (oy > nu) {
+if (oy > 0.0) {
+dS++; gt[dS] = left;
 }
-if (ng > 0.0) {
-dR++; gp[dR] = right;
+if (nu > 0.0) {
+dS++; gt[dS] = right;
 }
 }
 else {
-if (ng > 0.0) {
-dR++; gp[dR] = right;
+if (nu > 0.0) {
+dS++; gt[dS] = right;
 }
-if (om > 0.0) {
-dR++; gp[dR] = left;
+if (oy > 0.0) {
+dS++; gt[dS] = left;
 }
 }
 }
 }
 ` : ''}
 ${(blasLayoutMask & 2) !== 0 ? /* wgsl */ `
-if (gN == 1u) {
-let hS = bitcast<u32>(node);
-if ((hS & 0x80000000u) != 0u) {
-bh = i32((hS >> 23u) & 0xffu);
+if (gR == 1u) {
+let hW = bitcast<u32>(node);
+if ((hW & 0x80000000u) != 0u) {
+bh = i32((hW >> 23u) & 0xffu);
 primitiveOffset = bo + blasOffset
-+ i32(hS & 0x007fffffu);
++ i32(hW & 0x007fffffu);
 }
 else {
 let i = node + bo;
-let ub = bvhBuffer[i];
-let rf = bvhBuffer[i + 1];
-let rh = bvhBuffer[i + 2];
-let ri = bvhBuffer[i + 3];
-let nodeMin = ub.xyz;
-let ec = vec3f(ub.w, rf.x, rf.y);
-let lV = array<u32, 4>(
-bitcast<u32>(rf.z), bitcast<u32>(rf.w),
-bitcast<u32>(rh.x), bitcast<u32>(rh.y)
+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 mh = array<u32, 4>(
+bitcast<u32>(ro.z), bitcast<u32>(ro.w),
+bitcast<u32>(rp.x), bitcast<u32>(rp.y)
 );
-let ro = unpack4x8unorm(bitcast<u32>(rh.z));
-let rp = unpack4x8unorm(bitcast<u32>(rh.w));
-let rq = unpack4x8unorm(bitcast<u32>(ri.x));
-let rl = unpack4x8unorm(bitcast<u32>(ri.y));
-let rm = unpack4x8unorm(bitcast<u32>(ri.z));
-let rn = unpack4x8unorm(bitcast<u32>(ri.w));
-let tx0 = (nodeMin.x + ro * ec.x - o.x) * gx.x;
-let tx1 = (nodeMin.x + rl * ec.x - o.x) * gx.x;
-let ty0 = (nodeMin.y + rp * ec.y - o.y) * gx.y;
-let ty1 = (nodeMin.y + rm * ec.y - o.y) * gx.y;
-let tz0 = (nodeMin.z + rq * ec.z - o.z) * gx.z;
-let tz1 = (nodeMin.z + rn * ec.z - o.z) * gx.z;
-let bJ = eV(gx, o);
-let mB = max(
+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) * gC.x;
+let tx1 = (nodeMin.x + rt * ec.x - o.x) * gC.x;
+let ty0 = (nodeMin.y + rA * ec.y - o.y) * gC.y;
+let ty1 = (nodeMin.y + ru * ec.y - o.y) * gC.y;
+let tz0 = (nodeMin.z + rB * ec.z - o.z) * gC.z;
+let tz1 = (nodeMin.z + rv * ec.z - o.z) * gC.z;
+let bJ = eZ(gC, o);
+let mL = max(
 max((min(tx0, tx1) - vec4f(bJ.x)), (min(ty0, ty1) - vec4f(bJ.y))),
 (min(tz0, tz1) - vec4f(bJ.z))
 );
-let rM = min(
+let rU = min(
 min((max(tx0, tx1) + vec4f(bJ.x)), (max(ty0, ty1) + vec4f(bJ.y))),
 (max(tz0, tz1) + vec4f(bJ.z))
 );
-var distance = select(rM, mB, mB > vec4f(0.0));
+var distance = select(rU, mL, mL > vec4f(0.0));
 distance = select(
 distance,
 vec4f(-1.0),
-mB > min(rM, vec4f(tMax))
+mL > min(rU, vec4f(tMax))
 );
-var fa = array<f32, 4>(
+var fd = array<f32, 4>(
 distance.x,
 distance.y,
 distance.z,
@@ -522,29 +522,29 @@ var dX = -1.0;
 var el = -1;
 for (var child = 0; child < 4; child++) {
 if (
-lV[child] != 0u &&
-fa[child] > dX
+mh[child] != 0u &&
+fd[child] > dX
 ) {
-dX = fa[child];
+dX = fd[child];
 el = child;
 }
 }
 if (el >= 0 && dX > 0.0) {
-let nl = lV[el];
-var jD = bitcast<i32>(nl);
-if ((nl & 0x80000000u) == 0u) {
-jD += blasOffset;
+let nD = mh[el];
+var jI = bitcast<i32>(nD);
+if ((nD & 0x80000000u) == 0u) {
+jI += blasOffset;
 }
-dR++;
-gp[dR] = jD;
-fa[el] = -1.0;
+dS++;
+gt[dS] = jI;
+fd[el] = -1.0;
 }
 }
 }
 }
 ` : ''}
 ${(blasLayoutMask & 1) !== 0 ? /* wgsl */ `
-if (gN == 0u) {
+if (gR == 0u) {
 let i = node + bo;
 let r1 = bvhBuffer[i];
 let bb = bitcast<i32>(r1.w);
@@ -556,34 +556,34 @@ let d0 = cM(
 o,
 bvhBuffer[left + bo].xyz,
 bvhBuffer[left + 1 + bo].xyz,
-gx,
+gC,
 tMax
 );
 let d1 = cM(
 o,
 bvhBuffer[right + bo].xyz,
 bvhBuffer[right + 1 + bo].xyz,
-gx,
+gC,
 tMax
 );
 
 if (d0 > d1) {
 if (d0 > 0.0) {
-dR++; gp[dR] = left;
+dS++; gt[dS] = left;
 
 }
 if (d1 > 0.0) {
-dR++; gp[dR] = right;
+dS++; gt[dS] = right;
 
 }
 }
 else {
 if (d1 > 0.0) {
-dR++; gp[dR] = right;
+dS++; gt[dS] = right;
 
 }
 if (d0 > 0.0) {
-dR++; gp[dR] = left;
+dS++; gt[dS] = left;
 
 }
 }
@@ -610,13 +610,13 @@ export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirecti
 ${hasDisplacement ? displacementWgsl : ''}
 ${(blasLayoutMask & 8) !== 0 ? cwbvhTraversalWgsl : ''}
 
-struct fu {
+struct fA {
 p0: vec3f,
 p1: vec3f,
 p2: vec3f,
 };
 
-fn ht(rad: f32, pos: vec3f, r: Ray) -> f32 {
+fn hx(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 +639,7 @@ return t2;
 return INF;
 }
 
-fn mU(pos: vec3f, u: vec3f, v: vec3f, n: vec3f, r: Ray) -> f32 {
+fn ni(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;
 
@@ -661,12 +661,12 @@ return INF;
 fn sphereSolidAnglePdf(origin: vec3f, center: vec3f, radius: f32) -> f32 {
 let aj = distance(origin, center);
 if (aj <= radius) { return INV4PI; }
-let jp = min(1.0, radius * radius / (aj * aj));
-let cosThetaMax = sqrt(max(0.0, 1.0 - jp));
+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);
 }
 
-fn mo(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
+fn mz(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
 
 
 var d: f32 = INF;
@@ -678,9 +678,9 @@ var d: f32 = INF;
 (*lightSample).isDelta = false;
 var u = light.u;
 var v = light.v;
-var dO = i32(light.litType);
+var dP = i32(light.litType);
 
-if (dO == RECT_LIGHT) {
+if (dP == RECT_LIGHT) {
 
 var pos = light.position - u * 0.5 - v * 0.5;
 var normal = normalize(cross(u, v));
@@ -688,7 +688,7 @@ if (dot(normal, r.d) > 0.0) {
 return INF;
 }
 
-d = mU(pos, u, v, normal, r);
+d = ni(pos, u, v, normal, r);
 if (d < 0.0) {
 d = INF;
 }
@@ -709,11 +709,11 @@ d = INF;
 }
 }
 
-else if (dO == SPHERE_LIGHT) {
+else if (dP == SPHERE_LIGHT) {
 if (light.radiusOrSpread <= 0.0) {
-let kh = light.position - r.o;
-let projection = dot(kh, r.d);
-let ba = kh - projection * r.d;
+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) {
 return INF;
 }
@@ -725,7 +725,7 @@ d = projection;
 (*lightSample).isDelta = true;
 }
 else {
-d = ht(light.radiusOrSpread, light.position, r);
+d = hx(light.radiusOrSpread, light.position, r);
 (*lightSample).isDelta = false;
 if (d > 0.0 && d != INF) {
 (*lightSample).direction = r.d;
@@ -754,11 +754,11 @@ light.radiusOrSpread <= 0.0
 }
 }
 
-else if (dO == SPOT_LIGHT) {
+else if (dP == SPOT_LIGHT) {
 if (light.radiusOrSpread <= 0.0) {
-let kh = light.position - r.o;
-let projection = dot(kh, r.d);
-let ba = kh - projection * r.d;
+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) {
 return INF;
 }
@@ -770,13 +770,13 @@ d = projection;
 (*lightSample).isDelta = true;
 }
 else {
-d = ht(light.radiusOrSpread, light.position, r);
+d = hx(light.radiusOrSpread, light.position, r);
 (*lightSample).isDelta = false;
 }
 if (d != INF) {
-let uX = r.o + d * r.d;
-let mr = bL(light, normalize(r.o - uX));
-if (mr <= 0.0) { return INF; }
+let ve = r.o + d * r.d;
+let mC = bL(light, normalize(r.o - ve));
+if (mC <= 0.0) { return INF; }
 if (light.radiusOrSpread > 0.0) {
 (*lightSample).direction = r.d;
 (*lightSample).dist = d;
@@ -785,7 +785,7 @@ r.o + r.d * d - light.position
 );
 (*lightSample).pdf = sphereSolidAnglePdf(r.o, light.position, light.radiusOrSpread);
 }
-(*lightSample).emission = light.emission * mr * select(
+(*lightSample).emission = light.emission * mC * select(
 1.0,
 1.0 / max(d * d, 1e-8),
 light.radiusOrSpread <= 0.0
@@ -793,7 +793,7 @@ light.radiusOrSpread <= 0.0
 }
 }
 
-else if (dO != RECT_LIGHT && dO != SPHERE_LIGHT && dO != SPOT_LIGHT) {
+else if (dP != RECT_LIGHT && dP != SPHERE_LIGHT && dP != SPOT_LIGHT) {
 
 d = INF;
 }
@@ -801,7 +801,7 @@ d = INF;
 return d;
 }
 
-fn fj(m0: vec3i, m1: vec3i, m2: vec3i, eZ: vec3f) -> i32 {
+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);
@@ -811,101 +811,101 @@ let m12 = ae(m1.z);
 let m20 = ae(m2.x);
 let m21 = ae(m2.y);
 let m22 = ae(m2.z);
-var w00 = m00.y * eZ.x;
-var w01 = m01.y * eZ.x;
-var w02 = m02.y * eZ.x;
-var w10 = m10.y * eZ.y;
-var w11 = m11.y * eZ.y;
-var w12 = m12.y * eZ.y;
-var w20 = m20.y * eZ.z;
-var w21 = m21.y * eZ.z;
-var w22 = m22.y * eZ.z;
-
-var hg = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
-
-w00 = w00 / hg;
-w01 = w01 / hg + w00;
-w02 = w02 / hg + w01;
-w10 = w10 / hg + w02;
-w11 = w11 / hg + w10;
-w12 = w12 / hg + w11;
-w20 = w20 / hg + w12;
-w21 = w21 / hg + w20;
-w22 = w22 / hg + w21;
+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 mV: f32;
+var nj: f32;
 if (rand < w00) {
-mV = m00.x;
+nj = m00.x;
 } else if (rand < w01) {
-mV = m01.x;
+nj = m01.x;
 } else if (rand < w02) {
-mV = m02.x;
+nj = m02.x;
 } else if (rand < w10) {
-mV = m10.x;
+nj = m10.x;
 } else if (rand < w11) {
-mV = m11.x;
+nj = m11.x;
 } else if (rand < w12) {
-mV = m12.x;
+nj = m12.x;
 } else if (rand < w20) {
-mV = m20.x;
+nj = m20.x;
 } else if (rand < w21) {
-mV = m21.x;
+nj = m21.x;
 } else {
-mV = m22.x;
+nj = m22.x;
 }
-return i32(mV);
+return i32(nj);
 }
 
-fn lM(
-oR: i32,
+fn lW(
+pa: i32,
 index: vec3i,
-eZ: vec3f
+eK: 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 fj(m0, m1, m2, eZ);
+return fm(m0, m1, m2, eK);
 }
-return oR;
+return pa;
 }
 
 
 
 ${hasAnisotropyDirections ? /* wgsl */ `
-fn eD(normal: vec3f, dp1: vec3f, dp2: vec3f, nS: vec2f, nT: vec2f, input: vec4f) -> mat2x3f {
-let determinant = nS.x * nT.y - nS.y * nT.x;
+fn eE(normal: vec3f, dp1: vec3f, dp2: vec3f, od: vec2f, oe: vec2f, input: vec4f) -> mat2x3f {
+let determinant = od.x * oe.y - od.y * oe.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 * nT.y - dp2 * nS.y) / determinant;
-let db = (dp2 * nS.x - dp1 * nT.x) / determinant;
+let dt = (dp1 * oe.y - dp2 * od.y) / determinant;
+let db = (dp2 * od.x - dp1 * oe.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 ie = select(-1.0, 1.0, normal.z >= 0.0);
-let dW = -1.0 / (ie + normal.z);
+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 + ie * normal.x * normal.x * dW, ie * xy, -ie * normal.x);
-b = vec3f(xy, ie + normal.y * normal.y * dW, -normal.y);
+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);
 }
 else { t = normalize(t); b = normalize(cross(normal, t)); }
 return mat2x3f(t, b * select(1.0, -1.0, sign < 0.0));
 }
 
 ` : /* wgsl */ ``}
-fn hp(
+fn ht(
 si: ptr<function, ad>,
-tri: fu,
-eZ: vec3f,
+tri: fA,
+eK: vec3f,
 index: vec3i,
 bU: bool,
-fq: i32
+fv: i32
 ) {
 (*si).hit = true;
 
@@ -915,22 +915,28 @@ let uvProjection = i32(material.uvProjection);
 let i0 = index.x;
 let i1 = index.y;
 let i2 = index.z;
-let oP = uvProjection == ${uvProjectionConstants.spherical};
+(*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;
+}
+let oY = uvProjection == ${uvProjectionConstants.spherical};
 
 var normal: vec3f = (*si).normal;
-var gV: vec3f;
+var gZ: vec3f;
 var n0 = vec3f(0.0);
 var n1 = vec3f(0.0);
 var n2 = vec3f(0.0);
 
 
-if (!bU || oP) {
+if (!bU || oY) {
 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' : ''};
-gV = normalize(eZ.x * n0 + eZ.y * n1 + eZ.z * n2);
+gZ = normalize(eK.x * n0 + eK.y * n1 + eK.z * n2);
 if (!bU) {
-normal = gV;
+normal = gZ;
 }
 }
 
@@ -943,14 +949,14 @@ 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 = eZ.x * uv0 + eZ.y * uv1 + eZ.z * uv2;
+uv = eK.x * uv0 + eK.y * uv1 + eK.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 = eZ.x * secondaryUv0
-+ eZ.y * secondaryUv1
-+ eZ.z * secondaryUv2;
+cX = eK.x * secondaryUv0
++ eK.y * secondaryUv1
++ eK.z * secondaryUv2;
 }
 }
 
@@ -958,23 +964,23 @@ 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(eZ.x * t0 + eZ.y * t1 + eZ.z * t2);
+(*si).tangent = normalize(eK.x * t0 + eK.y * t1 + eK.z * t2);
 }
 
-if (fq >= 0) {
-(*si).materialIndex = fq;
+if (fv >= 0) {
+(*si).materialIndex = fv;
 }
 else {
-(*si).materialIndex = lM(
+(*si).materialIndex = lW(
 (*si).materialIndex,
 index,
-eZ
+eK
 );
 }
 
 if (uvProjection > 0) {
 
-uv = gC(uvProjection, (*si).position, select(normal, gV, oP));
+uv = gH(uvProjection, (*si).position, select(normal, gZ, oY));
 cX = uv;
 }
 
@@ -992,41 +998,41 @@ let directionMaterial = materialsBuffer[(*si).materialIndex];
 if (directionMaterial.anisotropyMapIndex >= 0.0 || directionMaterial.specularAnisotropyRotation != 0.0 || directionMaterial.coatAnisotropyRotation != 0.0${hasCoatNormals ? " || (USE_COAT_NORMAL_MAPS && directionMaterial.coatNormalMapIndex >= 0.0)" : ""}) {
 let dp1 = tri.p0 - tri.p2;
 let dp2 = tri.p1 - tri.p2;
-var aU = vec4f(0.0);
+var aT = vec4f(0.0);
 if (USE_TANGENT) {
-aU = eZ.x * attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]
-+ eZ.y * attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]
-+ eZ.z * attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF];
-}
-let eP = eD(normal, dp1, dp2, uv0-uv2, uv1-uv2, aU);
-(*si).geometryTangent = eP[0];
-(*si).geometryBitangent = eP[1];
-var fU = eP;
+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 fY = eS;
 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;
-fU = eD(normal, dp1, dp2, a-c, b-c, select(aU, vec4f(0.0), aU.w == 0.0));
+fY = eE(normal, dp1, dp2, a-c, b-c, select(aT, vec4f(0.0), aT.w == 0.0));
 }
-(*si).directionTangent = fU[0];
-(*si).directionBitangent = fU[1];
+(*si).directionTangent = fY[0];
+(*si).directionBitangent = fY[1];
 ${hasCoatNormals ? /* wgsl */ `
 if (USE_COAT_NORMAL_MAPS && directionMaterial.coatNormalMapIndex >= 0.0) {
-let ku = i32(directionMaterial.coatNormalMapIndex);
-var lW = eP;
-if (USE_UV1 && mapInfo[ku + NUM_MAPS * 2].x > 0.5) {
+let kC = i32(directionMaterial.coatNormalMapIndex);
+var mi = eS;
+if (USE_UV1 && mapInfo[kC + 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;
-lW = eD(normal, dp1, dp2, a-c, b-c,
-select(aU, vec4f(0.0), aU.w == 0.0));
+mi = eE(normal, dp1, dp2, a-c, b-c,
+select(aT, vec4f(0.0), aT.w == 0.0));
 }
 
 
-let decoded = sampleMap(ku, getMapUvSet(ku, uv,
+let decoded = sampleMap(kC, getMapUvSet(kC, uv,
 select(cX, uv, uvProjection > 0))).rgb * 2.0 - 1.0;
-let mapped = lW[0] * decoded.x * directionMaterial.coatNormalScale.x
-+ lW[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
+let mapped = mi[0] * decoded.x * directionMaterial.coatNormalScale.x
++ mi[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { (*si).coatNormal = normalize(mapped); }
 }
 ` : ''}
@@ -1041,14 +1047,14 @@ if (!bU) {
 
 
 let geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-let kf = eZ.x * n0 + eZ.y * n1 + eZ.z * n2;
+let km = eK.x * n0 + eK.y * n1 + eK.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 * eZ.x * (eZ.x - 1.0)
-+ (a + b + c) * eZ.x * eZ.y
-+ b * eZ.y * (eZ.y - 1.0);
-if (dot(kf, geometricNormal) > 0.0) {
+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 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);
@@ -1066,22 +1072,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 = kf * h;
+(*si).shadowOffset = km * h;
 }
 (*si).uv = uv;
 (*si).uv1 = cX;
 if (USE_NORMAL_MAPS) {
 let dp1 = tri.p0 - tri.p2;
 let dp2 = tri.p1 - tri.p2;
-let nS = uv0 - uv2;
-let nT = uv1 - uv2;
-(*si).normal = ob(
-(*si).materialIndex, uv, normal, dp1, dp2, nS, nT
+let od = uv0 - uv2;
+let oe = uv1 - uv2;
+(*si).normal = om(
+(*si).materialIndex, uv, normal, dp1, dp2, od, oe
 );
 }
 }
 
-struct eB {
+struct eC {
 t: f32,
 barycentric: vec3f,
 };
@@ -1090,8 +1096,8 @@ barycentric: vec3f,
 
 
 
-fn fI(o: vec3f, d: vec3f, tri: fu, ey: i32, gL: vec3f, tMax: f32) -> eB {
-var ti: eB;
+fn fL(o: vec3f, d: vec3f, tri: fA, ey: i32, gP: vec3f, tMax: f32) -> eC {
+var ti: eC;
 
 
 var p0t = tri.p0 - o;
@@ -1111,9 +1117,9 @@ p2t = p2t.zxy;
 
 
 
-p0t = vec3f(p0t.xy + gL.xy * p0t.z, p0t.z);
-p1t = vec3f(p1t.xy + gL.xy * p1t.z, p1t.z);
-p2t = vec3f(p2t.xy + gL.xy * p2t.z, p2t.z);
+p0t = vec3f(p0t.xy + gP.xy * p0t.z, p0t.z);
+p1t = vec3f(p1t.xy + gP.xy * p1t.z, p1t.z);
+p2t = vec3f(p2t.xy + gP.xy * p2t.z, p2t.z);
 
 
 var e = vec3f(
@@ -1125,9 +1131,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 if (DEPTH_QUERY_MODE) {
 
 
-let rt = abs(vec3f(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+let rE = 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) <= rt * 1e-6);
+e = select(e, vec3f(0.0), abs(e) <= rE * 1e-6);
 }
 
 
@@ -1138,19 +1144,19 @@ return ti;
 let det = e.x + e.y + e.z;
 if (DEPTH_QUERY_MODE && det == 0.0) { return ti; }
 
-p0t.z *= gL.z;
-p1t.z *= gL.z;
-p2t.z *= gL.z;
-let rd = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+p0t.z *= gP.z;
+p1t.z *= gP.z;
+p2t.z *= gP.z;
+let rn = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
 
 
-if (abs(rd) > abs(tMax * det)) {
+if (abs(rn) > abs(tMax * det)) {
 return ti;
 }
 
-let sm = 1. / det;
-ti.t = rd * sm;
-ti.barycentric = e * sm;
+let sw = 1. / det;
+ti.t = rn * sw;
+ti.barycentric = e * sw;
 
 return ti;
 }
@@ -1160,26 +1166,26 @@ return ti;
 
 override DEPTH_QUERY_MODE: bool = false;
 
-fn eX(d: vec3f) -> vec3f {
+fn fb(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 eV(gx: vec3f, o: vec3f) -> vec3f {
+fn eZ(gC: vec3f, o: vec3f) -> vec3f {
 if (!DEPTH_QUERY_MODE) { return vec3f(0.0); }
-return abs(gx) * max(vec3f(1.0), abs(o)) * 1e-6;
+return abs(gC) * max(vec3f(1.0), abs(o)) * 1e-6;
 }
 
 
 
-fn cM(o: vec3f, vD: vec3f, vC: vec3f, gx: vec3f, tMax: f32) -> f32 {
-let uK = (vD - o) * gx;
-let uL = (vC - o) * gx;
-let bJ = eV(gx, o);
-let mB = min(uK, uL) - bJ;
-let rM = max(uK, uL) + bJ;
-let t0 = max(mB.x, max(mB.y, mB.z));
-let t1 = min(rM.x, min(rM.y, rM.z));
+fn cM(o: vec3f, vK: vec3f, vJ: vec3f, gC: vec3f, tMax: f32) -> f32 {
+let uR = (vK - o) * gC;
+let uS = (vJ - o) * gC;
+let bJ = eZ(gC, o);
+let mL = min(uR, uS) - bJ;
+let rU = max(uR, uS) + bJ;
+let t0 = max(mL.x, max(mL.y, mL.z));
+let t1 = min(rU.x, min(rU.y, rU.z));
 return select(select(t1, t0, t0 > 0.0), -1.0, (t0 > t1 || t0 > tMax));
 }
 
@@ -1187,7 +1193,7 @@ 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 mj(d: vec3f, ey: i32) -> vec3f {
+fn mv(d: vec3f, ey: i32) -> vec3f {
 
 
 if (ey == 0) {
@@ -1199,33 +1205,33 @@ return vec3f(-d.x, -d.y, 1.0) / d.z;
 }
 }
 
-fn lX(
+fn mj(
 si: ptr<function, ad>,
-lp: fu,
+lC: fA,
 aB: vec3f,
-hs: vec3i,
+hw: vec3i,
 bU: bool,
 ao: i32,
-eC: vec3f,
-eU: vec3f,
-fq: i32
+eD: vec3f,
+eY: vec3f,
+fv: i32
 ) {
 (*si).instanceIndex = ao;
 (*si).barycentrics = aB.xy;
-(*si).normal = eC;
-(*si).position = eU;
+(*si).normal = eD;
+(*si).position = eY;
 (*si).materialIndex = i32(ae(
 bitcast<i32>(instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE}].z)
 ).x);
 
 
-hp(
+ht(
 si,
-lp,
+lC,
 aB,
-hs,
+hw,
 bU,
-fq
+fv
 );
 
 let l2w = mat4x4<f32>(
@@ -1246,7 +1252,7 @@ w2l[1].xyz,
 w2l[2].xyz
 ));
 
-(*si).faceNormal = normalize(aD * eC);
+(*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);` : ''}
@@ -1269,7 +1275,7 @@ ${createIntersectionAlphaWgsl(hasAnisotropyDirections)}
 
 
 
-fn cY(ray: Ray, si: ptr<function, ad>, bounces: i32, doubleSided: bool, lq: bool) {
+fn cZ(ray: Ray, si: ptr<function, ad>, bounces: i32, doubleSided: bool, lD: bool) {
 
 (*si).hit = false;
 
@@ -1279,37 +1285,37 @@ return;
 
 var tMax = RAY_MAX_DISTANCE;
 var ey: i32;
-var gL: vec3f;
+var gP: vec3f;
 
-var hs: vec3i;
-var lp: fu;
+var hw: vec3i;
+var lC: fA;
 var ao: i32;
-var hK: i32 = (*si).triangleIndex;
+var hO: i32 = (*si).triangleIndex;
 
 ${getBVHTraverseCode(`
 (*si).triangleIndex = triangleIndex;
-lp = tri;
-hs = index;
+lC = tri;
+hw = index;
 ao = cf;
 `, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections)}
 
-if (qT) {
-lX(
+if (rb) {
+mj(
 si,
-lp,
+lC,
 aB,
-hs,
+hw,
 bU,
 ao,
-eC,
-eU,
+eD,
+eY,
 -1
 );
 }
 }
 
 
-fn iH(ray: Ray, si: ptr<function, ad>, instanceIndex: i32, maxDistance: f32) {
+fn iM(ray: Ray, si: ptr<function, ad>, instanceIndex: i32, maxDistance: f32) {
 (*si).hit = false;
 
 if (rtUniform.isEmpty > 0) {
@@ -1318,19 +1324,19 @@ return;
 
 let bounces = 0;
 let doubleSided = true;
-let lq = false;
+let lD = false;
 var tMax = maxDistance;
 var ey: i32;
-var gL: vec3f;
-var hs: vec3i;
-var lp: fu;
+var gP: vec3f;
+var hw: vec3i;
+var lC: fA;
 var ao: i32;
-var hK: i32 = -1;
+var hO: i32 = -1;
 
 ${getBVHTraverseCode(`
 (*si).triangleIndex = triangleIndex;
-lp = tri;
-hs = index;
+lC = tri;
+hw = index;
 ao = cf;
 `, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections, `
 if (cf != instanceIndex) {
@@ -1338,16 +1344,16 @@ continue;
 }
 `)}
 
-if (qT) {
+if (rb) {
 (*si).instanceIndex = ao;
-(*si).normal = eC;
-(*si).position = eU;
+(*si).normal = eD;
+(*si).position = eY;
 (*si).materialIndex = i32(ae(bitcast<i32>(instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE}].z)).x);
-hp(
+ht(
 si,
-lp,
+lC,
 aB,
-hs,
+hw,
 bU,
 -1
 );
@@ -1369,7 +1375,7 @@ w2l[0].xyz,
 w2l[1].xyz,
 w2l[2].xyz
 ));
-(*si).faceNormal = normalize(aD * eC);
+(*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);` : ''}
@@ -1387,45 +1393,45 @@ ${hasAnisotropyDirections ? /* wgsl */ `
 }
 }
 
-fn ex(ray: Ray, lightDistance: f32, jG: i32) -> bool {
+fn ex(ray: Ray, lightDistance: f32, jL: i32) -> bool {
 if (rtUniform.isEmpty > 0) {
 return false;
 }
 
 let doubleSided = true;
-let qg = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-var tMax = qg;
+let qo = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
+var tMax = qo;
 var ey: i32;
-var gL: vec3f;
+var gP: vec3f;
 
 let bounces = 1;
-var lq = false;
-var hK: i32 = jG;
+var lD = false;
+var hO: i32 = jL;
 
 ${getBVHTraverseCode(
     /*wgsl */ `
 
 
 
-var jn = true;
+var jt = true;
 
-if (jn) {
+if (jt) {
 if (HAS_ALPHA) {
-let materialIndex = i32(ae(bitcast<i32>(oh.z)).x);
-if (!nr(
+let materialIndex = i32(ae(bitcast<i32>(ou.z)).x);
+if (!nG(
 materialIndex,
 index,
 aB,
-eU,
-eC
+eY,
+eD
 )) {
 
-tMax = qg;
-jn = false;
+tMax = qo;
+jt = false;
 }
 }
 }
-if (jn) {
+if (jt) {
 return true;
 }
 `, hasDisplacement, true, blasLayoutMask, hasAnisotropyDirections)}