rayzee 11.16.0 → 11.17.0

package/dist/BidirectionalIntegrator-BH-c324Z.js

@@ -0,0 +1,960 @@
+import { L as e, M as t, Q as n, U as r, c as i, d as a, it as o, j as s, nt as c, s as l, st as u, u as d, vt as f, w as p } from "./Common-jRX6P1vs.js";
+import { E as m, O as h, S as ee, T as g, a as _, b as v, c as y, j as b, k as x, p as S, t as te, x as ne } from "./TextureSampling-Cmd2X04v.js";
+import { o as re } from "./TextureBuckets-BfkUIWK6.js";
+import { A as ie, An as C, Bn as w, Cn as ae, Ct as oe, Dt as T, Et as E, Gn as se, Hn as ce, J as le, Jn as D, Jt as O, Ln as ue, M as k, Mn as de, P as fe, Qn as A, Qt as j, Rt as pe, Tn as M, Tt as me, Un as he, Ut as ge, Vn as _e, Wn as N, Wt as ve, Xt as ye, Z as P, _ as be, _t as xe, bt as Se, c as F, dt as Ce, et as we, g as Te, gt as Ee, h as I, ht as De, j as Oe, jn as L, k as ke, kn as Ae, kt as je, l as Me, mt as Ne, nn as Pe, nt as Fe, pn as R, q as Ie, qt as Le, r as Re, tt as ze, ut as Be, x as Ve, xt as He, yt as Ue } from "./CompactKernel-cuEVr6Jy.js";
+import { r as We } from "./BufferLayout-QzWWnb3A.js";
+import { DataTexture as Ge, FloatType as Ke, RedFormat as qe, Vector3 as Je } from "three";
+import { Break as Ye, Fn as Xe, If as z, Loop as Ze, Return as B, abs as V, atomicAdd as Qe, atomicFunc as $e, atomicLoad as et, atomicStore as tt, bool as nt, cos as rt, cross as it, dot as H, exp2 as at, float as U, floor as ot, instanceIndex as st, int as W, ivec2 as ct, ivec3 as lt, length as ut, localId as dt, log2 as ft, max as G, min as pt, mix as mt, normalize as ht, sampler as gt, select as K, sin as _t, sqrt as vt, storage as yt, texture as bt, uint as q, uniform as J, uniformArray as xt, vec2 as St, vec3 as Y, vec4 as Ct, workgroupId as wt } from "three/tsl";
+//#region \0rolldown/runtime.js
+var Tt = Object.defineProperty, Et = (e, t) => {
+	let n = {};
+	for (var r in e) Tt(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || Tt(n, Symbol.toStringTag, { value: "Module" }), n;
+}, Dt = /* @__PURE__ */ Et({
+	LampPick: () => Ot,
+	areaLightDirectPdfW: () => Lt,
+	directionalConeSolidAngle: () => It,
+	lampCount: () => kt,
+	lampPickPdf: () => Pt,
+	pickLamp: () => Nt,
+	spotConeSolidAngle: () => Ft
+}), Ot = u({
+	kind: "int",
+	index: "int",
+	pdf: "float",
+	total: "float"
+}), kt = (e) => e.numDirectional.add(e.numArea).add(e.numPoint).add(e.numSpot), At = (e, t) => K(t.lessThan(e.numDirectional), W(0), K(t.lessThan(e.numDirectional.add(e.numArea)), W(1), K(t.lessThan(e.numDirectional.add(e.numArea).add(e.numPoint)), W(2), W(3)))), jt = (e, t) => K(t.equal(W(0)), W(0), K(t.equal(W(1)), e.numDirectional, K(t.equal(W(2)), e.numDirectional.add(e.numArea), e.numDirectional.add(e.numArea).add(e.numPoint)))), Mt = (e, t, n, r, i) => {
+	let a = (e, t, n) => z(t.greaterThan(W(0)), () => {
+		Ze({
+			start: W(0),
+			end: t,
+			type: "int",
+			condition: "<"
+		}, ({ i: t }) => {
+			i(W(e), t, n(t).toVar());
+		});
+	});
+	a(0, e.numDirectional, (t) => ke(Ce.wrap(xe(e.directional, t)), n, r, W(0))), a(1, e.numArea, (i) => {
+		let a = Be.wrap(Ee(e.area, i));
+		return K(a.intensity.greaterThan(0), k(a, t, n, r), U(0));
+	}), a(2, e.numPoint, (i) => ie(Ne.wrap(Ue(e.point, i)), t, n, r)), a(3, e.numSpot, (i) => Oe(De.wrap(He(e.spot, i)), t, n, r));
+};
+function Nt(e, t, n, r, i, a) {
+	let o = W(-1).toVar(), s = W(-1).toVar(), c = U(0).toVar(), l = U(0).toVar();
+	Mt(e, t, n, r, (t, n, r) => {
+		l.addAssign(r), z(r.greaterThan(0).and(a(W(g + 64).add(jt(e, t)).add(n)).mul(l).lessThan(r)), () => {
+			o.assign(t), s.assign(n), c.assign(r);
+		});
+	});
+	let u = kt(e).toVar(), d = c.div(G(l, 1e-10)).toVar();
+	return z(l.lessThanEqual(0), () => {
+		let t = pt(W(i.mul(U(u))), u.sub(W(1))).toVar();
+		o.assign(At(e, t)), s.assign(t.sub(jt(e, o))), d.assign(U(1).div(G(U(u), 1)));
+	}), Ot({
+		kind: o,
+		index: s,
+		pdf: d,
+		total: l
+	});
+}
+function Pt(e, t, n, r, i, a) {
+	let o = U(0).toVar(), s = U(0).toVar();
+	return Mt(e, r, i, a, (e, r, i) => {
+		o.addAssign(i), z(e.equal(t).and(r.equal(n)), () => {
+			s.assign(i);
+		});
+	}), K(o.greaterThan(0), s.div(o), U(1).div(G(U(kt(e)), 1)));
+}
+var Ft = (e) => U(2 * i).mul(G(U(1).sub(rt(e.angle)), 1e-10)), It = (e) => U(2 * i).mul(G(U(1).sub(rt(e.angle.mul(.5))), 1e-10)), Lt = (e, t, n, r) => {
+	let i = T(t, e.position.sub(e.u).sub(e.v), e.u.mul(2), e.v.mul(2)).toVar();
+	return K(e.shape.lessThan(.5).and(i.greaterThan(1e-5)), U(1).div(i), n.mul(n).div(G(e.area.mul(G(r, .001)), 1e-10)));
+}, Rt = /* @__PURE__ */ Et({
+	DIM_CONNECT_PATH: () => 16,
+	DIM_CONNECT_VERTEX: () => 17,
+	DIM_EMIT: () => X,
+	LIGHT_PIXEL_ROW_OFFSET: () => zt,
+	PASS_TAG_BIT: () => Ht,
+	SOURCE: () => on,
+	SPLAT_MAX: () => Vt,
+	SPLAT_SCALE: () => Bt,
+	STRATEGY: () => en,
+	STRATEGY_ALONE: () => 8,
+	emitterAreaPdf: () => rn,
+	emitterSideProbability: () => nn,
+	facingSide: () => fn,
+	lampSource: () => cn,
+	lightEndCosine: () => pn,
+	lightPathPixel: () => Wt,
+	mergeEta: () => Xt,
+	mergeRadiusAt: () => Yt,
+	mergeVmAt: () => Zt,
+	mis: () => Q,
+	misMergePartial: () => Qt,
+	misOnHit: () => Gt,
+	misOnScatter: () => qt,
+	misOnSpecular: () => Kt,
+	misPartial: () => Jt,
+	misWeight: () => $t,
+	resolveSurfaceMaterial: () => dn,
+	sourceLampIndex: () => un,
+	sourceLampType: () => ln,
+	sourcePick: () => sn,
+	strategyWeight: () => tn,
+	sunEmissionPdf: () => an
+}), X = g + 2048, zt = 65536, Bt = 16384, Vt = 4096, Ht = 2147483648, Ut = 1e30, Z = (e) => K(e.equal(e), e, U(0)).clamp(0, Ut), Wt = (e, t) => {
+	let n = q(t.x);
+	return St(U(q(e).mod(n)).add(.5), U(q(e).div(n).add(q(zt))).add(.5));
+}, Q = (e) => e.mul(e), Gt = (e, t, n) => {
+	let r = G(n, 1e-6);
+	e.dVCM.assign(Z(e.dVCM.mul(Q(t.mul(t).div(r))))), e.dVC.assign(Z(e.dVC.div(Q(r))));
+}, Kt = (e, t) => {
+	e.dVC.assign(Z(e.dVC.mul(Q(t)))), e.dVCM.assign(0);
+}, qt = (e, t, n, r) => {
+	let i = G(n, 1e-12), a = e.dVC.mul(Q(r)).add(e.dVCM);
+	e.dVC.assign(Z(Q(t.div(i)).mul(Z(e.vm ? a.add(e.vm) : a)))), e.dVCM.assign(Z(Q(U(1).div(i))));
+}, Jt = (e, t, n) => {
+	let r = t.dVCM.add(t.dVC.mul(Q(n)));
+	return Z(Z(Q(e)).mul(Z(t.vm ? r.add(t.vm) : r)));
+}, Yt = (e, t) => G(e.mergeConst.add(e.mergeSlope.mul(ut(t.sub(e.cameraPosition)))), e.mergeMin), Xt = (e, t) => t.mul(t).mul(Math.PI).mul(U(e.lightPaths)), Zt = (e, t) => {
+	let n = Xt(e, Yt(e, t)).mul(e.mergeTrust);
+	return n.mul(n);
+}, Qt = (e, t, n) => Z(Z(e.dVCM.add(e.dVC.mul(Q(t)))).mul(n)), $t = (e, t) => U(1).div(U(1).add(Z(e)).add(Z(t))), en = {
+	ALL: 0,
+	HIT: 1,
+	NEE: 2,
+	CONNECT: 3,
+	LIGHT_TRACE: 4,
+	MERGE: 5
+}, tn = (e, t, n, r = U(1)) => K(e.equal(q(en.ALL)).or(e.equal(q(t))), n, K(e.equal(q(t + 8)), r, U(0))), nn = (e, t) => K(e.equal(W(2)), U(.5), K(e.equal(W(1)), K(t.lessThan(0), U(1), U(0)), K(t.greaterThan(0), U(1), U(0)))), rn = (e, t, n = 1) => G(H(e, d), 0).div(G(t, 1e-10)).mul(n), an = (e, t, n) => e.sunPick.mul(n).div(G(t.y, 1e-30)), on = {
+	SUN: 0,
+	EMITTERS: 1,
+	ENVIRONMENT: 2,
+	LAMPS: 3
+}, sn = (e, t) => {
+	let n = W(t);
+	return e.sourceCdf.element(n).sub(K(n.greaterThan(W(0)), e.sourceCdf.element(G(n.sub(W(1)), W(0))), U(0)));
+}, cn = (e, t, n) => K(t.equal(W(0)), W(e.sourceOffsets[0]), K(t.equal(W(1)), W(e.sourceOffsets[1]), K(t.equal(W(2)), W(e.sourceOffsets[2]), W(e.sourceOffsets[3])))).add(n), ln = (e, t) => K(t.lessThan(W(e.sourceOffsets[1])), W(0), K(t.lessThan(W(e.sourceOffsets[2])), W(1), K(t.lessThan(W(e.sourceOffsets[3])), W(2), W(3)))), un = (e, t, n) => t.sub(K(n.equal(W(0)), W(e.sourceOffsets[0]), K(n.equal(W(1)), W(e.sourceOffsets[1]), K(n.equal(W(2)), W(e.sourceOffsets[2]), W(e.sourceOffsets[3])))));
+function dn(e, t, r, i) {
+	let a = o.wrap(p(W(e), i)).toVar();
+	a.normalMapIndex.assign(W(-1)), a.bumpMapIndex.assign(W(-1)), a.displacementMapIndex.assign(W(-1));
+	let s = c.wrap(S(a, t, r, Ct(0))).toVar(), u = s.roughness.toVar();
+	a.color.assign(s.albedo), a.metalness.assign(s.metalness.clamp(0, 1)), a.roughness.assign(s.roughness.clamp(l, 1)), a.sheenRoughness.assign(a.sheenRoughness.clamp(.05, 1));
+	let d = _({
+		uv: t,
+		transform: a.albedoTransform
+	}).toVar();
+	z(a.anisotropyMapIndex.greaterThanEqual(W(0)), () => {
+		let e = y(a, d).toVar();
+		a.anisotropy.assign(e.x), a.anisotropyRotation.assign(e.y);
+	});
+	let f = n.wrap(te(a, d)).toVar();
+	return a.transmission.assign(f.transmission), a.clearcoat.assign(f.clearcoat), a.clearcoatRoughness.assign(f.clearcoatRoughness), a.sheenColor.assign(f.sheenColor), a.sheenRoughness.assign(f.sheenRoughness), a.iridescence.assign(f.iridescence), a.iridescenceThicknessRange.assign(St(a.iridescenceThicknessRange.x, f.iridescenceThickness)), a.specularIntensity.assign(f.specularIntensity), a.specularColor.assign(f.specularColor), a.diffuseTransmission.assign(f.diffuseTransmission), a.diffuseTransmissionColor.assign(f.diffuseTransmissionColor), a.diffuseRoughness.assign(f.diffuseRoughness), z(u.lessThan(l).and(a.anisotropy.equal(0)).and(a.clearcoat.equal(0)).and(a.transmission.equal(0)).and(a.subsurface.equal(0)), () => {
+		a.roughness.assign(0);
+	}), a;
+}
+var fn = (e, t, n) => K(n.diffuseTransmission.greaterThan(0).and(H(e, t).lessThan(0)), e.negate(), e), pn = (e, t, n, r) => V(H(e, t)).mul(V(H(r, n))).div(G(V(H(e, n)), 1e-4)), mn = 4;
+mn * mn;
+var hn = 4096, gn = hn + 1, _n = Math.ceil(gn * 4 / 256) * 64, vn = .2, yn = (e) => {
+	let t = ht(it(K(V(e.x).greaterThan(.9), Y(0, 1, 0), Y(1, 0, 0)), e)).toVar();
+	return {
+		u: t,
+		v: it(e, t).toVar()
+	};
+}, bn = (e) => {
+	let t = e.div(G(V(e.x).add(V(e.y)).add(V(e.z)), 1e-20)).toVar(), n = St(t.x, t.z).toVar();
+	z(t.y.lessThan(0), () => {
+		n.assign(St(U(1).sub(V(t.z)).mul(K(t.x.greaterThanEqual(0), 1, -1)), U(1).sub(V(t.x)).mul(K(t.z.greaterThanEqual(0), 1, -1))));
+	});
+	let r = ot(n.mul(.5).add(.5).mul(mn)).clamp(0, mn - 1);
+	return W(r.y).mul(mn).add(W(r.x));
+}, xn = (e, t, n) => {
+	let { u: r, v: i } = yn(t), a = n.sub(e.sceneCenter);
+	return St(H(a, r), H(a, i)).div(e.sceneRadius);
+}, Sn = (e) => {
+	let t = e.mul(.5).add(.5).mul(64).toVar();
+	return K(t.x.greaterThanEqual(0).and(t.y.greaterThanEqual(0)).and(t.x.lessThan(64)).and(t.y.lessThan(64)), W(t.y).mul(64).add(W(t.x)), W(-1));
+}, Cn = (e, t, n) => e.guide.greaterThan(q(0)).and(t.load(ct(W(hn), n)).x.greaterThan(0)), wn = (e, t, n, r) => {
+	let i = xn(e, n, r).toVar(), a = e.sceneRadius.mul(e.sceneRadius).toVar(), o = K(H(i, i).lessThanEqual(1), U(1).div(G(a.mul(Math.PI), 1e-30)), U(0)).toVar(), s = bn(n).toVar(), c = Sn(i).toVar(), l = (e) => t.load(ct(G(e, W(0)), s)).x, u = K(c.greaterThanEqual(W(0)), l(c).sub(K(c.greaterThan(W(0)), l(c.sub(W(1))), U(0))), U(0)).mul(hn / 4).div(G(a, 1e-30));
+	return K(Cn(e, t, s), mt(u, o, vn), o);
+}, Tn = (e, t, n, r, i) => {
+	let { u: a, v: o } = yn(n), s = St(0).toVar(), c = bn(n).toVar();
+	return z(Cn(e, t, c).and(r.lessThan(1 - vn)), () => {
+		let e = r.div(1 - vn).toVar(), n = W(0).toVar(), a = W(hn - 1).toVar();
+		Ze(n.lessThan(a), () => {
+			let r = n.add(a).div(2).toVar();
+			z(t.load(ct(r, c)).x.lessThanEqual(e), () => {
+				n.assign(r.add(1));
+			}).Else(() => {
+				a.assign(r);
+			});
+		});
+		let o = St(U(n.mod(W(64))), U(n.div(W(64))));
+		s.assign(o.add(i).div(64).mul(2).sub(1));
+	}).Else(() => {
+		let e = vt(i.x), t = i.y.mul(2 * Math.PI);
+		s.assign(St(e.mul(rt(t)), e.mul(_t(t))));
+	}), e.sceneCenter.add(n.mul(e.sceneRadius)).add(a.mul(s.x).add(o.mul(s.y)).mul(e.sceneRadius));
+}, En = (e, t, n, r) => {
+	let i = Sn(xn(t, n, r)).toVar();
+	z(t.guideLearning.greaterThan(q(0)).and(i.greaterThanEqual(W(0))), () => {
+		Qe(e.element(q(Le.GUIDE).add(q(bn(n).mul(W(hn)).add(i)))), q(1));
+	});
+};
+function Dn({ counters: e, out: t }) {
+	return Xe(() => {
+		let n = st;
+		z(n.greaterThanEqual(q(16)), () => {
+			B();
+		});
+		let r = q(Le.GUIDE).add(n.mul(q(hn))).toVar(), i = U(0).toVar();
+		Ze({
+			start: W(0),
+			end: W(hn),
+			type: "int",
+			condition: "<"
+		}, ({ i: t }) => {
+			i.addAssign(U(et(e.element(r.add(q(t))))));
+		});
+		let a = n.mul(q(_n)).toVar(), o = U(0).toVar();
+		Ze({
+			start: W(0),
+			end: W(hn),
+			type: "int",
+			condition: "<"
+		}, ({ i: n }) => {
+			o.addAssign(U(et(e.element(r.add(q(n)))))), t.element(a.add(q(n))).assign(K(i.greaterThan(0), K(n.equal(W(hn - 1)), U(1), o.div(i)), U(0)));
+		}), t.element(a.add(q(hn))).assign(i);
+	})().compute(16, [16]);
+}
+function On({ counters: e }) {
+	return Xe(() => {
+		z(st.lessThan(q(O)), () => {
+			tt(e.element(q(Le.GUIDE).add(st)), q(0));
+		});
+	})().compute(O, [256]);
+}
+//#endregion
+//#region src/addons/bidirectional/LightGenerateKernel.js
+function kn(e) {
+	let { rayBufferRW: n, hitBufferRW: i, activeIndicesRW: a, counters: o, lightBuffer: s, triangleBuffer: c, bvhBuffer: l, emissiveTriangleCount: u, emissiveVec4Offset: d, emissiveTotalPower: f, emissiveBoost: p, sunDirection: g, sunRadiance: _, sunParams: v, environmentIntensity: y, envTexture: S, envCDFTexture: te, envMatrix: ne, envResolution: re, directionalLightsBuffer: ie, areaLightsBuffer: C, pointLightsBuffer: ae, spotLightsBuffer: T, bidirectional: D, resolution: O, frame: k, transmissiveBounces: de } = e, { lightPaths: fe } = D;
+	return Xe(() => {
+		let e = st;
+		z(e.equal(q(0)), () => {
+			tt(o.element(q(Le.ACTIVE_RAY_COUNT)), fe), tt(o.element(q(Le.ENTERING_COUNT)), fe);
+		}), z(e.greaterThanEqual(fe), () => {
+			B();
+		}), a.element(e).assign(e);
+		let A = Wt(e, O).toVar(), j = b({ state: m({
+			pixelCoord: A,
+			rayIndex: W(3),
+			frame: k
+		}) }).toVar(), M = Y(0).toVar(), F = Y(0, 1, 0).toVar(), I = Y(0).toVar(), Oe = U(0).toVar(), L = U(0).toVar(), ke = W(-1).toVar(), Ae = W(0).toVar(), je = U(1).toVar(), Me = nt(!1).toVar(), Pe = h(A, W(0), W(X + 4), j, O, k).toVar(), R = W(0).toVar(), Re = W(D.sourceCount - 1).toVar();
+		Ze(R.lessThan(Re), () => {
+			let e = R.add(Re).div(2).toVar();
+			z(D.sourceCdf.element(e).lessThanEqual(Pe), () => {
+				R.assign(e.add(1));
+			}).Else(() => {
+				Re.assign(e);
+			});
+		});
+		let Ve = D.guideTexture, We = (e) => {
+			let t = Tn(D, Ve, e, h(A, W(0), W(X + 7), j, O, k), x(A, W(0), W(X + 6), j, O, k)).toVar();
+			return {
+				start: t,
+				pdf: wn(D, Ve, e, t)
+			};
+		};
+		z(R.equal(W(on.SUN)), () => {
+			let e = ze(g, v, x(A, W(0), W(X + 5), j, O, k)).toVar(), t = Fe(e, g, _, v).mul(y).toVar(), n = We(e), r = an(D, v, n.pdf).toVar();
+			z(t.x.add(t.y).add(t.z).greaterThan(0).and(r.greaterThan(0)), () => {
+				M.assign(n.start), F.assign(e.negate()), I.assign(t.div(r)), Oe.assign(Q(U(1).div(v.y.mul(r)))), L.assign(Q(U(1).div(r))), Me.assign(!0);
+			});
+		}).ElseIf(R.equal(W(on.EMITTERS)), () => {
+			let e = le(s, d, u, h(A, W(0), W(X), j, O, k)).toVar(), n = d.add(e.mul(W(2))), i = s.element(n).toVar(), a = s.element(n.add(W(1))).toVar();
+			ke.assign(W(i.x)), Ae.assign(W(i.w));
+			let o = Ie.wrap(P(ke, c, l, Ae)).toVar(), m = we(o.v0, o.v1, o.v2, x(A, W(0), W(X + 1), j, O, k)).toVar(), g = ht(it(o.v1.sub(o.v0), o.v2.sub(o.v0))).toVar(), _ = ee(r(c, ke, 4).z).toVar(), v = K(_.equal(W(1)).or(_.equal(W(2)).and(h(A, W(0), W(X + 3), j, O, k).lessThan(.5))).toVar(), g.negate(), g).toVar();
+			F.assign(pe(v, x(A, W(0), W(X + 2), j, O, k)));
+			let y = H(F, v).toVar(), b = G(i.y, 0).div(G(f, 1e-10)).div(G(a.w, 1e-20)).mul(K(_.equal(W(2)), U(.5), U(1))).mul(D.emitterPick).toVar(), S = b.mul(y).div(Math.PI).toVar();
+			z(y.greaterThan(1e-6).and(S.greaterThan(0)), () => {
+				M.assign(t(m, v)), I.assign(a.xyz.mul(p).mul(Math.PI).div(b)), Oe.assign(Q(U(1).div(S))), L.assign(Q(y.div(S))), je.assign(y), Me.assign(!0);
+			});
+		}).ElseIf(R.equal(W(on.ENVIRONMENT)), () => {
+			let e = ve(te, ne, re, x(A, W(0), W(X + 5), j, O, k)), t = e.direction.toVar(), n = e.pdf.toVar(), r = ge({
+				tex: S,
+				samp: gt(S),
+				direction: t,
+				environmentMatrix: ne,
+				environmentIntensity: y,
+				enableEnvironmentLight: U(1)
+			}).xyz.toVar(), i = We(t), a = D.envPick.mul(n).mul(i.pdf).toVar();
+			z(r.x.add(r.y).add(r.z).greaterThan(0).and(a.greaterThan(0)), () => {
+				M.assign(i.start), F.assign(t.negate()), I.assign(r.div(a)), Oe.assign(Q(n.div(a))), L.assign(Q(U(1).div(a))), ke.assign(W(-1 - on.ENVIRONMENT)), Me.assign(!0);
+			});
+		}).ElseIf(R.greaterThanEqual(W(on.LAMPS)), () => {
+			let e = sn(D, R).toVar(), t = ln(D, R).toVar(), n = un(D, R, t).toVar();
+			ke.assign(W(-1).sub(R));
+			let r = U(0).toVar(), i = Y(0).toVar(), a = x(A, W(0), W(X + 2), j, O, k).toVar();
+			z(t.equal(W(0)), () => {
+				let t = Ce.wrap(xe(ie, n)), a = ht(t.direction).toVar();
+				i.assign(t.color.mul(t.intensity)), r.assign(e), z(t.angle.greaterThan(0), () => {
+					let e = It(t).toVar();
+					a.assign(oe(a, t.angle.mul(.5), x(A, W(0), W(X + 5), j, O, k))), i.divAssign(e), r.divAssign(e);
+				});
+				let o = We(a);
+				r.mulAssign(o.pdf), M.assign(o.start), F.assign(a.negate());
+			}).ElseIf(t.equal(W(1)), () => {
+				let t = Be.wrap(Ee(C, n)), o = t.shape.greaterThan(.5), s = x(A, W(0), W(X + 1), j, O, k).toVar(), c = vt(s.x), l = s.y.mul(2 * Math.PI);
+				M.assign(t.position.add(t.u.mul(K(o, c.mul(rt(l)), s.x.mul(2).sub(1)))).add(t.v.mul(K(o, c.mul(_t(l)), s.y.mul(2).sub(1))))), F.assign(pe(t.normal, a));
+				let u = H(F, t.normal).toVar();
+				i.assign(K(t.area.greaterThan(0).and(u.greaterThan(1e-6)), Te(t).mul(be(u, t.spread)).mul(u), Y(0))), r.assign(e.div(G(t.area, 1e-20)).mul(u).div(Math.PI)), L.assign(Q(u.div(G(r, 1e-30))));
+			}).ElseIf(t.equal(W(2)), () => {
+				let t = Ne.wrap(Ue(ae, n));
+				M.assign(t.position), F.assign(oe(Y(0, 1, 0), U(Math.PI), a)), i.assign(t.color.mul(t.intensity)), r.assign(e.div(4 * Math.PI));
+			}).Else(() => {
+				let t = De.wrap(He(T, n));
+				M.assign(t.position), F.assign(oe(t.direction, t.angle, a));
+				let o = F.negate();
+				i.assign(t.color.mul(t.intensity).mul(Se({
+					coneCosine: rt(t.angle),
+					blend: t.penumbra,
+					angleCosine: H(F, t.direction)
+				})).mul(E(t, o)).mul(me(t, o))), r.assign(e.div(Ft(t)));
+			}), z(i.x.add(i.y).add(i.z).greaterThan(0).and(r.greaterThan(0)), () => {
+				I.assign(i.div(r)), Oe.assign(Q(U(1).div(r))), Me.assign(!0);
+			});
+		}), z(Me.not(), () => {
+			_e(n, e, F, q(0)), B();
+		});
+		let Ge = G(G(G(I.x, I.y), I.z), 1e-20).toVar();
+		ce(n, e, M, W(0), W(0)), _e(n, e, F, q(ye.ACTIVE | ye.REDIRECTED | ye.LIGHT_PATH | ye.LIGHT_EMITTED)), N(n, e, I.div(Ge), U(0)), he(n, e, Ct(Y(0), U(1))), w(n, e, q(0), q(de), U(1), U(1), U(1)), se(i, e, j, Oe, L), ue(i, e, ke, Ae, je, Ge);
+	});
+}
+//#endregion
+//#region src/addons/bidirectional/ConnectKernel.js
+function An(e) {
+	let { rayBufferRW: n, hitBufferRO: r, activeIndicesRO: i, counters: o, bvhBuffer: c, triangleBuffer: l, materialBuffer: u, resolution: d, frame: f, accumFrame: p, currentBounce: m, chunkRowBase: ee, lightPaths: g, slotsPerPath: _, lightTag: y, passTag: x, strategyView: S, maxBounceCount: te, globalIlluminationIntensity: ne, fireflyThreshold: re, mergeVm: ie = null, diffuseTransmission: C = !0 } = e;
+	return Xe(() => {
+		let e = st;
+		z(e.greaterThanEqual(et(o.element(q(Le.ENTERING_COUNT)))), () => {
+			B();
+		});
+		let w = i.element(e).toVar(), oe = Pe(w);
+		z(de(r, oe).notEqual(x), () => {
+			B();
+		});
+		let T = L(r, oe), E = {
+			...T,
+			vm: ie?.(T.position) ?? null
+		}, se = W(E.extra).add(W(1)).toVar(), ce = W(d.x), le = W(w).add(ee.mul(ce)), D = St(U(le.mod(ce)).add(.5), U(le.div(ce)).add(.5)).toVar(), O = W(m).mul(W(32)), ue = b({ state: M(r, w).bitXor(q(2654435769)) }).toVar(), k = h(D, W(0), O.add(W(16)), ue, d, f).toVar(), A = h(D, W(0), O.add(W(17)), ue, d, f).toVar(), pe = pt(q(U(g).mul(k)), g.sub(q(1))).toVar().mul(_).toVar(), me = pt(W(R(r, j(pe), y)), W(te).add(W(1)).sub(se)).toVar();
+		z(me.lessThan(W(1)), () => {
+			B();
+		});
+		let ge = pt(W(U(me).mul(A)), me.sub(W(1))).toVar(), _e = L(r, j(pe.add(q(ge)))), N = {
+			..._e,
+			vm: ie?.(_e.position) ?? null
+		}, ve = N.position.sub(E.position).toVar(), ye = G(H(ve, ve), 1e-12).toVar(), P = ve.div(vt(ye)).toVar(), be = H(P, E.N).toVar(), xe = H(P, E.facetN).toVar(), Se = H(P, N.facetN).negate().toVar(), F = be.greaterThan(0).and(xe.greaterThan(0)).and(Se.greaterThan(0)), Ce = be.lessThan(0).and(xe.lessThan(0)), we = Se.lessThan(0);
+		z((C ? Ce.or(be.greaterThan(0).and(xe.greaterThan(0))).and(we.or(Se.greaterThan(0))) : F).not(), () => {
+			B();
+		});
+		let Te = dn(E.materialIndex, E.uv, E.N, u), Ee = dn(N.materialIndex, N.uv, N.N, u), De = P.negate();
+		C && z(Ce.and(Te.diffuseTransmission.lessThanEqual(0)).or(we.and(Ee.diffuseTransmission.lessThanEqual(0))), () => {
+			B();
+		});
+		let Oe = (e) => C ? fn(E.N, e, Te) : E.N, ke = (e) => C ? fn(N.N, e, Ee) : N.N, Ae = je(E.V, P, E.N, Te).toVar(), Me = je(De, N.V, ke(De), Ee).toVar(), Ne = (C ? V(be) : be).mul(pn(N.V, N.N, N.facetN, De)).div(ye), Fe = Ve(E.V, P, E.N, Te), Ie = Ve(P, E.V, Oe(P), Te), Re = Ve(N.V, De, N.N, Ee), ze = Ve(De, N.V, ke(De), Ee), Be = Jt(Fe.mul(C ? V(Se) : Se).div(ye), N, ze), He = Jt(Re.mul(C ? V(xe) : xe).div(ye), E, Ie), Ue = se.add(ge).add(W(1)), We = tn(S, en.CONNECT, $t(Be, He), U(1).div(U(Ue.sub(W(1))))), Ge = I(E.throughput.mul(Ae).mul(Me).mul(N.throughput).mul(Ne.mul(We).mul(U(me)).mul(ne)), U(Ue.sub(W(1))), re, W(p)).toVar();
+		z(s(Ge).greaterThan(0), () => {
+			let e = t(E.position, C ? K(Ce, E.facetN.negate(), E.facetN) : E.facetN).toVar(), r = t(N.position, C ? K(we, N.facetN.negate(), N.facetN) : N.facetN).sub(e).toVar(), i = ut(r).toVar(), o = fe(e, r.div(i), i.mul(a), v, c, l, u);
+			z(o.greaterThan(0), () => {
+				let e = ae(n, w).toVar();
+				he(n, w, Ct(e.xyz.add(Ge.mul(o)), e.w));
+			});
+		});
+	});
+}
+var jn = 4294967295, Mn = 1024, Nn = Math.log2(1.25), Pn = (e, t) => W(G(ot(ft(t.div(e.mergeMin)).div(Nn)), 0)), Fn = (e, t) => e.mergeMin.mul(at(U(t.add(W(1))).mul(Nn))).mul(2).div(G(U(1).sub(e.mergeSlope), .5)), In = (e, t, n) => q(t.x).mul(q(73856093)).bitXor(q(t.y).mul(q(19349663))).bitXor(q(t.z).mul(q(83492791))).bitXor(q(e).mul(q(2654435761))).bitAnd(n), Ln = (e, t) => {
+	let n = Pn(e, Yt(e, t)).toVar();
+	return {
+		shell: n,
+		cell: lt(ot(t.div(Fn(e, n)))).toVar()
+	};
+};
+function Rn({ head: e, hashSize: t }) {
+	return Xe(() => {
+		z(st.lessThan(q(t)), () => {
+			tt(e.element(st), q(jn));
+		});
+	})().compute(Math.ceil(t / 256) * 256, [256]);
+}
+function zn({ hitBufferRW: e, head: t, bidirectional: n }) {
+	let { lightPaths: r, slotsPerPath: i, lightTag: a, hashMask: o } = n;
+	return Xe(() => {
+		let s = st.toVar();
+		z(s.greaterThanEqual(r.mul(i)), () => {
+			B();
+		});
+		let c = s.mod(i).toVar();
+		z(c.greaterThanEqual(R(e, j(s.sub(c)), a)), () => {
+			B();
+		});
+		let l = j(s), { shell: u, cell: d } = Ln(n, C(e, l)), f = In(u, d, o);
+		D(e, l, $e("atomicExchange", t.element(f), s));
+	});
+}
+function Bn(e) {
+	let { rayBufferRW: t, hitBufferRO: n, activeIndicesRO: r, counters: i, head: a, materialBuffer: o, bidirectional: c, maxBounceCount: l, globalIlluminationIntensity: u, fireflyThreshold: d, accumFrame: f, diffuseTransmission: p = !0 } = e, { passTag: m, slotsPerPath: h, strategyView: ee, hashMask: g } = c;
+	return Xe(() => {
+		let e = st;
+		z(e.greaterThanEqual(et(i.element(q(Le.ENTERING_COUNT)))), () => {
+			B();
+		});
+		let _ = r.element(e).toVar(), v = Pe(_);
+		z(de(n, v).notEqual(m), () => {
+			B();
+		});
+		let y = L(n, v), b = W(y.extra).toVar(), x = W(l).add(W(1)).sub(b).toVar(), S = dn(y.materialIndex, y.uv, y.N, o), te = Y(0).toVar(), ne = Yt(c, y.position).toVar(), re = ne.mul(ne).toVar(), ie = Xt(c, ne).toVar(), w = ie.mul(c.mergeTrust), oe = U(1).div(G(w.mul(w), 1e-30)).toVar(), T = ut(y.position.sub(c.cameraPosition)).toVar(), E = Pn(c, G(c.mergeConst.add(c.mergeSlope.mul(G(T.sub(ne), 0))), c.mergeMin)).toVar(), se = pt(Pn(c, c.mergeConst.add(c.mergeSlope.mul(T.add(ne)))), E.add(W(1))).toVar();
+		Ze({
+			start: W(0),
+			end: W(16),
+			type: "int",
+			condition: "<"
+		}, ({ i: e }) => {
+			let t = E.add(e.shiftRight(W(3))).toVar();
+			z(t.greaterThan(se), () => {
+				Ye();
+			});
+			let r = Fn(c, t).toVar(), i = e.bitAnd(W(7)), o = lt(ot(y.position.div(r).sub(.5))).add(lt(i.bitAnd(W(1)), i.shiftRight(W(1)).bitAnd(W(1)), i.shiftRight(W(2)))).toVar(), s = et(a.element(In(t, o, g))).toVar(), l = W(0).toVar();
+			Ze(s.notEqual(q(jn)).and(l.lessThan(W(Mn))), () => {
+				let e = j(s), r = C(n, e).toVar(), i = r.sub(y.position), a = W(s.mod(h)).add(W(1)).toVar();
+				z(H(i, i).lessThan(re).and(a.lessThanEqual(x)), () => {
+					let i = Ln(c, r);
+					z(i.shell.equal(t).and(i.cell.x.equal(o.x)).and(i.cell.y.equal(o.y)).and(i.cell.z.equal(o.z)), () => {
+						let t = L(n, e), r = H(t.V, y.N).toVar(), i = H(t.V, y.facetN).toVar(), o = r.greaterThan(0).and(i.greaterThan(0)), s = S.diffuseTransmission.greaterThan(0).and(r.lessThan(0)).and(i.lessThan(0));
+						z(p ? o.or(s) : o, () => {
+							let e = je(y.V, t.V, y.N, S), n = Qt(t, Ve(y.V, t.V, y.N, S), oe), o = p ? fn(y.N, t.V, S) : y.N, s = Qt(y, Ve(t.V, y.V, o, S), oe), c = b.add(a), l = tn(ee, en.MERGE, $t(n, s), U(1).div(U(c))), m = K(c.greaterThan(W(1)), u, U(1)), h = p ? V(r).div(G(V(i), 1e-4)) : r.div(G(i, 1e-4));
+							te.addAssign(I(y.throughput.mul(e).mul(t.throughput).mul(l.mul(h).div(ie).mul(m)), U(c.sub(W(1))), d, W(f)));
+						});
+					});
+				}), s.assign(Ae(n, e)), l.addAssign(W(1));
+			});
+		}), z(s(te).greaterThan(0), () => {
+			let e = ae(t, _).toVar();
+			he(t, _, Ct(e.xyz.add(te), e.w));
+		});
+	});
+}
+function Vn(n) {
+	let { hitBufferRO: r, splatBuffer: i, bvhBuffer: o, triangleBuffer: s, materialBuffer: c, lightPaths: l, slotsPerPath: u, lightTag: d, strategyView: f, cameraPosition: p, cameraForward: m, cameraClipStart: h, cameraViewMatrix: ee, cameraProjectionMatrix: g, pixelArea: _, renderWidth: v, renderHeight: y, globalIlluminationIntensity: x, fireflyThreshold: S, accumFrame: te, frame: re, mergeVm: ie = null, diffuseTransmission: C = !0 } = n;
+	return Xe(() => {
+		let n = st.toVar();
+		z(n.greaterThanEqual(l.mul(u)), () => {
+			B();
+		});
+		let w = n.mod(u).toVar(), ae = R(r, j(n.sub(w)), d);
+		z(w.greaterThanEqual(ae), () => {
+			B();
+		});
+		let oe = L(r, j(n)), T = {
+			...oe,
+			vm: ie?.(oe.position) ?? null
+		}, E = p.sub(T.position).toVar(), se = G(H(E, E), 1e-12).toVar(), ce = E.div(vt(se)).toVar(), le = H(ce, T.facetN).toVar(), D = H(ce, m).negate().toVar(), O = le.lessThan(0), ue = C ? K(O, T.extra.bitAnd(q(2)), T.extra.bitAnd(q(1))).notEqual(q(0)) : T.extra.notEqual(q(0)), k = h.div(G(D, 1e-6)).toVar();
+		z((C ? le.equal(0) : le.lessThanEqual(0)).or(D.lessThanEqual(1e-6)).or(ue).or(se.lessThanEqual(k.mul(k))), () => {
+			B();
+		});
+		let de = g.mul(ee.mul(Ct(T.position, 1))).toVar();
+		z(de.w.lessThanEqual(0), () => {
+			B();
+		});
+		let A = ot(de.x.div(de.w).mul(.5).add(.5).mul(U(v))).toVar(), pe = ot(U(.5).sub(de.y.div(de.w).mul(.5)).mul(U(y))).toVar();
+		z(A.lessThan(0).or(pe.lessThan(0)).or(A.greaterThanEqual(U(v))).or(pe.greaterThanEqual(U(y))), () => {
+			B();
+		});
+		let M = dn(T.materialIndex, T.uv, T.N, c);
+		C && z(O.and(M.diffuseTransmission.lessThanEqual(0)), () => {
+			B();
+		});
+		let me = C ? fn(T.N, ce, M) : T.N, he = je(ce, T.V, me, M).toVar(), ge = U(1).div(_.mul(D).mul(D).mul(D)).div(se).toVar(), _e = Jt(ge.mul(C ? V(le) : le).div(U(l)), T, Ve(ce, T.V, me, M)), N = w.add(q(1)), ve = U(1).toVar();
+		z(N.greaterThan(q(1)), () => {
+			ve.assign(x);
+		});
+		let ye = I(T.throughput.mul(he).mul(pn(T.V, T.N, T.facetN, ce)).mul(ge.div(U(l)).mul(tn(f, en.LIGHT_TRACE, $t(_e, U(0)))).mul(ve)), U(w), S, W(te)).toVar(), P = t(T.position, C ? K(O, T.facetN.negate(), T.facetN) : T.facetN).toVar(), be = p.sub(P).toVar(), xe = ut(be).toVar(), Se = fe(P, be.div(xe), xe.sub(k).mul(a), ne, o, s, c);
+		z(Se.greaterThan(0), () => {
+			let t = pt(e(ye.mul(Se)), Y(Vt)).mul(Bt).toVar(), r = U(b({ state: n.bitXor(q(re).mul(q(2654435769))) }).shiftRight(q(8))).mul(1 / 16777216).toVar(), a = q(pe).mul(q(v)).add(q(A)).mul(q(3)).toVar();
+			Qe(i.element(a), q(ot(t.x.add(r)))), Qe(i.element(a.add(q(1))), q(ot(t.y.add(r)))), Qe(i.element(a.add(q(2))), q(ot(t.z.add(r))));
+		});
+	});
+}
+function Hn(e) {
+	let { rayBufferRW: t, splatBuffer: n, renderWidth: r, chunkRowBase: i, chunkRows: a } = e;
+	return Xe(() => {
+		let e = W(wt.x).mul(16).add(W(dt.x)), o = W(wt.y).mul(16).add(W(dt.y));
+		z(e.lessThan(r).and(o.lessThan(a)), () => {
+			let a = q(o.mul(r).add(e)), s = q(o.add(i).mul(r).add(e)).mul(q(3)).toVar(), c = et(n.element(s)).toVar(), l = et(n.element(s.add(q(1)))).toVar(), u = et(n.element(s.add(q(2)))).toVar();
+			z(c.bitOr(l).bitOr(u).notEqual(q(0)), () => {
+				tt(n.element(s), q(0)), tt(n.element(s.add(q(1))), q(0)), tt(n.element(s.add(q(2))), q(0));
+				let e = ae(t, a).toVar();
+				he(t, a, Ct(e.xyz.add(Y(U(c), U(l), U(u)).div(Bt)), e.w));
+			});
+		});
+	});
+}
+//#endregion
+//#region src/addons/bidirectional/BidirectionalIntegrator.js
+var { PASS_TAG_BIT: Un, STRATEGY: Wn, STRATEGY_ALONE: Gn, SOURCE: $, mergeVmAt: Kn } = Rt, qn = {
+	...Rt,
+	...Dt,
+	guidedDiscPdf: wn,
+	recordEscape: En
+}, Jn = 256 * 1024 * 1024, Yn = .05, Xn = .5, Zn = (1 << 24) - 1, Qn = 1, $n = .75, er = .25, tr = class {
+	constructor(e) {
+		this.pt = e, this.bounceKernels = [
+			"connect",
+			"merge",
+			"lightCopyback"
+		], this.merging = !1, this._mergeRadiusPixels = Qn, this._mergeHeadAttr = null, this._lightCacheSlots = 0, this._splatAttr = null, this._lightTag = 0, this._passTag = 0, this._lightTraced = !1, this._lastLightBounceCounts = null, this._lastLightBounceEnergy = null, this._lastLightCurveKey = null, this._lightCurveKey = null, this.uniforms = {
+			lib: qn,
+			lightPaths: J(0, "uint"),
+			slotsPerPath: J(1, "uint"),
+			lightTag: J(1, "uint"),
+			passTag: J(0, "uint"),
+			lightTrace: J(0, "uint"),
+			strategyView: J(0, "uint"),
+			pixelArea: J(1, "float"),
+			cameraPosition: J(new Je(), "vec3"),
+			cameraForward: J(new Je(0, 0, -1), "vec3"),
+			sunPick: J(0, "float"),
+			emitterPick: J(0, "float"),
+			envPick: J(0, "float"),
+			envTable: J(0, "uint"),
+			sourceCdf: xt(new Float32Array($.LAMPS), "float"),
+			sourceCount: $.LAMPS,
+			sourceOffsets: [
+				$.LAMPS,
+				$.LAMPS,
+				$.LAMPS,
+				$.LAMPS
+			],
+			sceneCenter: J(new Je(), "vec3"),
+			sceneRadius: J(1, "float"),
+			guide: J(0, "uint"),
+			guideLearning: J(1, "uint"),
+			guideTexture: null,
+			merging: !1,
+			mergeConst: J(0, "float"),
+			mergeSlope: J(0, "float"),
+			mergeMin: J(1, "float"),
+			mergeTrust: J(er, "float"),
+			hashMask: J(0, "uint")
+		}, this._lightGuiding = !0, this._guideTexture = null, this._guideBuildAttr = null, this._u32Views = /* @__PURE__ */ new WeakMap();
+	}
+	get name() {
+		return this.merging ? "vcm" : "bidirectional";
+	}
+	select(e) {
+		this.merging = e === "vcm", this.uniforms.merging = this.merging, this._lastLightCurveKey = null;
+	}
+	get hitStride() {
+		return 7;
+	}
+	cacheBytes(e, t) {
+		let n = Math.floor(Math.min(Jn, e * .45, t * .05) / 64) * 64;
+		return this._lightCacheSlots = n / 64, n;
+	}
+	get lightVertices() {
+		return this._lightCacheSlots;
+	}
+	beforeKernelBuild() {
+		this._sizeSourceTable();
+	}
+	allocate(e) {
+		(!this._splatAttr || this._splatAttr.count < e * 3) && (this._splatAttr?.dispose(), this._splatAttr = f(e * 3, 1, Uint32Array));
+		let t = this.merging ? 2 ** Math.ceil(Math.log2(Math.max(this._lightCacheSlots, 1024))) : 0;
+		this._mergeHeadAttr?.count !== t && (this._mergeHeadAttr?.dispose(), this._mergeHeadAttr = t > 0 ? f(t, 1, Uint32Array) : null), this.uniforms.hashMask.value = Math.max(t - 1, 0), this._guideTexture || (this._guideTexture = new Ge(null, gn, 16, qe, Ke), this._guideTexture.source.dataReady = !1, this._guideTexture.needsUpdate = !0, this._guideBuildAttr = f(_n * 16, 1, Float32Array)), this.uniforms.guideTexture = bt(this._guideTexture), this.uniforms.guide.value = 0;
+	}
+	registerKernels(e) {
+		let { km: t, qm: n, pb: r, counters: i, bounceCountsBuf: a, wfCurrentBounce: o, copyReadB: s, copyWriteA: c, maxRays: l, w: u, own: d, freshLight: f, freshTri: p, freshBvh: m, freshMat: h, freshEnvTex: ee, freshEnvCDF: g, materialLayers: _ } = e, v = _?.diffuseTransmission ?? !0, y = this.uniforms, b = n.MAX_BOUNCE_SNAPSHOTS, x = (e) => {
+			let t = q(o).clamp(q(0), q(b - 1));
+			Me(i, a, t.add(q(2 * b)), t.add(q(3 * b)), e);
+		};
+		if (t.register("lightSnapshot", F({
+			counters: i,
+			record: x
+		})().compute([
+			1,
+			1,
+			1
+		], [
+			1,
+			1,
+			1
+		])), t.register("lightCopyback", Re({
+			counters: i,
+			survivors: s,
+			activeIndicesRW: c,
+			record: x
+		})().compute([
+			Math.ceil(l / 256),
+			1,
+			1
+		], [
+			256,
+			1,
+			1
+		])), t.register("guideClear", On({ counters: i })), t.register("guideBuild", Dn({
+			counters: i,
+			out: yt(this._guideBuildAttr, "float")
+		})), t.register("lightGenerate", d(kn({
+			rayBufferRW: r.rayBuffer.rw,
+			hitBufferRW: r.hitBuffer.rw,
+			activeIndicesRW: n.activeIndices.a,
+			counters: i,
+			lightBuffer: f,
+			triangleBuffer: p,
+			bvhBuffer: m,
+			emissiveTriangleCount: this.pt.emissiveTriangleCount,
+			emissiveVec4Offset: this.pt.emissiveVec4Offset,
+			emissiveTotalPower: this.pt.emissiveTotalPower,
+			emissiveBoost: this.pt.emissiveBoost,
+			sunDirection: this.pt.sunDirection,
+			sunRadiance: this.pt.sunRadiance,
+			sunParams: this.pt.sunParams,
+			environmentIntensity: this.pt.environmentIntensity,
+			envTexture: ee,
+			envCDFTexture: g,
+			envMatrix: this.pt.environmentMatrix,
+			envResolution: this.pt.envResolution,
+			directionalLightsBuffer: this.pt.directionalLightsBufferNode,
+			areaLightsBuffer: this.pt.areaLightsBufferNode,
+			pointLightsBuffer: this.pt.pointLightsBufferNode,
+			spotLightsBuffer: this.pt.spotLightsBufferNode,
+			bidirectional: y,
+			resolution: this.pt.resolution,
+			frame: this.pt.seedFrame,
+			transmissiveBounces: this.pt.transmissiveBounces
+		})()).compute([
+			Math.ceil(l / 256),
+			1,
+			1
+		], [
+			256,
+			1,
+			1
+		])), t.register("connect", d(An({
+			rayBufferRW: r.rayBuffer.rw,
+			hitBufferRO: r.hitBuffer.ro,
+			activeIndicesRO: n.getActiveReadRO(),
+			counters: i,
+			bvhBuffer: m,
+			triangleBuffer: p,
+			materialBuffer: h,
+			resolution: this.pt.resolution,
+			frame: this.pt.seedFrame,
+			accumFrame: this.pt.frame,
+			currentBounce: this.pt._wfCurrentBounce,
+			chunkRowBase: this.pt._wfChunkRowBase,
+			lightPaths: y.lightPaths,
+			slotsPerPath: y.slotsPerPath,
+			lightTag: y.lightTag,
+			passTag: y.passTag,
+			strategyView: y.strategyView,
+			maxBounceCount: this.pt.maxBounces,
+			globalIlluminationIntensity: this.pt.globalIlluminationIntensity,
+			fireflyThreshold: this.pt.fireflyThreshold,
+			mergeVm: y.merging ? (e) => Kn(y, e) : null,
+			diffuseTransmission: v
+		})()).compute([
+			Math.ceil(l / 256),
+			1,
+			1
+		], [
+			256,
+			1,
+			1
+		])), y.merging) {
+			let e = yt(this._mergeHeadAttr, "uint").toAtomic();
+			t.register("mergeClear", Rn({
+				head: e,
+				hashSize: this._mergeHeadAttr.count
+			})), t.register("mergeInsert", zn({
+				hitBufferRW: r.hitBuffer.rw,
+				head: e,
+				bidirectional: y
+			})().compute([
+				Math.ceil(this._lightCacheSlots / 256),
+				1,
+				1
+			], [
+				256,
+				1,
+				1
+			])), t.register("merge", d(Bn({
+				rayBufferRW: r.rayBuffer.rw,
+				hitBufferRO: r.hitBuffer.ro,
+				activeIndicesRO: n.getActiveReadRO(),
+				counters: i,
+				head: e,
+				materialBuffer: h,
+				bidirectional: y,
+				maxBounceCount: this.pt.maxBounces,
+				globalIlluminationIntensity: this.pt.globalIlluminationIntensity,
+				fireflyThreshold: this.pt.fireflyThreshold,
+				accumFrame: this.pt.frame,
+				diffuseTransmission: v
+			})()).compute([
+				Math.ceil(l / 256),
+				1,
+				1
+			], [
+				256,
+				1,
+				1
+			]));
+		}
+		let S = yt(this._splatAttr, "uint").toAtomic();
+		t.register("lightSplat", d(Vn({
+			hitBufferRO: r.hitBuffer.ro,
+			splatBuffer: S,
+			bvhBuffer: m,
+			triangleBuffer: p,
+			materialBuffer: h,
+			lightPaths: y.lightPaths,
+			slotsPerPath: y.slotsPerPath,
+			lightTag: y.lightTag,
+			strategyView: y.strategyView,
+			cameraPosition: y.cameraPosition,
+			cameraForward: y.cameraForward,
+			cameraClipStart: this.pt.cameraClipStart,
+			cameraViewMatrix: this.pt.cameraViewMatrix,
+			cameraProjectionMatrix: this.pt.cameraProjectionMatrix,
+			pixelArea: y.pixelArea,
+			renderWidth: this.pt._wfRenderWidth,
+			renderHeight: this.pt._wfRenderHeight,
+			globalIlluminationIntensity: this.pt.globalIlluminationIntensity,
+			fireflyThreshold: this.pt.fireflyThreshold,
+			accumFrame: this.pt.frame,
+			frame: this.pt.seedFrame,
+			mergeVm: y.merging ? (e) => Kn(y, e) : null,
+			diffuseTransmission: v
+		})()).compute([
+			Math.ceil(this._lightCacheSlots / 256),
+			1,
+			1
+		], [
+			256,
+			1,
+			1
+		])), t.register("splatResolve", Hn({
+			rayBufferRW: r.rayBuffer.rw,
+			splatBuffer: S,
+			renderWidth: this.pt._wfRenderWidth,
+			chunkRowBase: this.pt._wfChunkRowBase,
+			chunkRows: this.pt._wfChunkRows
+		})().compute([
+			Math.ceil(u / 16),
+			Math.ceil(this.pt._chunkRows / 16),
+			1
+		], [
+			16,
+			16,
+			1
+		]));
+	}
+	beginFrame(e) {
+		let t = this._updateBidirectionalUniforms();
+		return this._lightTraced = t && this.uniforms.lightTrace.value > 0, t && (this._updateLightGuide(), this._traceLightPaths(e)), t;
+	}
+	beforeShade() {
+		this.uniforms.passTag.value = this._nextPassTag();
+	}
+	afterShade(e) {
+		e.dispatch("connect"), this.merging && e.dispatch("merge");
+	}
+	resolve(e) {
+		this._lightTraced && e.dispatch("splatResolve");
+	}
+	get curveKey() {
+		return this._lightCurveKey;
+	}
+	applyLightCurve(e, t, n) {
+		this._lastLightBounceCounts = e, this._lastLightBounceEnergy = t, this._lastLightCurveKey = n;
+	}
+	describe() {
+		return `${this.name}: ${this._lightCacheSlots.toLocaleString("en-US")} light vertex slots`;
+	}
+	gpuResources() {
+		return this._splatAttr ? [this._splatAttr, this._mergeHeadAttr].filter(Boolean) : null;
+	}
+	dispose() {
+		this._splatAttr?.dispose(), this._splatAttr = null, this._mergeHeadAttr?.dispose(), this._mergeHeadAttr = null, this._disposeLightGuide();
+	}
+	setBidirectionalStrategy(e = "all", { alone: t = !1 } = {}) {
+		let n = {
+			all: Wn.ALL,
+			hit: Wn.HIT,
+			nee: Wn.NEE,
+			connect: Wn.CONNECT,
+			lightTrace: Wn.LIGHT_TRACE,
+			merge: Wn.MERGE
+		}[e] ?? Wn.ALL;
+		this.uniforms.strategyView.value = n === Wn.ALL ? n : n + (t ? Gn : 0);
+	}
+	setMergeRadius(e = Qn) {
+		this._mergeRadiusPixels = Math.max(e, .001);
+	}
+	setMergeTrust(e = er) {
+		this.uniforms.mergeTrust.value = Math.max(e, 1e-4);
+	}
+	_updateBidirectionalUniforms() {
+		let e = this.uniforms, t = this.pt._wfRenderWidth.value, n = this.pt._wfRenderHeight.value, r = this.pt.maxBounces.value + 1, i = this._updateSourceTable() > 0 ? Math.min(Math.ceil(t * n * Xn), this.pt._packedBuffers.capacity, Math.floor(this._lightCacheSlots / r)) : 0;
+		if (e.lightPaths.value = i, e.slotsPerPath.value = r, this._lightCurveKey = `${i}:${r}:${this.pt._bounceLoopBound()}`, i === 0) return e.lightTrace.value = 0, !1;
+		this._lightTag = this._lightTag % Zn + 1, e.lightTag.value = this._lightTag;
+		let a = this.pt.cameraWorldMatrix.value.elements;
+		e.cameraPosition.value.set(a[12], a[13], a[14]), e.cameraForward.value.set(-a[8], -a[9], -a[10]).normalize();
+		let o = this.pt.cameraProjectionMatrix.value.elements;
+		e.pixelArea.value = 4 / (o[0] * o[5] * t * n);
+		let s = this.pt.cameraProjection.value === re.perspective && !this.pt.enableDOF.value;
+		return e.lightTrace.value = +!!s, this.merging && this._updateMergeRadius(t, n), !0;
+	}
+	_updateMergeRadius(e, t) {
+		let n = this.uniforms, r = this._mergeRadiusPixels * (this.pt.frameCount + 1) ** (($n - 1) / 2), i = this.pt.cameraProjection.value, a = this.pt.cameraProjectionMatrix.value.elements, o = 0, s = 0;
+		i === re.orthographic ? s = r * 2 / (a[5] * t) : o = i === re.equirectangular ? r * 2 * Math.PI / e : r * Math.sqrt(n.pixelArea.value), n.mergeSlope.value = Math.min(o, .1), n.mergeConst.value = s, n.mergeMin.value = Math.max(s, o * .001 * n.sceneRadius.value, 1e-9);
+	}
+	_sizeSourceTable() {
+		let e = this.uniforms, t = $.LAMPS;
+		[
+			"directional",
+			"area",
+			"point",
+			"spot"
+		].forEach((n, r) => {
+			e.sourceOffsets[r] = t, t += this.pt[`${n}LightsBufferNode`].array.length / A[n];
+		}), e.sourceCount = t, e.sourceCdf.array.length !== t && (e.sourceCdf.array = new Float32Array(t));
+	}
+	_updateSourceTable() {
+		let e = this.uniforms, t = e.sourceCdf.array, n = new Float64Array(t.length), r = (e, t) => Math.max(.2126 * e[t] + .7152 * e[t + 1] + .0722 * e[t + 2], 0), i = (e) => ({
+			a: this.pt[`${e}LightsBufferNode`].array,
+			n: this.pt[`num${e[0].toUpperCase()}${e.slice(1)}Lights`].value,
+			f: A[e]
+		}), a = i("directional"), o = this.pt.enableEnvironment.value > 0, s = this.pt.environment.exactTable;
+		e.envTable.value = +!!s;
+		let c = o && (this.pt.hasSun.value > 0 || s) || a.n > 0, l = c || this.merging ? this._sceneDisc() : 0, u = c ? l * Yn : 0;
+		if (o && s && (n[$.ENVIRONMENT] = Math.max(s.radianceIntegral, 0) * this.pt.environmentIntensity.value * u), this.pt.emissiveTriangleCount.value > 0 && (n[$.EMITTERS] = Math.PI * this.pt.emissiveBoost.value * this.pt.emissiveTotalPower.value), o && this.pt.hasSun.value > 0) {
+			let { x: e, y: t, z: r } = this.pt.sunRadiance.value;
+			n[$.SUN] = Math.max(.2126 * e + .7152 * t + .0722 * r, 0) * this.pt.environmentIntensity.value * this.pt.sunParams.value.y * u;
+		}
+		for (let t = 0; t < a.n; t++) n[e.sourceOffsets[0] + t] = r(a.a, t * a.f + 3) * a.a[t * a.f + 6] * u;
+		let d = i("area");
+		for (let t = 0; t < d.n; t++) {
+			let i = d.a, a = t * d.f, o = i[a + 4] * i[a + 8] - i[a + 5] * i[a + 7], s = i[a + 5] * i[a + 6] - i[a + 3] * i[a + 8], c = i[a + 3] * i[a + 7] - i[a + 4] * i[a + 6], l = 4 * Math.hypot(o, s, c) * (i[a + 15] > .5 ? Math.PI / 4 : 1);
+			n[e.sourceOffsets[1] + t] = l > 0 ? r(i, a + 9) * Math.max(i[a + 12], 0) * (i[a + 13] > .5 ? 1 : l) : 0;
+		}
+		let f = i("point");
+		for (let t = 0; t < f.n; t++) n[e.sourceOffsets[2] + t] = 4 * Math.PI * r(f.a, t * f.f + 3) * Math.max(f.a[t * f.f + 6], 0);
+		let p = i("spot");
+		for (let t = 0; t < p.n; t++) {
+			let i = t * p.f;
+			n[e.sourceOffsets[3] + t] = 2 * Math.PI * (1 - Math.cos(p.a[i + 10])) * r(p.a, i + 6) * Math.max(p.a[i + 9], 0);
+		}
+		let m = 0;
+		for (let e = 0; e < n.length; e++) m += Number.isFinite(n[e]) ? n[e] : 0;
+		let h = 0;
+		for (let e = 0; e < n.length; e++) h += Number.isFinite(n[e]) ? n[e] : 0, t[e] = m > 0 ? h / m : 0;
+		m > 0 && (t[t.length - 1] = 1);
+		let ee = (e) => Math.fround(t[e] - (e > 0 ? t[e - 1] : 0));
+		return e.sunPick.value = ee($.SUN), e.emitterPick.value = ee($.EMITTERS), e.envPick.value = ee($.ENVIRONMENT), m;
+	}
+	_sceneDisc() {
+		let e = this.uniforms, t = this._visibleSceneBounds();
+		if (!t) return 0;
+		let [n, r, i] = t.min, [a, o, s] = t.max, c = .5 * Math.hypot(a - n, o - r, s - i);
+		return c > 0 && Number.isFinite(c) ? (e.sceneCenter.value.set((n + a) / 2, (r + o) / 2, (i + s) / 2), e.sceneRadius.value = c, Math.PI * c * c) : 0;
+	}
+	_visibleSceneBounds() {
+		let e = this.pt._bvhRecords, t = e ? null : this.pt.bvhStorageAttr?.array;
+		if (!e && !(t?.length >= 16)) return null;
+		let n = this.pt._instanceTable?.blasBase ?? 1;
+		if (e && !e.isResident(0, n)) return this.pt._whenTLASResident(() => {}), null;
+		let r = (e) => {
+			let t = this._u32Views.get(e);
+			return t || this._u32Views.set(e, t = new Uint32Array(e.buffer, e.byteOffset, e.length)), t;
+		}, i = (n) => {
+			let i = e ? e.chunkFor(n) : t;
+			return {
+				f: i,
+				u: r(i),
+				o: e ? e.baseOf(n) : n * 16
+			};
+		}, a = (e) => {
+			if (e.u[e.o + 3] !== We.CLUSTER_LEAF) return e.f[e.o + 2] !== 0;
+			let t = (e.u[e.o] >>> 28 & 3) + 1;
+			for (let n = 0; n < t; n++) if (!(e.u[e.o + 12 + n] & 2147483648)) return !0;
+			return !1;
+		}, o = i(0);
+		if (o.u[o.o + 3] >= 1073741824) return null;
+		let s = e ? e.recordCount : t.length / 16, c = [], l = [];
+		for (let e = 0; e < 3; e++) for (let t of [1, -1]) {
+			let n = (n, r) => t > 0 ? n.f[n.o + r * 8 + 4 + e] : -n.f[n.o + r * 8 + e], r = (e, t) => e.u[e.o + 3 + t * 4], u = -Infinity, d = [], f = (e) => {
+				let t = n(e, 0), i = n(e, 1), a = t <= i ? 0 : 1;
+				d.push(r(e, a), a === 0 ? t : i, r(e, 1 - a), a === 0 ? i : t);
+			};
+			f(o);
+			let p = 0;
+			for (; d.length;) {
+				let e = d.pop(), t = d.pop();
+				if (e <= u) continue;
+				if (t >= s || ++p > s) return null;
+				let n = i(t);
+				n.u[n.o + 3] >= 1073741824 ? a(n) && (u = e) : f(n);
+			}
+			if (u === -Infinity) return null;
+			(t > 0 ? l : c)[e] = t > 0 ? u : -u;
+		}
+		return {
+			min: c,
+			max: l
+		};
+	}
+	setLightGuiding(e) {
+		this._lightGuiding = e !== !1, this.uniforms.guide.value = 0, this.pt.reset();
+	}
+	_updateLightGuide() {
+		let e = this.uniforms, t = this.pt._kernelManager;
+		e.guideLearning.value = +!!this._lightGuiding;
+		let n = this.pt.frameCount;
+		if (n === 0) {
+			t.dispatch("guideClear"), e.guide.value = 0;
+			return;
+		}
+		if (!this._lightGuiding || !(n <= 32 ? !(n & n - 1) : n % 32 == 0)) return;
+		t.dispatch("guideBuild");
+		let r = this.pt.renderer.backend;
+		this.pt.renderer.initTexture(this._guideTexture);
+		let i = r.device.createCommandEncoder({ label: "LightGuide" });
+		i.copyBufferToTexture({
+			buffer: r.get(this._guideBuildAttr).buffer,
+			bytesPerRow: _n * 4,
+			rowsPerImage: 16
+		}, { texture: r.get(this._guideTexture).texture }, [gn, 16]), r.device.queue.submit([i.finish()]), e.guide.value = 1;
+	}
+	_disposeLightGuide() {
+		this._guideBuildAttr?.dispose(), this._guideTexture?.dispose(), this._guideTexture = this._guideBuildAttr = null, this.uniforms.guideTexture = null;
+	}
+	_nextPassTag() {
+		return this._passTag = this._passTag + 1 & 2147483647, (Un | this._passTag) >>> 0;
+	}
+	_traceLightPaths(e) {
+		let t = this.pt._kernelManager, n = this.uniforms.lightPaths.value;
+		this.pt._wfChunkRowBase.value = 0, this.pt._wfMaxRayCount.value = n, t.setDispatchForCount("lightGenerate", n), t.dispatch("lightGenerate");
+		let r = this.pt._useDynamicDispatch, i = this._lastLightCurveKey === this._lightCurveKey, a = i ? this._lastLightBounceCounts : null, o = i ? this._lastLightBounceEnergy : null, s = this.pt._bounceEarlyExitThreshold >= 0 ? this.pt._bounceEarlyExitThreshold * n * 64 : -1;
+		for (let i = 0; i <= e; i++) {
+			this.pt._wfCurrentBounce.value = i;
+			let c = i > 0 ? a?.[i - 1] : void 0, l = r && c > 0 ? Math.min(n, Math.ceil(c * 1.5) + 1024) : n;
+			for (let e of this.pt.bounceKernels) t.setDispatchForCount(e, l);
+			if (r || t.dispatch("enterFull"), t.dispatch("extend"), this.pt._sortMaterials && (t.dispatch("resetGlobalHist"), t.dispatch("globalHist"), t.dispatch("globalPrefix"), t.dispatch("globalScatter")), t.dispatch("shade"), t.dispatch("compact"), t.dispatch(r ? "lightCopyback" : "lightSnapshot"), s >= 0 && i < e && o?.[i] !== void 0 && o[i] <= s) break;
+		}
+		this.uniforms.lightTrace.value > 0 && (t.setDispatchForCount("lightSplat", n * this.uniforms.slotsPerPath.value), t.dispatch("lightSplat")), this.merging && (t.dispatch("mergeClear"), t.setDispatchForCount("mergeInsert", n * this.uniforms.slotsPerPath.value), t.dispatch("mergeInsert"));
+	}
+};
+//#endregion
+export { Et as n, tr as t };