@meimu/mutracer 0.1.3 → 0.1.4

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

@@ -12,25 +12,25 @@ int triangleIndex = primitiveOffset + k;
 ${skipTriangleCode}
 vec4 r3 = dp(triangleIndex);
 ivec3 index = floatBitsToInt(r3.xyz) + vertexOffset;
-fu tri = fu(
-ky(positionBuffer, index.x, vertexColumns).xyz,
-ky(positionBuffer, index.y, vertexColumns).xyz,
-ky(positionBuffer, index.z, vertexColumns).xyz
+fA tri = fA(
+kG(positionBuffer, index.x, vertexColumns).xyz,
+kG(positionBuffer, index.y, vertexColumns).xyz,
+kG(positionBuffer, index.z, vertexColumns).xyz
 );
-eB hit = fI(o, d, tri, ey, gL, tMax);
+eC hit = fL(o, d, tri, ey, gP, 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 kd = int(ae(
+int kk = int(ae(
 floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)
 ).x);
-bool iI = fetchMatData(
-kd * MAT_DATA_SIZE + MAT_ROW_ALPHA
+bool iN = fetchMatData(
+kk * MAT_DATA_SIZE + MAT_ROW_ALPHA
 ).z > 0.5;
-if (!doubleSided && !iI && dot(faceNormal, d) > 0.0) {
+if (!doubleSided && !iN && dot(faceNormal, d) > 0.0) {
 continue;
 }
 
@@ -41,31 +41,31 @@ ${handleHitCode}
     return glsl `
 ivec2 stack[STACK_SIZE];
 int top = -1;
-int sG = -1;
+int sO = -1;
 float tMax = ${initialTMax};
 
 vec3 o = ray.o;
 vec3 d = ray.d;
 
-bool qT = false;
-vec3 hx;
+bool rb = false;
+vec3 hB;
 vec3 aB;
-ivec3 hs;
+ivec3 hw;
 
-fu lp;
+fA lC;
 
 
 top = 0;
 stack[0] = ivec2(0, -1);
 
-int wk = 0;
-while(top >= 0 && wk < 5000) {
-wk++;
+int wr = 0;
+while(top >= 0 && wr < 5000) {
+wr++;
 ivec2 node = stack[top--];
 
 int cf = node.y;
 
-if (cf != sG) {
+if (cf != sO) {
 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));
-gL = mj(d, ey);
-sG = cf;
+gP = mv(d, ey);
+sO = cf;
 }
 
 int bo = cf < 0 ? 0 : blasOffset;
-uint fG = cf < 0 ? 0u : floatBitsToUint(bv(cf * ${INSTANCE_VEC4_STRIDE}).x);
-int gN = int(fG >> 30u);
-int eS = int(fG & 0x3fffffffu);
+uint fJ = cf < 0 ? 0u : floatBitsToUint(bv(cf * ${INSTANCE_VEC4_STRIDE}).x);
+int gR = int(fJ >> 30u);
+int eW = int(fJ & 0x3fffffffu);
 int bh = 0;
 int primitiveOffset = 0;
 
-if (gN == 3) {
-uint hS = uint(node.x);
-if ((hS & 0x80000000u) != 0u) {
-bh = int((hS >> 23u) & 0xffu);
-primitiveOffset = bo + eS + int(hS & 0x007fffffu);
+if (gR == 3) {
+uint hW = uint(node.x);
+if ((hW & 0x80000000u) != 0u) {
+bh = int((hW >> 23u) & 0xffu);
+primitiveOffset = bo + eW + int(hW & 0x007fffffu);
 }
 else {
 int i = node.x + bo;
-vec4 ju = dp(i);
-vec4 fC = dp(i + 1);
-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)
+vec4 jA = dp(i);
+vec4 fF = dp(i + 1);
+vec4 mV = dp(i + 2);
+vec4 mW = dp(i + 3);
+vec4 mX = dp(i + 4);
+uint header = floatBitsToUint(jA.w);
+int rG = int(header << 24u) >> 24;
+int rH = int((header >> 8u) << 24u) >> 24;
+int rI = int((header >> 16u) << 24u) >> 24;
+vec3 hJ = vec3(
+uintBitsToFloat(uint(rG + 127) << 23u),
+uintBitsToFloat(uint(rH + 127) << 23u),
+uintBitsToFloat(uint(rI + 127) << 23u)
 );
-uint childBase = floatBitsToUint(fC.x);
-uint oH = floatBitsToUint(fC.y);
+uint childBase = floatBitsToUint(fF.x);
+uint oQ = floatBitsToUint(fF.y);
 uint internalMask = header >> 24u;
-uint ul = (d.x < 0.0 ? 4u : 0u) |
+uint ut = (d.x < 0.0 ? 4u : 0u) |
 (d.y < 0.0 ? 2u : 0u) |
 (d.z < 0.0 ? 1u : 0u);
-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)
+uint gI[12] = uint[12](
+floatBitsToUint(mV.x), floatBitsToUint(mV.y),
+floatBitsToUint(mV.z), floatBitsToUint(mV.w),
+floatBitsToUint(mW.x), floatBitsToUint(mW.y),
+floatBitsToUint(mW.z), floatBitsToUint(mW.w),
+floatBitsToUint(mX.x), floatBitsToUint(mX.y),
+floatBitsToUint(mX.z), floatBitsToUint(mX.w)
 );
 
 for (int order = 7; order >= 0; order--) {
-uint slot = uint(order) ^ ul;
-uint su = slot >= 4u
-? floatBitsToUint(fC.w)
-: floatBitsToUint(fC.z);
-uint meta = (su >> ((slot & 3u) * 8u)) & 0xffu;
+uint slot = uint(order) ^ ut;
+uint sE = slot >= 4u
+? floatBitsToUint(fF.w)
+: floatBitsToUint(fF.z);
+uint meta = (sE >> ((slot & 3u) * 8u)) & 0xffu;
 if (meta == 0u) continue;
-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)
+uint lY = (slot & 3u) * 8u;
+uint kV = slot >> 2u;
+vec3 tH = vec3(
+float((gI[kV] >> lY) & 0xffu),
+float((gI[2u + kV] >> lY) & 0xffu),
+float((gI[4u + kV] >> lY) & 0xffu)
 );
-vec3 tw = vec3(
-float((gE[6u + kM] >> lO) & 0xffu),
-float((gE[8u + kM] >> lO) & 0xffu),
-float((gE[10u + kM] >> lO) & 0xffu)
+vec3 tG = vec3(
+float((gI[6u + kV] >> lY) & 0xffu),
+float((gI[8u + kV] >> lY) & 0xffu),
+float((gI[10u + kV] >> lY) & 0xffu)
 );
-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);
+vec3 uW = jA.xyz + tH * hJ;
+vec3 uV = jA.xyz + tG * hJ;
+if (cM(o, d, uW, uV, tMax) <= 0.0) continue;
+uint jC = meta & 0x1fu;
+if (jC >= 24u) {
+uint ns = internalMask & ((1u << slot) - 1u);
+uint sX = childBase + qT(ns);
 stack[++top] = ivec2(
-eS + int(sQ * 5u), cf
+eW + int(sX * 5u), cf
 );
 }
 else {
-uint triangleCount = qK(meta >> 5u);
-uint rK = oH + jw;
-uint uZ = 0x80000000u |
+uint triangleCount = qT(meta >> 5u);
+uint rS = oQ + jC;
+uint vh = 0x80000000u |
 (triangleCount << 23u) |
-(rK & 0x007fffffu);
-stack[++top] = ivec2(int(uZ), cf);
+(rS & 0x007fffffu);
+stack[++top] = ivec2(int(vh), cf);
 }
 }
 }
 }
-else if (gN == 2) {
+else if (gR == 2) {
 int i = node.x + bo;
-vec4 uR = dp(i);
-vec4 uS = dp(i + 1);
-vec4 uT = dp(i + 2);
-vec4 uU = dp(i + 3);
-bh = int(floatBitsToUint(uT.w));
+vec4 uY = dp(i);
+vec4 uZ = dp(i + 1);
+vec4 va = dp(i + 2);
+vec4 vb = dp(i + 3);
+bh = int(floatBitsToUint(va.w));
 if (bh > 0) {
-primitiveOffset = bo + eS + int(floatBitsToUint(uU.w));
+primitiveOffset = bo + eW + int(floatBitsToUint(vb.w));
 }
 else {
-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);
+int left = eW + int(floatBitsToUint(uY.w) * 4u);
+int right = eW + int(floatBitsToUint(uZ.w) * 4u);
+float d0 = cM(o, d, uY.xyz, uZ.xyz, tMax);
+float d1 = cM(o, d, va.xyz, vb.xyz, tMax);
 if (d0 > d1) {
 if (d0 > 0.0) stack[++top] = ivec2(left, cf);
 if (d1 > 0.0) stack[++top] = ivec2(right, cf);
@@ -195,62 +195,62 @@ if (d0 > 0.0) stack[++top] = ivec2(left, cf);
 }
 }
 }
-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 if (gR == 1) {
+uint hW = uint(node.x);
+if ((hW & 0x80000000u) != 0u) {
+bh = int((hW >> 23u) & 0xffu);
+primitiveOffset = bo + eW + int(hW & 0x007fffffu);
 }
 else {
 int i = node.x + bo;
-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 ui = dp(i);
+vec4 ro = dp(i + 1);
+vec4 rp = dp(i + 2);
+vec4 rq = dp(i + 3);
+vec3 nodeMin = ui.xyz;
+vec3 ec = vec3(ui.w, ro.x, ro.y);
+uint mh[4] = uint[4](
+floatBitsToUint(ro.z), floatBitsToUint(ro.w),
+floatBitsToUint(rp.x), floatBitsToUint(rp.y)
 );
-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);
+vec4 rw = fc(floatBitsToUint(rp.z));
+vec4 rA = fc(floatBitsToUint(rp.w));
+vec4 rB = fc(floatBitsToUint(rq.x));
+vec4 rt = fc(floatBitsToUint(rq.y));
+vec4 ru = fc(floatBitsToUint(rq.z));
+vec4 rv = fc(floatBitsToUint(rq.w));
+vec3 gC = fb(d);
+vec3 bJ = eZ(gC, o);
+vec4 tx0 = (nodeMin.x + rw * ec.x - o.x) * gC.x;
+vec4 tx1 = (nodeMin.x + rt * ec.x - o.x) * gC.x;
+vec4 ty0 = (nodeMin.y + rA * ec.y - o.y) * gC.y;
+vec4 ty1 = (nodeMin.y + ru * ec.y - o.y) * gC.y;
+vec4 tz0 = (nodeMin.z + rB * ec.z - o.z) * gC.z;
+vec4 tz1 = (nodeMin.z + rv * ec.z - o.z) * gC.z;
+vec4 mL = max(max((min(tx0, tx1) - vec4(bJ.x)), (min(ty0, ty1) - vec4(bJ.y))), (min(tz0, tz1) - vec4(bJ.z)));
+vec4 rU = min(min((max(tx0, tx1) + vec4(bJ.x)), (max(ty0, ty1) + vec4(bJ.y))), (max(tz0, tz1) + vec4(bJ.z)));
+vec4 distance = mix(rU, mL, greaterThan(mL, vec4(0.0)));
+distance = mix(distance, vec4(-1.0), greaterThan(mL, min(rU, vec4(tMax))));
+float fd[4] = float[4](distance.x, distance.y, distance.z, distance.w);
 
 
 for (int order = 0; order < 4; order++) {
 float dX = -1.0;
 int el = -1;
 for (int child = 0; child < 4; child++) {
-if (lV[child] != 0u && fa[child] > dX) {
-dX = fa[child];
+if (mh[child] != 0u && fd[child] > dX) {
+dX = fd[child];
 el = child;
 }
 }
 if (el >= 0 && dX > 0.0) {
-uint nl = lV[el];
-int jD = int(nl);
-if ((nl & 0x80000000u) == 0u) {
-jD += eS;
+uint nD = mh[el];
+int jI = int(nD);
+if ((nD & 0x80000000u) == 0u) {
+jI += eW;
 }
-stack[++top] = ivec2(jD, cf);
-fa[el] = -1.0;
+stack[++top] = ivec2(jI, cf);
+fd[el] = -1.0;
 }
 }
 }
@@ -262,7 +262,7 @@ int bb = floatBitsToInt(r1.w);
 
 if (bb >= 0) {
 int left = node.x + 2;
-int right = bb + eS;
+int right = bb + eW;
 
 float d0 = cM(o, d, dp(left + bo).xyz, dp(left + 1 + bo).xyz, tMax);
 float d1 = cM(o, d, dp(right + bo).xyz, dp(right + 1 + bo).xyz, tMax);
@@ -321,13 +321,13 @@ export default createShaderMixin({
     },
     main: glsl `
 
-struct fu {
+struct fA {
 vec3 p0;
 vec3 p1;
 vec3 p2;
 };
 #ifdef NUM_LIGHTS
-float ht(float rad, vec3 pos, Ray r) {
+float hx(float rad, vec3 pos, Ray r) {
 vec3 op = pos - r.o;
 float eps = 0.001;
 float b = dot(op, r.d);
@@ -347,7 +347,7 @@ return t2;
 return INF;
 }
 
-float mU(vec3 pos, vec3 u, vec3 v, vec3 n, Ray r) {
+float ni(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 mo(Ray r, Light light, out LightSampleRec lightSample) {
+float mz(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 = mU(pos, u, v, normal, r);
+d = ni(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 kh = light.position - r.o;
-float projection = dot(kh, r.d);
-vec3 ba = kh - projection * r.d;
+vec3 ko = light.position - r.o;
+float projection = dot(ko, r.d);
+vec3 ba = ko - projection * r.d;
 if (projection <= EPS || dot(ba, ba) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
@@ -411,7 +411,7 @@ lightSample.dist = d;
 lightSample.pdf = 1.0;
 lightSample.isDelta = true;
 } else {
-d = ht(light.radius, light.position, r);
+d = hx(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d < 0.) {
@@ -436,9 +436,9 @@ lightSample.emission = light.radius <= 0.0
 #ifdef HAS_SPOT_LIGHTS
 if (type == SPOT_LIGHT) {
 if (light.radius <= 0.0) {
-vec3 kh = light.position - r.o;
-float projection = dot(kh, r.d);
-vec3 ba = kh - projection * r.d;
+vec3 ko = light.position - r.o;
+float projection = dot(ko, r.d);
+vec3 ba = ko - projection * r.d;
 if (projection <= EPS || dot(ba, ba) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
@@ -447,13 +447,13 @@ lightSample.dist = d;
 lightSample.pdf = 1.0;
 lightSample.isDelta = true;
 } else {
-d = ht(light.radius, light.position, r);
+d = hx(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d != INF) {
-vec3 uX = r.o + d * r.d;
-float mr = bL(light, normalize(r.o - uX));
-if (mr <= 0.0) return INF;
+vec3 ve = r.o + d * r.d;
+float mC = bL(light, normalize(r.o - ve));
+if (mC <= 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 * mr * (light.radius <= 0.0
+lightSample.emission = light.emission * mC * (light.radius <= 0.0
 ? 1.0 / max(d * d, 1e-8)
 : 1.0);
 }
@@ -474,7 +474,7 @@ return d;
 }
 #endif
 
-int fj(ivec4 m0, ivec4 m1, ivec4 m2, vec3 eZ) {
+int fm(ivec4 m0, ivec4 m1, ivec4 m2, vec3 eK) {
 vec2 m00 = ae(m0.x);
 vec2 m01 = ae(m0.y);
 vec2 m02 = ae(m0.z);
@@ -484,86 +484,92 @@ vec2 m12 = ae(m1.z);
 vec2 m20 = ae(m2.x);
 vec2 m21 = ae(m2.y);
 vec2 m22 = ae(m2.z);
-float w00 = m00.y * eZ.x;
-float w01 = m01.y * eZ.x;
-float w02 = m02.y * eZ.x;
-float w10 = m10.y * eZ.y;
-float w11 = m11.y * eZ.y;
-float w12 = m12.y * eZ.y;
-float w20 = m20.y * eZ.z;
-float w21 = m21.y * eZ.z;
-float w22 = m22.y * eZ.z;
-
-float 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;
+float w00 = m00.y * eK.x;
+float w01 = m01.y * eK.x;
+float w02 = m02.y * eK.x;
+float w10 = m10.y * eK.y;
+float w11 = m11.y * eK.y;
+float w12 = m12.y * eK.y;
+float w20 = m20.y * eK.z;
+float w21 = m21.y * eK.z;
+float w22 = m22.y * eK.z;
+
+float 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;
 
 float rand = eo(0u);
-float mV;
+float nj;
 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 int(mV);
+return int(nj);
 }
 
 
 vec4 bv(int i);
 
 
-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;
+mat2x3 eE(vec3 normal, vec3 dp1, vec3 dp2, vec2 od, vec2 oe, vec4 aT) {
+float determinant = od.x * oe.y - od.y * oe.x;
+vec3 t = aT.xyz;
 vec3 b = vec3(0.0);
 
-float qu = abs(aU.w) > 1.5 ? 0.0 : aU.w;
+float qC = abs(aT.w) > 1.5 ? 0.0 : aT.w;
 if (abs(determinant) > 1e-12) {
-vec3 dt = (dp1 * nT.y - dp2 * nS.y) / determinant;
-vec3 db = (dp2 * nS.x - dp1 * nT.x) / determinant;
+vec3 dt = (dp1 * oe.y - dp2 * od.y) / determinant;
+vec3 db = (dp2 * od.x - dp1 * oe.x) / determinant;
 if (dot(t, t) < 1e-8) { t = dt; }
-if (qu == 0.0) { qu = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
+if (qC == 0.0) { qC = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
 }
 t -= normal * dot(normal, t);
 if (dot(t, t) < 1e-8) {
-float ie = (normal.z >= 0.0 ? 1.0 : -1.0);
-float dW = -1.0 / (ie + normal.z);
+float ik = (normal.z >= 0.0 ? 1.0 : -1.0);
+float dW = -1.0 / (ik + normal.z);
 float xy = normal.x * normal.y * dW;
-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);
+t = vec3(1.0 + ik * normal.x * normal.x * dW, ik * xy, -ik * normal.x);
+b = vec3(xy, ik + normal.y * normal.y * dW, -normal.y);
 }
 else { t = normalize(t); b = normalize(cross(normal, t)); }
-return mat2x3(t, b * (qu < 0.0 ? -1.0 : 1.0));
+return mat2x3(t, b * (qC < 0.0 ? -1.0 : 1.0));
 }
 
-void hp(inout ad si, fu tri, vec3 barycentric, ivec3 index) {
+void ht(inout ad si, fA tri, vec3 barycentric, ivec3 index) {
 si.hit = true;
 si.position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
-ivec2 i0 = gM(index.x, vertexColumns);
-ivec2 i1 = gM(index.y, vertexColumns);
-ivec2 i2 = gM(index.z, vertexColumns);
+ivec2 i0 = gQ(index.x, vertexColumns);
+ivec2 i1 = gQ(index.y, vertexColumns);
+ivec2 i2 = gQ(index.z, vertexColumns);
+si.vertexColor = vec3(1.0);
+#ifdef USE_VERTEX_COLOR
+si.vertexColor = barycentric.x * texelFetch(colorBuffer, i0, 0).rgb
++ barycentric.y * texelFetch(colorBuffer, i1, 0).rgb
++ barycentric.z * texelFetch(colorBuffer, i2, 0).rgb;
+#endif
 
 vec3 n0 = texelFetch(normalBuffer, i0, 0).xyz;
 vec3 n1 = texelFetch(normalBuffer, i1, 0).xyz;
@@ -576,14 +582,14 @@ si.vertexNormal = normal;
 
 
 vec3 geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-vec3 kf = barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2;
+vec3 km = 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(kf, geometricNormal) > 0.0) {
+if (dot(km, 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 +607,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 = kf * h;
+si.shadowOffset = km * h;
 
 
 ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
@@ -609,7 +615,7 @@ ivec4 m1 = ivec4(texelFetch(materialIndexBuffer, i1, 0));
 ivec4 m2 = ivec4(texelFetch(materialIndexBuffer, i2, 0));
 
 if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
-si.materialIndex = fj(m0, m1, m2, barycentric);
+si.materialIndex = fm(m0, m1, m2, barycentric);
 }
 
 vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
@@ -624,14 +630,14 @@ vec2 cX = barycentric.x * secondaryUv0
 + barycentric.y * secondaryUv1
 + barycentric.z * secondaryUv2;
 
-vec4 lC = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
-int uvProjection = int(lC.r);
+vec4 lM = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
+int uvProjection = int(lM.r);
 if (uvProjection > 0) {
-uv = gC(uvProjection, si.position, normal, lC.zw);
+uv = gH(uvProjection, si.position, normal, lM.zw);
 cX = uv;
 } else {
-uv *= lC.zw;
-cX *= lC.zw;
+uv *= lM.zw;
+cX *= lM.zw;
 }
 #else
 vec2 uv = vec2(0.0);
@@ -640,51 +646,51 @@ vec2 cX = vec2(0.0);
 
 #ifdef NUM_COAT_NORMAL_MAPS
 si.coatNormal = normal;
-float lm = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
+float lw = 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 te = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
-if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || te != 0.0
+float tm = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
+if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || tm != 0.0
 #ifdef NUM_COAT_NORMAL_MAPS
-|| lm >= 0.0
+|| lw >= 0.0
 #endif
 ) {
 vec3 dp1 = tri.p0 - tri.p2;
 vec3 dp2 = tri.p1 - tri.p2;
-vec4 aU = vec4(0.0);
+vec4 aT = vec4(0.0);
 #ifdef USE_TANGENT
-aU = barycentric.x * texelFetch(tangentBuffer, i0, 0)
+aT = barycentric.x * texelFetch(tangentBuffer, i0, 0)
 + barycentric.y * texelFetch(tangentBuffer, i1, 0)
 + barycentric.z * texelFetch(tangentBuffer, i2, 0);
 #endif
-mat2x3 eP = eD(normal, dp1, dp2, uv0-uv2, uv1-uv2, aU);
-si.geometryTangent = eP[0];
-si.geometryBitangent = eP[1];
-mat2x3 fU = eP;
+mat2x3 eS = eE(normal, dp1, dp2, uv0-uv2, uv1-uv2, aT);
+si.geometryTangent = eS[0];
+si.geometryBitangent = eS[1];
+mat2x3 fY = eS;
 #ifdef NUM_ANISOTROPY_MAPS
 if (directionMaterial.x >= 0.0 && mapUvChannel[int(directionMaterial.x)] > 0.5) {
 vec2 a = texelFetch(uv1Buffer, i0, 0).xy;
 vec2 b = texelFetch(uv1Buffer, i1, 0).xy;
 vec2 c = texelFetch(uv1Buffer, i2, 0).xy;
-fU = eD(normal, dp1, dp2, a-c, b-c, (aU.w == 0.0 ? vec4(0.0) : aU));
+fY = eE(normal, dp1, dp2, a-c, b-c, (aT.w == 0.0 ? vec4(0.0) : aT));
 }
 #endif
-si.directionTangent = fU[0];
-si.directionBitangent = fU[1];
+si.directionTangent = fY[0];
+si.directionBitangent = fY[1];
 #ifdef NUM_COAT_NORMAL_MAPS
-if (lm >= 0.0) {
-int ku = int(lm);
-mat2x3 lW = eP;
-if (mapUvChannel[ku] > 0.5) {
+if (lw >= 0.0) {
+int kC = int(lw);
+mat2x3 mi = eS;
+if (mapUvChannel[kC] > 0.5) {
 vec2 a = texelFetch(uv1Buffer, i0, 0).xy;
 vec2 b = texelFetch(uv1Buffer, i1, 0).xy;
 vec2 c = texelFetch(uv1Buffer, i2, 0).xy;
-lW = eD(normal, dp1, dp2, a-c, b-c,
-aU.w == 0.0 ? vec4(0.0) : aU);
+mi = eE(normal, dp1, dp2, a-c, b-c,
+aT.w == 0.0 ? vec4(0.0) : aT);
 }
-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;
+vec3 decoded = sampleMap(kC, getMapUvSet(kC, uv, cX)).rgb * 2.0 - 1.0;
+vec3 mapped = mi[0] * decoded.x * directionMaterial.z
++ mi[1] * decoded.y * directionMaterial.w + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { si.coatNormal = normalize(mapped); }
 }
 #endif
@@ -702,52 +708,52 @@ 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 nS = uv0 - uv2;
-vec2 nT = uv1 - uv2;
-si.normal = ob(
-si.materialIndex, uv, normal, dp1, dp2, nS, nT
+vec2 od = uv0 - uv2;
+vec2 oe = uv1 - uv2;
+si.normal = om(
+si.materialIndex, uv, normal, dp1, dp2, od, oe
 );
 #else
 si.normal = normal;
 #endif
 }
 
-struct eB {
+struct eC {
 float t;
 vec3 barycentric;
 };
 
 vec4 dp(int i) {
-return ky(bvhBuffer, i, bvhColumns);
+return kG(bvhBuffer, i, bvhColumns);
 }
 
 vec4 bv(int i) {
-return ky(instancesBuffer, i, instancesColumns);
+return kG(instancesBuffer, i, instancesColumns);
 }
 
 
 
-uint qK(uint value) {
+uint qT(uint value) {
 value -= (value >> 1u) & 0x55555555u;
 value = (value & 0x33333333u) + ((value >> 2u) & 0x33333333u);
 value = (value + (value >> 4u)) & 0x0f0f0f0fu;
 return (value * 0x01010101u) >> 24u;
 }
 
-vec4 eY(uint lL) {
+vec4 fc(uint lV) {
 return vec4(
-float(lL & 0xffu),
-float((lL >> 8u) & 0xffu),
-float((lL >> 16u) & 0xffu),
-float(lL >> 24u)
+float(lV & 0xffu),
+float((lV >> 8u) & 0xffu),
+float((lV >> 16u) & 0xffu),
+float(lV >> 24u)
 ) / 255.0;
 }
 
 
 
 
-eB fI(vec3 o, vec3 d, fu tri, int ey, vec3 gL, float tMax) {
-eB ti;
+eC fL(vec3 o, vec3 d, fA tri, int ey, vec3 gP, float tMax) {
+eC ti;
 
 
 vec3 p0t = tri.p0 - o;
@@ -766,9 +772,9 @@ p2t = p2t.zxy;
 }
 
 
-p0t.xy += gL.xy * p0t.z;
-p1t.xy += gL.xy * p1t.z;
-p2t.xy += gL.xy * p2t.z;
+p0t.xy += gP.xy * p0t.z;
+p1t.xy += gP.xy * p1t.z;
+p2t.xy += gP.xy * p2t.z;
 
 
 vec3 e = vec3(
@@ -778,9 +784,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 );
 
 #ifdef DEPTH_QUERY_MODE
-vec3 rt = abs(vec3(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+vec3 rE = 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), rt * 1e-6));
+e = mix(e, vec3(0.0), lessThanEqual(abs(e), rE * 1e-6));
 #endif
 
 
@@ -793,19 +799,19 @@ float det = e.x + e.y + e.z;
 if (det == 0.0) return ti;
 #endif
 
-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);
+p0t.z *= gP.z;
+p1t.z *= gP.z;
+p2t.z *= gP.z;
+float 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;
 }
 
-float sm = 1. / det;
-ti.t = rd * sm;
-ti.barycentric = e * sm;
+float sw = 1. / det;
+ti.t = rn * sw;
+ti.barycentric = e * sw;
 
 return ti;
 }
@@ -816,7 +822,7 @@ vec3 max;
 };
 
 
-vec3 eX(vec3 d) {
+vec3 fb(vec3 d) {
 #ifdef DEPTH_QUERY_MODE
 vec3 ap = mix(d, mix(vec3(1e-20), vec3(-1e-20), lessThan(d, vec3(0.0))), lessThan(abs(d), vec3(1e-20)));
 return 1.0 / ap;
@@ -825,9 +831,9 @@ return 1.0 / d;
 #endif
 }
 
-vec3 eV(vec3 gx, vec3 o) {
+vec3 eZ(vec3 gC, vec3 o) {
 #ifdef DEPTH_QUERY_MODE
-return abs(gx) * max(vec3(1.0), abs(o)) * 1e-6;
+return abs(gC) * max(vec3(1.0), abs(o)) * 1e-6;
 #else
 return vec3(0.0);
 #endif
@@ -835,21 +841,21 @@ return vec3(0.0);
 
 
 
-float cM(vec3 o, vec3 d, vec3 vD, vec3 vC, float tMax) {
+float cM(vec3 o, vec3 d, vec3 vK, vec3 vJ, float tMax) {
 #ifdef DEPTH_QUERY_MODE
-vec3 gx = eX(d);
-vec3 uK = (vD - o) * gx;
-vec3 uL = (vC - o) * gx;
-vec3 bJ = eV(gx, o);
+vec3 gC = fb(d);
+vec3 uR = (vK - o) * gC;
+vec3 uS = (vJ - o) * gC;
+vec3 bJ = eZ(gC, o);
 #else
-vec3 uK = (vD - o) / d;
-vec3 uL = (vC - o) / d;
+vec3 uR = (vK - o) / d;
+vec3 uS = (vJ - o) / d;
 vec3 bJ = vec3(0.0);
 #endif
-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));
+vec3 mL = min(uR, uS) - bJ;
+vec3 rU = max(uR, uS) + bJ;
+float t0 = max(mL.x, max(mL.y, mL.z));
+float t1 = min(rU.x, min(rU.y, rU.z));
 
 return (t0 > t1 || t0 > tMax) ? -1.0 : (t0 > 0.0 ? t0 : t1);
 }
@@ -858,7 +864,7 @@ int maxDimension(vec3 v) {
 return v.x > v.y ? (v.x > v.z ? 0 : 2) : (v.y > v.z ? 1 : 2);
 }
 
-vec3 mj(vec3 d, int ey) {
+vec3 mv(vec3 d, int ey) {
 
 
 if (ey == 0) {
@@ -871,7 +877,7 @@ return vec3(-d.x, -d.y, 1.0) / d.z;
 }
 
 
-void cY(in Ray ray, inout ad si, bool doubleSided) {
+void cZ(in Ray ray, inout ad si, bool doubleSided) {
 si.hit = false;
 
 if (isEmptyScene) {
@@ -879,24 +885,24 @@ return;
 }
 
 int ey = maxDimension(abs(ray.d));
-vec3 gL = mj(ray.d, ey);
+vec3 gP = mv(ray.d, ey);
 int ao;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-lp = tri;
-hx = faceNormal;
+lC = tri;
+hB = faceNormal;
 aB = hit.barycentric;
-hs = index;
-qT = true;
+hw = index;
+rb = true;
 ao = cf;
 `)}
 
-if (qT) {
+if (rb) {
 si.instanceIndex = ao;
 si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
 
-hp(si, lp, aB, hs);
+ht(si, lC, aB, hw);
 mat4 l2w = mat4(
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 5),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 6),
@@ -910,7 +916,7 @@ bv(ao * ${INSTANCE_VEC4_STRIDE} + 3),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 4)
 );
 mat3 aD = transpose(mat3(w2l));
-si.faceNormal = normalize(aD * hx);
+si.faceNormal = normalize(aD * hB);
 si.vertexNormal = normalize(aD * si.vertexNormal);
 si.normal = normalize(aD * si.normal);
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -931,7 +937,7 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 
 
-void iH(in Ray ray, inout ad si, int instanceIndex, float maxDistance) {
+void iM(in Ray ray, inout ad si, int instanceIndex, float maxDistance) {
 si.hit = false;
 
 if (isEmptyScene) {
@@ -940,16 +946,16 @@ return;
 
 bool doubleSided = true;
 int ey = maxDimension(abs(ray.d));
-vec3 gL = mj(ray.d, ey);
+vec3 gP = mv(ray.d, ey);
 int ao;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-lp = tri;
-hx = faceNormal;
+lC = tri;
+hB = faceNormal;
 aB = hit.barycentric;
-hs = index;
-qT = true;
+hw = index;
+rb = true;
 ao = cf;
 `, glsl `
 if (cf != instanceIndex) {
@@ -957,10 +963,10 @@ continue;
 }
 `, 'maxDistance')}
 
-if (qT) {
+if (rb) {
 si.instanceIndex = ao;
 si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
-hp(si, lp, aB, hs);
+ht(si, lC, aB, hw);
 mat4 l2w = mat4(
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 5),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 6),
@@ -974,7 +980,7 @@ bv(ao * ${INSTANCE_VEC4_STRIDE} + 3),
 bv(ao * ${INSTANCE_VEC4_STRIDE} + 4)
 );
 mat3 aD = transpose(mat3(w2l));
-si.faceNormal = normalize(aD * hx);
+si.faceNormal = normalize(aD * hB);
 si.vertexNormal = normalize(aD * si.vertexNormal);
 si.normal = normalize(aD * si.normal);
 #ifdef NUM_COAT_NORMAL_MAPS
@@ -994,7 +1000,7 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 }
 
-bool ex(in Ray ray, float lightDistance, int jG) {
+bool ex(in Ray ray, float lightDistance, int jL) {
 
 if (isEmptyScene) {
 return false;
@@ -1002,27 +1008,27 @@ return false;
 
 bool doubleSided = true;
 int ey = maxDimension(abs(ray.d));
-vec3 gL = mj(ray.d, ey);
+vec3 gP = mv(ray.d, ey);
 
 ${getBVHTraverseCode(glsl `
 
 
-bool jn = true;
+bool jt = true;
 vec3 barycentric = hit.barycentric;
 vec3 position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
 
-if (jn) {
+if (jt) {
 #ifdef HAS_ALPHA
 int materialIndex = int(ae(floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)).x);
-ivec2 i0 = gM(index.x, vertexColumns);
-ivec2 i1 = gM(index.y, vertexColumns);
-ivec2 i2 = gM(index.z, vertexColumns);
+ivec2 i0 = gQ(index.x, vertexColumns);
+ivec2 i1 = gQ(index.y, vertexColumns);
+ivec2 i2 = gQ(index.z, vertexColumns);
 ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
 ivec4 m1 = ivec4(texelFetch(materialIndexBuffer, i1, 0));
 ivec4 m2 = ivec4(texelFetch(materialIndexBuffer, i2, 0));
 
 if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
-materialIndex = fj(m0, m1, m2, barycentric);
+materialIndex = fm(m0, m1, m2, barycentric);
 }
 
 int ii = materialIndex * MAT_DATA_SIZE;
@@ -1036,12 +1042,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 lC = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(lC.r);
+vec4 lM = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(lM.r);
 if (uvProjection > 0) {
-uv = gC(uvProjection, position, hx, lC.zw);
+uv = gH(uvProjection, position, hB, lM.zw);
 } else {
-uv *= lC.zw;
+uv *= lM.zw;
 }
 
 alpha *= sampleMap(diffuseMapIndex, uv).a;
@@ -1055,32 +1061,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 lC = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(lC.r);
+vec4 lM = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(lM.r);
 if (uvProjection > 0) {
-uv = gC(uvProjection, position, hx, lC.zw);
+uv = gH(uvProjection, position, hB, lM.zw);
 } else {
-uv *= lC.zw;
+uv *= lM.zw;
 }
 alpha *= sampleMap(alphaMapIndex, uv).g;
 }
 #endif
 float alphaCutoff = fetchMatData(ii + MAT_ROW_STANDALONE_MAPS).a;
-alpha = lg(
+alpha = lr(
 alpha, int(fetchMatData(ii + MAT_ROW_ALPHA).w), alphaCutoff
 );
 if (eo(0u) > alpha) {
 
 tMax = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-jn = false;
+jt = false;
 }
 #endif
 }
-if (jn) {
+if (jt) {
 return true;
 }
 `, glsl `
-if (triangleIndex == jG) {
+if (triangleIndex == jL) {
 continue;
 }
 `, 'min(max(lightDistance, 0.0), RAY_MAX_DISTANCE)')}