@meimu/mutracer 0.1.1 → 0.1.3

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

@@ -13,24 +13,24 @@ ${skipTriangleCode}
 vec4 r3 = dp(triangleIndex);
 ivec3 index = floatBitsToInt(r3.xyz) + vertexOffset;
 fu tri = fu(
-kw(positionBuffer, index.x, vertexColumns).xyz,
-kw(positionBuffer, index.y, vertexColumns).xyz,
-kw(positionBuffer, index.z, vertexColumns).xyz
+ky(positionBuffer, index.x, vertexColumns).xyz,
+ky(positionBuffer, index.y, vertexColumns).xyz,
+ky(positionBuffer, index.z, vertexColumns).xyz
 );
-eB hit = fI(o, d, tri, ey, gJ, tMax);
+eB hit = fI(o, d, tri, ey, gL, tMax);
 
 if (hit.t > 0.0) {
 tMax = hit.t;
 vec3 e1 = tri.p1 - tri.p0;
 vec3 e2 = tri.p2 - tri.p0;
 vec3 faceNormal = normalize(cross(e1, e2));
-int kb = int(ae(
+int kd = int(ae(
 floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)
 ).x);
-bool iH = fetchMatData(
-kb * MAT_DATA_SIZE + MAT_ROW_ALPHA
+bool iI = fetchMatData(
+kd * MAT_DATA_SIZE + MAT_ROW_ALPHA
 ).z > 0.5;
-if (!doubleSided && !iH && dot(faceNormal, d) > 0.0) {
+if (!doubleSided && !iI && dot(faceNormal, d) > 0.0) {
 continue;
 }
 
@@ -41,31 +41,31 @@ ${handleHitCode}
     return glsl `
 ivec2 stack[STACK_SIZE];
 int top = -1;
-int sB = -1;
+int sG = -1;
 float tMax = ${initialTMax};
 
 vec3 o = ray.o;
 vec3 d = ray.d;
 
-bool qP = false;
-vec3 hy;
+bool qT = false;
+vec3 hx;
 vec3 aB;
 ivec3 hs;
 
-fu lm;
+fu lp;
 
 
 top = 0;
 stack[0] = ivec2(0, -1);
 
-int wd = 0;
-while(top >= 0 && wd < 5000) {
-wd++;
+int wk = 0;
+while(top >= 0 && wk < 5000) {
+wk++;
 ivec2 node = stack[top--];
 
 int cf = node.y;
 
-if (cf != sB) {
+if (cf != sG) {
 if (cf < 0) {
 o = ray.o;
 d = ray.d;
@@ -81,110 +81,110 @@ o = (w2l * vec4(ray.o, 1.0)).xyz;
 d = (w2l * vec4(ray.d, 0.0)).xyz;
 }
 ey = maxDimension(abs(d));
-gJ = mg(d, ey);
-sB = cf;
+gL = mj(d, ey);
+sG = cf;
 }
 
 int bo = cf < 0 ? 0 : blasOffset;
 uint fG = cf < 0 ? 0u : floatBitsToUint(bv(cf * ${INSTANCE_VEC4_STRIDE}).x);
-int gL = int(fG >> 30u);
+int gN = int(fG >> 30u);
 int eS = int(fG & 0x3fffffffu);
 int bh = 0;
 int primitiveOffset = 0;
 
-if (gL == 3) {
-uint hT = uint(node.x);
-if ((hT & 0x80000000u) != 0u) {
-bh = int((hT >> 23u) & 0xffu);
-primitiveOffset = bo + eS + int(hT & 0x007fffffu);
+if (gN == 3) {
+uint hS = uint(node.x);
+if ((hS & 0x80000000u) != 0u) {
+bh = int((hS >> 23u) & 0xffu);
+primitiveOffset = bo + eS + int(hS & 0x007fffffu);
 }
 else {
 int i = node.x + bo;
-vec4 jr = dp(i);
+vec4 ju = dp(i);
 vec4 fC = dp(i + 1);
-vec4 mH = dp(i + 2);
-vec4 mI = dp(i + 3);
-vec4 mJ = dp(i + 4);
-uint header = floatBitsToUint(jr.w);
-int rq = int(header << 24u) >> 24;
-int rr = int((header >> 8u) << 24u) >> 24;
-int rs = int((header >> 16u) << 24u) >> 24;
-vec3 hG = vec3(
-uintBitsToFloat(uint(rq + 127) << 23u),
-uintBitsToFloat(uint(rr + 127) << 23u),
-uintBitsToFloat(uint(rs + 127) << 23u)
+vec4 mK = dp(i + 2);
+vec4 mL = dp(i + 3);
+vec4 mM = dp(i + 4);
+uint header = floatBitsToUint(ju.w);
+int rv = int(header << 24u) >> 24;
+int rw = int((header >> 8u) << 24u) >> 24;
+int rA = int((header >> 16u) << 24u) >> 24;
+vec3 hF = vec3(
+uintBitsToFloat(uint(rv + 127) << 23u),
+uintBitsToFloat(uint(rw + 127) << 23u),
+uintBitsToFloat(uint(rA + 127) << 23u)
 );
 uint childBase = floatBitsToUint(fC.x);
-uint oE = floatBitsToUint(fC.y);
+uint oH = floatBitsToUint(fC.y);
 uint internalMask = header >> 24u;
-uint uf = (d.x < 0.0 ? 4u : 0u) |
+uint ul = (d.x < 0.0 ? 4u : 0u) |
 (d.y < 0.0 ? 2u : 0u) |
 (d.z < 0.0 ? 1u : 0u);
-uint gA[12] = uint[12](
-floatBitsToUint(mH.x), floatBitsToUint(mH.y),
-floatBitsToUint(mH.z), floatBitsToUint(mH.w),
-floatBitsToUint(mI.x), floatBitsToUint(mI.y),
-floatBitsToUint(mI.z), floatBitsToUint(mI.w),
-floatBitsToUint(mJ.x), floatBitsToUint(mJ.y),
-floatBitsToUint(mJ.z), floatBitsToUint(mJ.w)
+uint gE[12] = uint[12](
+floatBitsToUint(mK.x), floatBitsToUint(mK.y),
+floatBitsToUint(mK.z), floatBitsToUint(mK.w),
+floatBitsToUint(mL.x), floatBitsToUint(mL.y),
+floatBitsToUint(mL.z), floatBitsToUint(mL.w),
+floatBitsToUint(mM.x), floatBitsToUint(mM.y),
+floatBitsToUint(mM.z), floatBitsToUint(mM.w)
 );
 
 for (int order = 7; order >= 0; order--) {
-uint slot = uint(order) ^ uf;
-uint sn = slot >= 4u
+uint slot = uint(order) ^ ul;
+uint su = slot >= 4u
 ? floatBitsToUint(fC.w)
 : floatBitsToUint(fC.z);
-uint meta = (sn >> ((slot & 3u) * 8u)) & 0xffu;
+uint meta = (su >> ((slot & 3u) * 8u)) & 0xffu;
 if (meta == 0u) continue;
-uint lL = (slot & 3u) * 8u;
-uint kJ = slot >> 2u;
-vec3 tq = vec3(
-float((gA[kJ] >> lL) & 0xffu),
-float((gA[2u + kJ] >> lL) & 0xffu),
-float((gA[4u + kJ] >> lL) & 0xffu)
+uint lO = (slot & 3u) * 8u;
+uint kM = slot >> 2u;
+vec3 tA = vec3(
+float((gE[kM] >> lO) & 0xffu),
+float((gE[2u + kM] >> lO) & 0xffu),
+float((gE[4u + kM] >> lO) & 0xffu)
 );
-vec3 tp = vec3(
-float((gA[6u + kJ] >> lL) & 0xffu),
-float((gA[8u + kJ] >> lL) & 0xffu),
-float((gA[10u + kJ] >> lL) & 0xffu)
+vec3 tw = vec3(
+float((gE[6u + kM] >> lO) & 0xffu),
+float((gE[8u + kM] >> lO) & 0xffu),
+float((gE[10u + kM] >> lO) & 0xffu)
 );
-vec3 uI = jr.xyz + tq * hG;
-vec3 uH = jr.xyz + tp * hG;
-if (cM(o, d, uI, uH, tMax) <= 0.0) continue;
-uint ju = meta & 0x1fu;
-if (ju >= 24u) {
-uint mY = internalMask & ((1u << slot) - 1u);
-uint sL = childBase + qG(mY);
+vec3 uP = ju.xyz + tA * hF;
+vec3 uO = ju.xyz + tw * hF;
+if (cM(o, d, uP, uO, tMax) <= 0.0) continue;
+uint jw = meta & 0x1fu;
+if (jw >= 24u) {
+uint ne = internalMask & ((1u << slot) - 1u);
+uint sQ = childBase + qK(ne);
 stack[++top] = ivec2(
-eS + int(sL * 5u), cf
+eS + int(sQ * 5u), cf
 );
 }
 else {
-uint triangleCount = qG(meta >> 5u);
-uint rF = oE + ju;
-uint uS = 0x80000000u |
+uint triangleCount = qK(meta >> 5u);
+uint rK = oH + jw;
+uint uZ = 0x80000000u |
 (triangleCount << 23u) |
-(rF & 0x007fffffu);
-stack[++top] = ivec2(int(uS), cf);
+(rK & 0x007fffffu);
+stack[++top] = ivec2(int(uZ), cf);
 }
 }
 }
 }
-else if (gL == 2) {
+else if (gN == 2) {
 int i = node.x + bo;
-vec4 uK = dp(i);
-vec4 uL = dp(i + 1);
-vec4 uM = dp(i + 2);
-vec4 uN = dp(i + 3);
-bh = int(floatBitsToUint(uM.w));
+vec4 uR = dp(i);
+vec4 uS = dp(i + 1);
+vec4 uT = dp(i + 2);
+vec4 uU = dp(i + 3);
+bh = int(floatBitsToUint(uT.w));
 if (bh > 0) {
-primitiveOffset = bo + eS + int(floatBitsToUint(uN.w));
+primitiveOffset = bo + eS + int(floatBitsToUint(uU.w));
 }
 else {
-int left = eS + int(floatBitsToUint(uK.w) * 4u);
-int right = eS + int(floatBitsToUint(uL.w) * 4u);
-float d0 = cM(o, d, uK.xyz, uL.xyz, tMax);
-float d1 = cM(o, d, uM.xyz, uN.xyz, tMax);
+int left = eS + int(floatBitsToUint(uR.w) * 4u);
+int right = eS + int(floatBitsToUint(uS.w) * 4u);
+float d0 = cM(o, d, uR.xyz, uS.xyz, tMax);
+float d1 = cM(o, d, uT.xyz, uU.xyz, tMax);
 if (d0 > d1) {
 if (d0 > 0.0) stack[++top] = ivec2(left, cf);
 if (d1 > 0.0) stack[++top] = ivec2(right, cf);
@@ -195,42 +195,42 @@ if (d0 > 0.0) stack[++top] = ivec2(left, cf);
 }
 }
 }
-else if (gL == 1) {
-uint hT = uint(node.x);
-if ((hT & 0x80000000u) != 0u) {
-bh = int((hT >> 23u) & 0xffu);
-primitiveOffset = bo + eS + int(hT & 0x007fffffu);
+else if (gN == 1) {
+uint hS = uint(node.x);
+if ((hS & 0x80000000u) != 0u) {
+bh = int((hS >> 23u) & 0xffu);
+primitiveOffset = bo + eS + int(hS & 0x007fffffu);
 }
 else {
 int i = node.x + bo;
-vec4 tV = dp(i);
-vec4 ra = dp(i + 1);
-vec4 rb = dp(i + 2);
-vec4 rc = dp(i + 3);
-vec3 nodeMin = tV.xyz;
-vec3 ec = vec3(tV.w, ra.x, ra.y);
-uint lS[4] = uint[4](
-floatBitsToUint(ra.z), floatBitsToUint(ra.w),
-floatBitsToUint(rb.x), floatBitsToUint(rb.y)
+vec4 ub = dp(i);
+vec4 rf = dp(i + 1);
+vec4 rh = dp(i + 2);
+vec4 ri = dp(i + 3);
+vec3 nodeMin = ub.xyz;
+vec3 ec = vec3(ub.w, rf.x, rf.y);
+uint lV[4] = uint[4](
+floatBitsToUint(rf.z), floatBitsToUint(rf.w),
+floatBitsToUint(rh.x), floatBitsToUint(rh.y)
 );
-vec4 rj = eY(floatBitsToUint(rb.z));
-vec4 rk = eY(floatBitsToUint(rb.w));
-vec4 rl = eY(floatBitsToUint(rc.x));
-vec4 rf = eY(floatBitsToUint(rc.y));
-vec4 rh = eY(floatBitsToUint(rc.z));
-vec4 ri = eY(floatBitsToUint(rc.w));
-vec3 gv = eX(d);
-vec3 bJ = eV(gv, o);
-vec4 tx0 = (nodeMin.x + rj * ec.x - o.x) * gv.x;
-vec4 tx1 = (nodeMin.x + rf * ec.x - o.x) * gv.x;
-vec4 ty0 = (nodeMin.y + rk * ec.y - o.y) * gv.y;
-vec4 ty1 = (nodeMin.y + rh * ec.y - o.y) * gv.y;
-vec4 tz0 = (nodeMin.z + rl * ec.z - o.z) * gv.z;
-vec4 tz1 = (nodeMin.z + ri * ec.z - o.z) * gv.z;
-vec4 my = max(max((min(tx0, tx1) - vec4(bJ.x)), (min(ty0, ty1) - vec4(bJ.y))), (min(tz0, tz1) - vec4(bJ.z)));
-vec4 rH = min(min((max(tx0, tx1) + vec4(bJ.x)), (max(ty0, ty1) + vec4(bJ.y))), (max(tz0, tz1) + vec4(bJ.z)));
-vec4 distance = mix(rH, my, greaterThan(my, vec4(0.0)));
-distance = mix(distance, vec4(-1.0), greaterThan(my, min(rH, vec4(tMax))));
+vec4 ro = eY(floatBitsToUint(rh.z));
+vec4 rp = eY(floatBitsToUint(rh.w));
+vec4 rq = eY(floatBitsToUint(ri.x));
+vec4 rl = eY(floatBitsToUint(ri.y));
+vec4 rm = eY(floatBitsToUint(ri.z));
+vec4 rn = eY(floatBitsToUint(ri.w));
+vec3 gx = eX(d);
+vec3 bJ = eV(gx, o);
+vec4 tx0 = (nodeMin.x + ro * ec.x - o.x) * gx.x;
+vec4 tx1 = (nodeMin.x + rl * ec.x - o.x) * gx.x;
+vec4 ty0 = (nodeMin.y + rp * ec.y - o.y) * gx.y;
+vec4 ty1 = (nodeMin.y + rm * ec.y - o.y) * gx.y;
+vec4 tz0 = (nodeMin.z + rq * ec.z - o.z) * gx.z;
+vec4 tz1 = (nodeMin.z + rn * ec.z - o.z) * gx.z;
+vec4 mB = max(max((min(tx0, tx1) - vec4(bJ.x)), (min(ty0, ty1) - vec4(bJ.y))), (min(tz0, tz1) - vec4(bJ.z)));
+vec4 rM = min(min((max(tx0, tx1) + vec4(bJ.x)), (max(ty0, ty1) + vec4(bJ.y))), (max(tz0, tz1) + vec4(bJ.z)));
+vec4 distance = mix(rM, mB, greaterThan(mB, vec4(0.0)));
+distance = mix(distance, vec4(-1.0), greaterThan(mB, min(rM, vec4(tMax))));
 float fa[4] = float[4](distance.x, distance.y, distance.z, distance.w);
 
 
@@ -238,18 +238,18 @@ for (int order = 0; order < 4; order++) {
 float dX = -1.0;
 int el = -1;
 for (int child = 0; child < 4; child++) {
-if (lS[child] != 0u && fa[child] > dX) {
+if (lV[child] != 0u && fa[child] > dX) {
 dX = fa[child];
 el = child;
 }
 }
 if (el >= 0 && dX > 0.0) {
-uint ni = lS[el];
-int jB = int(ni);
-if ((ni & 0x80000000u) == 0u) {
-jB += eS;
+uint nl = lV[el];
+int jD = int(nl);
+if ((nl & 0x80000000u) == 0u) {
+jD += eS;
 }
-stack[++top] = ivec2(jB, cf);
+stack[++top] = ivec2(jD, cf);
 fa[el] = -1.0;
 }
 }
@@ -347,7 +347,7 @@ return t2;
 return INF;
 }
 
-float mR(vec3 pos, vec3 u, vec3 v, vec3 n, Ray r) {
+float mU(vec3 pos, vec3 u, vec3 v, vec3 n, Ray r) {
 float dt = dot(r.d, n);
 float t = (dot(n, pos) - dot(n, r.o)) / dt;
 
@@ -366,7 +366,7 @@ return t;
 return INF;
 }
 
-float mk(Ray r, Light light, out LightSampleRec lightSample) {
+float mo(Ray r, Light light, out LightSampleRec lightSample) {
 
 
 
@@ -383,7 +383,7 @@ vec3 normal = normalize(cross(u, v));
 if (dot(normal, r.d) > 0.) 
 return INF;
 
-d = mR(pos, u, v, normal, r);
+d = mU(pos, u, v, normal, r);
 if (d < 0.) {
 d = INF;
 }
@@ -400,9 +400,9 @@ lightSample.emission = light.emission;
 #ifdef HAS_SPHERE_LIGHTS
 if (type == SPHERE_LIGHT) {
 if (light.radius <= 0.0) {
-vec3 kf = light.position - r.o;
-float projection = dot(kf, r.d);
-vec3 ba = kf - projection * r.d;
+vec3 kh = light.position - r.o;
+float projection = dot(kh, r.d);
+vec3 ba = kh - projection * r.d;
 if (projection <= EPS || dot(ba, ba) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
@@ -436,9 +436,9 @@ lightSample.emission = light.radius <= 0.0
 #ifdef HAS_SPOT_LIGHTS
 if (type == SPOT_LIGHT) {
 if (light.radius <= 0.0) {
-vec3 kf = light.position - r.o;
-float projection = dot(kf, r.d);
-vec3 ba = kf - projection * r.d;
+vec3 kh = light.position - r.o;
+float projection = dot(kh, r.d);
+vec3 ba = kh - projection * r.d;
 if (projection <= EPS || dot(ba, ba) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
@@ -451,9 +451,9 @@ d = ht(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d != INF) {
-vec3 uQ = r.o + d * r.d;
-float mo = bL(light, normalize(r.o - uQ));
-if (mo <= 0.0) return INF;
+vec3 uX = r.o + d * r.d;
+float mr = bL(light, normalize(r.o - uX));
+if (mr <= 0.0) return INF;
 float aj = distance(r.o, light.position);
 float cosThetaMax = aj <= light.radius
 ? -1.0
@@ -463,7 +463,7 @@ lightSample.pdf = aj <= light.radius
 ? INV4PI
 : 1.0 / max(TWOPI * (1.0 - cosThetaMax), 1e-8);
 }
-lightSample.emission = light.emission * mo * (light.radius <= 0.0
+lightSample.emission = light.emission * mr * (light.radius <= 0.0
 ? 1.0 / max(d * d, 1e-8)
 : 1.0);
 }
@@ -494,76 +494,76 @@ float w20 = m20.y * eZ.z;
 float w21 = m21.y * eZ.z;
 float w22 = m22.y * eZ.z;
 
-float he = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
+float hg = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
 
-w00 = w00 / he;
-w01 = w01 / he + w00;
-w02 = w02 / he + w01;
-w10 = w10 / he + w02;
-w11 = w11 / he + w10;
-w12 = w12 / he + w11;
-w20 = w20 / he + w12;
-w21 = w21 / he + w20;
-w22 = w22 / he + w21;
+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;
 
 float rand = eo(0u);
-float mS;
+float mV;
 if (rand < w00) {
-mS = m00.x;
+mV = m00.x;
 } else if (rand < w01) {
-mS = m01.x;
+mV = m01.x;
 } else if (rand < w02) {
-mS = m02.x;
+mV = m02.x;
 } else if (rand < w10) {
-mS = m10.x;
+mV = m10.x;
 } else if (rand < w11) {
-mS = m11.x;
+mV = m11.x;
 } else if (rand < w12) {
-mS = m12.x;
+mV = m12.x;
 } else if (rand < w20) {
-mS = m20.x;
+mV = m20.x;
 } else if (rand < w21) {
-mS = m21.x;
+mV = m21.x;
 } else {
-mS = m22.x;
+mV = m22.x;
 }
-return int(mS);
+return int(mV);
 }
 
 
 vec4 bv(int i);
 
 
-mat2x3 eD(vec3 normal, vec3 dp1, vec3 dp2, vec2 nP, vec2 nQ, vec4 aU) {
-float determinant = nP.x * nQ.y - nP.y * nQ.x;
+mat2x3 eD(vec3 normal, vec3 dp1, vec3 dp2, vec2 nS, vec2 nT, vec4 aU) {
+float determinant = nS.x * nT.y - nS.y * nT.x;
 vec3 t = aU.xyz;
 vec3 b = vec3(0.0);
 
-float qq = abs(aU.w) > 1.5 ? 0.0 : aU.w;
+float qu = abs(aU.w) > 1.5 ? 0.0 : aU.w;
 if (abs(determinant) > 1e-12) {
-vec3 dt = (dp1 * nQ.y - dp2 * nP.y) / determinant;
-vec3 db = (dp2 * nP.x - dp1 * nQ.x) / determinant;
+vec3 dt = (dp1 * nT.y - dp2 * nS.y) / determinant;
+vec3 db = (dp2 * nS.x - dp1 * nT.x) / determinant;
 if (dot(t, t) < 1e-8) { t = dt; }
-if (qq == 0.0) { qq = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
+if (qu == 0.0) { qu = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
 }
 t -= normal * dot(normal, t);
 if (dot(t, t) < 1e-8) {
-float ig = (normal.z >= 0.0 ? 1.0 : -1.0);
-float dW = -1.0 / (ig + normal.z);
+float ie = (normal.z >= 0.0 ? 1.0 : -1.0);
+float dW = -1.0 / (ie + normal.z);
 float xy = normal.x * normal.y * dW;
-t = vec3(1.0 + ig * normal.x * normal.x * dW, ig * xy, -ig * normal.x);
-b = vec3(xy, ig + normal.y * normal.y * dW, -normal.y);
+t = vec3(1.0 + ie * normal.x * normal.x * dW, ie * xy, -ie * normal.x);
+b = vec3(xy, ie + normal.y * normal.y * dW, -normal.y);
 }
 else { t = normalize(t); b = normalize(cross(normal, t)); }
-return mat2x3(t, b * (qq < 0.0 ? -1.0 : 1.0));
+return mat2x3(t, b * (qu < 0.0 ? -1.0 : 1.0));
 }
 
 void hp(inout ad si, fu tri, vec3 barycentric, ivec3 index) {
 si.hit = true;
 si.position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
-ivec2 i0 = gK(index.x, vertexColumns);
-ivec2 i1 = gK(index.y, vertexColumns);
-ivec2 i2 = gK(index.z, vertexColumns);
+ivec2 i0 = gM(index.x, vertexColumns);
+ivec2 i1 = gM(index.y, vertexColumns);
+ivec2 i2 = gM(index.z, vertexColumns);
 
 vec3 n0 = texelFetch(normalBuffer, i0, 0).xyz;
 vec3 n1 = texelFetch(normalBuffer, i1, 0).xyz;
@@ -576,14 +576,14 @@ si.vertexNormal = normal;
 
 
 vec3 geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-vec3 kd = barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2;
+vec3 kf = barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2;
 float a = dot(n2 - n0, tri.p0 - tri.p2);
 float b = dot(n2 - n1, tri.p1 - tri.p2);
 float c = dot(n1 - n0, tri.p1 - tri.p0);
 float h = a * barycentric.x * (barycentric.x - 1.0)
 + (a + b + c) * barycentric.x * barycentric.y
 + b * barycentric.y * (barycentric.y - 1.0);
-if (dot(kd, geometricNormal) > 0.0) {
+if (dot(kf, geometricNormal) > 0.0) {
 float h0 = max(max(dot(tri.p1 - tri.p0, n0), dot(tri.p2 - tri.p0, n0)), 0.0);
 float h1 = max(max(dot(tri.p0 - tri.p1, n1), dot(tri.p2 - tri.p1, n1)), 0.0);
 float h2 = max(max(dot(tri.p0 - tri.p2, n2), dot(tri.p1 - tri.p2, n2)), 0.0);
@@ -601,7 +601,7 @@ 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 = kd * h;
+si.shadowOffset = kf * h;
 
 
 ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
@@ -624,14 +624,14 @@ vec2 cX = barycentric.x * secondaryUv0
 + barycentric.y * secondaryUv1
 + barycentric.z * secondaryUv2;
 
-vec4 lw = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
-int uvProjection = int(lw.r);
+vec4 lC = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
+int uvProjection = int(lC.r);
 if (uvProjection > 0) {
-uv = gz(uvProjection, si.position, normal, lw.zw);
+uv = gC(uvProjection, si.position, normal, lC.zw);
 cX = uv;
 } else {
-uv *= lw.zw;
-cX *= lw.zw;
+uv *= lC.zw;
+cX *= lC.zw;
 }
 #else
 vec2 uv = vec2(0.0);
@@ -640,13 +640,13 @@ vec2 cX = vec2(0.0);
 
 #ifdef NUM_COAT_NORMAL_MAPS
 si.coatNormal = normal;
-float lj = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
+float lm = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
 #endif
 vec4 directionMaterial = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_DIRECTION_NORMAL);
-float sZ = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
-if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || sZ != 0.0
+float te = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
+if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || te != 0.0
 #ifdef NUM_COAT_NORMAL_MAPS
-|| lj >= 0.0
+|| lm >= 0.0
 #endif
 ) {
 vec3 dp1 = tri.p0 - tri.p2;
@@ -672,19 +672,19 @@ fU = eD(normal, dp1, dp2, a-c, b-c, (aU.w == 0.0 ? vec4(0.0) : aU));
 si.directionTangent = fU[0];
 si.directionBitangent = fU[1];
 #ifdef NUM_COAT_NORMAL_MAPS
-if (lj >= 0.0) {
-int kq = int(lj);
-mat2x3 lT = eP;
-if (mapUvChannel[kq] > 0.5) {
+if (lm >= 0.0) {
+int ku = int(lm);
+mat2x3 lW = eP;
+if (mapUvChannel[ku] > 0.5) {
 vec2 a = texelFetch(uv1Buffer, i0, 0).xy;
 vec2 b = texelFetch(uv1Buffer, i1, 0).xy;
 vec2 c = texelFetch(uv1Buffer, i2, 0).xy;
-lT = eD(normal, dp1, dp2, a-c, b-c,
+lW = eD(normal, dp1, dp2, a-c, b-c,
 aU.w == 0.0 ? vec4(0.0) : aU);
 }
-vec3 decoded = sampleMap(kq, getMapUvSet(kq, uv, cX)).rgb * 2.0 - 1.0;
-vec3 mapped = lT[0] * decoded.x * directionMaterial.z
-+ lT[1] * decoded.y * directionMaterial.w + normal * decoded.z;
+vec3 decoded = sampleMap(ku, getMapUvSet(ku, uv, cX)).rgb * 2.0 - 1.0;
+vec3 mapped = lW[0] * decoded.x * directionMaterial.z
++ lW[1] * decoded.y * directionMaterial.w + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { si.coatNormal = normalize(mapped); }
 }
 #endif
@@ -702,10 +702,10 @@ si.tangent = normalize(barycentric.x * t0 + barycentric.y * t1 + barycentric.z *
 #if defined(NUM_NORMAL_MAPS)
 vec3 dp1 = tri.p0 - tri.p2;
 vec3 dp2 = tri.p1 - tri.p2;
-vec2 nP = uv0 - uv2;
-vec2 nQ = uv1 - uv2;
-si.normal = nY(
-si.materialIndex, uv, normal, dp1, dp2, nP, nQ
+vec2 nS = uv0 - uv2;
+vec2 nT = uv1 - uv2;
+si.normal = ob(
+si.materialIndex, uv, normal, dp1, dp2, nS, nT
 );
 #else
 si.normal = normal;
@@ -718,35 +718,35 @@ vec3 barycentric;
 };
 
 vec4 dp(int i) {
-return kw(bvhBuffer, i, bvhColumns);
+return ky(bvhBuffer, i, bvhColumns);
 }
 
 vec4 bv(int i) {
-return kw(instancesBuffer, i, instancesColumns);
+return ky(instancesBuffer, i, instancesColumns);
 }
 
 
 
-uint qG(uint value) {
+uint qK(uint value) {
 value -= (value >> 1u) & 0x55555555u;
 value = (value & 0x33333333u) + ((value >> 2u) & 0x33333333u);
 value = (value + (value >> 4u)) & 0x0f0f0f0fu;
 return (value * 0x01010101u) >> 24u;
 }
 
-vec4 eY(uint lI) {
+vec4 eY(uint lL) {
 return vec4(
-float(lI & 0xffu),
-float((lI >> 8u) & 0xffu),
-float((lI >> 16u) & 0xffu),
-float(lI >> 24u)
+float(lL & 0xffu),
+float((lL >> 8u) & 0xffu),
+float((lL >> 16u) & 0xffu),
+float(lL >> 24u)
 ) / 255.0;
 }
 
 
 
 
-eB fI(vec3 o, vec3 d, fu tri, int ey, vec3 gJ, float tMax) {
+eB fI(vec3 o, vec3 d, fu tri, int ey, vec3 gL, float tMax) {
 eB ti;
 
 
@@ -766,9 +766,9 @@ p2t = p2t.zxy;
 }
 
 
-p0t.xy += gJ.xy * p0t.z;
-p1t.xy += gJ.xy * p1t.z;
-p2t.xy += gJ.xy * p2t.z;
+p0t.xy += gL.xy * p0t.z;
+p1t.xy += gL.xy * p1t.z;
+p2t.xy += gL.xy * p2t.z;
 
 
 vec3 e = vec3(
@@ -778,9 +778,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 );
 
 #ifdef DEPTH_QUERY_MODE
-vec3 ro = abs(vec3(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+vec3 rt = abs(vec3(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
 + abs(vec3(p1t.y * p2t.x, p2t.y * p0t.x, p0t.y * p1t.x));
-e = mix(e, vec3(0.0), lessThanEqual(abs(e), ro * 1e-6));
+e = mix(e, vec3(0.0), lessThanEqual(abs(e), rt * 1e-6));
 #endif
 
 
@@ -793,19 +793,19 @@ float det = e.x + e.y + e.z;
 if (det == 0.0) return ti;
 #endif
 
-p0t.z *= gJ.z;
-p1t.z *= gJ.z;
-p2t.z *= gJ.z;
-float qZ = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+p0t.z *= gL.z;
+p1t.z *= gL.z;
+p2t.z *= gL.z;
+float rd = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
 
 
-if (abs(qZ) > abs(tMax * det)) {
+if (abs(rd) > abs(tMax * det)) {
 return ti;
 }
 
-float sg = 1. / det;
-ti.t = qZ * sg;
-ti.barycentric = e * sg;
+float sm = 1. / det;
+ti.t = rd * sm;
+ti.barycentric = e * sm;
 
 return ti;
 }
@@ -825,9 +825,9 @@ return 1.0 / d;
 #endif
 }
 
-vec3 eV(vec3 gv, vec3 o) {
+vec3 eV(vec3 gx, vec3 o) {
 #ifdef DEPTH_QUERY_MODE
-return abs(gv) * max(vec3(1.0), abs(o)) * 1e-6;
+return abs(gx) * max(vec3(1.0), abs(o)) * 1e-6;
 #else
 return vec3(0.0);
 #endif
@@ -835,21 +835,21 @@ return vec3(0.0);
 
 
 
-float cM(vec3 o, vec3 d, vec3 vw, vec3 vu, float tMax) {
+float cM(vec3 o, vec3 d, vec3 vD, vec3 vC, float tMax) {
 #ifdef DEPTH_QUERY_MODE
-vec3 gv = eX(d);
-vec3 uD = (vw - o) * gv;
-vec3 uE = (vu - o) * gv;
-vec3 bJ = eV(gv, o);
+vec3 gx = eX(d);
+vec3 uK = (vD - o) * gx;
+vec3 uL = (vC - o) * gx;
+vec3 bJ = eV(gx, o);
 #else
-vec3 uD = (vw - o) / d;
-vec3 uE = (vu - o) / d;
+vec3 uK = (vD - o) / d;
+vec3 uL = (vC - o) / d;
 vec3 bJ = vec3(0.0);
 #endif
-vec3 my = min(uD, uE) - bJ;
-vec3 rH = max(uD, uE) + bJ;
-float t0 = max(my.x, max(my.y, my.z));
-float t1 = min(rH.x, min(rH.y, rH.z));
+vec3 mB = min(uK, uL) - bJ;
+vec3 rM = max(uK, uL) + bJ;
+float t0 = max(mB.x, max(mB.y, mB.z));
+float t1 = min(rM.x, min(rM.y, rM.z));
 
 return (t0 > t1 || t0 > tMax) ? -1.0 : (t0 > 0.0 ? t0 : t1);
 }
@@ -858,7 +858,7 @@ int maxDimension(vec3 v) {
 return v.x > v.y ? (v.x > v.z ? 0 : 2) : (v.y > v.z ? 1 : 2);
 }
 
-vec3 mg(vec3 d, int ey) {
+vec3 mj(vec3 d, int ey) {
 
 
 if (ey == 0) {
@@ -879,24 +879,24 @@ return;
 }
 
 int ey = maxDimension(abs(ray.d));
-vec3 gJ = mg(ray.d, ey);
+vec3 gL = mj(ray.d, ey);
 int ao;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-lm = tri;
-hy = faceNormal;
+lp = tri;
+hx = faceNormal;
 aB = hit.barycentric;
 hs = index;
-qP = true;
+qT = true;
 ao = cf;
 `)}
 
-if (qP) {
+if (qT) {
 si.instanceIndex = ao;
 si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
 
-hp(si, lm, aB, hs);
+hp(si, lp, aB, hs);
 mat4 l2w = mat4(
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 5),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 6),
@@ -910,7 +910,7 @@ bv(ao * ${INSTANCE_VEC4_STRIDE} + 3),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 4)
 );
 mat3 aD = transpose(mat3(w2l));
-si.faceNormal = normalize(aD * hy);
+si.faceNormal = normalize(aD * hx);
 si.vertexNormal = normalize(aD * si.vertexNormal);
 si.normal = normalize(aD * si.normal);
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -931,7 +931,7 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 
 
-void iG(in Ray ray, inout ad si, int instanceIndex, float maxDistance) {
+void iH(in Ray ray, inout ad si, int instanceIndex, float maxDistance) {
 si.hit = false;
 
 if (isEmptyScene) {
@@ -940,16 +940,16 @@ return;
 
 bool doubleSided = true;
 int ey = maxDimension(abs(ray.d));
-vec3 gJ = mg(ray.d, ey);
+vec3 gL = mj(ray.d, ey);
 int ao;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-lm = tri;
-hy = faceNormal;
+lp = tri;
+hx = faceNormal;
 aB = hit.barycentric;
 hs = index;
-qP = true;
+qT = true;
 ao = cf;
 `, glsl `
 if (cf != instanceIndex) {
@@ -957,10 +957,10 @@ continue;
 }
 `, 'maxDistance')}
 
-if (qP) {
+if (qT) {
 si.instanceIndex = ao;
 si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
-hp(si, lm, aB, hs);
+hp(si, lp, aB, hs);
 mat4 l2w = mat4(
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 5),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 6),
@@ -974,7 +974,7 @@ bv(ao * ${INSTANCE_VEC4_STRIDE} + 3),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 4)
 );
 mat3 aD = transpose(mat3(w2l));
-si.faceNormal = normalize(aD * hy);
+si.faceNormal = normalize(aD * hx);
 si.vertexNormal = normalize(aD * si.vertexNormal);
 si.normal = normalize(aD * si.normal);
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -994,7 +994,7 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 }
 
-bool ex(in Ray ray, float lightDistance, int jE) {
+bool ex(in Ray ray, float lightDistance, int jG) {
 
 if (isEmptyScene) {
 return false;
@@ -1002,21 +1002,21 @@ return false;
 
 bool doubleSided = true;
 int ey = maxDimension(abs(ray.d));
-vec3 gJ = mg(ray.d, ey);
+vec3 gL = mj(ray.d, ey);
 
 ${getBVHTraverseCode(glsl `
 
 
-bool jl = true;
+bool jn = true;
 vec3 barycentric = hit.barycentric;
 vec3 position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
 
-if (jl) {
+if (jn) {
 #ifdef HAS_ALPHA
 int materialIndex = int(ae(floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)).x);
-ivec2 i0 = gK(index.x, vertexColumns);
-ivec2 i1 = gK(index.y, vertexColumns);
-ivec2 i2 = gK(index.z, vertexColumns);
+ivec2 i0 = gM(index.x, vertexColumns);
+ivec2 i1 = gM(index.y, vertexColumns);
+ivec2 i2 = gM(index.z, vertexColumns);
 ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
 ivec4 m1 = ivec4(texelFetch(materialIndexBuffer, i1, 0));
 ivec4 m2 = ivec4(texelFetch(materialIndexBuffer, i2, 0));
@@ -1036,12 +1036,12 @@ vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
 vec2 uv1 = texelFetch(uvBuffer, i1, 0).xy;
 vec2 uv2 = texelFetch(uvBuffer, i2, 0).xy;
 vec2 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
-vec4 lw = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(lw.r);
+vec4 lC = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(lC.r);
 if (uvProjection > 0) {
-uv = gz(uvProjection, position, hy, lw.zw);
+uv = gC(uvProjection, position, hx, lC.zw);
 } else {
-uv *= lw.zw;
+uv *= lC.zw;
 }
 
 alpha *= sampleMap(diffuseMapIndex, uv).a;
@@ -1055,32 +1055,32 @@ vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
 vec2 uv1 = texelFetch(uvBuffer, i1, 0).xy;
 vec2 uv2 = texelFetch(uvBuffer, i2, 0).xy;
 vec2 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
-vec4 lw = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(lw.r);
+vec4 lC = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(lC.r);
 if (uvProjection > 0) {
-uv = gz(uvProjection, position, hy, lw.zw);
+uv = gC(uvProjection, position, hx, lC.zw);
 } else {
-uv *= lw.zw;
+uv *= lC.zw;
 }
 alpha *= sampleMap(alphaMapIndex, uv).g;
 }
 #endif
 float alphaCutoff = fetchMatData(ii + MAT_ROW_STANDALONE_MAPS).a;
-alpha = ld(
+alpha = lg(
 alpha, int(fetchMatData(ii + MAT_ROW_ALPHA).w), alphaCutoff
 );
 if (eo(0u) > alpha) {
 
 tMax = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-jl = false;
+jn = false;
 }
 #endif
 }
-if (jl) {
+if (jn) {
 return true;
 }
 `, glsl `
-if (triangleIndex == jE) {
+if (triangleIndex == jG) {
 continue;
 }
 `, 'min(max(lightDistance, 0.0), RAY_MAX_DISTANCE)')}