@meimu/mutracer 0.1.5 → 0.3.0

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

@@ -6,31 +6,31 @@ import { INSTANCE_VEC4_STRIDE } from '../../bvhAccel.js';
 import { createShaderMixin, glsl, Shader } from '../../shader.js';
 function getBVHTraverseCode(handleHitCode, skipTriangleCode = '', initialTMax = 'RAY_MAX_DISTANCE') {
     const intersectTriangles = glsl `
-ivec3 vertexOffset = ivec3(floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).y));
-for (int k = 0; k < bh; k++) {
+ivec3 vertexOffset = ivec3(floatBitsToInt(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).y));
+for (int k = 0; k < primitiveCount; k++) {
 int triangleIndex = primitiveOffset + k;
 ${skipTriangleCode}
-vec4 r3 = dp(triangleIndex);
+vec4 r3 = fetchBVH(triangleIndex);
 ivec3 index = floatBitsToInt(r3.xyz) + vertexOffset;
-fB tri = fB(
-kG(positionBuffer, index.x, vertexColumns).xyz,
-kG(positionBuffer, index.y, vertexColumns).xyz,
-kG(positionBuffer, index.z, vertexColumns).xyz
+fw tri = fw(
+fetchData(positionBuffer, index.x, vertexColumns).xyz,
+fetchData(positionBuffer, index.y, vertexColumns).xyz,
+fetchData(positionBuffer, index.z, vertexColumns).xyz
 );
-eC hit = fM(o, d, tri, ey, gQ, tMax);
+ev hit = fM(o, d, tri, dZ, gH, 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 kk = int(ae(
-floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)
+int ku = int(af(
+floatBitsToInt(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).z)
 ).x);
-bool iN = fetchMatData(
-kk * MAT_DATA_SIZE + MAT_ROW_ALPHA
+bool iL = fetchMatData(
+ku * MAT_DATA_SIZE + MAT_ROW_ALPHA
 ).z > 0.5;
-if (!doubleSided && !iN && dot(faceNormal, d) > 0.0) {
+if (!doubleSided && !iL && dot(faceNormal, d) > 0.0) {
 continue;
 }
 
@@ -41,262 +41,262 @@ ${handleHitCode}
     return glsl `
 ivec2 stack[STACK_SIZE];
 int top = -1;
-int sO = -1;
+int ug = -1;
 float tMax = ${initialTMax};
 
 vec3 o = ray.o;
 vec3 d = ray.d;
 
-bool rb = false;
-vec3 hB;
-vec3 aB;
-ivec3 hw;
+bool sd = false;
+vec3 hz;
+vec3 aw;
+ivec3 hr;
 
-fB lB;
+fw lR;
 
 
 top = 0;
 stack[0] = ivec2(0, -1);
 
-int wr = 0;
-while(top >= 0 && wr < 5000) {
-wr++;
+int yK = 0;
+while(top >= 0 && yK < 5000) {
+yK++;
 ivec2 node = stack[top--];
 
-int cf = node.y;
+int bK = node.y;
 
-if (cf != sO) {
-if (cf < 0) {
+if (bK != ug) {
+if (bK < 0) {
 o = ray.o;
 d = ray.d;
 }
 else {
 mat4 w2l = mat4(
-bv(cf * ${INSTANCE_VEC4_STRIDE} + 1),
-bv(cf * ${INSTANCE_VEC4_STRIDE} + 2),
-bv(cf * ${INSTANCE_VEC4_STRIDE} + 3),
-bv(cf * ${INSTANCE_VEC4_STRIDE} + 4)
+fetchIns(bK * ${INSTANCE_VEC4_STRIDE} + 1),
+fetchIns(bK * ${INSTANCE_VEC4_STRIDE} + 2),
+fetchIns(bK * ${INSTANCE_VEC4_STRIDE} + 3),
+fetchIns(bK * ${INSTANCE_VEC4_STRIDE} + 4)
 );
 o = (w2l * vec4(ray.o, 1.0)).xyz;
 d = (w2l * vec4(ray.d, 0.0)).xyz;
 }
-ey = maxDimension(abs(d));
-gQ = mu(d, ey);
-sO = cf;
+dZ = maxDimension(abs(d));
+gH = mU(d, dZ);
+ug = bK;
 }
 
-int bo = cf < 0 ? 0 : blasOffset;
-uint fK = cf < 0 ? 0u : floatBitsToUint(bv(cf * ${INSTANCE_VEC4_STRIDE}).x);
-int gS = int(fK >> 30u);
-int eW = int(fK & 0x3fffffffu);
-int bh = 0;
+int bufferOff = bK < 0 ? 0 : blasOffset;
+uint fK = bK < 0 ? 0u : floatBitsToUint(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).x);
+int gN = int(fK >> 30u);
+int eQ = int(fK & 0x3fffffffu);
+int primitiveCount = 0;
 int primitiveOffset = 0;
 
-if (gS == 3) {
-uint hW = uint(node.x);
-if ((hW & 0x80000000u) != 0u) {
-bh = int((hW >> 23u) & 0xffu);
-primitiveOffset = bo + eW + int(hW & 0x007fffffu);
+if (gN == 3) {
+uint hT = uint(node.x);
+if ((hT & 0x80000000u) != 0u) {
+primitiveCount = int((hT >> 23u) & 0xffu);
+primitiveOffset = bufferOff + eQ + int(hT & 0x007fffffu);
 }
 else {
-int i = node.x + bo;
-vec4 jA = dp(i);
-vec4 fG = dp(i + 1);
-vec4 mU = dp(i + 2);
-vec4 mV = dp(i + 3);
-vec4 mW = 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)
+int i = node.x + bufferOff;
+vec4 jF = fetchBVH(i);
+vec4 fF = fetchBVH(i + 1);
+vec4 nI = fetchBVH(i + 2);
+vec4 nJ = fetchBVH(i + 3);
+vec4 nK = fetchBVH(i + 4);
+uint header = floatBitsToUint(jF.w);
+int sD = int(header << 24u) >> 24;
+int sE = int((header >> 8u) << 24u) >> 24;
+int sF = int((header >> 16u) << 24u) >> 24;
+vec3 hG = vec3(
+uintBitsToFloat(uint(sD + 127) << 23u),
+uintBitsToFloat(uint(sE + 127) << 23u),
+uintBitsToFloat(uint(sF + 127) << 23u)
 );
-uint childBase = floatBitsToUint(fG.x);
-uint oP = floatBitsToUint(fG.y);
+uint childBase = floatBitsToUint(fF.x);
+uint ps = floatBitsToUint(fF.y);
 uint internalMask = header >> 24u;
-uint ut = (d.x < 0.0 ? 4u : 0u) |
+uint wm = (d.x < 0.0 ? 4u : 0u) |
 (d.y < 0.0 ? 2u : 0u) |
 (d.z < 0.0 ? 1u : 0u);
-uint gJ[12] = uint[12](
-floatBitsToUint(mU.x), floatBitsToUint(mU.y),
-floatBitsToUint(mU.z), floatBitsToUint(mU.w),
-floatBitsToUint(mV.x), floatBitsToUint(mV.y),
-floatBitsToUint(mV.z), floatBitsToUint(mV.w),
-floatBitsToUint(mW.x), floatBitsToUint(mW.y),
-floatBitsToUint(mW.z), floatBitsToUint(mW.w)
+uint gF[12] = uint[12](
+floatBitsToUint(nI.x), floatBitsToUint(nI.y),
+floatBitsToUint(nI.z), floatBitsToUint(nI.w),
+floatBitsToUint(nJ.x), floatBitsToUint(nJ.y),
+floatBitsToUint(nJ.z), floatBitsToUint(nJ.w),
+floatBitsToUint(nK.x), floatBitsToUint(nK.y),
+floatBitsToUint(nK.z), floatBitsToUint(nK.w)
 );
 
 for (int order = 7; order >= 0; order--) {
-uint slot = uint(order) ^ ut;
-uint sE = slot >= 4u
-? floatBitsToUint(fG.w)
-: floatBitsToUint(fG.z);
-uint meta = (sE >> ((slot & 3u) * 8u)) & 0xffu;
+uint slot = uint(order) ^ wm;
+uint tW = slot >= 4u
+? floatBitsToUint(fF.w)
+: floatBitsToUint(fF.z);
+uint meta = (tW >> ((slot & 3u) * 8u)) & 0xffu;
 if (meta == 0u) continue;
-uint lX = (slot & 3u) * 8u;
-uint kV = slot >> 2u;
-vec3 tH = vec3(
-float((gJ[kV] >> lX) & 0xffu),
-float((gJ[2u + kV] >> lX) & 0xffu),
-float((gJ[4u + kV] >> lX) & 0xffu)
+uint mt = (slot & 3u) * 8u;
+uint lh = slot >> 2u;
+vec3 ve = vec3(
+float((gF[lh] >> mt) & 0xffu),
+float((gF[2u + lh] >> mt) & 0xffu),
+float((gF[4u + lh] >> mt) & 0xffu)
 );
-vec3 tG = vec3(
-float((gJ[6u + kV] >> lX) & 0xffu),
-float((gJ[8u + kV] >> lX) & 0xffu),
-float((gJ[10u + kV] >> lX) & 0xffu)
+vec3 vd = vec3(
+float((gF[6u + lh] >> mt) & 0xffu),
+float((gF[8u + lh] >> mt) & 0xffu),
+float((gF[10u + lh] >> mt) & 0xffu)
 );
-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 nr = internalMask & ((1u << slot) - 1u);
-uint sX = childBase + qT(nr);
+vec3 xn = jF.xyz + ve * hG;
+vec3 xm = jF.xyz + vd * hG;
+if (cH(o, d, xn, xm, tMax) <= 0.0) continue;
+uint jH = meta & 0x1fu;
+if (jH >= 24u) {
+uint oa = internalMask & ((1u << slot) - 1u);
+uint ur = childBase + rT(oa);
 stack[++top] = ivec2(
-eW + int(sX * 5u), cf
+eQ + int(ur * 5u), bK
 );
 }
 else {
-uint triangleCount = qT(meta >> 5u);
-uint rS = oP + jC;
-uint vh = 0x80000000u |
+uint triangleCount = rT(meta >> 5u);
+uint sT = ps + jH;
+uint xC = 0x80000000u |
 (triangleCount << 23u) |
-(rS & 0x007fffffu);
-stack[++top] = ivec2(int(vh), cf);
+(sT & 0x007fffffu);
+stack[++top] = ivec2(int(xC), bK);
 }
 }
 }
 }
-else if (gS == 2) {
-int i = node.x + bo;
-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 + eW + int(floatBitsToUint(vb.w));
+else if (gN == 2) {
+int i = node.x + bufferOff;
+vec4 xq = fetchBVH(i);
+vec4 xr = fetchBVH(i + 1);
+vec4 xs = fetchBVH(i + 2);
+vec4 xt = fetchBVH(i + 3);
+primitiveCount = int(floatBitsToUint(xs.w));
+if (primitiveCount > 0) {
+primitiveOffset = bufferOff + eQ + int(floatBitsToUint(xt.w));
 }
 else {
-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);
+int left = eQ + int(floatBitsToUint(xq.w) * 4u);
+int right = eQ + int(floatBitsToUint(xr.w) * 4u);
+float d0 = cH(o, d, xq.xyz, xr.xyz, tMax);
+float d1 = cH(o, d, xs.xyz, xt.xyz, tMax);
 if (d0 > d1) {
-if (d0 > 0.0) stack[++top] = ivec2(left, cf);
-if (d1 > 0.0) stack[++top] = ivec2(right, cf);
+if (d0 > 0.0) stack[++top] = ivec2(left, bK);
+if (d1 > 0.0) stack[++top] = ivec2(right, bK);
 }
 else {
-if (d1 > 0.0) stack[++top] = ivec2(right, cf);
-if (d0 > 0.0) stack[++top] = ivec2(left, cf);
+if (d1 > 0.0) stack[++top] = ivec2(right, bK);
+if (d0 > 0.0) stack[++top] = ivec2(left, bK);
 }
 }
 }
-else if (gS == 1) {
-uint hW = uint(node.x);
-if ((hW & 0x80000000u) != 0u) {
-bh = int((hW >> 23u) & 0xffu);
-primitiveOffset = bo + eW + int(hW & 0x007fffffu);
+else if (gN == 1) {
+uint hT = uint(node.x);
+if ((hT & 0x80000000u) != 0u) {
+primitiveCount = int((hT >> 23u) & 0xffu);
+primitiveOffset = bufferOff + eQ + int(hT & 0x007fffffu);
 }
 else {
-int i = node.x + bo;
-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 mg[4] = uint[4](
-floatBitsToUint(ro.z), floatBitsToUint(ro.w),
-floatBitsToUint(rp.x), floatBitsToUint(rp.y)
+int i = node.x + bufferOff;
+vec4 vW = fetchBVH(i);
+vec4 sq = fetchBVH(i + 1);
+vec4 qI = fetchBVH(i + 2);
+vec4 oF = fetchBVH(i + 3);
+vec3 nodeMin = vW.xyz;
+vec3 ea = vec3(vW.w, sq.x, sq.y);
+uint mF[4] = uint[4](
+floatBitsToUint(sq.z), floatBitsToUint(sq.w),
+floatBitsToUint(qI.x), floatBitsToUint(qI.y)
 );
-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 gE = fb(d);
-vec3 bJ = eZ(gE, o);
-vec4 tx0 = (nodeMin.x + rw * ec.x - o.x) * gE.x;
-vec4 tx1 = (nodeMin.x + rt * ec.x - o.x) * gE.x;
-vec4 ty0 = (nodeMin.y + rA * ec.y - o.y) * gE.y;
-vec4 ty1 = (nodeMin.y + ru * ec.y - o.y) * gE.y;
-vec4 tz0 = (nodeMin.z + rB * ec.z - o.z) * gE.z;
-vec4 tz1 = (nodeMin.z + rv * ec.z - o.z) * gE.z;
-vec4 mK = 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, mK, greaterThan(mK, vec4(0.0)));
-distance = mix(distance, vec4(-1.0), greaterThan(mK, min(rU, vec4(tMax))));
-float fd[4] = float[4](distance.x, distance.y, distance.z, distance.w);
+vec4 wV = eX(floatBitsToUint(qI.z));
+vec4 wW = eX(floatBitsToUint(qI.w));
+vec4 wX = eX(floatBitsToUint(oF.x));
+vec4 wR = eX(floatBitsToUint(oF.y));
+vec4 wS = eX(floatBitsToUint(oF.z));
+vec4 wU = eX(floatBitsToUint(oF.w));
+vec3 gb = eW(d);
+vec3 padding = eU(gb, o);
+vec4 tx0 = (nodeMin.x + wV * ea.x - o.x) * gb.x;
+vec4 tx1 = (nodeMin.x + wR * ea.x - o.x) * gb.x;
+vec4 ty0 = (nodeMin.y + wW * ea.y - o.y) * gb.y;
+vec4 ty1 = (nodeMin.y + wS * ea.y - o.y) * gb.y;
+vec4 tz0 = (nodeMin.z + wX * ea.z - o.z) * gb.z;
+vec4 tz1 = (nodeMin.z + wU * ea.z - o.z) * gb.z;
+vec4 ns = max(max((min(tx0, tx1) - vec4(padding.x)), (min(ty0, ty1) - vec4(padding.y))), (min(tz0, tz1) - vec4(padding.z)));
+vec4 sW = min(min((max(tx0, tx1) + vec4(padding.x)), (max(ty0, ty1) + vec4(padding.y))), (max(tz0, tz1) + vec4(padding.z)));
+vec4 distance = mix(sW, ns, greaterThan(ns, vec4(0.0)));
+distance = mix(distance, vec4(-1.0), greaterThan(ns, min(sW, vec4(tMax))));
+float eY[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;
+float dW = -1.0;
+int ej = -1;
 for (int child = 0; child < 4; child++) {
-if (mg[child] != 0u && fd[child] > dX) {
-dX = fd[child];
-el = child;
+if (mF[child] != 0u && eY[child] > dW) {
+dW = eY[child];
+ej = child;
 }
 }
-if (el >= 0 && dX > 0.0) {
-uint nC = mg[el];
-int jI = int(nC);
-if ((nC & 0x80000000u) == 0u) {
-jI += eW;
+if (ej >= 0 && dW > 0.0) {
+uint ol = mF[ej];
+int jO = int(ol);
+if ((ol & 0x80000000u) == 0u) {
+jO += eQ;
 }
-stack[++top] = ivec2(jI, cf);
-fd[el] = -1.0;
+stack[++top] = ivec2(jO, bK);
+eY[ej] = -1.0;
 }
 }
 }
 }
 else {
-int i = node.x + bo;
-vec4 r1 = dp(i);
-int bb = floatBitsToInt(r1.w);
+int i = node.x + bufferOff;
+vec4 r1 = fetchBVH(i);
+int bf = floatBitsToInt(r1.w);
 
-if (bb >= 0) {
+if (bf >= 0) {
 int left = node.x + 2;
-int right = bb + eW;
+int right = bf + eQ;
 
-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);
+float d0 = cH(o, d, fetchBVH(left + bufferOff).xyz, fetchBVH(left + 1 + bufferOff).xyz, tMax);
+float d1 = cH(o, d, fetchBVH(right + bufferOff).xyz, fetchBVH(right + 1 + bufferOff).xyz, tMax);
 if (d0 > d1) {
 if (d0 > 0.0) {
-stack[++top] = ivec2(left, cf);
+stack[++top] = ivec2(left, bK);
 }
 if (d1 > 0.0) {
-stack[++top] = ivec2(right, cf);
+stack[++top] = ivec2(right, bK);
 }
 }
 else {
 if (d1 > 0.0) {
-stack[++top] = ivec2(right, cf);
+stack[++top] = ivec2(right, bK);
 }
 if (d0 > 0.0) {
-stack[++top] = ivec2(left, cf);
+stack[++top] = ivec2(left, bK);
 }
 }
 }
 else {
-if (cf < 0) {
-for (int k = 0; k < -bb; k++) {
-vec4 r3 = dp(i + 2 + k);
+if (bK < 0) {
+for (int k = 0; k < -bf; k++) {
+vec4 r3 = fetchBVH(i + 2 + k);
 stack[++top] = ivec2(floatBitsToInt(r3.y), floatBitsToInt(r3.x));
 }
 }
 else {
-bh = -bb;
+primitiveCount = -bf;
 primitiveOffset = i + 2;
 }
 }
 }
-if (bh > 0) {
+if (primitiveCount > 0) {
 ${intersectTriangles}
 }
 }
@@ -321,13 +321,13 @@ export default createShaderMixin({
     },
     main: glsl `
 
-struct fB {
+struct fw {
 vec3 p0;
 vec3 p1;
 vec3 p2;
 };
 #ifdef NUM_LIGHTS
-float hx(float rad, vec3 pos, Ray r) {
+float hs(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 nh(vec3 pos, vec3 u, vec3 v, vec3 n, Ray r) {
+float nV(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,17 @@ return t;
 return INF;
 }
 
-float my(Ray r, Light light, out LightSampleRec lightSample) {
+float sphereSolidAnglePdf(vec3 origin, vec3 center, float radius) {
+float ao = distance(origin, center);
+if (ao <= radius) return INV4PI;
+float sinThetaMaxSquared = min(1.0, radius * radius / (ao * ao));
+float cosThetaMax = sqrt(max(0.0, 1.0 - sinThetaMaxSquared));
+
+float oneMinusCosThetaMax = sinThetaMaxSquared / (1.0 + cosThetaMax);
+return 1.0 / max(TWOPI * oneMinusCosThetaMax, 1e-8);
+}
+
+float mX(Ray r, Light light, out LightSampleRec lightSample) {
 
 
 
@@ -383,15 +393,15 @@ vec3 normal = normalize(cross(u, v));
 if (dot(normal, r.d) > 0.) 
 return INF;
 
-d = nh(pos, u, v, normal, r);
+d = nV(pos, u, v, normal, r);
 if (d < 0.) {
 d = INF;
 }
 else {
-float cc = dot(-r.d, normal);
+float ct = dot(-r.d, normal);
 float spread = light.spread;
-if (cc >= cos(spread * PI / 2.0)) {
-lightSample.pdf = (d * d) / (light.area * cc);
+if (ct >= cos(spread * PI / 2.0)) {
+lightSample.pdf = (d * d) / (light.area * ct);
 lightSample.emission = light.emission;
 }
 }
@@ -400,10 +410,10 @@ lightSample.emission = light.emission;
 #ifdef HAS_SPHERE_LIGHTS
 if (type == SPHERE_LIGHT) {
 if (light.radius <= 0.0) {
-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;
+vec3 kz = light.position - r.o;
+float projection = dot(kz, r.d);
+vec3 bd = kz - projection * r.d;
+if (projection <= EPS || dot(bd, bd) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
 lightSample.normal = -r.d;
@@ -411,21 +421,15 @@ lightSample.dist = d;
 lightSample.pdf = 1.0;
 lightSample.isDelta = true;
 } else {
-d = hx(light.radius, light.position, r);
+d = hs(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d < 0.) {
 d = INF;
 }
 else {
-float aj = distance(r.o, light.position);
-float cosThetaMax = aj <= light.radius
-? -1.0
-: sqrt(max(0.0, 1.0 - light.radius * light.radius / (aj * aj)));
 if (light.radius > 0.0) {
-lightSample.pdf = aj <= light.radius
-? INV4PI
-: 1.0 / max(TWOPI * (1.0 - cosThetaMax), 1e-8);
+lightSample.pdf = sphereSolidAnglePdf(r.o, light.position, light.radius);
 }
 lightSample.emission = light.radius <= 0.0
 ? light.emission / max(d * d, 1e-8)
@@ -436,10 +440,10 @@ lightSample.emission = light.radius <= 0.0
 #ifdef HAS_SPOT_LIGHTS
 if (type == SPOT_LIGHT) {
 if (light.radius <= 0.0) {
-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;
+vec3 kz = light.position - r.o;
+float projection = dot(kz, r.d);
+vec3 bd = kz - projection * r.d;
+if (projection <= EPS || dot(bd, bd) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
 lightSample.normal = -r.d;
@@ -447,23 +451,17 @@ lightSample.dist = d;
 lightSample.pdf = 1.0;
 lightSample.isDelta = true;
 } else {
-d = hx(light.radius, light.position, r);
+d = hs(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d != INF) {
-vec3 ve = r.o + d * r.d;
-float mB = bL(light, normalize(r.o - ve));
-if (mB <= 0.0) return INF;
-float aj = distance(r.o, light.position);
-float cosThetaMax = aj <= light.radius
-? -1.0
-: sqrt(max(0.0, 1.0 - light.radius * light.radius / (aj * aj)));
+vec3 xv = r.o + d * r.d;
+float ne = evaluateSpotEmissionMultiplier(light, normalize(r.o - xv));
+if (ne <= 0.0) return INF;
 if (light.radius > 0.0) {
-lightSample.pdf = aj <= light.radius
-? INV4PI
-: 1.0 / max(TWOPI * (1.0 - cosThetaMax), 1e-8);
+lightSample.pdf = sphereSolidAnglePdf(r.o, light.position, light.radius);
 }
-lightSample.emission = light.emission * mB * (light.radius <= 0.0
+lightSample.emission = light.emission * ne * (light.radius <= 0.0
 ? 1.0 / max(d * d, 1e-8)
 : 1.0);
 }
@@ -474,96 +472,96 @@ return d;
 }
 #endif
 
-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);
-vec2 m10 = ae(m1.x);
-vec2 m11 = ae(m1.y);
-vec2 m12 = ae(m1.z);
-vec2 m20 = ae(m2.x);
-vec2 m21 = ae(m2.y);
-vec2 m22 = ae(m2.z);
-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 ni;
+int fh(ivec4 m0, ivec4 m1, ivec4 m2, vec3 bary) {
+vec2 m00 = af(m0.x);
+vec2 m01 = af(m0.y);
+vec2 m02 = af(m0.z);
+vec2 m10 = af(m1.x);
+vec2 m11 = af(m1.y);
+vec2 m12 = af(m1.z);
+vec2 m20 = af(m2.x);
+vec2 m21 = af(m2.y);
+vec2 m22 = af(m2.z);
+float w00 = m00.y * bary.x;
+float w01 = m01.y * bary.x;
+float w02 = m02.y * bary.x;
+float w10 = m10.y * bary.y;
+float w11 = m11.y * bary.y;
+float w12 = m12.y * bary.y;
+float w20 = m20.y * bary.z;
+float w21 = m21.y * bary.z;
+float w22 = m22.y * bary.z;
+
+float hd = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
+
+w00 = w00 / hd;
+w01 = w01 / hd + w00;
+w02 = w02 / hd + w01;
+w10 = w10 / hd + w02;
+w11 = w11 / hd + w10;
+w12 = w12 / hd + w11;
+w20 = w20 / hd + w12;
+w21 = w21 / hd + w20;
+w22 = w22 / hd + w21;
+
+float rand = ek(0u);
+float nW;
 if (rand < w00) {
-ni = m00.x;
+nW = m00.x;
 } else if (rand < w01) {
-ni = m01.x;
+nW = m01.x;
 } else if (rand < w02) {
-ni = m02.x;
+nW = m02.x;
 } else if (rand < w10) {
-ni = m10.x;
+nW = m10.x;
 } else if (rand < w11) {
-ni = m11.x;
+nW = m11.x;
 } else if (rand < w12) {
-ni = m12.x;
+nW = m12.x;
 } else if (rand < w20) {
-ni = m20.x;
+nW = m20.x;
 } else if (rand < w21) {
-ni = m21.x;
+nW = m21.x;
 } else {
-ni = m22.x;
+nW = m22.x;
 }
-return int(ni);
+return int(nW);
 }
 
 
-vec4 bv(int i);
+vec4 fetchIns(int i);
 
 
-mat2x3 eE(vec3 normal, vec3 dp1, vec3 dp2, vec2 oc, vec2 od, vec4 aT) {
-float determinant = oc.x * od.y - oc.y * od.x;
-vec3 t = aT.xyz;
+mat2x3 ez(vec3 normal, vec3 dp1, vec3 dp2, vec2 oM, vec2 oN, vec4 aS) {
+float determinant = oM.x * oN.y - oM.y * oN.x;
+vec3 t = aS.xyz;
 vec3 b = vec3(0.0);
 
-float qC = abs(aT.w) > 1.5 ? 0.0 : aT.w;
+float rw = abs(aS.w) > 1.5 ? 0.0 : aS.w;
 if (abs(determinant) > 1e-12) {
-vec3 dt = (dp1 * od.y - dp2 * oc.y) / determinant;
-vec3 db = (dp2 * oc.x - dp1 * od.x) / determinant;
+vec3 dt = (dp1 * oN.y - dp2 * oM.y) / determinant;
+vec3 db = (dp2 * oM.x - dp1 * oN.x) / determinant;
 if (dot(t, t) < 1e-8) { t = dt; }
-if (qC == 0.0) { qC = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
+if (rw == 0.0) { rw = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
 }
 t -= normal * dot(normal, t);
 if (dot(t, t) < 1e-8) {
 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 + ik * normal.x * normal.x * dW, ik * xy, -ik * normal.x);
-b = vec3(xy, ik + normal.y * normal.y * dW, -normal.y);
+float cv = -1.0 / (ik + normal.z);
+float xy = normal.x * normal.y * cv;
+t = vec3(1.0 + ik * normal.x * normal.x * cv, ik * xy, -ik * normal.x);
+b = vec3(xy, ik + normal.y * normal.y * cv, -normal.y);
 }
 else { t = normalize(t); b = normalize(cross(normal, t)); }
-return mat2x3(t, b * (qC < 0.0 ? -1.0 : 1.0));
+return mat2x3(t, b * (rw < 0.0 ? -1.0 : 1.0));
 }
 
-void ht(inout ad si, fB tri, vec3 barycentric, ivec3 index) {
+void hn(inout SurfaceInteraction si, fw tri, vec3 barycentric, ivec3 index) {
 si.hit = true;
 si.position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
-ivec2 i0 = gR(index.x, vertexColumns);
-ivec2 i1 = gR(index.y, vertexColumns);
-ivec2 i2 = gR(index.z, vertexColumns);
+ivec2 i0 = gM(index.x, vertexColumns);
+ivec2 i1 = gM(index.y, vertexColumns);
+ivec2 i2 = gM(index.z, vertexColumns);
 si.vertexColor = vec3(1.0);
 #ifdef USE_VERTEX_COLOR
 si.vertexColor = barycentric.x * texelFetch(colorBuffer, i0, 0).rgb
@@ -582,14 +580,14 @@ si.vertexNormal = normal;
 
 
 vec3 geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-vec3 km = barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2;
+vec3 kw = 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(km, geometricNormal) > 0.0) {
+if (dot(kw, 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);
@@ -607,7 +605,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 = km * h;
+si.shadowOffset = kw * h;
 
 
 ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
@@ -615,7 +613,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 = fm(m0, m1, m2, barycentric);
+si.materialIndex = fh(m0, m1, m2, barycentric);
 }
 
 vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
@@ -626,80 +624,80 @@ vec2 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
 vec2 secondaryUv0 = texelFetch(uv1Buffer, i0, 0).xy;
 vec2 secondaryUv1 = texelFetch(uv1Buffer, i1, 0).xy;
 vec2 secondaryUv2 = texelFetch(uv1Buffer, i2, 0).xy;
-vec2 cX = barycentric.x * secondaryUv0
+vec2 cQ = barycentric.x * secondaryUv0
 + barycentric.y * secondaryUv1
 + barycentric.z * secondaryUv2;
 
-vec4 lL = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
-int uvProjection = int(lL.r);
+vec4 mb = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
+int uvProjection = int(mb.r);
 if (uvProjection > 0) {
-uv = gI(uvProjection, si.position, normal, lL.zw);
-cX = uv;
+uv = gE(uvProjection, si.position, normal, mb.zw);
+cQ = uv;
 } else {
-uv *= lL.zw;
-cX *= lL.zw;
+uv *= mb.zw;
+cQ *= mb.zw;
 }
 #else
 vec2 uv = vec2(0.0);
-vec2 cX = vec2(0.0);
+vec2 cQ = vec2(0.0);
 #endif
 
 #ifdef USE_COAT_NORMAL_FRAMES
 si.coatNormal = normal;
 #ifdef NUM_COAT_NORMAL_MAPS
-float oU = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
+float pH = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
 #endif
 #endif
 vec4 directionMaterial = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_DIRECTION_NORMAL);
-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
+float uQ = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
+if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || uQ != 0.0
 #ifdef USE_COAT_NORMAL_FRAMES
 || fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_COAT).w > 0.0
 #endif
 ) {
 vec3 dp1 = tri.p0 - tri.p2;
 vec3 dp2 = tri.p1 - tri.p2;
-vec4 aT = vec4(0.0);
+vec4 aS = vec4(0.0);
 #ifdef USE_TANGENT
-aT = barycentric.x * texelFetch(tangentBuffer, i0, 0)
+aS = barycentric.x * texelFetch(tangentBuffer, i0, 0)
 + barycentric.y * texelFetch(tangentBuffer, i1, 0)
 + barycentric.z * texelFetch(tangentBuffer, i2, 0);
 #endif
-mat2x3 eS = eE(normal, dp1, dp2, uv0-uv2, uv1-uv2, aT);
-si.geometryTangent = eS[0];
-si.geometryBitangent = eS[1];
-mat2x3 fZ = eS;
+mat2x3 eL = ez(normal, dp1, dp2, uv0-uv2, uv1-uv2, aS);
+si.geometryTangent = eL[0];
+si.geometryBitangent = eL[1];
+mat2x3 fX = eL;
 #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;
-fZ = eE(normal, dp1, dp2, a-c, b-c, (aT.w == 0.0 ? vec4(0.0) : aT));
+fX = ez(normal, dp1, dp2, a-c, b-c, (aS.w == 0.0 ? vec4(0.0) : aS));
 }
 #endif
-si.directionTangent = fZ[0];
-si.directionBitangent = fZ[1];
+si.directionTangent = fX[0];
+si.directionBitangent = fX[1];
 #if defined(USE_COAT_NORMAL_FRAMES) && defined(NUM_COAT_NORMAL_MAPS)
-if (oU >= 0.0) {
-int kC = int(oU);
-mat2x3 mh = eS;
-if (mapUvChannel[kC] > 0.5) {
+if (pH >= 0.0) {
+int kP = int(pH);
+mat2x3 mG = eL;
+if (mapUvChannel[kP] > 0.5) {
 vec2 a = texelFetch(uv1Buffer, i0, 0).xy;
 vec2 b = texelFetch(uv1Buffer, i1, 0).xy;
 vec2 c = texelFetch(uv1Buffer, i2, 0).xy;
-mh = eE(normal, dp1, dp2, a-c, b-c,
-aT.w == 0.0 ? vec4(0.0) : aT);
+mG = ez(normal, dp1, dp2, a-c, b-c,
+aS.w == 0.0 ? vec4(0.0) : aS);
 }
-vec3 decoded = sampleMap(kC, getMapUvSet(kC, uv, cX)).rgb * 2.0 - 1.0;
-vec3 mapped = mh[0] * decoded.x * directionMaterial.z
-+ mh[1] * decoded.y * directionMaterial.w + normal * decoded.z;
+vec3 decoded = sampleMap(kP, getMapUvSet(kP, uv, cQ)).rgb * 2.0 - 1.0;
+vec3 mapped = mG[0] * decoded.x * directionMaterial.z
++ mG[1] * decoded.y * directionMaterial.w + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { si.coatNormal = normalize(mapped); }
 }
 #endif
 }
 
 si.uv = uv;
-si.uv1 = cX;
+si.uv1 = cQ;
 
 #ifdef USE_TANGENT
 vec3 t0 = texelFetch(tangentBuffer, i0, 0).xyz;
@@ -710,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 oc = uv0 - uv2;
-vec2 od = uv1 - uv2;
-si.normal = ol(
-si.materialIndex, uv, normal, dp1, dp2, oc, od
+vec2 oM = uv0 - uv2;
+vec2 oN = uv1 - uv2;
+si.normal = oS(
+si.materialIndex, uv, normal, dp1, dp2, oM, oN
 );
 #else
 si.normal = normal;
 #endif
 }
 
-struct eC {
+struct ev {
 float t;
 vec3 barycentric;
 };
 
-vec4 dp(int i) {
-return kG(bvhBuffer, i, bvhColumns);
+vec4 fetchBVH(int i) {
+return fetchData(bvhBuffer, i, bvhColumns);
 }
 
-vec4 bv(int i) {
-return kG(instancesBuffer, i, instancesColumns);
+vec4 fetchIns(int i) {
+return fetchData(instancesBuffer, i, instancesColumns);
 }
 
 
 
-uint qT(uint value) {
+uint rT(uint value) {
 value -= (value >> 1u) & 0x55555555u;
 value = (value & 0x33333333u) + ((value >> 2u) & 0x33333333u);
 value = (value + (value >> 4u)) & 0x0f0f0f0fu;
 return (value * 0x01010101u) >> 24u;
 }
 
-vec4 fc(uint lU) {
+vec4 eX(uint mo) {
 return vec4(
-float(lU & 0xffu),
-float((lU >> 8u) & 0xffu),
-float((lU >> 16u) & 0xffu),
-float(lU >> 24u)
+float(mo & 0xffu),
+float((mo >> 8u) & 0xffu),
+float((mo >> 16u) & 0xffu),
+float(mo >> 24u)
 ) / 255.0;
 }
 
 
 
 
-eC fM(vec3 o, vec3 d, fB tri, int ey, vec3 gQ, float tMax) {
-eC ti;
+ev fM(vec3 o, vec3 d, fw tri, int dZ, vec3 gH, float tMax) {
+ev ti;
 
 
 vec3 p0t = tri.p0 - o;
@@ -763,20 +761,20 @@ vec3 p1t = tri.p1 - o;
 vec3 p2t = tri.p2 - o;
 
 
-if (ey == 0) {
+if (dZ == 0) {
 p0t = p0t.yzx;
 p1t = p1t.yzx;
 p2t = p2t.yzx;
-} else if (ey == 1) {
+} else if (dZ == 1) {
 p0t = p0t.zxy;
 p1t = p1t.zxy;
 p2t = p2t.zxy;
 }
 
 
-p0t.xy += gQ.xy * p0t.z;
-p1t.xy += gQ.xy * p1t.z;
-p2t.xy += gQ.xy * p2t.z;
+p0t.xy += gH.xy * p0t.z;
+p1t.xy += gH.xy * p1t.z;
+p2t.xy += gH.xy * p2t.z;
 
 
 vec3 e = vec3(
@@ -786,9 +784,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 );
 
 #ifdef DEPTH_QUERY_MODE
-vec3 rE = abs(vec3(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+vec3 sB = 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), rE * 1e-6));
+e = mix(e, vec3(0.0), lessThanEqual(abs(e), sB * 1e-6));
 #endif
 
 
@@ -801,19 +799,19 @@ float det = e.x + e.y + e.z;
 if (det == 0.0) return ti;
 #endif
 
-p0t.z *= gQ.z;
-p1t.z *= gQ.z;
-p2t.z *= gQ.z;
-float rn = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+p0t.z *= gH.z;
+p1t.z *= gH.z;
+p2t.z *= gH.z;
+float sp = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
 
 
-if (abs(rn) > abs(tMax * det)) {
+if (abs(sp) > abs(tMax * det)) {
 return ti;
 }
 
-float sw = 1. / det;
-ti.t = rn * sw;
-ti.barycentric = e * sw;
+float tP = 1. / det;
+ti.t = sp * tP;
+ti.barycentric = e * tP;
 
 return ti;
 }
@@ -824,18 +822,18 @@ vec3 max;
 };
 
 
-vec3 fb(vec3 d) {
+vec3 eW(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;
+vec3 ah = mix(d, mix(vec3(1e-20), vec3(-1e-20), lessThan(d, vec3(0.0))), lessThan(abs(d), vec3(1e-20)));
+return 1.0 / ah;
 #else
 return 1.0 / d;
 #endif
 }
 
-vec3 eZ(vec3 gE, vec3 o) {
+vec3 eU(vec3 gb, vec3 o) {
 #ifdef DEPTH_QUERY_MODE
-return abs(gE) * max(vec3(1.0), abs(o)) * 1e-6;
+return abs(gb) * max(vec3(1.0), abs(o)) * 1e-6;
 #else
 return vec3(0.0);
 #endif
@@ -843,21 +841,21 @@ return vec3(0.0);
 
 
 
-float cM(vec3 o, vec3 d, vec3 vK, vec3 vJ, float tMax) {
+float cH(vec3 o, vec3 d, vec3 xU, vec3 xT, float tMax) {
 #ifdef DEPTH_QUERY_MODE
-vec3 gE = fb(d);
-vec3 uR = (vK - o) * gE;
-vec3 uS = (vJ - o) * gE;
-vec3 bJ = eZ(gE, o);
+vec3 gb = eW(d);
+vec3 xg = (xU - o) * gb;
+vec3 xh = (xT - o) * gb;
+vec3 padding = eU(gb, o);
 #else
-vec3 uR = (vK - o) / d;
-vec3 uS = (vJ - o) / d;
-vec3 bJ = vec3(0.0);
+vec3 xg = (xU - o) / d;
+vec3 xh = (xT - o) / d;
+vec3 padding = vec3(0.0);
 #endif
-vec3 mK = min(uR, uS) - bJ;
-vec3 rU = max(uR, uS) + bJ;
-float t0 = max(mK.x, max(mK.y, mK.z));
-float t1 = min(rU.x, min(rU.y, rU.z));
+vec3 ns = min(xg, xh) - padding;
+vec3 sW = max(xg, xh) + padding;
+float t0 = max(ns.x, max(ns.y, ns.z));
+float t1 = min(sW.x, min(sW.y, sW.z));
 
 return (t0 > t1 || t0 > tMax) ? -1.0 : (t0 > 0.0 ? t0 : t1);
 }
@@ -866,12 +864,12 @@ int maxDimension(vec3 v) {
 return v.x > v.y ? (v.x > v.z ? 0 : 2) : (v.y > v.z ? 1 : 2);
 }
 
-vec3 mu(vec3 d, int ey) {
+vec3 mU(vec3 d, int dZ) {
 
 
-if (ey == 0) {
+if (dZ == 0) {
 return vec3(-d.y, -d.z, 1.0) / d.x;
-} else if (ey == 1) {
+} else if (dZ == 1) {
 return vec3(-d.z, -d.x, 1.0) / d.y;
 } else {
 return vec3(-d.x, -d.y, 1.0) / d.z;
@@ -879,50 +877,50 @@ return vec3(-d.x, -d.y, 1.0) / d.z;
 }
 
 
-void cZ(in Ray ray, inout ad si, bool doubleSided) {
+void intersectScene(in Ray ray, inout SurfaceInteraction si, bool doubleSided) {
 si.hit = false;
 
 if (isEmptyScene) {
 return;
 }
 
-int ey = maxDimension(abs(ray.d));
-vec3 gQ = mu(ray.d, ey);
-int ao;
+int dZ = maxDimension(abs(ray.d));
+vec3 gH = mU(ray.d, dZ);
+int am;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-lB = tri;
-hB = faceNormal;
-aB = hit.barycentric;
-hw = index;
-rb = true;
-ao = cf;
+lR = tri;
+hz = faceNormal;
+aw = hit.barycentric;
+hr = index;
+sd = true;
+am = bK;
 `)}
 
-if (rb) {
-si.instanceIndex = ao;
-si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
+if (sd) {
+si.instanceIndex = am;
+si.materialIndex = int(af(floatBitsToInt(fetchIns(am * ${INSTANCE_VEC4_STRIDE}).z)).x);
 
-ht(si, lB, aB, hw);
+hn(si, lR, aw, hr);
 mat4 l2w = mat4(
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 5),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 6),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 7),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 8)
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 5),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 6),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 7),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 8)
 );
 mat4 w2l = mat4(
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 1),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 2),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 3),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 4)
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 1),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 2),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 3),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 4)
 );
