@meimu/mutracer 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,1441 @@
+// 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 { uvProjectionConstants } from '../../MaterialTable.js';
+import { INSTANCE_VEC4_STRIDE } from '../../bvhAccel.js';
+import pdm_displacementWgsl from './pdm_displacement.wgsl.js';
+import { createIntersectionAlphaWgsl } from './intersectionAlpha.wgsl.js';
+const displacementWgsl = pdm_displacementWgsl;
+const flatIntersectCode = function () {
+    return /* wgsl */ `
+let hit = fI(o, d, tri, ey, gJ, tMax);
+if (hit.t > 0.0) {
+let e1 = tri.p1 - tri.p0;
+let e2 = tri.p2 - tri.p0;
+eC = normalize(cross(e1, e2));
+let kb = i32(ae(bitcast<i32>(od.z)).x);
+let iH = materialsBuffer[kb].doubleSided > 0.5;
+if (!doubleSided && !iH && dot(eC, d) > 0.0) {
+eC = vec3f(0.0);
+continue;
+}
+
+tMax = hit.t;
+qP = true;
+oh = true;
+eU = o + tMax * d;
+aB = hit.barycentric;
+}
+`;
+};
+function getPDMDisplacmentCode(anyHit) {
+    return /*wgsl */ `
+let kL = oP(
+o, d, tMax,
+tri.p0, tri.p1, tri.p2,
+n0, n1, n2,
+uv0, uv1, uv2,
+displacementMapIndex,
+nX(displacementMapIndex),
+minH, maxH,
+hScale,
+matData.displacementStepSize,
+i32(matData.displacementUvProjection),
+displacementUvProjectionScale,
+${anyHit ? 'true' : 'false'},
+ln
+);
+`;
+}
+const displacementIntersectCode = function (anyHit, hasAnisotropyDirections) {
+    return /* wgsl */ `
+
+let hScale = od.w;
+let th = bitcast<i32>(r3.w);
+if (abs(hScale) > 0.0 && th > 0) {
+
+let n0 = normalize(attrBuffers[index.x * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+let n1 = normalize(attrBuffers[index.y * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+let n2 = normalize(attrBuffers[index.z * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+
+let minH = f32(th >> 8) / 255.0;
+let maxH = f32(th & 0xff) / 255.0;
+
+let pA = tri.p0 + n0 * hScale * minH;
+let pB = tri.p1 + n1 * hScale * minH;
+let pC = tri.p2 + n2 * hScale * minH;
+let pD = tri.p0 + n0 * hScale * maxH;
+let pE = tri.p1 + n1 * hScale * maxH;
+let pF = tri.p2 + n2 * hScale * maxH;
+
+let materialIndex = i32(ae(bitcast<i32>(od.z)).x);
+let matData = materialsBuffer[materialIndex];
+let displacementUvProjectionScale = vec2f(matData.displacementUvProjectionScale);
+let displacementMapIndex = i32(matData.displacementMapIndex);
+
+
+var uv0 = attrBuffers[index.x * ATTR_STRIDE + UV_OFF].xy;
+var uv1 = attrBuffers[index.y * ATTR_STRIDE + UV_OFF].xy;
+var uv2 = attrBuffers[index.z * ATTR_STRIDE + UV_OFF].xy;
+
+${getPDMDisplacmentCode(anyHit)}
+
+if (kL.t < tMax) {
+eC = kL.normal;
+
+
+tMax = kL.t;
+
+aB = kL.barycentric;
+eU = o + tMax * d;
+
+bU = true;
+qP = true;
+oh = true;
+}
+}
+else {
+${flatIntersectCode()}
+}
+`;
+};
+const cwbvhTraversalWgsl = /* wgsl */ `
+fn bp(value: u32) -> vec4f {
+return vec4f(
+f32(value & 0xffu),
+f32((value >> 8u) & 0xffu),
+f32((value >> 16u) & 0xffu),
+f32(value >> 24u)
+);
+}
+
+
+
+
+
+
+
+fn kl(value: u32) -> u32 {
+return (bitcast<u32>(f32(value)) >> 23u) - 127u;
+}
+
+fn nL(value: u32) -> u32 {
+return (bitcast<u32>(f32(value)) >> 23u) - 127u;
+}
+
+fn oe(
+node: i32,
+sX: i32,
+n0: vec4f,
+o: vec3f,
+gv: vec3f,
+tMax: f32
+) -> u32 {
+let i = node + sX;
+let n2 = bvhBuffer[i + 2];
+let n3 = bvhBuffer[i + 3];
+let n4 = bvhBuffer[i + 4];
+let header = bitcast<u32>(n0.w);
+let rq = bitcast<i32>((header & 0xffu) << 24u) >> 24;
+let rr = bitcast<i32>(((header >> 8u) & 0xffu) << 24u) >> 24;
+let rs = bitcast<i32>(((header >> 16u) & 0xffu) << 24u) >> 24;
+let hG = vec3f(
+bitcast<f32>(u32(rq + 127) << 23u),
+bitcast<f32>(u32(rr + 127) << 23u),
+bitcast<f32>(u32(rs + 127) << 23u)
+);
+let bJ = eV(gv, o);
+let eH = (n0.xyz - o) * gv;
+let da = hG * gv;
+let wl = bp(bitcast<u32>(n2.x));
+let wm = bp(bitcast<u32>(n2.y));
+let wn = bp(bitcast<u32>(n2.z));
+let wo = bp(bitcast<u32>(n2.w));
+let wp = bp(bitcast<u32>(n3.x));
+let wq = bp(bitcast<u32>(n3.y));
+let wf = bp(bitcast<u32>(n3.z));
+let wg = bp(bitcast<u32>(n3.w));
+let wh = bp(bitcast<u32>(n4.x));
+let wi = bp(bitcast<u32>(n4.y));
+let wj = bp(bitcast<u32>(n4.z));
+let wk = bp(bitcast<u32>(n4.w));
+
+let uZ = wl * da.x + eH.x;
+let vb = wn * da.y + eH.y;
+let vd = wp * da.z + eH.z;
+let uT = wf * da.x + eH.x;
+let uV = wh * da.y + eH.y;
+let uX = wj * da.z + eH.z;
+let wr = max(
+max((min(uZ, uT) - vec4f(bJ.x)), (min(vb, uV) - vec4f(bJ.y))),
+(min(vd, uX) - vec4f(bJ.z))
+);
+let vZ = min(
+min((max(uZ, uT) + vec4f(bJ.x)), (max(vb, uV) + vec4f(bJ.y))),
+(max(vd, uX) + vec4f(bJ.z))
+);
+
+let va = wm * da.x + eH.x;
+let vc = wo * da.y + eH.y;
+let ve = wq * da.z + eH.z;
+let uU = wg * da.x + eH.x;
+let uW = wi * da.y + eH.y;
+let uY = wk * da.z + eH.z;
+let ws = max(
+max((min(va, uU) - vec4f(bJ.x)), (min(vc, uW) - vec4f(bJ.y))),
+(min(ve, uY) - vec4f(bJ.z))
+);
+let wa = min(
+min((max(va, uU) + vec4f(bJ.x)), (max(vc, uW) + vec4f(bJ.y))),
+(max(ve, uY) + vec4f(bJ.z))
+);
+
+let uw = (wr <= min(vZ, vec4f(tMax))) & (vZ > vec4f(0.0));
+let ux = (ws <= min(wa, vec4f(tMax))) & (wa > vec4f(0.0));
+return select(0u, 1u, uw.x)
+| select(0u, 2u, uw.y)
+| select(0u, 4u, uw.z)
+| select(0u, 8u, uw.w)
+| select(0u, 16u, ux.x)
+| select(0u, 32u, ux.y)
+| select(0u, 64u, ux.z)
+| select(0u, 128u, ux.w);
+}
+
+`;
+function getBVHTraverseCode(handleHitCode, hasDisplacement, anyHit, blasLayoutMask, hasAnisotropyDirections, skipTriangleCode = '') {
+    const intersectTriangles = /* wgsl */ `
+let od = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
+let vertexOffset = vec3i(bitcast<i32>(od.y));
+for (var k = 0; k < bh; k++) {
+let triangleIndex = primitiveOffset + k;
+${skipTriangleCode}
+if (bounces > 0 && triangleIndex == hL) {
+continue;
+}
+
+let r3 = bvhBuffer[triangleIndex];
+let index = bitcast<vec3i>(r3.xyz) + vertexOffset;
+var tri = fu(
+attrBuffers[index.x * ATTR_STRIDE + POSITION_OFF]${hasAnisotropyDirections ? '.xyz' : ''},
+attrBuffers[index.y * ATTR_STRIDE + POSITION_OFF]${hasAnisotropyDirections ? '.xyz' : ''},
+attrBuffers[index.z * ATTR_STRIDE + POSITION_OFF]${hasAnisotropyDirections ? '.xyz' : ''}
+);
+var oh = false;
+
+${hasDisplacement
+        ? displacementIntersectCode(anyHit, hasAnisotropyDirections)
+        : flatIntersectCode()}
+if (oh) {
+${handleHitCode}
+}
+}
+`;
+    return /* wgsl */ `
+var d = ray.d;
+var o = ray.o;
+var lN: array<i32, TLAS_STACK_SIZE>;
+var jb = -1;
+var gv = eX(d);
+var bU = false;
+var qP = false;
+var eU: vec3f;
+var eC: vec3f;
+var aB: vec3f;
+
+
+if (cM(o, bvhBuffer[0].xyz, bvhBuffer[1].xyz, gv, tMax) > 0.0) {
+jb = 0;
+lN[0] = 0;
+}
+while (jb >= 0) {
+let sI = lN[jb];
+jb--;
+o = ray.o;
+d = ray.d;
+gv = eX(d);
+
+let vR = bvhBuffer[sI];
+let eR = bitcast<i32>(vR.w);
+if (eR >= 0) {
+let left = sI + 2;
+let right = eR;
+let d0 = cM(
+o,
+bvhBuffer[left].xyz,
+bvhBuffer[left + 1].xyz,
+gv,
+tMax
+);
+let d1 = cM(
+o,
+bvhBuffer[right].xyz,
+bvhBuffer[right + 1].xyz,
+gv,
+tMax
+);
+
+if (d0 > d1) {
+if (d0 > 0.0) { jb++; lN[jb] = left; }
+if (d1 > 0.0) { jb++; lN[jb] = right; }
+}
+else {
+if (d1 > 0.0) { jb++; lN[jb] = right; }
+if (d0 > 0.0) { jb++; lN[jb] = left; }
+}
+}
+else {
+let qx = -eR;
+
+
+for (
+var mi = qx - 1;
+mi >= 0;
+mi--
+) {
+let pm = bvhBuffer[sI + 2 + mi];
+let cf = bitcast<i32>(pm.x);
+let uG = bitcast<i32>(pm.y);
+let od = instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE}];
+let w2l = mat4x4<f32>(
+instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 1],
+instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 2],
+instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 3],
+instancesBuffer[cf * ${INSTANCE_VEC4_STRIDE} + 4]
+);
+o = (w2l * vec4f(ray.o, 1.0)).xyz;
+d = (w2l * vec4f(ray.d, 0.0)).xyz;
+gv = eX(d);
+ey = maxDimension(abs(d));
+gJ = mg(d, ey);
+
+let fG = bitcast<u32>(od.x);
+let gL = fG >> 30u;
+let blasOffset = i32(fG & 0x3fffffffu);
+let bo = rtUniform.blasOffset;
+
+${(blasLayoutMask & 8) !== 0 ? /* wgsl */ `
+if (gL == 3u) {
+
+
+
+
+var rY: array<vec2u, BLAS_STACK_SIZE>;
+var pa = -1;
+var rK = 0u;
+var kN = 0u;
+
+var ep = 0x80000000u;
+let uf = select(0u, 4u, d.x < 0.0)
+| select(0u, 2u, d.y < 0.0)
+| select(0u, 1u, d.z < 0.0);
+let pZ = 7u - uf;
+
+
+
+
+while (rK < 4096u) {
+rK++;
+
+let internalMask = ep & 0xffu;
+let pV =
+kl(ep >> 24u) + 24u;
+ep &= ~(1u << pV);
+if ((ep & 0xff000000u) != 0u) {
+pa++;
+
+rY[pa] = vec2u(kN, ep);
+}
+
+let slot = (pV - 24u) ^ pZ;
+let mY = (1u << slot) - 1u;
+let relativeIndex = countOneBits(internalMask & mY);
+let rW = kN + relativeIndex;
+let node = blasOffset + i32(rW * 5u);
+let jr = bvhBuffer[node + bo];
+let tS = oe(
+node, bo, jr, o, gv, tMax
+);
+
+
+ep = 0u;
+if (tS != 0u) {
+let fC = bvhBuffer[node + bo + 1];
+let rB = bitcast<u32>(jr.w) >> 24u;
+var tf = 0u;
+var jX = tS;
+while (jX != 0u) {
+let rm = kl(jX);
+jX &= ~(1u << rm);
+let sn = select(
+bitcast<u32>(fC.z),
+bitcast<u32>(fC.w),
+rm >= 4u
+);
+let sR =
+(sn >> ((rm & 3u) * 8u)) & 0xffu;
+let ju = sR & 0x1fu;
+let uF = select(
+ju,
+ju ^ pZ,
+ju >= 24u
+);
+let uA = (sR >> 5u) & 0x7u;
+tf |= uA << uF;
+}
+
+kN = bitcast<u32>(fC.x);
+ep = (tf & 0xff000000u) | rB;
+let oE = bitcast<u32>(fC.y);
+var oF = tf & 0x00ffffffu;
+while (oF != 0u) {
+let nF = nL(oF);
+oF &= ~(1u << nF);
+let bh = 1;
+let primitiveOffset = bo + blasOffset
++ i32(oE + nF);
+${intersectTriangles}
+}
+}
+
+if ((ep & 0xff000000u) != 0u) { continue; }
+if (pa >= 0) {
+let qa = rY[pa];
+kN = qa.x;
+ep = qa.y;
+pa--;
+}
+else { break; }
+}
+}
+` : ''}
+
+var gn: array<i32, BLAS_STACK_SIZE>;
+var dR = -1;
+if (gL != 3u) {
+dR = 0;
+
+gn[0] = uG;
+}
+
+while (dR >= 0) {
+
+let node = gn[dR];
+dR--;
+var bh = 0;
+var primitiveOffset = 0;
+
+${(blasLayoutMask & 4) !== 0 ? /* wgsl */ `
+if (gL == 2u) {
+let i = node + bo;
+let uK = bvhBuffer[i];
+let uL = bvhBuffer[i + 1];
+let uM = bvhBuffer[i + 2];
+let uN = bvhBuffer[i + 3];
+bh = i32(bitcast<u32>(uM.w));
+if (bh > 0) {
+primitiveOffset = bo + blasOffset
++ i32(bitcast<u32>(uN.w));
+}
+else {
+let left = blasOffset + i32(bitcast<u32>(uK.w) * 4u);
+let right = blasOffset + i32(bitcast<u32>(uL.w) * 4u);
+let oi = cM(
+o, uK.xyz, uL.xyz, gv, tMax
+);
+let nd = cM(
+o, uM.xyz, uN.xyz, gv, tMax
+);
+if (oi > nd) {
+if (oi > 0.0) {
+dR++; gn[dR] = left;
+}
+if (nd > 0.0) {
+dR++; gn[dR] = right;
+}
+}
+else {
+if (nd > 0.0) {
+dR++; gn[dR] = right;
+}
+if (oi > 0.0) {
+dR++; gn[dR] = left;
+}
+}
+}
+}
+` : ''}
+${(blasLayoutMask & 2) !== 0 ? /* wgsl */ `
+if (gL == 1u) {
+let hT = bitcast<u32>(node);
+if ((hT & 0x80000000u) != 0u) {
+bh = i32((hT >> 23u) & 0xffu);
+primitiveOffset = bo + blasOffset
++ i32(hT & 0x007fffffu);
+}
+else {
+let i = node + bo;
+let tV = bvhBuffer[i];
+let ra = bvhBuffer[i + 1];
+let rb = bvhBuffer[i + 2];
+let rc = bvhBuffer[i + 3];
+let nodeMin = tV.xyz;
+let ec = vec3f(tV.w, ra.x, ra.y);
+let lS = array<u32, 4>(
+bitcast<u32>(ra.z), bitcast<u32>(ra.w),
+bitcast<u32>(rb.x), bitcast<u32>(rb.y)
+);
+let rj = unpack4x8unorm(bitcast<u32>(rb.z));
+let rk = unpack4x8unorm(bitcast<u32>(rb.w));
+let rl = unpack4x8unorm(bitcast<u32>(rc.x));
+let rf = unpack4x8unorm(bitcast<u32>(rc.y));
+let rh = unpack4x8unorm(bitcast<u32>(rc.z));
+let ri = unpack4x8unorm(bitcast<u32>(rc.w));
+let tx0 = (nodeMin.x + rj * ec.x - o.x) * gv.x;
+let tx1 = (nodeMin.x + rf * ec.x - o.x) * gv.x;
+let ty0 = (nodeMin.y + rk * ec.y - o.y) * gv.y;
+let ty1 = (nodeMin.y + rh * ec.y - o.y) * gv.y;
+let tz0 = (nodeMin.z + rl * ec.z - o.z) * gv.z;
+let tz1 = (nodeMin.z + ri * ec.z - o.z) * gv.z;
+let bJ = eV(gv, o);
+let my = max(
+max((min(tx0, tx1) - vec4f(bJ.x)), (min(ty0, ty1) - vec4f(bJ.y))),
+(min(tz0, tz1) - vec4f(bJ.z))
+);
+let rH = min(
+min((max(tx0, tx1) + vec4f(bJ.x)), (max(ty0, ty1) + vec4f(bJ.y))),
+(max(tz0, tz1) + vec4f(bJ.z))
+);
+var distance = select(rH, my, my > vec4f(0.0));
+distance = select(
+distance,
+vec4f(-1.0),
+my > min(rH, vec4f(tMax))
+);
+var fa = array<f32, 4>(
+distance.x,
+distance.y,
+distance.z,
+distance.w
+);
+
+
+for (var order = 0; order < 4; order++) {
+var dX = -1.0;
+var el = -1;
+for (var child = 0; child < 4; child++) {
+if (
+lS[child] != 0u &&
+fa[child] > dX
+) {
+dX = fa[child];
+el = child;
+}
+}
+if (el >= 0 && dX > 0.0) {
+let ni = lS[el];
+var jB = bitcast<i32>(ni);
+if ((ni & 0x80000000u) == 0u) {
+jB += blasOffset;
+}
+dR++;
+gn[dR] = jB;
+fa[el] = -1.0;
+}
+}
+}
+}
+` : ''}
+${(blasLayoutMask & 1) !== 0 ? /* wgsl */ `
+if (gL == 0u) {
+let i = node + bo;
+let r1 = bvhBuffer[i];
+let bb = bitcast<i32>(r1.w);
+
+if (bb >= 0) {
+let left = node + 2;
+let right = bb + blasOffset;
+let d0 = cM(
+o,
+bvhBuffer[left + bo].xyz,
+bvhBuffer[left + 1 + bo].xyz,
+gv,
+tMax
+);
+let d1 = cM(
+o,
+bvhBuffer[right + bo].xyz,
+bvhBuffer[right + 1 + bo].xyz,
+gv,
+tMax
+);
+
+if (d0 > d1) {
+if (d0 > 0.0) {
+dR++; gn[dR] = left;
+
+}
+if (d1 > 0.0) {
+dR++; gn[dR] = right;
+
+}
+}
+else {
+if (d1 > 0.0) {
+dR++; gn[dR] = right;
+
+}
+if (d0 > 0.0) {
+dR++; gn[dR] = left;
+
+}
+}
+}
+else {
+bh = -bb;
+primitiveOffset = i + 2;
+}
+}
+` : ''}
+if (bh > 0) {
+${intersectTriangles}
+}
+}
+}
+}
+}
+
+`;
+}
+export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections = true, hasCoatNormals = false, blasLayoutMask = 1 }) {
+    return /*wgsl*/ `
+
+${hasDisplacement ? displacementWgsl : ''}
+${(blasLayoutMask & 8) !== 0 ? cwbvhTraversalWgsl : ''}
+
+struct fu {
+p0: vec3f,
+p1: vec3f,
+p2: vec3f,
+};
+
+fn ht(rad: f32, pos: vec3f, r: Ray) -> f32 {
+let op: vec3f = pos - r.o;
+let eps: f32 = 0.001;
+let b: f32 = dot(op, r.d);
+var det: f32 = b * b - dot(op, op) + rad * rad;
+if (det < 0.0) {
+return INF;
+}
+
+det = sqrt(det);
+let t1: f32 = b - det;
+if (t1 > eps) {
+return t1;
+}
+
+let t2: f32 = b + det;
+if (t2 > eps) {
+return t2;
+}
+
+return INF;
+}
+
+fn mR(pos: vec3f, u: vec3f, v: vec3f, n: vec3f, r: Ray) -> f32 {
+let dt: f32 = dot(r.d, n);
+let t: f32 = (dot(n, pos) - dot(n, r.o)) / dt;
+
+if (t > EPS) {
+let p: vec3f = r.o + r.d * t;
+let vi: vec3f = p - pos;
+let a1: f32 = dot(u / dot(u, u), vi);
+if (a1 >= 0.0 && a1 <= 1.0) {
+let a2: f32 = dot(v / dot(v, v), vi);
+if (a2 >= 0.0 && a2 <= 1.0) {
+return t;
+}
+}
+}
+
+return INF;
+}
+
+fn sphereSolidAnglePdf(origin: vec3f, center: vec3f, radius: f32) -> f32 {
+let aj = distance(origin, center);
+if (aj <= radius) { return INV4PI; }
+let jn = min(1.0, radius * radius / (aj * aj));
+let cosThetaMax = sqrt(max(0.0, 1.0 - jn));
+return 1.0 / max(TWOPI * (1.0 - cosThetaMax), 1e-8);
+}
+
+fn mk(r: Ray, light: Light, lightSample: ptr<function, LightSampleRec>) -> f32 {
+
+
+var d: f32 = INF;
+(*lightSample).direction = r.d;
+(*lightSample).normal = -r.d;
+(*lightSample).dist = INF;
+(*lightSample).pdf = 0.0;
+(*lightSample).emission = vec3f(0.0);
+(*lightSample).isDelta = false;
+var u = light.u;
+var v = light.v;
+var dO = i32(light.litType);
+
+if (dO == RECT_LIGHT) {
+
+var pos = light.position - u * 0.5 - v * 0.5;
+var normal = normalize(cross(u, v));
+if (dot(normal, r.d) > 0.0) { 
+return INF;
+}
+
+d = mR(pos, u, v, normal, r);
+if (d < 0.0) {
+d = INF;
+}
+else {
+var cc: f32 = dot(-r.d, normal);
+let spread = light.radiusOrSpread;
+if (cc >= cos(spread * PI / 2.0)) {
+(*lightSample).direction = r.d;
+(*lightSample).normal = normal;
+(*lightSample).dist = d;
+(*lightSample).pdf = (d * d) / (light.area * cc);
+(*lightSample).emission = light.emission;
+(*lightSample).isDelta = false;
+}
+else {
+d = INF;
+}
+}
+}
+
+else if (dO == SPHERE_LIGHT) {
+if (light.radiusOrSpread <= 0.0) {
+let kf = light.position - r.o;
+let projection = dot(kf, r.d);
+let 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.radiusOrSpread, light.position, r);
+(*lightSample).isDelta = false;
+if (d > 0.0 && d != INF) {
+(*lightSample).direction = r.d;
+(*lightSample).dist = d;
+(*lightSample).normal = normalize(
+r.o + r.d * d - light.position
+);
+(*lightSample).pdf = sphereSolidAnglePdf(
+r.o,
+light.position,
+light.radiusOrSpread
+);
+}
+}
+if (d < 0.0) {
+d = INF;
+}
+else {
+(*lightSample).direction = r.d;
+(*lightSample).dist = d;
+(*lightSample).emission = select(
+light.emission,
+light.emission / max(d * d, 1e-8),
+light.radiusOrSpread <= 0.0
+);
+}
+}
+
+else if (dO == SPOT_LIGHT) {
+if (light.radiusOrSpread <= 0.0) {
+let kf = light.position - r.o;
+let projection = dot(kf, r.d);
+let 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.radiusOrSpread, light.position, r);
+(*lightSample).isDelta = false;
+}
+if (d != INF) {
+let uQ = r.o + d * r.d;
+let mo = bL(light, normalize(r.o - uQ));
+if (mo <= 0.0) { return INF; }
+if (light.radiusOrSpread > 0.0) {
+(*lightSample).direction = r.d;
+(*lightSample).dist = d;
+(*lightSample).normal = normalize(
+r.o + r.d * d - light.position
+);
+(*lightSample).pdf = sphereSolidAnglePdf(r.o, light.position, light.radiusOrSpread);
+}
+(*lightSample).emission = light.emission * mo * select(
+1.0,
+1.0 / max(d * d, 1e-8),
+light.radiusOrSpread <= 0.0
+);
+}
+}
+
+else if (dO != RECT_LIGHT && dO != SPHERE_LIGHT && dO != SPOT_LIGHT) {
+
+d = INF;
+}
+
+return d;
+}
+
+fn fj(m0: vec3i, m1: vec3i, m2: vec3i, eZ: vec3f) -> i32 {
+let m00 = ae(m0.x);
+let m01 = ae(m0.y);
+let m02 = ae(m0.z);
+let m10 = ae(m1.x);
+let m11 = ae(m1.y);
+let m12 = ae(m1.z);
+let m20 = ae(m2.x);
+let m21 = ae(m2.y);
+let m22 = ae(m2.z);
+var w00 = m00.y * eZ.x;
+var w01 = m01.y * eZ.x;
+var w02 = m02.y * eZ.x;
+var w10 = m10.y * eZ.y;
+var w11 = m11.y * eZ.y;
+var w12 = m12.y * eZ.y;
+var w20 = m20.y * eZ.z;
+var w21 = m21.y * eZ.z;
+var w22 = m22.y * eZ.z;
+
+var 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;
+
+let rand = eo(0u);
+var mS: f32;
+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 i32(mS);
+}
+
+fn lJ(
+oN: i32,
+index: vec3i,
+eZ: vec3f
+) -> i32 {
+let m0 = vec3i(attrBuffers[index.x * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+let m1 = vec3i(attrBuffers[index.y * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+let m2 = vec3i(attrBuffers[index.z * ATTR_STRIDE + MATERIALINDEX_OFF]${hasAnisotropyDirections ? '.xyz' : ''});
+if (m0.x > 0 || m1.x > 0 || m2.x > 0) {
+return fj(m0, m1, m2, eZ);
+}
+return oN;
+}
+
+
+
+${hasAnisotropyDirections ? /* wgsl */ `
+fn eD(normal: vec3f, dp1: vec3f, dp2: vec3f, nP: vec2f, nQ: vec2f, input: vec4f) -> mat2x3f {
+let determinant = nP.x * nQ.y - nP.y * nQ.x;
+var t = input.xyz;
+var b = vec3f(0.0);
+
+var sign = select(input.w, 0.0, abs(input.w) > 1.5);
+if (abs(determinant) > 1e-12) {
+let dt = (dp1 * nQ.y - dp2 * nP.y) / determinant;
+let db = (dp2 * nP.x - dp1 * nQ.x) / determinant;
+if (dot(t, t) < 1e-8) { t = dt; }
+if (sign == 0.0) { sign = select(1.0, -1.0, dot(cross(normal, dt), db) < 0.0); }
+}
+t -= normal * dot(normal, t);
+if (dot(t, t) < 1e-8) {
+let ig = select(-1.0, 1.0, normal.z >= 0.0);
+let dW = -1.0 / (ig + normal.z);
+let xy = normal.x * normal.y * dW;
+t = vec3f(1.0 + ig * normal.x * normal.x * dW, ig * xy, -ig * normal.x);
+b = vec3f(xy, ig + normal.y * normal.y * dW, -normal.y);
+}
+else { t = normalize(t); b = normalize(cross(normal, t)); }
+return mat2x3f(t, b * select(1.0, -1.0, sign < 0.0));
+}
+
+` : /* wgsl */ ``}
+fn hp(
+si: ptr<function, ad>,
+tri: fu,
+eZ: vec3f,
+index: vec3i,
+bU: bool,
+fq: i32
+) {
+(*si).hit = true;
+
+let material = materialsBuffer[(*si).materialIndex];
+let uvProjection = i32(material.uvProjection);
+
+let i0 = index.x;
+let i1 = index.y;
+let i2 = index.z;
+let oL = uvProjection == ${uvProjectionConstants.spherical};
+
+var normal: vec3f = (*si).normal;
+var gU: vec3f;
+var n0 = vec3f(0.0);
+var n1 = vec3f(0.0);
+var n2 = vec3f(0.0);
+
+
+if (!bU || oL) {
+n0 = attrBuffers[i0 * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
+n1 = attrBuffers[i1 * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
+n2 = attrBuffers[i2 * ATTR_STRIDE + NORMAL_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
+gU = normalize(eZ.x * n0 + eZ.y * n1 + eZ.z * n2);
+if (!bU) {
+normal = gU;
+}
+}
+
+var uv: vec2f;
+var uv0: vec2f;
+var uv1: vec2f;
+var uv2: vec2f;
+var cX = vec2f(0.0);
+if (USE_UV) {
+uv0 = attrBuffers[i0 * ATTR_STRIDE + UV_OFF].xy;
+uv1 = attrBuffers[i1 * ATTR_STRIDE + UV_OFF].xy;
+uv2 = attrBuffers[i2 * ATTR_STRIDE + UV_OFF].xy;
+uv = eZ.x * uv0 + eZ.y * uv1 + eZ.z * uv2;
+if (USE_UV1) {
+let secondaryUv0 = attrBuffers[i0 * ATTR_STRIDE + UV1_OFF].xy;
+let secondaryUv1 = attrBuffers[i1 * ATTR_STRIDE + UV1_OFF].xy;
+let secondaryUv2 = attrBuffers[i2 * ATTR_STRIDE + UV1_OFF].xy;
+cX = eZ.x * secondaryUv0
++ eZ.y * secondaryUv1
++ eZ.z * secondaryUv2;
+}
+}
+
+if (USE_TANGENT) {
+let t0 = attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
+let t1 = attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
+let t2 = attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF]${hasAnisotropyDirections ? '.xyz' : ''};
+(*si).tangent = normalize(eZ.x * t0 + eZ.y * t1 + eZ.z * t2);
+}
+
+if (fq >= 0) {
+(*si).materialIndex = fq;
+}
+else {
+(*si).materialIndex = lJ(
+(*si).materialIndex,
+index,
+eZ
+);
+}
+
+if (uvProjection > 0) {
+
+uv = gz(uvProjection, (*si).position, select(normal, gU, oL));
+cX = uv;
+}
+
+uv = uv * material.uvScale;
+cX = cX * material.uvScale;
+
+
+if (uvProjection == ${uvProjectionConstants.triplanar}) {
+uv = fract(uv);
+}
+
+${hasAnisotropyDirections ? /* wgsl */ `
+${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normal;` : ''}
+let directionMaterial = materialsBuffer[(*si).materialIndex];
+if (directionMaterial.anisotropyMapIndex >= 0.0 || directionMaterial.specularAnisotropyRotation != 0.0 || directionMaterial.coatAnisotropyRotation != 0.0${hasCoatNormals ? " || (USE_COAT_NORMAL_MAPS && directionMaterial.coatNormalMapIndex >= 0.0)" : ""}) {
+let dp1 = tri.p0 - tri.p2;
+let dp2 = tri.p1 - tri.p2;
+var aU = vec4f(0.0);
+if (USE_TANGENT) {
+aU = eZ.x * attrBuffers[i0 * ATTR_STRIDE + TANGENT_OFF]
++ eZ.y * attrBuffers[i1 * ATTR_STRIDE + TANGENT_OFF]
++ eZ.z * attrBuffers[i2 * ATTR_STRIDE + TANGENT_OFF];
+}
+let eP = eD(normal, dp1, dp2, uv0-uv2, uv1-uv2, aU);
+(*si).geometryTangent = eP[0];
+(*si).geometryBitangent = eP[1];
+var fU = eP;
+if (USE_UV1 && directionMaterial.anisotropyMapIndex >= 0.0 && mapInfo[i32(directionMaterial.anisotropyMapIndex) + NUM_MAPS * 2].x > 0.5) {
+let a = attrBuffers[i0 * ATTR_STRIDE + UV1_OFF].xy;
+let b = attrBuffers[i1 * ATTR_STRIDE + UV1_OFF].xy;
+let c = attrBuffers[i2 * ATTR_STRIDE + UV1_OFF].xy;
+fU = eD(normal, dp1, dp2, a-c, b-c, select(aU, vec4f(0.0), aU.w == 0.0));
+}
+(*si).directionTangent = fU[0];
+(*si).directionBitangent = fU[1];
+${hasCoatNormals ? /* wgsl */ `
+if (USE_COAT_NORMAL_MAPS && directionMaterial.coatNormalMapIndex >= 0.0) {
+let kq = i32(directionMaterial.coatNormalMapIndex);
+var lT = eP;
+if (USE_UV1 && mapInfo[kq + NUM_MAPS * 2].x > 0.5) {
+let a = attrBuffers[i0 * ATTR_STRIDE + UV1_OFF].xy;
+let b = attrBuffers[i1 * ATTR_STRIDE + UV1_OFF].xy;
+let c = attrBuffers[i2 * ATTR_STRIDE + UV1_OFF].xy;
+lT = eD(normal, dp1, dp2, a-c, b-c,
+select(aU, vec4f(0.0), aU.w == 0.0));
+}
+
+
+let decoded = sampleMap(kq, getMapUvSet(kq, uv,
+select(cX, uv, uvProjection > 0))).rgb * 2.0 - 1.0;
+let mapped = lT[0] * decoded.x * directionMaterial.coatNormalScale.x
++ lT[1] * decoded.y * directionMaterial.coatNormalScale.y + normal * decoded.z;
+if (dot(mapped, mapped) > 1e-12) { (*si).coatNormal = normalize(mapped); }
+}
+` : ''}
+}
+
+` : /* wgsl */ ``}
+(*si).normal = normal;
+(*si).vertexNormal = normal;
+(*si).shadowOffset = vec3f(0.0);
+if (!bU) {
+
+
+
+let geometricNormal = normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
+let kd = eZ.x * n0 + eZ.y * n1 + eZ.z * n2;
+let a = dot(n2 - n0, tri.p0 - tri.p2);
+let b = dot(n2 - n1, tri.p1 - tri.p2);
+let c = dot(n1 - n0, tri.p1 - tri.p0);
+var h = a * eZ.x * (eZ.x - 1.0)
++ (a + b + c) * eZ.x * eZ.y
++ b * eZ.y * (eZ.y - 1.0);
+if (dot(kd, geometricNormal) > 0.0) {
+var h0 = max(max(dot(tri.p1 - tri.p0, n0), dot(tri.p2 - tri.p0, n0)), 0.0);
+var h1 = max(max(dot(tri.p0 - tri.p1, n1), dot(tri.p2 - tri.p1, n1)), 0.0);
+var 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 {
+var h0 = max(max(dot(tri.p0 - tri.p1, n0), dot(tri.p0 - tri.p2, n0)), 0.0);
+var h1 = max(max(dot(tri.p1 - tri.p0, n1), dot(tri.p1 - tri.p2, n1)), 0.0);
+var 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;
+}
+(*si).uv = uv;
+(*si).uv1 = cX;
+if (USE_NORMAL_MAPS) {
+let dp1 = tri.p0 - tri.p2;
+let dp2 = tri.p1 - tri.p2;
+let nP = uv0 - uv2;
+let nQ = uv1 - uv2;
+(*si).normal = nY(
+(*si).materialIndex, uv, normal, dp1, dp2, nP, nQ
+);
+}
+}
+
+struct eB {
+t: f32,
+barycentric: vec3f,
+};
+
+
+
+
+
+fn fI(o: vec3f, d: vec3f, tri: fu, ey: i32, gJ: vec3f, tMax: f32) -> eB {
+var ti: eB;
+
+
+var p0t = tri.p0 - o;
+var p1t = tri.p1 - o;
+var 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 = vec3f(p0t.xy + gJ.xy * p0t.z, p0t.z);
+p1t = vec3f(p1t.xy + gJ.xy * p1t.z, p1t.z);
+p2t = vec3f(p2t.xy + gJ.xy * p2t.z, p2t.z);
+
+
+var e = vec3f(
+p1t.x * p2t.y - p1t.y * p2t.x,
+p2t.x * p0t.y - p2t.y * p0t.x,
+p0t.x * p1t.y - p0t.y * p1t.x
+);
+
+if (DEPTH_QUERY_MODE) {
+
+
+let ro = abs(vec3f(p1t.x * p2t.y, p2t.x * p0t.y, p0t.x * p1t.y))
++ abs(vec3f(p1t.y * p2t.x, p2t.y * p0t.x, p0t.y * p1t.x));
+e = select(e, vec3f(0.0), abs(e) <= ro * 1e-6);
+}
+
+
+if (any(e < vec3f(0)) && any(e > vec3f(0))) {
+return ti;
+}
+
+let det = e.x + e.y + e.z;
+if (DEPTH_QUERY_MODE && det == 0.0) { return ti; }
+
+p0t.z *= gJ.z;
+p1t.z *= gJ.z;
+p2t.z *= gJ.z;
+let qZ = (e.x * p0t.z + e.y * p1t.z + e.z * p2t.z);
+
+
+if (abs(qZ) > abs(tMax * det)) {
+return ti;
+}
+
+let sg = 1. / det;
+ti.t = qZ * sg;
+ti.barycentric = e * sg;
+
+return ti;
+}
+
+
+
+
+override DEPTH_QUERY_MODE: bool = false;
+
+fn eX(d: vec3f) -> vec3f {
+if (!DEPTH_QUERY_MODE) { return 1.0 / d; }
+return 1.0 / select(d, select(vec3f(1e-20), vec3f(-1e-20), d < vec3f(0.0)), abs(d) < vec3f(1e-20));
+}
+
+fn eV(gv: vec3f, o: vec3f) -> vec3f {
+if (!DEPTH_QUERY_MODE) { return vec3f(0.0); }
+return abs(gv) * max(vec3f(1.0), abs(o)) * 1e-6;
+}
+
+
+
+fn cM(o: vec3f, vw: vec3f, vu: vec3f, gv: vec3f, tMax: f32) -> f32 {
+let uD = (vw - o) * gv;
+let uE = (vu - o) * gv;
+let bJ = eV(gv, o);
+let my = min(uD, uE) - bJ;
+let rH = max(uD, uE) + bJ;
+let t0 = max(my.x, max(my.y, my.z));
+let t1 = min(rH.x, min(rH.y, rH.z));
+return select(select(t1, t0, t0 > 0.0), -1.0, (t0 > t1 || t0 > tMax));
+}
+
+fn maxDimension(v: vec3f) -> i32 {
+return select(select(2, 1, v.y > v.z), select(2, 0, v.x > v.z), v.x > v.y);
+}
+
+fn mg(d: vec3f, ey: i32) -> vec3f {
+
+
+if (ey == 0) {
+return vec3f(-d.y, -d.z, 1.0) / d.x;
+} else if (ey == 1) {
+return vec3f(-d.z, -d.x, 1.0) / d.y;
+} else {
+return vec3f(-d.x, -d.y, 1.0) / d.z;
+}
+}
+
+fn lU(
+si: ptr<function, ad>,
+lm: fu,
+aB: vec3f,
+hs: vec3i,
+bU: bool,
+ao: i32,
+eC: vec3f,
+eU: vec3f,
+fq: i32
+) {
+(*si).instanceIndex = ao;
+(*si).barycentrics = aB.xy;
+(*si).normal = eC;
+(*si).position = eU;
+(*si).materialIndex = i32(ae(
+bitcast<i32>(instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE}].z)
+).x);
+
+
+hp(
+si,
+lm,
+aB,
+hs,
+bU,
+fq
+);
+
+let l2w = mat4x4<f32>(
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 5],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 6],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 7],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 8]
+);
+let w2l = mat4x4<f32>(
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 1],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 2],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 3],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 4]
+);
+let aD = transpose(mat3x3<f32>(
+w2l[0].xyz,
+w2l[1].xyz,
+w2l[2].xyz
+));
+
+(*si).faceNormal = normalize(aD * eC);
+(*si).vertexNormal = normalize(aD * (*si).vertexNormal);
+(*si).normal = normalize(aD * (*si).normal);
+${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aD * (*si).coatNormal);` : ''}
+if (USE_TANGENT && dot((*si).tangent, (*si).tangent) > 0.0) {
+(*si).tangent = normalize((l2w * vec4f((*si).tangent, 0.0)).xyz);
+}
+${hasAnisotropyDirections ? /* wgsl */ `
+(*si).directionTangent = (l2w * vec4f((*si).directionTangent, 0.0)).xyz;
+(*si).directionBitangent = (l2w * vec4f((*si).directionBitangent, 0.0)).xyz;
+(*si).geometryTangent = (l2w * vec4f((*si).geometryTangent, 0.0)).xyz;
+(*si).geometryBitangent = (l2w * vec4f((*si).geometryBitangent, 0.0)).xyz;
+` : /* wgsl */ ``}
+(*si).shadowOffset = (l2w * vec4f((*si).shadowOffset, 0.0)).xyz;
+(*si).position = (l2w * vec4((*si).position, 1.0)).xyz;
+}
+
+
+${createIntersectionAlphaWgsl(hasAnisotropyDirections)}
+
+
+
+
+fn cY(ray: Ray, si: ptr<function, ad>, bounces: i32, doubleSided: bool, ln: bool) {
+
+(*si).hit = false;
+
+if (rtUniform.isEmpty > 0) {
+return;
+}
+
+var tMax = RAY_MAX_DISTANCE;
+var ey: i32;
+var gJ: vec3f;
+
+var hs: vec3i;
+var lm: fu;
+var ao: i32;
+var hL: i32 = (*si).triangleIndex;
+
+${getBVHTraverseCode(`
+(*si).triangleIndex = triangleIndex;
+lm = tri;
+hs = index;
+ao = cf;
+`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections)}
+
+if (qP) {
+lU(
+si,
+lm,
+aB,
+hs,
+bU,
+ao,
+eC,
+eU,
+-1
+);
+}
+}
+
+
+fn iG(ray: Ray, si: ptr<function, ad>, instanceIndex: i32, maxDistance: f32) {
+(*si).hit = false;
+
+if (rtUniform.isEmpty > 0) {
+return;
+}
+
+let bounces = 0;
+let doubleSided = true;
+let ln = false;
+var tMax = maxDistance;
+var ey: i32;
+var gJ: vec3f;
+var hs: vec3i;
+var lm: fu;
+var ao: i32;
+var hL: i32 = -1;
+
+${getBVHTraverseCode(`
+(*si).triangleIndex = triangleIndex;
+lm = tri;
+hs = index;
+ao = cf;
+`, hasDisplacement, false, blasLayoutMask, hasAnisotropyDirections, `
+if (cf != instanceIndex) {
+continue;
+}
+`)}
+
+if (qP) {
+(*si).instanceIndex = ao;
+(*si).normal = eC;
+(*si).position = eU;
+(*si).materialIndex = i32(ae(bitcast<i32>(instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE}].z)).x);
+hp(
+si,
+lm,
+aB,
+hs,
+bU,
+-1
+);
+
+let l2w = mat4x4<f32>(
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 5],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 6],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 7],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 8]
+);
+let w2l = mat4x4<f32>(
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 1],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 2],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 3],
+instancesBuffer[ao * ${INSTANCE_VEC4_STRIDE} + 4]
+);
+let aD = transpose(mat3x3<f32>(
+w2l[0].xyz,
+w2l[1].xyz,
+w2l[2].xyz
+));
+(*si).faceNormal = normalize(aD * eC);
+(*si).vertexNormal = normalize(aD * (*si).vertexNormal);
+(*si).normal = normalize(aD * (*si).normal);
+${hasCoatNormals ? /* wgsl */ `  (*si).coatNormal = normalize(aD * (*si).coatNormal);` : ''}
+if (USE_TANGENT && dot((*si).tangent, (*si).tangent) > 0.0) {
+(*si).tangent = normalize((l2w * vec4f((*si).tangent, 0.0)).xyz);
+}
+${hasAnisotropyDirections ? /* wgsl */ `
+(*si).directionTangent = (l2w * vec4f((*si).directionTangent, 0.0)).xyz;
+(*si).directionBitangent = (l2w * vec4f((*si).directionBitangent, 0.0)).xyz;
+(*si).geometryTangent = (l2w * vec4f((*si).geometryTangent, 0.0)).xyz;
+(*si).geometryBitangent = (l2w * vec4f((*si).geometryBitangent, 0.0)).xyz;
+` : /* wgsl */ ``}
+(*si).shadowOffset = (l2w * vec4f((*si).shadowOffset, 0.0)).xyz;
+(*si).position = (l2w * vec4((*si).position, 1.0)).xyz;
+}
+}
+
+fn ex(ray: Ray, lightDistance: f32, jE: i32) -> bool {
+if (rtUniform.isEmpty > 0) {
+return false;
+}
+
+let doubleSided = true;
+let qc = min(max(lightDistance, 0.0), RAY_MAX_DISTANCE);
+var tMax = qc;
+var ey: i32;
+var gJ: vec3f;
+
+let bounces = 1;
+var ln = false;
+var hL: i32 = jE;
+
+${getBVHTraverseCode(
+    /*wgsl */ `
+
+
+
+var jl = true;
+
+if (jl) {
+if (HAS_ALPHA) {
+let materialIndex = i32(ae(bitcast<i32>(od.z)).x);
+if (!nl(
+materialIndex,
+index,
+aB,
+eU,
+eC
+)) {
+
+tMax = qc;
+jl = false;
+}
+}
+}
+if (jl) {
+return true;
+}
+`, hasDisplacement, true, blasLayoutMask, hasAnisotropyDirections)}
+
+return false;
+}
+
+`;
+}
+//# sourceMappingURL=intersect.wgsl.js.map