@meimu/mutracer 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,1091 @@
+import { mapAlphaUsageConstants } from '../../materialConstants.js';
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+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++) {
+int triangleIndex = primitiveOffset + k;
+${skipTriangleCode}
+vec4 r3 = dp(triangleIndex);
+ivec3 index = floatBitsToInt(r3.xyz) + vertexOffset;
+fu tri = fu(
+kw(positionBuffer, index.x, vertexColumns).xyz,
+kw(positionBuffer, index.y, vertexColumns).xyz,
+kw(positionBuffer, index.z, vertexColumns).xyz
+);
+eB hit = fI(o, d, tri, ey, gJ, tMax);
+
+if (hit.t > 0.0) {
+tMax = hit.t;
+vec3 e1 = tri.p1 - tri.p0;
+vec3 e2 = tri.p2 - tri.p0;
+vec3 faceNormal = normalize(cross(e1, e2));
+int kb = int(ae(
+floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)
+).x);
+bool iH = fetchMatData(
+kb * MAT_DATA_SIZE + MAT_ROW_ALPHA
+).z > 0.5;
+if (!doubleSided && !iH && dot(faceNormal, d) > 0.0) {
+continue;
+}
+
+${handleHitCode}
+}
+}
+`;
+    return glsl `
+ivec2 stack[STACK_SIZE];
+int top = -1;
+int sB = -1;
+float tMax = ${initialTMax};
+
+vec3 o = ray.o;
+vec3 d = ray.d;
+
+bool qP = false;
+vec3 hy;
+vec3 aB;
+ivec3 hs;
+
+fu lm;
+
+
+top = 0;
+stack[0] = ivec2(0, -1);
+
+int wd = 0;
+while(top >= 0 && wd < 5000) {
+wd++;
+ivec2 node = stack[top--];
+
+int cf = node.y;
+
+if (cf != sB) {
+if (cf < 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)
+);
+o = (w2l * vec4(ray.o, 1.0)).xyz;
+d = (w2l * vec4(ray.d, 0.0)).xyz;
+}
+ey = maxDimension(abs(d));
+gJ = mg(d, ey);
+sB = cf;
+}
+
+int bo = cf < 0 ? 0 : blasOffset;
+uint fG = cf < 0 ? 0u : floatBitsToUint(bv(cf * ${INSTANCE_VEC4_STRIDE}).x);
+int gL = int(fG >> 30u);
+int eS = int(fG & 0x3fffffffu);
+int bh = 0;
+int primitiveOffset = 0;
+
+if (gL == 3) {
+uint hT = uint(node.x);
+if ((hT & 0x80000000u) != 0u) {
+bh = int((hT >> 23u) & 0xffu);
+primitiveOffset = bo + eS + int(hT & 0x007fffffu);
+}
+else {
+int i = node.x + bo;
+vec4 jr = dp(i);
+vec4 fC = dp(i + 1);
+vec4 mH = dp(i + 2);
+vec4 mI = dp(i + 3);
+vec4 mJ = dp(i + 4);
+uint header = floatBitsToUint(jr.w);
+int rq = int(header << 24u) >> 24;
+int rr = int((header >> 8u) << 24u) >> 24;
+int rs = int((header >> 16u) << 24u) >> 24;
+vec3 hG = vec3(
+uintBitsToFloat(uint(rq + 127) << 23u),
+uintBitsToFloat(uint(rr + 127) << 23u),
+uintBitsToFloat(uint(rs + 127) << 23u)
+);
+uint childBase = floatBitsToUint(fC.x);
+uint oE = floatBitsToUint(fC.y);
+uint internalMask = header >> 24u;
+uint uf = (d.x < 0.0 ? 4u : 0u) |
+(d.y < 0.0 ? 2u : 0u) |
+(d.z < 0.0 ? 1u : 0u);
+uint gA[12] = uint[12](
+floatBitsToUint(mH.x), floatBitsToUint(mH.y),
+floatBitsToUint(mH.z), floatBitsToUint(mH.w),
+floatBitsToUint(mI.x), floatBitsToUint(mI.y),
+floatBitsToUint(mI.z), floatBitsToUint(mI.w),
+floatBitsToUint(mJ.x), floatBitsToUint(mJ.y),
+floatBitsToUint(mJ.z), floatBitsToUint(mJ.w)
+);
+
+for (int order = 7; order >= 0; order--) {
+uint slot = uint(order) ^ uf;
+uint sn = slot >= 4u
+? floatBitsToUint(fC.w)
+: floatBitsToUint(fC.z);
+uint meta = (sn >> ((slot & 3u) * 8u)) & 0xffu;
+if (meta == 0u) continue;
+uint lL = (slot & 3u) * 8u;
+uint kJ = slot >> 2u;
+vec3 tq = vec3(
+float((gA[kJ] >> lL) & 0xffu),
+float((gA[2u + kJ] >> lL) & 0xffu),
+float((gA[4u + kJ] >> lL) & 0xffu)
+);
+vec3 tp = vec3(
+float((gA[6u + kJ] >> lL) & 0xffu),
+float((gA[8u + kJ] >> lL) & 0xffu),
+float((gA[10u + kJ] >> lL) & 0xffu)
+);
+vec3 uI = jr.xyz + tq * hG;
+vec3 uH = jr.xyz + tp * hG;
+if (cM(o, d, uI, uH, tMax) <= 0.0) continue;
+uint ju = meta & 0x1fu;
+if (ju >= 24u) {
+uint mY = internalMask & ((1u << slot) - 1u);
+uint sL = childBase + qG(mY);
+stack[++top] = ivec2(
+eS + int(sL * 5u), cf
+);
+}
+else {
+uint triangleCount = qG(meta >> 5u);
+uint rF = oE + ju;
+uint uS = 0x80000000u |
+(triangleCount << 23u) |
+(rF & 0x007fffffu);
+stack[++top] = ivec2(int(uS), cf);
+}
+}
+}
+}
+else if (gL == 2) {
+int i = node.x + bo;
+vec4 uK = dp(i);
+vec4 uL = dp(i + 1);
+vec4 uM = dp(i + 2);
+vec4 uN = dp(i + 3);
+bh = int(floatBitsToUint(uM.w));
+if (bh > 0) {
+primitiveOffset = bo + eS + int(floatBitsToUint(uN.w));
+}
+else {
+int left = eS + int(floatBitsToUint(uK.w) * 4u);
+int right = eS + int(floatBitsToUint(uL.w) * 4u);
+float d0 = cM(o, d, uK.xyz, uL.xyz, tMax);
+float d1 = cM(o, d, uM.xyz, uN.xyz, tMax);
+if (d0 > d1) {
+if (d0 > 0.0) stack[++top] = ivec2(left, cf);
+if (d1 > 0.0) stack[++top] = ivec2(right, cf);
+}
+else {
+if (d1 > 0.0) stack[++top] = ivec2(right, cf);
+if (d0 > 0.0) stack[++top] = ivec2(left, cf);
+}
+}
+}
+else if (gL == 1) {
+uint hT = uint(node.x);
+if ((hT & 0x80000000u) != 0u) {
+bh = int((hT >> 23u) & 0xffu);
+primitiveOffset = bo + eS + int(hT & 0x007fffffu);
+}
+else {
+int i = node.x + bo;
+vec4 tV = dp(i);
+vec4 ra = dp(i + 1);
+vec4 rb = dp(i + 2);
+vec4 rc = dp(i + 3);
+vec3 nodeMin = tV.xyz;
+vec3 ec = vec3(tV.w, ra.x, ra.y);
+uint lS[4] = uint[4](
+floatBitsToUint(ra.z), floatBitsToUint(ra.w),
+floatBitsToUint(rb.x), floatBitsToUint(rb.y)
+);
+vec4 rj = eY(floatBitsToUint(rb.z));
+vec4 rk = eY(floatBitsToUint(rb.w));
+vec4 rl = eY(floatBitsToUint(rc.x));
+vec4 rf = eY(floatBitsToUint(rc.y));
+vec4 rh = eY(floatBitsToUint(rc.z));
+vec4 ri = eY(floatBitsToUint(rc.w));
+vec3 gv = eX(d);
+vec3 bJ = eV(gv, o);
+vec4 tx0 = (nodeMin.x + rj * ec.x - o.x) * gv.x;
+vec4 tx1 = (nodeMin.x + rf * ec.x - o.x) * gv.x;
+vec4 ty0 = (nodeMin.y + rk * ec.y - o.y) * gv.y;
+vec4 ty1 = (nodeMin.y + rh * ec.y - o.y) * gv.y;
+vec4 tz0 = (nodeMin.z + rl * ec.z - o.z) * gv.z;
+vec4 tz1 = (nodeMin.z + ri * ec.z - o.z) * gv.z;
+vec4 my = max(max((min(tx0, tx1) - vec4(bJ.x)), (min(ty0, ty1) - vec4(bJ.y))), (min(tz0, tz1) - vec4(bJ.z)));
+vec4 rH = min(min((max(tx0, tx1) + vec4(bJ.x)), (max(ty0, ty1) + vec4(bJ.y))), (max(tz0, tz1) + vec4(bJ.z)));
+vec4 distance = mix(rH, my, greaterThan(my, vec4(0.0)));
+distance = mix(distance, vec4(-1.0), greaterThan(my, min(rH, vec4(tMax))));
+float fa[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 (lS[child] != 0u && fa[child] > dX) {
+dX = fa[child];
+el = child;
+}
+}
+if (el >= 0 && dX > 0.0) {
+uint ni = lS[el];
+int jB = int(ni);
+if ((ni & 0x80000000u) == 0u) {
+jB += eS;
+}
+stack[++top] = ivec2(jB, cf);
+fa[el] = -1.0;
+}
+}
+}
+}
+else {
+int i = node.x + bo;
+vec4 r1 = dp(i);
+int bb = floatBitsToInt(r1.w);
+
+if (bb >= 0) {
+int left = node.x + 2;
+int right = bb + eS;
+
+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);
+if (d0 > d1) {
+if (d0 > 0.0) {
+stack[++top] = ivec2(left, cf);
+}
+if (d1 > 0.0) {
+stack[++top] = ivec2(right, cf);
+}
+}
+else {
+if (d1 > 0.0) {
+stack[++top] = ivec2(right, cf);
+}
+if (d0 > 0.0) {
+stack[++top] = ivec2(left, cf);
+}
+}
+}
+else {
+if (cf < 0) {
+for (int k = 0; k < -bb; k++) {
+vec4 r3 = dp(i + 2 + k);
+stack[++top] = ivec2(floatBitsToInt(r3.y), floatBitsToInt(r3.x));
+}
+}
+else {
+bh = -bb;
+primitiveOffset = i + 2;
+}
+}
+}
+if (bh > 0) {
+${intersectTriangles}
+}
+}
+`;
+}
+export default createShaderMixin({
+    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'),
+        bvhBuffer: Shader.uniform('sampler2D'),
+        instancesBuffer: Shader.uniform('sampler2D'),
+        bvhColumns: Shader.uniform('int', 1),
+        vertexColumns: Shader.uniform('int', 1),
+        instancesColumns: Shader.uniform('int', 1),
+        blasOffset: Shader.uniform('int'),
+        isEmptyScene: Shader.uniform('bool')
+    },
+    main: glsl `
+
+struct fu {
+vec3 p0;
+vec3 p1;
+vec3 p2;
+};
+#ifdef NUM_LIGHTS
+float ht(float rad, vec3 pos, Ray r) {
+vec3 op = pos - r.o;
+float eps = 0.001;
+float b = dot(op, r.d);
+float det = b * b - dot(op, op) + rad * rad;
+if (det < 0.0)
+return INF;
+
+det = sqrt(det);
+float t1 = b - det;
+if (t1 > eps)
+return t1;
+
+float t2 = b + det;
+if (t2 > eps)
+return t2;
+
+return INF;
+}
+
+float mR(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;
+
+if (t > EPS) {
+vec3 p = r.o + r.d * t;
+vec3 vi = p - pos;
+float a1 = dot(u / dot(u, u), vi);
+if (a1 >= 0.0 && a1 <= 1.0) {
+float a2 = dot(v / dot(v, v), vi);
+if (a2 >= 0.0 && a2 <= 1.0) {
+return t;
+}
+}
+}
+
+return INF;
+}
+
+float mk(Ray r, Light light, out LightSampleRec lightSample) {
+
+
+
+float d = INF;
+vec3 u = light.u;
+vec3 v = light.v;
+int type = int(light.type);
+
+#ifdef HAS_RECT_LIGHTS
+if (type == RECT_LIGHT) {
+
+vec3 pos = light.position-u*0.5-v*0.5;
+vec3 normal = normalize(cross(u, v));
+if (dot(normal, r.d) > 0.) 
+return INF;
+
+d = mR(pos, u, v, normal, r);
+if (d < 0.) {
+d = INF;
+}
+else {
+float cc = dot(-r.d, normal);
+float spread = light.spread;
+if (cc >= cos(spread * PI / 2.0)) {
+lightSample.pdf = (d * d) / (light.area * cc);
+lightSample.emission = light.emission;
+}
+}
+}
+#endif
+#ifdef HAS_SPHERE_LIGHTS
+if (type == SPHERE_LIGHT) {
+if (light.radius <= 0.0) {
+vec3 kf = light.position - r.o;
+float projection = dot(kf, r.d);
+vec3 ba = kf - projection * r.d;
+if (projection <= EPS || dot(ba, ba) > 1e-8) return INF;
+d = projection;
+lightSample.direction = r.d;
+lightSample.normal = -r.d;
+lightSample.dist = d;
+lightSample.pdf = 1.0;
+lightSample.isDelta = true;
+} else {
+d = ht(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.emission = light.radius <= 0.0
+? light.emission / max(d * d, 1e-8)
+: light.emission;
+}
+}
+#endif
+#ifdef HAS_SPOT_LIGHTS
+if (type == SPOT_LIGHT) {
+if (light.radius <= 0.0) {
+vec3 kf = light.position - r.o;
+float projection = dot(kf, r.d);
+vec3 ba = kf - projection * r.d;
+if (projection <= EPS || dot(ba, ba) > 1e-8) return INF;
+d = projection;
+lightSample.direction = r.d;
+lightSample.normal = -r.d;
+lightSample.dist = d;
+lightSample.pdf = 1.0;
+lightSample.isDelta = true;
+} else {
+d = ht(light.radius, light.position, r);
+lightSample.isDelta = false;
+}
+if (d != INF) {
+vec3 uQ = r.o + d * r.d;
+float mo = bL(light, normalize(r.o - uQ));
+if (mo <= 0.0) return INF;
+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.emission = light.emission * mo * (light.radius <= 0.0
+? 1.0 / max(d * d, 1e-8)
+: 1.0);
+}
+}
+#endif
+
+return d;
+}
+#endif
+
+int fj(ivec4 m0, ivec4 m1, ivec4 m2, vec3 eZ) {
+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 * 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 he = w00 + w01 + w02 + w10 + w11 + w12 + w20 + w21 + w22;
+
+w00 = w00 / he;
+w01 = w01 / he + w00;
+w02 = w02 / he + w01;
+w10 = w10 / he + w02;
+w11 = w11 / he + w10;
+w12 = w12 / he + w11;
+w20 = w20 / he + w12;
+w21 = w21 / he + w20;
+w22 = w22 / he + w21;
+
+float rand = eo(0u);
+float mS;
+if (rand < w00) {
+mS = m00.x;
+} else if (rand < w01) {
+mS = m01.x;
+} else if (rand < w02) {
+mS = m02.x;
+} else if (rand < w10) {
+mS = m10.x;
+} else if (rand < w11) {
+mS = m11.x;
+} else if (rand < w12) {
+mS = m12.x;
+} else if (rand < w20) {
+mS = m20.x;
+} else if (rand < w21) {
+mS = m21.x;
+} else {
+mS = m22.x;
+}
+return int(mS);
+}
+
+
+vec4 bv(int i);
+
+
+mat2x3 eD(vec3 normal, vec3 dp1, vec3 dp2, vec2 nP, vec2 nQ, vec4 aU) {
+float determinant = nP.x * nQ.y - nP.y * nQ.x;
+vec3 t = aU.xyz;
+vec3 b = vec3(0.0);
+
+float qq = abs(aU.w) > 1.5 ? 0.0 : aU.w;
+if (abs(determinant) > 1e-12) {
+vec3 dt = (dp1 * nQ.y - dp2 * nP.y) / determinant;
+vec3 db = (dp2 * nP.x - dp1 * nQ.x) / determinant;
+if (dot(t, t) < 1e-8) { t = dt; }
+if (qq == 0.0) { qq = (dot(cross(normal, dt), db) < 0.0 ? -1.0 : 1.0); }
+}
+t -= normal * dot(normal, t);
+if (dot(t, t) < 1e-8) {
+float ig = (normal.z >= 0.0 ? 1.0 : -1.0);
+float dW = -1.0 / (ig + normal.z);
+float xy = normal.x * normal.y * dW;
+t = vec3(1.0 + ig * normal.x * normal.x * dW, ig * xy, -ig * normal.x);
+b = vec3(xy, ig + normal.y * normal.y * dW, -normal.y);
+}
+else { t = normalize(t); b = normalize(cross(normal, t)); }
+return mat2x3(t, b * (qq < 0.0 ? -1.0 : 1.0));
+}
+
+void hp(inout ad si, fu tri, vec3 barycentric, ivec3 index) {
+si.hit = true;
+si.position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
+ivec2 i0 = gK(index.x, vertexColumns);
+ivec2 i1 = gK(index.y, vertexColumns);
+ivec2 i2 = gK(index.z, vertexColumns);
+
+vec3 n0 = texelFetch(normalBuffer, i0, 0).xyz;
+vec3 n1 = texelFetch(normalBuffer, i1, 0).xyz;
+vec3 n2 = texelFetch(normalBuffer, i2, 0).xyz;
+vec3 normal = normalize(barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2);
+si.vertexNormal = normal;
+
+
+
+
+
+vec3 geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
+vec3 kd = barycentric.x * n0 + barycentric.y * n1 + barycentric.z * n2;
+float a = dot(n2 - n0, tri.p0 - tri.p2);
+float b = dot(n2 - n1, tri.p1 - tri.p2);
+float c = dot(n1 - n0, tri.p1 - tri.p0);
+float h = a * barycentric.x * (barycentric.x - 1.0)
++ (a + b + c) * barycentric.x * barycentric.y
++ b * barycentric.y * (barycentric.y - 1.0);
+if (dot(kd, geometricNormal) > 0.0) {
+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);
+h0 = max(dot(tri.p0 - si.position, n0) + h0, 0.0);
+h1 = max(dot(tri.p1 - si.position, n1) + h1, 0.0);
+h2 = max(dot(tri.p2 - si.position, n2) + h2, 0.0);
+h = max(min(min(h0, h1), h2), h * 0.5);
+}
+else {
+float h0 = max(max(dot(tri.p0 - tri.p1, n0), dot(tri.p0 - tri.p2, n0)), 0.0);
+float h1 = max(max(dot(tri.p1 - tri.p0, n1), dot(tri.p1 - tri.p2, n1)), 0.0);
+float h2 = max(max(dot(tri.p2 - tri.p0, n2), dot(tri.p2 - tri.p1, n2)), 0.0);
+h0 = max(dot(si.position - tri.p0, n0) + h0, 0.0);
+h1 = max(dot(si.position - tri.p1, n1) + h1, 0.0);
+h2 = max(dot(si.position - tri.p2, n2) + h2, 0.0);
+h = min(-min(min(h0, h1), h2), h * 0.5);
+}
+si.shadowOffset = kd * h;
+
+
+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) {
+si.materialIndex = fj(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;
+#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 cX = barycentric.x * secondaryUv0
++ barycentric.y * secondaryUv1
++ barycentric.z * secondaryUv2;
+
+vec4 lw = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_UV);
+int uvProjection = int(lw.r);
+if (uvProjection > 0) {
+uv = gz(uvProjection, si.position, normal, lw.zw);
+cX = uv;
+} else {
+uv *= lw.zw;
+cX *= lw.zw;
+}
+#else
+vec2 uv = vec2(0.0);
+vec2 cX = vec2(0.0);
+#endif
+
+#ifdef NUM_COAT_NORMAL_MAPS
+si.coatNormal = normal;
+float lj = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_LAYER_MAPS).z;
+#endif
+vec4 directionMaterial = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_DIRECTION_NORMAL);
+float sZ = fetchMatData(si.materialIndex * MAT_DATA_SIZE + MAT_ROW_FILM_TEXTURE).x;
+if (directionMaterial.x >= 0.0 || directionMaterial.y != 0.0 || sZ != 0.0
+#ifdef NUM_COAT_NORMAL_MAPS
+|| lj >= 0.0
+#endif
+) {
+vec3 dp1 = tri.p0 - tri.p2;
+vec3 dp2 = tri.p1 - tri.p2;
+vec4 aU = vec4(0.0);
+#ifdef USE_TANGENT
+aU = 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;
+#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));
+}
+#endif
+si.directionTangent = fU[0];
+si.directionBitangent = fU[1];
+#ifdef NUM_COAT_NORMAL_MAPS
+if (lj >= 0.0) {
+int kq = int(lj);
+mat2x3 lT = eP;
+if (mapUvChannel[kq] > 0.5) {
+vec2 a = texelFetch(uv1Buffer, i0, 0).xy;
+vec2 b = texelFetch(uv1Buffer, i1, 0).xy;
+vec2 c = texelFetch(uv1Buffer, i2, 0).xy;
+lT = eD(normal, dp1, dp2, a-c, b-c,
+aU.w == 0.0 ? vec4(0.0) : aU);
+}
+vec3 decoded = sampleMap(kq, getMapUvSet(kq, uv, cX)).rgb * 2.0 - 1.0;
+vec3 mapped = lT[0] * decoded.x * directionMaterial.z
++ lT[1] * decoded.y * directionMaterial.w + normal * decoded.z;
+if (dot(mapped, mapped) > 1e-12) { si.coatNormal = normalize(mapped); }
+}
+#endif
+}
+
+si.uv = uv;
+si.uv1 = cX;
+
+#ifdef USE_TANGENT
+vec3 t0 = texelFetch(tangentBuffer, i0, 0).xyz;
+vec3 t1 = texelFetch(tangentBuffer, i1, 0).xyz;
+vec3 t2 = texelFetch(tangentBuffer, i2, 0).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 nP = uv0 - uv2;
+vec2 nQ = uv1 - uv2;
+si.normal = nY(
+si.materialIndex, uv, normal, dp1, dp2, nP, nQ
+);
+#else
+si.normal = normal;
+#endif
+}
+
+struct eB {
+float t;
+vec3 barycentric;
+};
+
+vec4 dp(int i) {
+return kw(bvhBuffer, i, bvhColumns);
+}
+
+vec4 bv(int i) {
+return kw(instancesBuffer, i, instancesColumns);
+}
+
+
+
+uint qG(uint value) {
+value -= (value >> 1u) & 0x55555555u;
+value = (value & 0x33333333u) + ((value >> 2u) & 0x33333333u);
+value = (value + (value >> 4u)) & 0x0f0f0f0fu;
+return (value * 0x01010101u) >> 24u;
+}
+
+vec4 eY(uint lI) {
+return vec4(
+float(lI & 0xffu),
+float((lI >> 8u) & 0xffu),
+float((lI >> 16u) & 0xffu),
+float(lI >> 24u)
+) / 255.0;
+}
+
+
+
+
+eB fI(vec3 o, vec3 d, fu tri, int ey, vec3 gJ, float tMax) {
+eB ti;
+
+
+vec3 p0t = tri.p0 - o;
+vec3 p1t = tri.p1 - o;
+vec3 p2t = tri.p2 - o;
+
+
+if (ey == 0) {
+p0t = p0t.yzx;
+p1t = p1t.yzx;
+p2t = p2t.yzx;
+} else if (ey == 1) {
+p0t = p0t.zxy;
+p1t = p1t.zxy;
+p2t = p2t.zxy;
+}
+
+
+p0t.xy += gJ.xy * p0t.z;
+p1t.xy += gJ.xy * p1t.z;
+p2t.xy += gJ.xy * p2t.z;
+
+
+vec3 e = vec3(
+p1t.x * p2t.y - p1t.y * p2t.x,
+p2t.x * p0t.y - p2t.y * p0t.x,
+p0t.x * p1t.y - p0t.y * p1t.x
+);
+
+#ifdef DEPTH_QUERY_MODE
+vec3 ro = abs(vec3(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
++ abs(vec3(p1t.y * p2t.x, p2t.y * p0t.x, p0t.y * p1t.x));
+e = mix(e, vec3(0.0), lessThanEqual(abs(e), ro * 1e-6));
+#endif
+
+
+if (any(lessThan(e, vec3(0))) && any(greaterThan(e, vec3(0)))) {
+return ti;
+}
+
+float det = e.x + e.y + e.z;
+#ifdef DEPTH_QUERY_MODE
+if (det == 0.0) return ti;
+#endif
+
+p0t.z *= gJ.z;
+p1t.z *= gJ.z;
+p2t.z *= gJ.z;
+float qZ = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+
+
+if (abs(qZ) > abs(tMax * det)) {
+return ti;
+}
+
+float sg = 1. / det;
+ti.t = qZ * sg;
+ti.barycentric = e * sg;
+
+return ti;
+}
+
+struct Box {
+vec3 min;
+vec3 max;
+};
+
+
+vec3 eX(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;
+#else
+return 1.0 / d;
+#endif
+}
+
+vec3 eV(vec3 gv, vec3 o) {
+#ifdef DEPTH_QUERY_MODE
+return abs(gv) * max(vec3(1.0), abs(o)) * 1e-6;
+#else
+return vec3(0.0);
+#endif
+}
+
+
+
+float cM(vec3 o, vec3 d, vec3 vw, vec3 vu, float tMax) {
+#ifdef DEPTH_QUERY_MODE
+vec3 gv = eX(d);
+vec3 uD = (vw - o) * gv;
+vec3 uE = (vu - o) * gv;
+vec3 bJ = eV(gv, o);
+#else
+vec3 uD = (vw - o) / d;
+vec3 uE = (vu - o) / d;
+vec3 bJ = vec3(0.0);
+#endif
+vec3 my = min(uD, uE) - bJ;
+vec3 rH = max(uD, uE) + bJ;
+float t0 = max(my.x, max(my.y, my.z));
+float t1 = min(rH.x, min(rH.y, rH.z));
+
+return (t0 > t1 || t0 > tMax) ? -1.0 : (t0 > 0.0 ? t0 : t1);
+}
+
+int maxDimension(vec3 v) {
+return v.x > v.y ? (v.x > v.z ? 0 : 2) : (v.y > v.z ? 1 : 2);
+}
+
+vec3 mg(vec3 d, int ey) {
+
+
+if (ey == 0) {
+return vec3(-d.y, -d.z, 1.0) / d.x;
+} else if (ey == 1) {
+return vec3(-d.z, -d.x, 1.0) / d.y;
+} else {
+return vec3(-d.x, -d.y, 1.0) / d.z;
+}
+}
+
+
+void cY(in Ray ray, inout ad si, bool doubleSided) {
+si.hit = false;
+
+if (isEmptyScene) {
+return;
+}
+
+int ey = maxDimension(abs(ray.d));
+vec3 gJ = mg(ray.d, ey);
+int ao;
+
+${getBVHTraverseCode(glsl `
+si.triangleIndex = triangleIndex;
+lm = tri;
+hy = faceNormal;
+aB = hit.barycentric;
+hs = index;
+qP = true;
+ao = cf;
+`)}
+
+if (qP) {
+si.instanceIndex = ao;
+si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
+
+hp(si, lm, aB, hs);
+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)
+);
+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)
+);
+mat3 aD = transpose(mat3(w2l));
+si.faceNormal = normalize(aD * hy);
+si.vertexNormal = normalize(aD * si.vertexNormal);
+si.normal = normalize(aD * si.normal);
+#ifdef NUM_COAT_NORMAL_MAPS
+si.coatNormal = normalize(aD * si.coatNormal);
+#endif
+#ifdef USE_TANGENT
+if (dot(si.tangent, si.tangent) > 0.0) {
+si.tangent = normalize(mat3(l2w) * si.tangent);
+}
+#endif
+si.shadowOffset = (l2w * vec4(si.shadowOffset, 0.0)).xyz;
+si.directionTangent = mat3(l2w) * si.directionTangent;
+si.directionBitangent = mat3(l2w) * si.directionBitangent;
+si.geometryTangent = mat3(l2w) * si.geometryTangent;
+si.geometryBitangent = mat3(l2w) * si.geometryBitangent;
+si.position = (l2w * vec4(si.position, 1.0)).xyz;
+}
+}
+
+
+void iG(in Ray ray, inout ad si, int instanceIndex, float maxDistance) {
+si.hit = false;
+
+if (isEmptyScene) {
+return;
+}
+
+bool doubleSided = true;
+int ey = maxDimension(abs(ray.d));
+vec3 gJ = mg(ray.d, ey);
+int ao;
+
+${getBVHTraverseCode(glsl `
+si.triangleIndex = triangleIndex;
+lm = tri;
+hy = faceNormal;
+aB = hit.barycentric;
+hs = index;
+qP = true;
+ao = cf;
+`, glsl `
+if (cf != instanceIndex) {
+continue;
+}
+`, 'maxDistance')}
+
+if (qP) {
+si.instanceIndex = ao;
+si.materialIndex = int(ae(floatBitsToInt(bv(ao * ${INSTANCE_VEC4_STRIDE}).z)).x);
+hp(si, lm, aB, hs);
+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)
+);
+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)
+);
+mat3 aD = transpose(mat3(w2l));
+si.faceNormal = normalize(aD * hy);
+si.vertexNormal = normalize(aD * si.vertexNormal);
+si.normal = normalize(aD * si.normal);
+#ifdef NUM_COAT_NORMAL_MAPS
+si.coatNormal = normalize(aD * si.coatNormal);
+#endif
+#ifdef USE_TANGENT
+if (dot(si.tangent, si.tangent) > 0.0) {
+si.tangent = normalize(mat3(l2w) * si.tangent);
+}
+#endif
+si.shadowOffset = (l2w * vec4(si.shadowOffset, 0.0)).xyz;
+si.directionTangent = mat3(l2w) * si.directionTangent;
+si.directionBitangent = mat3(l2w) * si.directionBitangent;
+si.geometryTangent = mat3(l2w) * si.geometryTangent;
+si.geometryBitangent = mat3(l2w) * si.geometryBitangent;
+si.position = (l2w * vec4(si.position, 1.0)).xyz;
+}
+}
+
+bool ex(in Ray ray, float lightDistance, int jE) {
+
+if (isEmptyScene) {
+return false;
+}
+
+bool doubleSided = true;
+int ey = maxDimension(abs(ray.d));
+vec3 gJ = mg(ray.d, ey);
+
+${getBVHTraverseCode(glsl `
+
+
+bool jl = true;
+vec3 barycentric = hit.barycentric;
+vec3 position = barycentric.x * tri.p0 + barycentric.y * tri.p1 + barycentric.z * tri.p2;
+
+if (jl) {
+#ifdef HAS_ALPHA
+int materialIndex = int(ae(floatBitsToInt(bv(cf * ${INSTANCE_VEC4_STRIDE}).z)).x);
+ivec2 i0 = gK(index.x, vertexColumns);
+ivec2 i1 = gK(index.y, vertexColumns);
+ivec2 i2 = gK(index.z, vertexColumns);
+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);
+}
+
+int ii = materialIndex * MAT_DATA_SIZE;
+int mapAlphaUsage = int(fetchMatData(ii + MAT_ROW_MISC).a);
+float alpha = fetchMatData(ii + MAT_ROW_ALPHA_FILM).r;
+#ifdef NUM_DIFFUSE_MAPS
+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 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
+vec4 lw = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(lw.r);
+if (uvProjection > 0) {
+uv = gz(uvProjection, position, hy, lw.zw);
+} else {
+uv *= lw.zw;
+}
+
+alpha *= sampleMap(diffuseMapIndex, uv).a;
+}
+}
+#endif
+#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 uv = barycentric.x * uv0 + barycentric.y * uv1 + barycentric.z * uv2;
+vec4 lw = fetchMatData(ii + MAT_ROW_UV);
+int uvProjection = int(lw.r);
+if (uvProjection > 0) {
+uv = gz(uvProjection, position, hy, lw.zw);
+} else {
+uv *= lw.zw;
+}
+alpha *= sampleMap(alphaMapIndex, uv).g;
+}
+#endif
+float alphaCutoff = fetchMatData(ii + MAT_ROW_STANDALONE_MAPS).a;
+alpha = ld(
+alpha, int(fetchMatData(ii + MAT_ROW_ALPHA).w), alphaCutoff
+);
+if (eo(0u) > alpha) {
+
+tMax = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
+jl = false;
+}
+#endif
+}
+if (jl) {
+return true;
+}
+`, glsl `
+if (triangleIndex == jE) {
+continue;
+}
+`, 'min(max(lightDistance, 0.0), RAY_MAX_DISTANCE)')}
+return false;
+}
+`
+});
+//# sourceMappingURL=intersect.glsl.js.map