@meimu/mutracer 0.2.0 → 0.3.1

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(bF(bY * ${INSTANCE_VEC4_STRIDE}).y));
+ivec3 vertexOffset = ivec3(floatBitsToInt(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).y));
 for (int k = 0; k < primitiveCount; k++) {
 int triangleIndex = primitiveOffset + k;
 ${skipTriangleCode}
-vec4 r3 = dJ(triangleIndex);
+vec4 r3 = fetchBVH(triangleIndex);
 ivec3 index = floatBitsToInt(r3.xyz) + vertexOffset;
-fP tri = fP(
-lm(positionBuffer, index.x, vertexColumns).xyz,
-lm(positionBuffer, index.y, vertexColumns).xyz,
-lm(positionBuffer, index.z, vertexColumns).xyz
+fL tri = fL(
+fetchData(positionBuffer, index.x, vertexColumns).xyz,
+fetchData(positionBuffer, index.y, vertexColumns).xyz,
+fetchData(positionBuffer, index.z, vertexColumns).xyz
 );
-eK hit = ga(o, d, tri, eq, gY, tMax);
+eF hit = fY(o, d, tri, ei, gZ, 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 kP = int(ah(
-floatBitsToInt(bF(bY * ${INSTANCE_VEC4_STRIDE}).z)
+int lc = int(af(
+floatBitsToInt(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).z)
 ).x);
-bool jd = fetchMatData(
-kP * MAT_DATA_SIZE + MAT_ROW_ALPHA
+bool jm = fetchMatData(
+lc * MAT_DATA_SIZE + MAT_ROW_ALPHA
 ).z > 0.5;
-if (!doubleSided && !jd && dot(faceNormal, d) > 0.0) {
+if (!doubleSided && !jm && dot(faceNormal, d) > 0.0) {
 continue;
 }
 
@@ -41,257 +41,260 @@ ${handleHitCode}
     return glsl `
 ivec2 stack[STACK_SIZE];
 int top = -1;
-int ud = -1;
+int vQ = -1;
 float tMax = ${initialTMax};
 
 vec3 o = ray.o;
 vec3 d = ray.d;
 
-bool sj = false;
-vec3 hS;
-vec3 aC;
-ivec3 hK;
+bool tD = false;
+vec3 hU;
+vec3 aw;
+ivec3 hL;
 
-fP mk;
+fL mL;
 
 
 top = 0;
 stack[0] = ivec2(0, -1);
 
-int yk = 0;
-while(top >= 0 && yk < 5000) {
-yk++;
+int AI = 0;
+while(top >= 0 && AI < 5000) {
+AI++;
 ivec2 node = stack[top--];
 
-int bY = node.y;
+int bK = node.y;
 
-if (bY != ud) {
-if (bY < 0) {
+if (bK != vQ) {
+if (bK < 0) {
 o = ray.o;
 d = ray.d;
 }
 else {
 mat4 w2l = mat4(
-bF(bY * ${INSTANCE_VEC4_STRIDE} + 1),
-bF(bY * ${INSTANCE_VEC4_STRIDE} + 2),
-bF(bY * ${INSTANCE_VEC4_STRIDE} + 3),
-bF(bY * ${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;
 }
-eq = maxDimension(abs(d));
-gY = nk(d, eq);
-ud = bY;
+ei = maxDimension(abs(d));
+gZ = nV(d, ei);
+vQ = bK;
 }
 
-int bw = bY < 0 ? 0 : blasOffset;
-uint fY = bY < 0 ? 0u : floatBitsToUint(bF(bY * ${INSTANCE_VEC4_STRIDE}).x);
-int he = int(fY >> 30u);
-int fg = int(fY & 0x3fffffffu);
+int bufferOff = bK < 0 ? 0 : blasOffset;
+uint fW = bK < 0 ? 0u : floatBitsToUint(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).x);
+int hj = int(fW >> 30u);
+int fc = int(fW & 0x3fffffffu);
 int primitiveCount = 0;
 int primitiveOffset = 0;
 
-if (he == 3) {
-uint iw = uint(node.x);
-if ((iw & 0x80000000u) != 0u) {
-primitiveCount = int((iw >> 23u) & 0xffu);
-primitiveOffset = bw + fg + int(iw & 0x007fffffu);
+if (hj == 3) {
+uint iE = uint(node.x);
+if ((iE & 0x80000000u) != 0u) {
+primitiveCount = int((iE >> 23u) & 0xffu);
+primitiveOffset = bufferOff + fc + int(iE & 0x007fffffu);
 }
 else {
-int i = node.x + bw;
-vec4 jZ = dJ(i);
-vec4 fU = dJ(i + 1);
-vec4 nS = dJ(i + 2);
-vec4 nT = dJ(i + 3);
-vec4 nU = dJ(i + 4);
-uint header = floatBitsToUint(jZ.w);
-int sH = int(header << 24u) >> 24;
-int sI = int((header >> 8u) << 24u) >> 24;
-int sJ = int((header >> 16u) << 24u) >> 24;
-vec3 hZ = vec3(
-uintBitsToFloat(uint(sH + 127) << 23u),
-uintBitsToFloat(uint(sI + 127) << 23u),
-uintBitsToFloat(uint(sJ + 127) << 23u)
+int i = node.x + bufferOff;
+vec4 kj = fetchBVH(i);
+vec4 fR = fetchBVH(i + 1);
+vec4 oG = fetchBVH(i + 2);
+vec4 oH = fetchBVH(i + 3);
+vec4 oI = fetchBVH(i + 4);
+uint header = floatBitsToUint(kj.w);
+int uc = int(header << 24u) >> 24;
+int ud = int((header >> 8u) << 24u) >> 24;
+int ue = int((header >> 16u) << 24u) >> 24;
+vec3 ih = vec3(
+uintBitsToFloat(uint(uc + 127) << 23u),
+uintBitsToFloat(uint(ud + 127) << 23u),
+uintBitsToFloat(uint(ue + 127) << 23u)
 );
-uint childBase = floatBitsToUint(fU.x);
-uint pM = floatBitsToUint(fU.y);
+uint childBase = floatBitsToUint(fR.x);
+uint qE = floatBitsToUint(fR.y);
 uint internalMask = header >> 24u;
-uint vU = (d.x < 0.0 ? 4u : 0u) |
+uint yl = (d.x < 0.0 ? 4u : 0u) |
 (d.y < 0.0 ? 2u : 0u) |
 (d.z < 0.0 ? 1u : 0u);
-uint gV[12] = uint[12](
-floatBitsToUint(nS.x), floatBitsToUint(nS.y),
-floatBitsToUint(nS.z), floatBitsToUint(nS.w),
-floatBitsToUint(nT.x), floatBitsToUint(nT.y),
-floatBitsToUint(nT.z), floatBitsToUint(nT.w),
-floatBitsToUint(nU.x), floatBitsToUint(nU.y),
-floatBitsToUint(nU.z), floatBitsToUint(nU.w)
+uint gX[12] = uint[12](
+floatBitsToUint(oG.x), floatBitsToUint(oG.y),
+floatBitsToUint(oG.z), floatBitsToUint(oG.w),
+floatBitsToUint(oH.x), floatBitsToUint(oH.y),
+floatBitsToUint(oH.z), floatBitsToUint(oH.w),
+floatBitsToUint(oI.x), floatBitsToUint(oI.y),
+floatBitsToUint(oI.z), floatBitsToUint(oI.w)
 );
 
 for (int order = 7; order >= 0; order--) {
-uint slot = uint(order) ^ vU;
-uint tT = slot >= 4u
-? floatBitsToUint(fU.w)
-: floatBitsToUint(fU.z);
-uint meta = (tT >> ((slot & 3u) * 8u)) & 0xffu;
+uint slot = uint(order) ^ yl;
+uint vF = slot >= 4u
+? floatBitsToUint(fR.w)
+: floatBitsToUint(fR.z);
+uint meta = (vF >> ((slot & 3u) * 8u)) & 0xffu;
 if (meta == 0u) continue;
-uint mI = (slot & 3u) * 8u;
-uint lF = slot >> 2u;
-vec3 uX = vec3(
-float((gV[lF] >> mI) & 0xffu),
-float((gV[2u + lF] >> mI) & 0xffu),
-float((gV[4u + lF] >> mI) & 0xffu)
+uint nr = (slot & 3u) * 8u;
+uint me = slot >> 2u;
+vec3 wS = vec3(
+float((gX[me] >> nr) & 0xffu),
+float((gX[2u + me] >> nr) & 0xffu),
+float((gX[4u + me] >> nr) & 0xffu)
 );
-vec3 uW = vec3(
-float((gV[6u + lF] >> mI) & 0xffu),
-float((gV[8u + lF] >> mI) & 0xffu),
-float((gV[10u + lF] >> mI) & 0xffu)
+vec3 wR = vec3(
+float((gX[6u + me] >> nr) & 0xffu),
+float((gX[8u + me] >> nr) & 0xffu),
+float((gX[10u + me] >> nr) & 0xffu)
 );
-vec3 wN = jZ.xyz + uX * hZ;
-vec3 wM = jZ.xyz + uW * hZ;
-if (cU(o, d, wN, wM, tMax) <= 0.0) continue;
-uint kb = meta & 0x1fu;
-if (kb >= 24u) {
-uint om = internalMask & ((1u << slot) - 1u);
-uint un = childBase + rY(om);
+vec3 zp = kj.xyz + wS * ih;
+vec3 zo = kj.xyz + wR * ih;
+if (bP(o, d, zp, zo, tMax) <= 0.0) continue;
+uint kl = meta & 0x1fu;
+if (kl >= 24u) {
+uint oZ = internalMask & ((1u << slot) - 1u);
+uint wb = childBase + tl(oZ);
 stack[++top] = ivec2(
-fg + int(un * 5u), bY
+fc + int(wb * 5u), bK
 );
 }
 else {
-uint triangleCount = rY(meta >> 5u);
-uint sV = pM + kb;
-uint wZ = 0x80000000u |
+uint triangleCount = tl(meta >> 5u);
+uint ut = qE + kl;
+uint zC = 0x80000000u |
 (triangleCount << 23u) |
-(sV & 0x007fffffu);
-stack[++top] = ivec2(int(wZ), bY);
+(ut & 0x007fffffu);
+stack[++top] = ivec2(int(zC), bK);
 }
 }
 }
 }
-else if (he == 2) {
-int i = node.x + bw;
-vec4 wP = dJ(i);
-vec4 wQ = dJ(i + 1);
-vec4 wR = dJ(i + 2);
-vec4 wS = dJ(i + 3);
-primitiveCount = int(floatBitsToUint(wR.w));
+else if (hj == 2) {
+int i = node.x + bufferOff;
+vec4 zr = fetchBVH(i);
+vec4 zs = fetchBVH(i + 1);
+vec4 zt = fetchBVH(i + 2);
+vec4 zu = fetchBVH(i + 3);
+primitiveCount = int(floatBitsToUint(zt.w));
 if (primitiveCount > 0) {
-primitiveOffset = bw + fg + int(floatBitsToUint(wS.w));
+primitiveOffset = bufferOff + fc + int(floatBitsToUint(zu.w));
 }
 else {
-int left = fg + int(floatBitsToUint(wP.w) * 4u);
-int right = fg + int(floatBitsToUint(wQ.w) * 4u);
-float d0 = cU(o, d, wP.xyz, wQ.xyz, tMax);
-float d1 = cU(o, d, wR.xyz, wS.xyz, tMax);
+int left = fc + int(floatBitsToUint(zr.w) * 4u);
+int right = fc + int(floatBitsToUint(zs.w) * 4u);
+float d0 = bP(o, d, zr.xyz, zs.xyz, tMax);
+float d1 = bP(o, d, zt.xyz, zu.xyz, tMax);
 if (d0 > d1) {
-if (d0 > 0.0) stack[++top] = ivec2(left, bY);
-if (d1 > 0.0) stack[++top] = ivec2(right, bY);
+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, bY);
-if (d0 > 0.0) stack[++top] = ivec2(left, bY);
+if (d1 > 0.0) stack[++top] = ivec2(right, bK);
+if (d0 > 0.0) stack[++top] = ivec2(left, bK);
 }
 }
 }
-else if (he == 1) {
-uint iw = uint(node.x);
-if ((iw & 0x80000000u) != 0u) {
-primitiveCount = int((iw >> 23u) & 0xffu);
-primitiveOffset = bw + fg + int(iw & 0x007fffffu);
+else if (hj == 1) {
+uint iE = uint(node.x);
+if ((iE & 0x80000000u) != 0u) {
+primitiveCount = int((iE >> 23u) & 0xffu);
+primitiveOffset = bufferOff + fc + int(iE & 0x007fffffu);
 }
 else {
-int i = node.x + bw;
-vec4 vJ = dJ(i);
-vec4 sz = dJ(i + 1);
-vec4 qR = dJ(i + 2);
-vec4 oQ = dJ(i + 3);
-vec3 nodeMin = vJ.xyz;
-vec3 er = vec3(vJ.w, sz.x, sz.y);
-uint mT[4] = uint[4](
-floatBitsToUint(sz.z), floatBitsToUint(sz.w),
-floatBitsToUint(qR.x), floatBitsToUint(qR.y)
+int i = node.x + bufferOff;
+vec4 xS = fetchBVH(i);
+vec4 tR = fetchBVH(i + 1);
+vec4 rW = fetchBVH(i + 2);
+vec4 pL = fetchBVH(i + 3);
+vec3 nodeMin = xS.xyz;
+vec3 ej = vec3(xS.w, tR.x, tR.y);
+uint nH[4] = uint[4](
+floatBitsToUint(tR.z), floatBitsToUint(tR.w),
+floatBitsToUint(rW.x), floatBitsToUint(rW.y)
 );
-vec4 wx = fp(floatBitsToUint(qR.z));
-vec4 wy = fp(floatBitsToUint(qR.w));
-vec4 wB = fp(floatBitsToUint(oQ.x));
-vec4 wu = fp(floatBitsToUint(oQ.y));
-vec4 wv = fp(floatBitsToUint(oQ.z));
-vec4 ww = fp(floatBitsToUint(oQ.w));
-vec3 gr = fo(d);
-vec3 padding = fk(gr, o);
-vec4 tx0 = (nodeMin.x + wx * er.x - o.x) * gr.x;
-vec4 tx1 = (nodeMin.x + wu * er.x - o.x) * gr.x;
-vec4 ty0 = (nodeMin.y + wy * er.y - o.y) * gr.y;
-vec4 ty1 = (nodeMin.y + wv * er.y - o.y) * gr.y;
-vec4 tz0 = (nodeMin.z + wB * er.z - o.z) * gr.z;
-vec4 tz1 = (nodeMin.z + ww * er.z - o.z) * gr.z;
-vec4 nJ = max(max((min(tx0, tx1) - vec4(padding.x)), (min(ty0, ty1) - vec4(padding.y))), (min(tz0, tz1) - vec4(padding.z)));
-vec4 sY = min(min((max(tx0, tx1) + vec4(padding.x)), (max(ty0, ty1) + vec4(padding.y))), (max(tz0, tz1) + vec4(padding.z)));
-vec4 distance = mix(sY, nJ, greaterThan(nJ, vec4(0.0)));
-distance = mix(distance, vec4(-1.0), greaterThan(nJ, min(sY, vec4(tMax))));
-float fq[4] = float[4](distance.x, distance.y, distance.z, distance.w);
+vec4 yV = fh(floatBitsToUint(rW.z));
+vec4 yW = fh(floatBitsToUint(rW.w));
+vec4 yX = fh(floatBitsToUint(pL.x));
+vec4 yS = fh(floatBitsToUint(pL.y));
+vec4 yT = fh(floatBitsToUint(pL.z));
+vec4 yU = fh(floatBitsToUint(pL.w));
+vec3 invD = traversalInverse(d);
+vec3 padding = ff(invD, o);
+vec4 tx0 = (nodeMin.x + yV * ej.x - o.x) * invD.x;
+vec4 tx1 = (nodeMin.x + yS * ej.x - o.x) * invD.x;
+vec4 ty0 = (nodeMin.y + yW * ej.y - o.y) * invD.y;
+vec4 ty1 = (nodeMin.y + yT * ej.y - o.y) * invD.y;
+vec4 tz0 = (nodeMin.z + yX * ej.z - o.z) * invD.z;
+vec4 tz1 = (nodeMin.z + yU * ej.z - o.z) * invD.z;
+vec4 ot = max(max((min(tx0, tx1) - vec4(padding.x)), (min(ty0, ty1) - vec4(padding.y))), (min(tz0, tz1) - vec4(padding.z)));
+vec4 uA = min(min((max(tx0, tx1) + vec4(padding.x)), (max(ty0, ty1) + vec4(padding.y))), (max(tz0, tz1) + vec4(padding.z)));
+vec4 distance = mix(uA, ot, greaterThan(ot, vec4(0.0)));
+distance = mix(distance, vec4(-1.0), greaterThan(ot, min(uA, vec4(tMax))));
+float fi[4] = float[4](distance.x, distance.y, distance.z, distance.w);
 
 
 for (int order = 0; order < 4; order++) {
-float em = -1.0;
-int eB = -1;
+float ee = -1.0;
+int eq = -1;
 for (int child = 0; child < 4; child++) {
-if (mT[child] != 0u && fq[child] > em) {
-em = fq[child];
-eB = child;
+if (nH[child] != 0u && fi[child] > ee) {
+ee = fi[child];
+eq = child;
 }
 }
-if (eB >= 0 && em > 0.0) {
-uint oy = mT[eB];
-int ki = int(oy);
-if ((oy & 0x80000000u) == 0u) {
-ki += fg;
+if (eq >= 0 && ee > 0.0) {
+uint ph = nH[eq];
+int kv = int(ph);
+if ((ph & 0x80000000u) == 0u) {
+kv += fc;
 }
-stack[++top] = ivec2(ki, bY);
-fq[eB] = -1.0;
+stack[++top] = ivec2(kv, bK);
+fi[eq] = -1.0;
 }
 }
 }
 }
 else {
-int i = node.x + bw;
-vec4 r1 = dJ(i);
-int bl = floatBitsToInt(r1.w);
+int i = node.x + bufferOff;
+vec4 r1 = fetchBVH(i);
+int bh = floatBitsToInt(r1.w);
 
-if (bl >= 0) {
+if (bh >= 0) {
 int left = node.x + 2;
-int right = bl + fg;
+int right = bh + fc;
 
-float d0 = cU(o, d, dJ(left + bw).xyz, dJ(left + 1 + bw).xyz, tMax);
-float d1 = cU(o, d, dJ(right + bw).xyz, dJ(right + 1 + bw).xyz, tMax);
+float d0 = bP(o, d, fetchBVH(left + bufferOff).xyz, fetchBVH(left + 1 + bufferOff).xyz, tMax);
+float d1 = bP(o, d, fetchBVH(right + bufferOff).xyz, fetchBVH(right + 1 + bufferOff).xyz, tMax);
 if (d0 > d1) {
 if (d0 > 0.0) {
-stack[++top] = ivec2(left, bY);
+stack[++top] = ivec2(left, bK);
 }
 if (d1 > 0.0) {
-stack[++top] = ivec2(right, bY);
+stack[++top] = ivec2(right, bK);
 }
 }
 else {
 if (d1 > 0.0) {
-stack[++top] = ivec2(right, bY);
+stack[++top] = ivec2(right, bK);
 }
 if (d0 > 0.0) {
-stack[++top] = ivec2(left, bY);
+stack[++top] = ivec2(left, bK);
 }
 }
 }
 else {
-if (bY < 0) {
-for (int k = 0; k < -bl; k++) {
-vec4 r3 = dJ(i + 2 + k);
+if (bK < 0) {
+for (int k = 0; k < -bh; k++) {
+vec4 r3 = fetchBVH(i + 2 + k);
+int box = floatBitsToInt(r3.w);
+if (bP(ray.o, ray.d, fetchBVH(box).xyz, fetchBVH(box + 1).xyz, tMax) > 0.0) {
 stack[++top] = ivec2(floatBitsToInt(r3.y), floatBitsToInt(r3.x));
 }
 }
+}
 else {
-primitiveCount = -bl;
+primitiveCount = -bh;
 primitiveOffset = i + 2;
 }
 }
@@ -303,31 +306,31 @@ ${intersectTriangles}
 `;
 }
 export default createShaderMixin({
+    defines: {
+        VERTEX_ATTRIBUTE_STRIDE: 2
+    },
     uniforms: {
         positionBuffer: Shader.uniform('sampler2D'),
-        normalBuffer: Shader.uniform('sampler2D'),
-        tangentBuffer: Shader.uniform('sampler2D'),
-        uvBuffer: Shader.uniform('sampler2D'),
-        uv1Buffer: Shader.uniform('sampler2D'),
-        colorBuffer: Shader.uniform('sampler2D'),
-        materialIndexBuffer: Shader.uniform('sampler2D'),
+        // Interleaved shading attributes; layout in webglVertexAttributes.ts.
+        vertexAttributes: Shader.uniform('sampler2D'),
+        // TLAS, BLASes and then the instance records.
         bvhBuffer: Shader.uniform('sampler2D'),
-        instancesBuffer: Shader.uniform('sampler2D'),
         bvhColumns: Shader.uniform('int', 1),
         vertexColumns: Shader.uniform('int', 1),
-        instancesColumns: Shader.uniform('int', 1),
+        vertexAttributeColumns: Shader.uniform('int', 1),
+        instancesOffset: Shader.uniform('int', 0),
         blasOffset: Shader.uniform('int'),
         isEmptyScene: Shader.uniform('bool')
     },
     main: glsl `
 
-struct fP {
+struct fL {
 vec3 p0;
 vec3 p1;
 vec3 p2;
 };
 #ifdef NUM_LIGHTS
-float hL(float rad, vec3 pos, Ray r) {
+float hM(float rad, vec3 pos, Ray r) {
 vec3 op = pos - r.o;
 float eps = 0.001;
 float b = dot(op, r.d);
@@ -347,7 +350,7 @@ return t2;
 return INF;
 }
 
-float og(vec3 pos, vec3 u, vec3 v, vec3 n, Ray r) {
+float oU(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 +369,17 @@ return t;
 return INF;
 }
 
-float nr(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 iB(Ray r, Light light, out LightSampleRec lightSample) {
 
 
 
@@ -383,15 +396,15 @@ vec3 normal = normalize(cross(u, v));
 if (dot(normal, r.d) > 0.) 
 return INF;
 
-d = og(pos, u, v, normal, r);
+d = oU(pos, u, v, normal, r);
 if (d < 0.) {
 d = INF;
 }
 else {
-float ci = dot(-r.d, normal);
+float cv = dot(-r.d, normal);
 float spread = light.spread;
-if (ci >= cos(spread * PI / 2.0)) {
-lightSample.pdf = (d * d) / (light.area * ci);
+if (cv >= cos(spread * PI / 2.0)) {
+lightSample.pdf = (d * d) / (light.area * cv);
 lightSample.emission = light.emission;
 }
 }
@@ -400,10 +413,10 @@ lightSample.emission = light.emission;
 #ifdef HAS_SPHERE_LIGHTS
 if (type == SPHERE_LIGHT) {
 if (light.radius <= 0.0) {
-vec3 kT = light.position - r.o;
-float projection = dot(kT, r.d);
-vec3 bk = kT - projection * r.d;
-if (projection <= EPS || dot(bk, bk) > 1e-8) return INF;
+vec3 lj = light.position - r.o;
+float projection = dot(lj, r.d);
+vec3 bf = lj - projection * r.d;
+if (projection <= EPS || dot(bf, bf) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
 lightSample.normal = -r.d;
@@ -411,21 +424,15 @@ lightSample.dist = d;
 lightSample.pdf = 1.0;
 lightSample.isDelta = true;
 } else {
-d = hL(light.radius, light.position, r);
+d = hM(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d < 0.) {
 d = INF;
 }
 else {
-float ak = distance(r.o, light.position);
-float cosThetaMax = ak <= light.radius
-? -1.0
-: sqrt(max(0.0, 1.0 - light.radius * light.radius / (ak * ak)));
 if (light.radius > 0.0) {
-lightSample.pdf = ak <= 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 +443,10 @@ lightSample.emission = light.radius <= 0.0
 #ifdef HAS_SPOT_LIGHTS
 if (type == SPOT_LIGHT) {
 if (light.radius <= 0.0) {
-vec3 kT = light.position - r.o;
-float projection = dot(kT, r.d);
-vec3 bk = kT - projection * r.d;
-if (projection <= EPS || dot(bk, bk) > 1e-8) return INF;
+vec3 lj = light.position - r.o;
+float projection = dot(lj, r.d);
+vec3 bf = lj - projection * r.d;
+if (projection <= EPS || dot(bf, bf) > 1e-8) return INF;
 d = projection;
 lightSample.direction = r.d;
 lightSample.normal = -r.d;
@@ -447,23 +454,17 @@ lightSample.dist = d;
 lightSample.pdf = 1.0;
 lightSample.isDelta = true;
 } else {
-d = hL(light.radius, light.position, r);
+d = hM(light.radius, light.position, r);
 lightSample.isDelta = false;
 }
 if (d != INF) {
-vec3 wW = r.o + d * r.d;
-float nv = bP(light, normalize(r.o - wW));
-if (nv <= 0.0) return INF;
-float ak = distance(r.o, light.position);
-float cosThetaMax = ak <= light.radius
-? -1.0
-: sqrt(max(0.0, 1.0 - light.radius * light.radius / (ak * ak)));
+vec3 zA = r.o + d * r.d;
+float od = evaluateSpotEmissionMultiplier(light, normalize(r.o - zA));
+if (od <= 0.0) return INF;
 if (light.radius > 0.0) {
-lightSample.pdf = ak <= 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 * nv * (light.radius <= 0.0
+lightSample.emission = light.emission * od * (light.radius <= 0.0
 ? 1.0 / max(d * d, 1e-8)
 : 1.0);
 }
@@ -474,106 +475,122 @@ return d;
 }
 #endif
 
-int fF(ivec4 m0, ivec4 m1, ivec4 m2, vec3 eU) {
-vec2 m00 = ah(m0.x);
-vec2 m01 = ah(m0.y);
-vec2 m02 = ah(m0.z);
-vec2 m10 = ah(m1.x);
-vec2 m11 = ah(m1.y);
-vec2 m12 = ah(m1.z);
-vec2 m20 = ah(m2.x);
-vec2 m21 = ah(m2.y);
-vec2 m22 = ah(m2.z);
-float w00 = m00.y * eU.x;
-float w01 = m01.y * eU.x;
-float w02 = m02.y * eU.x;
-float w10 = m10.y * eU.y;
-float w11 = m11.y * eU.y;
-float w12 = m12.y * eU.y;
-float w20 = m20.y * eU.z;
-float w21 = m21.y * eU.z;
-float w22 = m22.y * eU.z;
-
-float hy = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
-
-w00 = w00 / hy;
-w01 = w01 / hy + w00;
-w02 = w02 / hy + w01;
-w10 = w10 / hy + w02;
-w11 = w11 / hy + w10;
-w12 = w12 / hy + w11;
-w20 = w20 / hy + w12;
-w21 = w21 / hy + w20;
-w22 = w22 / hy + w21;
-
-float rand = eC(0u);
-float oh;
+int fv(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 hB = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
+
+w00 = w00 / hB;
+w01 = w01 / hB + w00;
+w02 = w02 / hB + w01;
+w10 = w10 / hB + w02;
+w11 = w11 / hB + w10;
+w12 = w12 / hB + w11;
+w20 = w20 / hB + w12;
+w21 = w21 / hB + w20;
+w22 = w22 / hB + w21;
+
+float rand = cm(0u);
+float oV;
 if (rand < w00) {
-oh = m00.x;
+oV = m00.x;
 } else if (rand < w01) {
-oh = m01.x;
+oV = m01.x;
 } else if (rand < w02) {
-oh = m02.x;
+oV = m02.x;
 } else if (rand < w10) {
-oh = m10.x;
+oV = m10.x;
 } else if (rand < w11) {
-oh = m11.x;
+oV = m11.x;
 } else if (rand < w12) {
-oh = m12.x;
+oV = m12.x;
 } else if (rand < w20) {
-oh = m20.x;
+oV = m20.x;
 } else if (rand < w21) {
-oh = m21.x;
+oV = m21.x;
 } else {
-oh = m22.x;
+oV = m22.x;
 }
-return int(oh);
+return int(oV);
 }
 
 
-vec4 bF(int i);
+vec4 fetchIns(int i);
+
+vec4 bs(int vertex, int slot) {
+return fetchData(vertexAttributes, vertex * VERTEX_ATTRIBUTE_STRIDE + slot, vertexAttributeColumns);
+}
+vec3 fetchVertexNormal(int vertex) { return bs(vertex, 0).xyz; }
+vec2 er(int vertex) { return bs(vertex, 1).xy; }
+ivec4 dT(int vertex) {
+return ivec4(bs(vertex, 0).w, bs(vertex, 1).zw, 0.0);
+}
+vec2 dK(int vertex) {
+#ifdef USE_UV1
+return bs(vertex, VERTEX_UV1_SLOT).xy;
+#else
+return vec2(0.0);
+#endif
+}
+#ifdef USE_TANGENT
+vec4 ef(int vertex) { return bs(vertex, VERTEX_TANGENT_SLOT); }
+#endif
 
 
-mat2x3 eP(vec3 normal, vec3 dp1, vec3 dp2, vec2 oW, vec2 oX, vec4 aX) {
-float determinant = oW.x * oX.y - oW.y * oX.x;
-vec3 t = aX.xyz;
+mat2x3 eI(vec3 normal, vec3 dp1, vec3 dp2, vec2 pU, vec2 pV, vec4 aT) {
+float determinant = pU.x * pV.y - pU.y * pV.x;
+vec3 t = aT.xyz;
 vec3 b = vec3(0.0);
 
-float rF = abs(aX.w) > 1.5 ? 0.0 : aX.w;
+float sO = abs(aT.w) > 1.5 ? 0.0 : aT.w;
 if (abs(determinant) > 1e-12) {
-vec3 dt = (dp1 * oX.y - dp2 * oW.y) / determinant;
-vec3 db = (dp2 * oW.x - dp1 * oX.x) / determinant;
+vec3 dt = (dp1 * pV.y - dp2 * pU.y) / determinant;
+vec3 db = (dp2 * pU.x - dp1 * pV.x) / determinant;
 if (dot(t, t) < 1e-8) { t = dt; }
-if (rF == 0.0) { rF = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
+if (sO == 0.0) { sO = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
 }
 t -= normal * dot(normal, t);
 if (dot(t, t) < 1e-8) {
-float iI = (normal.z >= 0.0 ? 1.0 : -1.0);
-float cL = -1.0 / (iI + normal.z);
-float xy = normal.x * normal.y * cL;
-t = vec3(1.0 + iI * normal.x * normal.x * cL, iI * xy, -iI * normal.x);
-b = vec3(xy, iI + normal.y * normal.y * cL, -normal.y);
+float iP = (normal.z >= 0.0 ? 1.0 : -1.0);
+float cA = -1.0 / (iP + normal.z);
+float xy = normal.x * normal.y * cA;
+t = vec3(1.0 + iP * normal.x * normal.x * cA, iP * xy, -iP * normal.x);
+b = vec3(xy, iP + normal.y * normal.y * cA, -normal.y);
 }
 else { t = normalize(t); b = normalize(cross(normal, t)); }
-return mat2x3(t, b * (rF < 0.0 ? -1.0 : 1.0));
+return mat2x3(t, b * (sO < 0.0 ? -1.0 : 1.0));
 }
 
-void hH(inout SurfaceInteraction si, fP tri, vec3 barycentric, ivec3 index) {
+void hI(inout SurfaceInteraction si, fL tri, vec3 barycentric, ivec3 index) {
 si.hit = true;
 si.position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
-ivec2 i0 = hd(index.x, vertexColumns);
-ivec2 i1 = hd(index.y, vertexColumns);
-ivec2 i2 = hd(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;
+si.vertexColor = barycentric.x * bs(index.x, VERTEX_COLOR_SLOT).rgb
++ barycentric.y * bs(index.y, VERTEX_COLOR_SLOT).rgb
++ barycentric.z * bs(index.z, VERTEX_COLOR_SLOT).rgb;
 #endif
 
-vec3 n0 = texelFetch(normalBuffer, i0, 0).xyz;
-vec3 n1 = texelFetch(normalBuffer, i1, 0).xyz;
-vec3 n2 = texelFetch(normalBuffer, i2, 0).xyz;
+vec3 n0 = fetchVertexNormal(index.x);
+vec3 n1 = fetchVertexNormal(index.y);
+vec3 n2 = fetchVertexNormal(index.z);
 vec3 normal = normalize(barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2);
 si.vertexNormal = normal;
 
@@ -582,14 +599,14 @@ si.vertexNormal = normal;
 
 
 vec3 geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
-vec3 kR = barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2;
+vec3 le = 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(kR, geometricNormal) > 0.0) {
+if (dot(le, 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,155 +624,154 @@ h1 = max(dot(si.position - tri.p1, n1) + h1, 0.0);
 h2 = max(dot(si.position - tri.p2, n2) + h2, 0.0);
 h = min(-min(min(h0, h1), h2), h * 0.5);
 }
-si.shadowOffset = kR * h;
-
+si.shadowOffset = le * h;
 
-ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
-ivec4 m1 = ivec4(texelFetch(materialIndexBuffer, i1, 0));
-ivec4 m2 = ivec4(texelFetch(materialIndexBuffer, i2, 0));
+ivec4 m0 = dT(index.x);
+ivec4 m1 = dT(index.y);
+ivec4 m2 = dT(index.z);
 
 if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
-si.materialIndex = fF(m0, m1, m2, barycentric);
+si.materialIndex = fv(m0, m1, m2, barycentric);
 }
 
-vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
-vec2 uv1 = texelFetch(uvBuffer, i1, 0).xy;
-vec2 uv2 = texelFetch(uvBuffer, i2, 0).xy;
+vec2 uv0 = er(index.x);
+vec2 uv1 = er(index.y);
+vec2 uv2 = er(index.z);
 #if defined(NUM_DIFFUSE_MAPS) || defined(NUM_NORMAL_MAPS) || defined(NUM_METALLIC_ROUGHNESS_MAPS) || defined(NUM_ROUGHNESS_MAPS) || defined(NUM_METALNESS_MAPS) || defined(NUM_EMISSIVE_MAPS) || defined(NUM_THIN_FILM_MAPS) || defined(NUM_ANISOTROPY_MAPS) || defined(NUM_COAT_NORMAL_MAPS)
 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 dj = barycentric.x * secondaryUv0
+vec2 secondaryUv0 = dK(index.x);
+vec2 secondaryUv1 = dK(index.y);
+vec2 secondaryUv2 = dK(index.z);
+vec2 cT = barycentric.x * secondaryUv0
 + barycentric.y * secondaryUv1
 + barycentric.z * secondaryUv2;
 
-vec4 mw = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
-int uvProjection = int(mw.r);
+vec4 mU = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
+int uvProjection = int(mU.r);
 if (uvProjection > 0) {
-uv = gU(uvProjection, si.position, normal, mw.zw);
-dj = uv;
+uv = gW(uvProjection, si.position, normal, mU.zw);
+cT = uv;
 } else {
-uv *= mw.zw;
-dj *= mw.zw;
+uv *= mU.zw;
+cT *= mU.zw;
 }
 #else
 vec2 uv = vec2(0.0);
-vec2 dj = vec2(0.0);
+vec2 cT = vec2(0.0);
 #endif
 
 #ifdef USE_COAT_NORMAL_FRAMES
 si.coatNormal = normal;
 #ifdef NUM_COAT_NORMAL_MAPS
-float pQ = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
+float qK = 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 uL = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
-if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || uL != 0.0
+float wB = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
+if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || wB != 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 aX = vec4(0.0);
+vec4 aT = vec4(0.0);
 #ifdef USE_TANGENT
-aX = barycentric.x * texelFetch(tangentBuffer, i0, 0)
-+ barycentric.y * texelFetch(tangentBuffer, i1, 0)
-+ barycentric.z * texelFetch(tangentBuffer, i2, 0);
+aT = barycentric.x * ef(index.x)
++ barycentric.y * ef(index.y)
++ barycentric.z * ef(index.z);
 #endif
-mat2x3 fc = eP(normal, dp1, dp2, uv0-uv2, uv1-uv2, aX);
-si.geometryTangent = fc[0];
-si.geometryBitangent = fc[1];
-mat2x3 gm = fc;
+mat2x3 eV = eI(normal, dp1, dp2, uv0-uv2, uv1-uv2, aT);
+si.geometryTangent = eV[0];
+si.geometryBitangent = eV[1];
+mat2x3 gp = eV;
 #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;
-gm = eP(normal, dp1, dp2, a-c, b-c, (aX.w == 0.0 ? vec4(0.0) : aX));
+vec2 a = dK(index.x);
+vec2 b = dK(index.y);
+vec2 c = dK(index.z);
+gp = eI(normal, dp1, dp2, a-c, b-c, (aT.w == 0.0 ? vec4(0.0) : aT));
 }
 #endif
-si.directionTangent = gm[0];
-si.directionBitangent = gm[1];
+si.directionTangent = gp[0];
+si.directionBitangent = gp[1];
 #if defined(USE_COAT_NORMAL_FRAMES) && defined(NUM_COAT_NORMAL_MAPS)
-if (pQ >= 0.0) {
-int lg = int(pQ);
-mat2x3 mU = fc;
-if (mapUvChannel[lg] > 0.5) {
-vec2 a = texelFetch(uv1Buffer, i0, 0).xy;
-vec2 b = texelFetch(uv1Buffer, i1, 0).xy;
-vec2 c = texelFetch(uv1Buffer, i2, 0).xy;
-mU = eP(normal, dp1, dp2, a-c, b-c,
-aX.w == 0.0 ? vec4(0.0) : aX);
-}
-vec3 decoded = sampleMap(lg, getMapUvSet(lg, uv, dj)).rgb * 2.0 - 1.0;
-vec3 mapped = mU[0] * decoded.x * directionMaterial.z
-+ mU[1] * decoded.y * directionMaterial.w + normal * decoded.z;
+if (qK >= 0.0) {
+int lI = int(qK);
+mat2x3 nI = eV;
+if (mapUvChannel[lI] > 0.5) {
+vec2 a = dK(index.x);
+vec2 b = dK(index.y);
+vec2 c = dK(index.z);
+nI = eI(normal, dp1, dp2, a-c, b-c,
+aT.w == 0.0 ? vec4(0.0) : aT);
+}
+vec3 decoded = sampleMap(lI, getMapUvSet(lI, uv, cT)).rgb * 2.0 - 1.0;
+vec3 mapped = nI[0] * decoded.x * directionMaterial.z
++ nI[1] * decoded.y * directionMaterial.w + normal * decoded.z;
 if (dot(mapped, mapped) > 1e-12) { si.coatNormal = normalize(mapped); }
 }
 #endif
 }
 
 si.uv = uv;
-si.uv1 = dj;
+si.uv1 = cT;
 
 #ifdef USE_TANGENT
-vec3 t0 = texelFetch(tangentBuffer, i0, 0).xyz;
-vec3 t1 = texelFetch(tangentBuffer, i1, 0).xyz;
-vec3 t2 = texelFetch(tangentBuffer, i2, 0).xyz;
+vec3 t0 = ef(index.x).xyz;
+vec3 t1 = ef(index.y).xyz;
+vec3 t2 = ef(index.z).xyz;
 si.tangent = normalize(barycentric.x * t0 + barycentric.y * t1 + barycentric.z * t2);
 #endif
 #if defined(NUM_NORMAL_MAPS)
 vec3 dp1 = tri.p0 - tri.p2;
 vec3 dp2 = tri.p1 - tri.p2;
-vec2 oW = uv0 - uv2;
-vec2 oX = uv1 - uv2;
-si.normal = pd(
-si.materialIndex, uv, normal, dp1, dp2, oW, oX
+vec2 pU = uv0 - uv2;
+vec2 pV = uv1 - uv2;
+si.normal = qa(
+si.materialIndex, uv, normal, dp1, dp2, pU, pV
 );
 #else
 si.normal = normal;
 #endif
 }
 
-struct eK {
+struct eF {
 float t;
 vec3 barycentric;
 };
 
-vec4 dJ(int i) {
-return lm(bvhBuffer, i, bvhColumns);
+vec4 fetchBVH(int i) {
+return fetchData(bvhBuffer, i, bvhColumns);
 }
 
-vec4 bF(int i) {
-return lm(instancesBuffer, i, instancesColumns);
+vec4 fetchIns(int i) {
+return fetchData(bvhBuffer, instancesOffset + i, bvhColumns);
 }
 
 
 
-uint rY(uint value) {
+uint tl(uint value) {
 value -= (value >> 1u) & 0x55555555u;
 value = (value & 0x33333333u) + ((value >> 2u) & 0x33333333u);
 value = (value + (value >> 4u)) & 0x0f0f0f0fu;
 return (value * 0x01010101u) >> 24u;
 }
 
-vec4 fp(uint mE) {
+vec4 fh(uint nk) {
 return vec4(
-float(mE & 0xffu),
-float((mE >> 8u) & 0xffu),
-float((mE >> 16u) & 0xffu),
-float(mE >> 24u)
+float(nk & 0xffu),
+float((nk >> 8u) & 0xffu),
+float((nk >> 16u) & 0xffu),
+float(nk >> 24u)
 ) / 255.0;
 }
 
 
 
 
-eK ga(vec3 o, vec3 d, fP tri, int eq, vec3 gY, float tMax) {
-eK ti;
+eF fY(vec3 o, vec3 d, fL tri, int ei, vec3 gZ, float tMax) {
+eF ti;
 
 
 vec3 p0t = tri.p0 - o;
@@ -763,20 +779,20 @@ vec3 p1t = tri.p1 - o;
 vec3 p2t = tri.p2 - o;
 
 
-if (eq == 0) {
+if (ei == 0) {
 p0t = p0t.yzx;
 p1t = p1t.yzx;
 p2t = p2t.yzx;
-} else if (eq == 1) {
+} else if (ei == 1) {
 p0t = p0t.zxy;
 p1t = p1t.zxy;
 p2t = p2t.zxy;
 }
 
 
-p0t.xy += gY.xy * p0t.z;
-p1t.xy += gY.xy * p1t.z;
-p2t.xy += gY.xy * p2t.z;
+p0t.xy += gZ.xy * p0t.z;
+p1t.xy += gZ.xy * p1t.z;
+p2t.xy += gZ.xy * p2t.z;
 
 
 vec3 e = vec3(
@@ -786,9 +802,9 @@ p0t.x * p1t.y - p0t.y * p1t.x
 );
 
 #ifdef DEPTH_QUERY_MODE
-vec3 sF = abs(vec3(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
+vec3 ua = 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), sF * 1e-6));
+e = mix(e, vec3(0.0), lessThanEqual(abs(e), ua * 1e-6));
 #endif
 
 
@@ -801,19 +817,19 @@ float det = e.x + e.y + e.z;
 if (det == 0.0) return ti;
 #endif
 
-p0t.z *= gY.z;
-p1t.z *= gY.z;
-p2t.z *= gY.z;
-float sw = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+p0t.z *= gZ.z;
+p1t.z *= gZ.z;
+p2t.z *= gZ.z;
+float tQ = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
 
 
-if (abs(sw) > abs(tMax * det)) {
+if (abs(tQ) > abs(tMax * det)) {
 return ti;
 }
 
-float tN = 1. / det;
-ti.t = sw * tN;
-ti.barycentric = e * tN;
+float vu = 1. / det;
+ti.t = tQ * vu;
+ti.barycentric = e * vu;
 
 return ti;
 }
@@ -824,18 +840,18 @@ vec3 max;
 };
 
 
-vec3 fo(vec3 d) {
+vec3 traversalInverse(vec3 d) {
 #ifdef DEPTH_QUERY_MODE
-vec3 aq = mix(d, mix(vec3(1e-20), vec3(-1e-20), lessThan(d, vec3(0.0))), lessThan(abs(d), vec3(1e-20)));
-return 1.0 / aq;
+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 fk(vec3 gr, vec3 o) {
+vec3 ff(vec3 invD, vec3 o) {
 #ifdef DEPTH_QUERY_MODE
-return abs(gr) * max(vec3(1.0), abs(o)) * 1e-6;
+return abs(invD) * max(vec3(1.0), abs(o)) * 1e-6;
 #else
 return vec3(0.0);
 #endif
@@ -843,21 +859,21 @@ return vec3(0.0);
 
 
 
-float cU(vec3 o, vec3 d, vec3 xq, vec3 xp, float tMax) {
+float bP(vec3 o, vec3 d, vec3 zT, vec3 zS, float tMax) {
 #ifdef DEPTH_QUERY_MODE
-vec3 gr = fo(d);
-vec3 wG = (xq - o) * gr;
-vec3 wI = (xp - o) * gr;
-vec3 padding = fk(gr, o);
+vec3 invD = traversalInverse(d);
+vec3 zi = (zT - o) * invD;
+vec3 zj = (zS - o) * invD;
+vec3 padding = ff(invD, o);
 #else
-vec3 wG = (xq - o) / d;
-vec3 wI = (xp - o) / d;
+vec3 zi = (zT - o) / d;
+vec3 zj = (zS - o) / d;
 vec3 padding = vec3(0.0);
 #endif
-vec3 nJ = min(wG, wI) - padding;
-vec3 sY = max(wG, wI) + padding;
-float t0 = max(nJ.x, max(nJ.y, nJ.z));
-float t1 = min(sY.x, min(sY.y, sY.z));
+vec3 ot = min(zi, zj) - padding;
+vec3 uA = max(zi, zj) + padding;
+float t0 = max(ot.x, max(ot.y, ot.z));
+float t1 = min(uA.x, min(uA.y, uA.z));
 
 return (t0 > t1 || t0 > tMax) ? -1.0 : (t0 > 0.0 ? t0 : t1);
 }
@@ -866,12 +882,12 @@ int maxDimension(vec3 v) {
 return v.x > v.y ? (v.x > v.z ? 0 : 2) : (v.y > v.z ? 1 : 2);
 }
 
-vec3 nk(vec3 d, int eq) {
+vec3 nV(vec3 d, int ei) {
 
 
-if (eq == 0) {
+if (ei == 0) {
 return vec3(-d.y, -d.z, 1.0) / d.x;
-} else if (eq == 1) {
+} else if (ei == 1) {
 return vec3(-d.z, -d.x, 1.0) / d.y;
 } else {
 return vec3(-d.x, -d.y, 1.0) / d.z;
@@ -886,39 +902,39 @@ if (isEmptyScene) {
 return;
 }
 
-int eq = maxDimension(abs(ray.d));
-vec3 gY = nk(ray.d, eq);
-int ap;
+int ei = maxDimension(abs(ray.d));
+vec3 gZ = nV(ray.d, ei);
+int am;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-mk = tri;
-hS = faceNormal;
-aC = hit.barycentric;
-hK = index;
-sj = true;
-ap = bY;
+mL = tri;
+hU = faceNormal;
+aw = hit.barycentric;
+hL = index;
+tD = true;
+am = bK;
 `)}
 
-if (sj) {
-si.instanceIndex = ap;
-si.materialIndex = int(ah(floatBitsToInt(bF(ap * ${INSTANCE_VEC4_STRIDE}).z)).x);
+if (tD) {
+si.instanceIndex = am;
+si.materialIndex = int(af(floatBitsToInt(fetchIns(am * ${INSTANCE_VEC4_STRIDE}).z)).x);
 
-hH(si, mk, aC, hK);
+hI(si, mL, aw, hL);
 mat4 l2w = mat4(
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 5),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 6),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 7),
-bF(ap * ${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(
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 1),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 2),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 3),
-bF(ap * ${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 aH = transpose(mat3(w2l));
-si.faceNormal = normalize(aH * hS);
+si.faceNormal = normalize(aH * hU);
 si.vertexNormal = normalize(aH * si.vertexNormal);
 si.normal = normalize(aH * si.normal);
 #ifdef USE_COAT_NORMAL_FRAMES
@@ -947,42 +963,42 @@ return;
 }
 
 bool doubleSided = true;
-int eq = maxDimension(abs(ray.d));
-vec3 gY = nk(ray.d, eq);
-int ap;
+int ei = maxDimension(abs(ray.d));
+vec3 gZ = nV(ray.d, ei);
+int am;
 
 ${getBVHTraverseCode(glsl `
 si.triangleIndex = triangleIndex;
-mk = tri;
-hS = faceNormal;
-aC = hit.barycentric;
-hK = index;
-sj = true;
-ap = bY;
+mL = tri;
+hU = faceNormal;
+aw = hit.barycentric;
+hL = index;
+tD = true;
+am = bK;
 `, glsl `
-if (bY != instanceIndex) {
+if (bK != instanceIndex) {
 continue;
 }
 `, 'maxDistance')}
 
-if (sj) {
-si.instanceIndex = ap;
-si.materialIndex = int(ah(floatBitsToInt(bF(ap * ${INSTANCE_VEC4_STRIDE}).z)).x);
-hH(si, mk, aC, hK);
+if (tD) {
+si.instanceIndex = am;
+si.materialIndex = int(af(floatBitsToInt(fetchIns(am * ${INSTANCE_VEC4_STRIDE}).z)).x);
+hI(si, mL, aw, hL);
 mat4 l2w = mat4(
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 5),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 6),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 7),
-bF(ap * ${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(
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 1),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 2),
-bF(ap * ${INSTANCE_VEC4_STRIDE} + 3),
-bF(ap * ${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 aH = transpose(mat3(w2l));
-si.faceNormal = normalize(aH * hS);
+si.faceNormal = normalize(aH * hU);
 si.vertexNormal = normalize(aH * si.vertexNormal);
 si.normal = normalize(aH * si.normal);
 #ifdef USE_COAT_NORMAL_FRAMES
@@ -1002,35 +1018,32 @@ si.position = (l2w * vec4(si.position, 1.0)).xyz;
 }
 }
 
-bool intersectSceneShadow(in Ray ray, float lightDistance, int kn) {
+bool intersectSceneShadow(in Ray ray, float lightDistance, int kx) {
 
 if (isEmptyScene) {
 return false;
 }
 
 bool doubleSided = true;
-int eq = maxDimension(abs(ray.d));
-vec3 gY = nk(ray.d, eq);
+int ei = maxDimension(abs(ray.d));
+vec3 gZ = nV(ray.d, ei);
 
 ${getBVHTraverseCode(glsl `
 
 
-bool jS = true;
+bool kc = true;
 vec3 barycentric = hit.barycentric;
 vec3 position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
 
-if (jS) {
+if (kc) {
 #ifdef HAS_ALPHA
-int materialIndex = int(ah(floatBitsToInt(bF(bY * ${INSTANCE_VEC4_STRIDE}).z)).x);
-ivec2 i0 = hd(index.x, vertexColumns);
-ivec2 i1 = hd(index.y, vertexColumns);
-ivec2 i2 = hd(index.z, vertexColumns);
-ivec4 m0 = ivec4(texelFetch(materialIndexBuffer, i0, 0));
-ivec4 m1 = ivec4(texelFetch(materialIndexBuffer, i1, 0));
-ivec4 m2 = ivec4(texelFetch(materialIndexBuffer, i2, 0));
+int materialIndex = int(af(floatBitsToInt(fetchIns(bK * ${INSTANCE_VEC4_STRIDE}).z)).x);
+ivec4 m0 = dT(index.x);
+ivec4 m1 = dT(index.y);
+ivec4 m2 = dT(index.z);
 
 if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
-materialIndex = fF(m0, m1, m2, barycentric);
+materialIndex = fv(m0, m1, m2, barycentric);
 }
 
 int ii = materialIndex * MAT_DATA_SIZE;
@@ -1040,16 +1053,16 @@ float alpha = fetchMatData(ii + MAT_ROW_ALPHA_FILM).r;
 if (mapAlphaUsage == ${mapAlphaUsageConstants.alpha + ''}) {
 int diffuseMapIndex = int(fetchMatData(ii + MAT_ROW_METALLIC_MAPS).z);
 if (diffuseMapIndex >= 0) {
-vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
-vec2 uv1 = texelFetch(uvBuffer, i1, 0).xy;
-vec2 uv2 = texelFetch(uvBuffer, i2, 0).xy;
+vec2 uv0 = er(index.x);
+vec2 uv1 = er(index.y);
+vec2 uv2 = er(index.z);
 vec2 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
-vec4 mw = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(mw.r);
+vec4 mU = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(mU.r);
 if (uvProjection > 0) {
-uv = gU(uvProjection, position, hS, mw.zw);
+uv = gW(uvProjection, position, hU, mU.zw);
 } else {
-uv *= mw.zw;
+uv *= mU.zw;
 }
 
 alpha *= sampleMap(diffuseMapIndex, uv).a;
@@ -1059,36 +1072,36 @@ alpha *= sampleMap(diffuseMapIndex, uv).a;
 #ifdef NUM_ALPHA_MAPS
 int alphaMapIndex = int(fetchMatData(ii + MAT_ROW_STANDALONE_MAPS).z);
 if (alphaMapIndex >= 0) {
-vec2 uv0 = texelFetch(uvBuffer, i0, 0).xy;
-vec2 uv1 = texelFetch(uvBuffer, i1, 0).xy;
-vec2 uv2 = texelFetch(uvBuffer, i2, 0).xy;
+vec2 uv0 = er(index.x);
+vec2 uv1 = er(index.y);
+vec2 uv2 = er(index.z);
 vec2 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
-vec4 mw = fetchMatData(ii + MAT_ROW_UV);
-int uvProjection = int(mw.r);
+vec4 mU = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(mU.r);
 if (uvProjection > 0) {
-uv = gU(uvProjection, position, hS, mw.zw);
+uv = gW(uvProjection, position, hU, mU.zw);
 } else {
-uv *= mw.zw;
+uv *= mU.zw;
 }
 alpha *= sampleMap(alphaMapIndex, uv).g;
 }
 #endif
 float alphaCutoff = fetchMatData(ii + MAT_ROW_STANDALONE_MAPS).a;
-alpha = mb(
+alpha = mB(
 alpha, int(fetchMatData(ii + MAT_ROW_ALPHA).w), alphaCutoff
 );
-if (eC(0u) > alpha) {
+if (cm(0u) > alpha) {
 
 tMax = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
-jS = false;
+kc = false;
 }
 #endif
 }
-if (jS) {
+if (kc) {
 return true;
 }
 `, glsl `
-if (triangleIndex == kn) {
+if (triangleIndex == kx) {
 continue;
 }
 `, 'min(max(lightDistance, 0.0), RAY_MAX_DISTANCE)')}