-mat3 aD = transpose(mat3(w2l));
-si.faceNormal = normalize(aD * hB);
-si.vertexNormal = normalize(aD * si.vertexNormal);
-si.normal = normalize(aD * si.normal);
+mat3 aG = transpose(mat3(w2l));
+si.faceNormal = normalize(aG * hz);
+si.vertexNormal = normalize(aG * si.vertexNormal);
+si.normal = normalize(aG * si.normal);
 #ifdef USE_COAT_NORMAL_FRAMES
-si.coatNormal = normalize(aD * si.coatNormal);
+si.coatNormal = normalize(aG * si.coatNormal);
 #endif
 #ifdef USE_TANGENT
 if (dot(si.tangent, si.tangent) > 0.0) {
@@ -939,7 +937,7 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 
 
-void iM(in Ray ray, inout ad si, int instanceIndex, float maxDistance) {
+void intersectSceneBevel(in Ray ray, inout SurfaceInteraction si, int instanceIndex, float maxDistance) {
 si.hit = false;
 
 if (isEmptyScene) {
@@ -947,46 +945,46 @@ return;
 }
 
 bool doubleSided = true;
-int ey = maxDimension(abs(ray.d));
-vec3 gQ = mu(ray.d, ey);
-int ao;
+int dZ = maxDimension(abs(ray.d));
+vec3 gH = mU(ray.d, dZ);
+int am;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-lB = tri;
-hB = faceNormal;
-aB = hit.barycentric;
-hw = index;
-rb = true;
-ao = cf;
+lR = tri;
+hz = faceNormal;
+aw = hit.barycentric;
+hr = index;
+sd = true;
+am = bK;
 `, glsl `
-if (cf != instanceIndex) {
+if (bK != instanceIndex) {
 continue;
 }
 `, 'maxDistance')}
 
-if (rb) {
-si.instanceIndex = ao;
-si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
-ht(si, lB, aB, hw);
+if (sd) {
+si.instanceIndex = am;
+si.materialIndex = int(af(floatBitsToInt(fetchIns(am * ${INSTANCE_VEC4_STRIDE}).z)).x);
+hn(si, lR, aw, hr);
 mat4 l2w = mat4(
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 5),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 6),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 7),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 8)
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 5),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 6),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 7),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 8)
 );
 mat4 w2l = mat4(
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 1),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 2),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 3),
-bv(ao * ${INSTANCE_VEC4_STRIDE} + 4)
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 1),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 2),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 3),
+fetchIns(am * ${INSTANCE_VEC4_STRIDE} + 4)
 );
-mat3 aD = transpose(mat3(w2l));
-si.faceNormal = normalize(aD * hB);
-si.vertexNormal = normalize(aD * si.vertexNormal);
-si.normal = normalize(aD * si.normal);
+mat3 aG = transpose(mat3(w2l));
+si.faceNormal = normalize(aG * hz);
+si.vertexNormal = normalize(aG * si.vertexNormal);
+si.normal = normalize(aG * si.normal);
 #ifdef USE_COAT_NORMAL_FRAMES
-si.coatNormal = normalize(aD * si.coatNormal);
+si.coatNormal = normalize(aG * si.coatNormal);
 #endif
 #ifdef USE_TANGENT
 if (dot(si.tangent, si.tangent) > 0.0) {
@@ -1002,35 +1000,35 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 }
 
-bool ex(in Ray ray, float lightDistance, int jL) {
+bool intersectSceneShadow(in Ray ray, float lightDistance, int jR) {
 
 if (isEmptyScene) {
 return false;
 }
 
 bool doubleSided = true;
-int ey = maxDimension(abs(ray.d));
-vec3 gQ = mu(ray.d, ey);
+int dZ = maxDimension(abs(ray.d));
+vec3 gH = mU(ray.d, dZ);
 
 ${getBVHTraverseCode(glsl `
 
 
-bool jt = true;
+bool jA = true;
 vec3 barycentric = hit.barycentric;
 vec3 position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
 
-if (jt) {
+if (jA) {
 #ifdef HAS_ALPHA
-int materialIndex = int(ae(floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)).x);
-ivec2 i0 = gR(index.x, vertexColumns);
-ivec2 i1 = gR(index.y, vertexColumns);
-ivec2 i2 = gR(index.z, vertexColumns);
+int materialIndex = int(af(floatBitsToInt(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).z)).x);
+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));
 
 if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
-materialIndex = fm(m0, m1, m2, barycentric);
+materialIndex = fh(m0, m1, m2, barycentric);
 }
 
 int ii = materialIndex * MAT_DATA_SIZE;
@@ -1044,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 lL = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(lL.r);
+vec4 mb = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(mb.r);
 if (uvProjection > 0) {
-uv = gI(uvProjection, position, hB, lL.zw);
+uv = gE(uvProjection, position, hz, mb.zw);
 } else {
-uv *= lL.zw;
+uv *= mb.zw;
 }
 
 alpha *= sampleMap(diffuseMapIndex, uv).a;
@@ -1063,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 lL = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(lL.r);
+vec4 mb = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(mb.r);
 if (uvProjection > 0) {
-uv = gI(uvProjection, position, hB, lL.zw);
+uv = gE(uvProjection, position, hz, mb.zw);
 } else {
-uv *= lL.zw;
+uv *= mb.zw;
 }
 alpha *= sampleMap(alphaMapIndex, uv).g;
 }
 #endif
 float alphaCutoff = fetchMatData(ii + MAT_ROW_STANDALONE_MAPS).a;
-alpha = lr(
+alpha = lJ(
 alpha, int(fetchMatData(ii + MAT_ROW_ALPHA).w), alphaCutoff
 );
-if (eo(0u) > alpha) {
+if (ek(0u) > alpha) {
 
 tMax = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-jt = false;
+jA = false;
 }
 #endif
 }
-if (jt) {
+if (jA) {
 return true;
 }
 `, glsl `
-if (triangleIndex == jL) {
+if (triangleIndex == jR) {
 continue;
 }
 `, 'min(max(lightDistance, 0.0), RAY_MAX_DISTANCE)')}