three-virtual-geometry 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2470 @@
+/*! three-virtual-geometry | MIT License | Independent implementation, not affiliated with Epic Games. Includes code derived from nanite-webgpu (MIT, Copyright (c) 2024 Marcin Matuszczyk). See THIRD_PARTY_NOTICES.md */
+import { MeshoptClusterizer as e, MeshoptDecoder as t, MeshoptEncoder as n, MeshoptSimplifier as r } from "meshoptimizer";
+import * as i from "three/webgpu";
+import { Fn as a, If as o, Loop as s, Return as c, atomicAdd as l, atomicLoad as u, atomicStore as d, bitcast as f, bool as p, bumpMap as m, cameraViewMatrix as h, ceil as g, clamp as _, context as v, dot as y, exp2 as b, faceDirection as x, float as S, floor as C, hash as w, instanceIndex as T, int as E, ivec2 as D, length as O, localId as k, log2 as ee, mat3 as A, mat4 as te, materialColor as j, materialReference as M, max as N, min as P, negateOnBackSide as F, normalLocal as ne, normalView as I, normalize as re, numWorkgroups as ie, positionView as ae, select as L, sqrt as oe, storage as R, texture as se, transformNormalToView as ce, uint as z, uniform as B, unpackUnorm2x16 as le, uvec4 as ue, varyingProperty as V, vec3 as de, vec4 as H, vertexIndex as fe, workgroupArray as pe, workgroupBarrier as me, workgroupId as he } from "three/tsl";
+//#region src/core/constants.ts
+var ge = 128, _e = 128, ve = 1e30, ye = .001, be = {
+	shaded: 0,
+	meshlets: 1,
+	lodLevel: 2,
+	instances: 3
+};
+//#endregion
+//#region src/core/preprocess/partition.ts
+function xe(e, t) {
+	let n = e.length;
+	if (n <= t) return [e.map((e, t) => t)];
+	let r = /* @__PURE__ */ new Map();
+	for (let t = 0; t < n; t++) for (let n of e[t].boundaryEdges) {
+		let e = r.get(n);
+		e ? e[e.length - 1] !== t && e.push(t) : r.set(n, [t]);
+	}
+	let i = Array.from({ length: n }, () => /* @__PURE__ */ new Map());
+	for (let e of r.values()) for (let t = 0; t < e.length; t++) for (let n = t + 1; n < e.length; n++) {
+		let r = e[t], a = e[n];
+		i[r].set(a, (i[r].get(a) || 0) + 1), i[a].set(r, (i[a].get(r) || 0) + 1);
+	}
+	let a = Ce(e.map((e) => e.center)), o = new Uint8Array(n), s = [];
+	for (let n of a) {
+		if (o[n]) continue;
+		let r = [n];
+		o[n] = 1;
+		let a = /* @__PURE__ */ new Map(), c = (e) => {
+			for (let [t, n] of i[e]) o[t] || a.set(t, (a.get(t) || 0) + n);
+		};
+		for (c(n); r.length < t && a.size > 0;) {
+			let t = -1, i = -1, s = Infinity;
+			for (let [r, c] of a) {
+				if (o[r]) continue;
+				let a = Se(e[r].center, e[n].center);
+				(c > i || c === i && a < s) && (t = r, i = c, s = a);
+			}
+			if (t < 0) break;
+			a.delete(t), o[t] = 1, r.push(t), c(t);
+		}
+		s.push(r);
+	}
+	let c = [], l = [], u = Math.max(2, Math.floor(t / 2));
+	for (let e of s) e.length >= u ? c.push(e) : (l.length + e.length > t && (c.push(l), l = []), l.push(...e));
+	return l.length > 0 && c.push(l), c;
+}
+function Se(e, t) {
+	let n = e[0] - t[0], r = e[1] - t[1], i = e[2] - t[2];
+	return n * n + r * r + i * i;
+}
+function Ce(e) {
+	let t = [
+		Infinity,
+		Infinity,
+		Infinity
+	], n = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (let r of e) for (let e = 0; e < 3; e++) t[e] = Math.min(t[e], r[e]), n[e] = Math.max(n[e], r[e]);
+	let r = Math.max(n[0] - t[0], n[1] - t[1], n[2] - t[2]) || 1, i = e.map((e) => {
+		let n = (n) => Math.min(1023, Math.max(0, Math.floor((e[n] - t[n]) / r * 1023)));
+		return we(n(0)) | we(n(1)) << 1 | we(n(2)) << 2;
+	});
+	return e.map((e, t) => t).sort((e, t) => i[e] - i[t]);
+}
+function we(e) {
+	return e &= 1023, e = (e | e << 16) & 50331903, e = (e | e << 8) & 50393103, e = (e | e << 4) & 51130563, e = (e | e << 2) & 153391689, e;
+}
+//#endregion
+//#region src/core/preprocess/voxelProxy.ts
+function Te(e, t, n, r, i) {
+	if (n.length === 0) return null;
+	let a = [
+		Infinity,
+		Infinity,
+		Infinity
+	], o = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (let t = 0; t < n.length; t++) {
+		let r = n[t] * 3;
+		for (let t = 0; t < 3; t++) a[t] = Math.min(a[t], e[r + t]), o[t] = Math.max(o[t], e[r + t]);
+	}
+	let s = Math.max(o[0] - a[0], o[1] - a[1], o[2] - a[2]);
+	if (!(s > 0)) return null;
+	let c = s / r, l = [
+		0,
+		1,
+		2
+	].map((e) => Math.ceil((o[e] - a[e]) / c) + 1 + 6), u = [
+		0,
+		1,
+		2
+	].map((e) => a[e] - 3 * c), [d, f, p] = l, m = d, h = d * f, g = d * f * p, _ = new Uint8Array(g), v = t ? new Float32Array(g * 3) : null, y = t ? new Uint32Array(g) : null, b = i ? new Float32Array(g * 2).fill(NaN) : null, x = 0, S = 0, C = (e, t, n, r, i, a) => {
+		let o = Math.floor((e - u[0]) / c) * 1 + Math.floor((t - u[1]) / c) * m + Math.floor((n - u[2]) / c) * h;
+		_[o] = 1, b && Number.isNaN(b[o * 2]) && (b[o * 2] = x, b[o * 2 + 1] = S), v && (v[o * 3] += r, v[o * 3 + 1] += i, v[o * 3 + 2] += a, y[o]++);
+	};
+	for (let r = 0; r < n.length; r += 3) {
+		let a = n[r] * 3, o = n[r + 1] * 3, s = n[r + 2] * 3, l = Math.max(Ee(e, a, o), Ee(e, o, s), Ee(e, s, a)), u = Math.max(1, Math.ceil(l / (c * .5)));
+		for (let c = 0; c <= u; c++) for (let l = 0; l <= u - c; l++) {
+			let d = c / u, f = l / u, p = 1 - d - f, m = e[a] * p + e[o] * d + e[s] * f, h = e[a + 1] * p + e[o + 1] * d + e[s + 1] * f, g = e[a + 2] * p + e[o + 2] * d + e[s + 2] * f;
+			if (i) {
+				let e = n[r] * 2, t = n[r + 1] * 2, a = n[r + 2] * 2;
+				x = i[e] * p + i[t] * d + i[a] * f, S = i[e + 1] * p + i[t + 1] * d + i[a + 1] * f;
+			}
+			t ? C(m, h, g, t[a] * p + t[o] * d + t[s] * f, t[a + 1] * p + t[o + 1] * d + t[s + 1] * f, t[a + 2] * p + t[o + 2] * d + t[s + 2] * f) : C(m, h, g, 0, 0, 0);
+		}
+	}
+	let w = De(U(_, l), l), T = new Float32Array(g);
+	for (let e = 0; e < g; e++) T[e] = w[e];
+	ke(T, l, 1, d), ke(T, l, m, f), ke(T, l, h, p);
+	let E = .5, D = d - 1, O = f - 1, k = p - 1, ee = new Int32Array(D * O * k).fill(-1), A = [], te = [], j = [], M = [], N = /* @__PURE__ */ new Float32Array(8);
+	for (let e = 0; e < k; e++) for (let t = 0; t < O; t++) for (let n = 0; n < D; n++) {
+		let r = n * 1 + t * m + e * h, i = 0;
+		for (let e = 0; e < 8; e++) N[e] = T[r + (e & 1) * 1 + (e >> 1 & 1) * m + (e >> 2 & 1) * h], N[e] >= E && i++;
+		if (i === 0 || i === 8) continue;
+		let a = 0, o = 0, s = 0, l = 0;
+		for (let e = 0; e < 8; e++) for (let t of [
+			1,
+			2,
+			4
+		]) {
+			if (e & t) continue;
+			let n = e | t, r = N[e], i = N[n];
+			if (r >= E == i >= E) continue;
+			let c = (E - r) / (i - r);
+			a += (e & 1) + (t === 1 ? c : 0), o += (e >> 1 & 1) + (t === 2 ? c : 0), s += (e >> 2 & 1) + (t === 4 ? c : 0), l++;
+		}
+		ee[n + t * D + e * D * O] = A.length / 3, A.push(u[0] + (n + .5 + a / l) * c, u[1] + (t + .5 + o / l) * c, u[2] + (e + .5 + s / l) * c);
+		let d = N[1] + N[3] + N[5] + N[7] - N[0] - N[2] - N[4] - N[6], f = N[2] + N[3] + N[6] + N[7] - N[0] - N[1] - N[4] - N[5], p = N[4] + N[5] + N[6] + N[7] - N[0] - N[1] - N[2] - N[3], g = Math.hypot(d, f, p) || 1;
+		if (te.push(-d / g, -f / g, -p / g), v) {
+			let e = 0, t = 0, n = 0, i = 0;
+			for (let a = 0; a < 8; a++) {
+				let o = r + (a & 1) * 1 + (a >> 1 & 1) * m + (a >> 2 & 1) * h;
+				y[o] && (e += v[o * 3], t += v[o * 3 + 1], n += v[o * 3 + 2], i += y[o]);
+			}
+			i ? j.push(e / i, t / i, n / i) : j.push(NaN, NaN, NaN);
+		}
+		if (b) {
+			let e = NaN, t = NaN;
+			for (let n = 0; n < 8 && Number.isNaN(e); n++) {
+				let i = r + (n & 1) * 1 + (n >> 1 & 1) * m + (n >> 2 & 1) * h;
+				e = b[i * 2], t = b[i * 2 + 1];
+			}
+			M.push(e, t);
+		}
+	}
+	let P = [], F = (e, t, n) => ee[e + t * D + n * D * O], ne = (e, t, n, r, i, a, o) => {
+		let s = A[n * 3] - A[e * 3], c = A[n * 3 + 1] - A[e * 3 + 1], l = A[n * 3 + 2] - A[e * 3 + 2], u = A[r * 3] - A[t * 3], d = A[r * 3 + 1] - A[t * 3 + 1], f = A[r * 3 + 2] - A[t * 3 + 2], p = c * f - l * d, m = l * u - s * f, h = s * d - c * u;
+		p * i + m * a + h * o >= 0 ? P.push(e, t, n, e, n, r) : P.push(e, n, t, e, r, n);
+	};
+	for (let e = 1; e < p - 1; e++) for (let t = 1; t < f - 1; t++) for (let n = 1; n < d - 1; n++) {
+		let r = n * 1 + t * m + e * h, i = T[r] >= E;
+		if (i !== T[r + 1] >= E) {
+			let r = i ? 1 : -1;
+			ne(F(n, t - 1, e - 1), F(n, t, e - 1), F(n, t, e), F(n, t - 1, e), r, 0, 0);
+		}
+		if (i !== T[r + m] >= E) {
+			let r = i ? 1 : -1;
+			ne(F(n - 1, t, e - 1), F(n, t, e - 1), F(n, t, e), F(n - 1, t, e), 0, r, 0);
+		}
+		if (i !== T[r + h] >= E) {
+			let r = i ? 1 : -1;
+			ne(F(n - 1, t - 1, e), F(n, t - 1, e), F(n, t, e), F(n - 1, t, e), 0, 0, r);
+		}
+	}
+	if (P.length === 0) return null;
+	let I = null;
+	v && (I = Float32Array.from(j), Ae(I, P, 3));
+	let re = null;
+	return b && (re = Float32Array.from(M), Ae(re, P, 2)), {
+		positions: Float32Array.from(A),
+		normals: Float32Array.from(te),
+		colors: I,
+		uvs: re,
+		indices: Uint32Array.from(P),
+		cellSize: c
+	};
+}
+function Ee(e, t, n) {
+	return Math.hypot(e[t] - e[n], e[t + 1] - e[n + 1], e[t + 2] - e[n + 2]);
+}
+function U(e, t) {
+	let n = e;
+	for (let e = 0; e < 3; e++) n = Oe(n, t, e, 1);
+	return n;
+}
+function De(e, t) {
+	let n = e;
+	for (let e = 0; e < 3; e++) n = Oe(n, t, e, 0);
+	return n;
+}
+function Oe(e, t, n, r) {
+	let [i, a, o] = t, s = n === 0 ? 1 : n === 1 ? i : i * a, c = t[n], l = new Uint8Array(e.length);
+	for (let t = 0; t < o; t++) for (let o = 0; o < a; o++) for (let u = 0; u < i; u++) {
+		let d = u + o * i + t * i * a, f = n === 0 ? u : n === 1 ? o : t, p = f > 0 ? e[d - s] : 0, m = f < c - 1 ? e[d + s] : 0;
+		l[d] = r ? e[d] | p | m : e[d] & p & m;
+	}
+	return l;
+}
+function ke(e, t, n, r) {
+	let [i, a, o] = t, s = new Float32Array(r), c = i * a * o / r;
+	for (let t = 0; t < c; t++) {
+		let o;
+		o = n === 1 ? t * i : n === i ? t % i + Math.floor(t / i) * i * a : t;
+		for (let t = 0; t < r; t++) s[t] = e[o + t * n];
+		for (let t = 0; t < r; t++) {
+			let i = t > 0 ? s[t - 1] : 0, a = t < r - 1 ? s[t + 1] : 0;
+			e[o + t * n] = (i + s[t] + a) / 3;
+		}
+	}
+}
+function Ae(e, t, n) {
+	let r = e.length / n;
+	for (let i = 0; i < 8; i++) {
+		let i = 0, a = new Float32Array(r * n), o = new Uint32Array(r);
+		for (let r = 0; r < t.length; r += 3) for (let i = 0; i < 3; i++) {
+			let s = t[r + i];
+			if (Number.isNaN(e[s * n])) for (let c = 1; c < 3; c++) {
+				let l = t[r + (i + c) % 3];
+				if (!Number.isNaN(e[l * n])) {
+					for (let t = 0; t < n; t++) a[s * n + t] += e[l * n + t];
+					o[s]++;
+				}
+			}
+		}
+		for (let t = 0; t < r; t++) if (Number.isNaN(e[t * n])) {
+			if (o[t]) for (let r = 0; r < n; r++) e[t * n + r] = a[t * n + r] / o[t];
+			else i++;
+		}
+		if (!i) return;
+	}
+	for (let t = 0; t < e.length; t++) Number.isNaN(e[t]) && (e[t] = .5);
+}
+//#endregion
+//#region src/core/preprocess/buildVirtualMesh.ts
+var je = {
+	groupSize: 12,
+	maxLodLevels: 24,
+	maxGroupKeepRatio: .9,
+	simplifyRatio: .5,
+	minLevelReduction: .03,
+	prune: !1,
+	tailSimplify: !0,
+	minRootTriangles: 4,
+	voxelLods: !0
+}, Me = 1024, Ne = [
+	64,
+	32,
+	16,
+	8,
+	4
+], Pe = () => new Promise((e) => setTimeout(e, 0));
+async function Fe(t, n = {}) {
+	let i = {
+		...je,
+		...n
+	}, a = performance.now();
+	await e.ready, await r.ready;
+	let o = t.positions, s = t.normals, c = t.colors ?? null, l = t.uvs ?? null, u = r.generatePositionRemap(o, 3), d = 0, f = ["LockBorder", "ErrorAbsolute"];
+	i.prune && f.push("Prune");
+	let p = [], m = /* @__PURE__ */ new Map(), h = C(t.indices, 0, null, 0), g = h, _ = Ue(g), v = 1, y = Math.max(1, h.length * 2);
+	for (let e = 1; e <= i.maxLodLevels && g.length > 1 && !(i.tailSimplify && _ <= Me); e++) {
+		let t = xe(g, i.groupSize), n = [];
+		for (let a of t) {
+			let t = a.map((e) => g[e]), s = He(t), c = G(s, o), l = Math.max(3, Math.floor(s.length * i.simplifyRatio / 3) * 3), [u, d] = r.simplify(c.indices, c.positions, 3, l, 1e10, f);
+			if (u.length > s.length * i.maxGroupKeepRatio) continue;
+			let p = Ge(t.map((e) => e.lodSphere)), m = Math.max(...t.map((e) => e.error)), h = Math.max(d, W(c.indices, u, c.positions)), _ = m + Math.max(h, 1e-7);
+			for (let e of t) e.parentSphere = p, e.parentError = _;
+			let v = new Uint32Array(u.length);
+			for (let e = 0; e < u.length; e++) v[e] = c.toGlobal[u[e]];
+			if (v.length > 0) {
+				let r = C(v, e, p, _);
+				n.push(...r);
+				for (let e of t) e.replacements = r;
+			}
+		}
+		if (await i.onProgress?.(Math.min(.99, p.length / y)), await Pe(), n.length === 0) break;
+		v = e + 1, g = n;
+		let a = Ue(g);
+		if (a > _ * (1 - i.minLevelReduction)) break;
+		_ = a;
+	}
+	return i.tailSimplify && (v = S(p.filter((e) => e.parentError >= ve), v)), await i.onProgress?.(1), Ie({
+		positions: o,
+		normals: s,
+		colors: c ?? void 0,
+		uvs: l ?? void 0,
+		indices: t.indices
+	}, p, v, d, performance.now() - a);
+	function b(e, t, n, r) {
+		let i = o.length / 3, a = e.length / 3, d = (e, t) => {
+			let n = new Float32Array(e.length + t.length);
+			return n.set(e), n.set(t, e.length), n;
+		};
+		o = d(o, e), s = d(s, t), c &&= d(c, n ?? new Float32Array(a * 3).fill(1)), l &&= d(l, r ?? new Float32Array(a * 2));
+		let f = new Uint32Array(u.length + a);
+		f.set(u);
+		for (let e = 0; e < a; e++) f[u.length + e] = i + e;
+		return u = f, i;
+	}
+	function x(e) {
+		return m.has(e) || m.set(e, Te(t.positions, t.colors, t.indices, e, t.uvs)), m.get(e);
+	}
+	function S(e, t) {
+		if (e.length === 0) return t;
+		let n = ["ErrorAbsolute"];
+		i.prune && n.push("Prune");
+		let a = e, s = t;
+		for (; s < t + i.maxLodLevels; s++) {
+			let e = He(a);
+			if (e.length / 3 <= i.minRootTriangles) break;
+			let t = G(e, o), c = Math.max(3, Math.floor(e.length / 2 / 3) * 3), l = e.length * i.maxGroupKeepRatio, u = Math.max(...a.map((e) => e.error)), [f, p] = r.simplify(t.indices, t.positions, 3, c, 1e10, n);
+			if (f.length > l) {
+				let [e, n] = r.simplifySloppy(t.indices, t.positions, 3, null, c, 1);
+				e.length < f.length && (f = e, p = n * r.getScale(t.positions, 3));
+			}
+			let m = null, h = Infinity;
+			if (f.length <= l) {
+				h = u + Math.max(Math.max(p, W(t.indices, f, t.positions)), 1e-7), m = new Uint32Array(f.length);
+				for (let e = 0; e < f.length; e++) m[e] = t.toGlobal[f[e]];
+			}
+			let g = null;
+			if (i.voxelLods) for (let e of Ne) {
+				let t = x(e);
+				if (!t) continue;
+				let n = Math.min(c, t.indices.length), [i, a] = r.simplify(t.indices, t.positions, 3, n, 1e10, ["ErrorAbsolute"]);
+				if (i.length === 0 || i.length > l) continue;
+				let o = Math.max(u * (1 + 1e-5) + 1e-7, 2 * t.cellSize + a);
+				o < h && (h = o, g = {
+					proxy: t,
+					indices: i
+				});
+			}
+			if (!Number.isFinite(h)) break;
+			if (g) {
+				let e = G(g.indices, g.proxy.positions), t = (t, n = 3) => {
+					let r = new Float32Array(e.toGlobal.length * n);
+					return e.toGlobal.forEach((e, i) => r.set(t.subarray(e * n, e * n + n), i * n)), r;
+				}, { proxy: n } = g, r = b(e.positions, t(n.normals), n.colors ? t(n.colors) : null, n.uvs ? t(n.uvs, 2) : null);
+				m = e.indices.map((e) => e + r), d++;
+			}
+			let _ = Ge(a.map((e) => e.lodSphere));
+			for (let e of a) e.parentSphere = _, e.parentError = h;
+			if (m.length === 0) return s + 1;
+			let v = C(m, s, _, h);
+			for (let e of a) e.replacements = v;
+			a = v;
+		}
+		return s;
+	}
+	function C(t, n, r, i) {
+		let a = G(t, o), s = e.buildMeshlets(a.indices, a.positions, 3, 128, 128, 0), c = [];
+		for (let e = 0; e < s.meshletCount; e++) {
+			let t = s.meshlets[e * 4 + 0], l = s.meshlets[e * 4 + 1], d = s.meshlets[e * 4 + 2], f = s.meshlets[e * 4 + 3], m = new Uint32Array(d);
+			for (let e = 0; e < d; e++) m[e] = a.toGlobal[s.vertices[t + e]];
+			let h = s.triangles.slice(l, l + f * 3), g = new Uint32Array(f * 3);
+			for (let e = 0; e < f * 3; e++) g[e] = m[h[e]];
+			let _ = We(g, o), v = {
+				indices: g,
+				lodLevel: n,
+				lodSphere: r ?? _,
+				error: i,
+				parentSphere: [
+					0,
+					0,
+					0,
+					0
+				],
+				parentError: ve,
+				cullSphere: _,
+				boundaryEdges: Be(g, u),
+				center: [
+					_[0],
+					_[1],
+					_[2]
+				],
+				replacements: [],
+				vertices: m,
+				localTriangles: h
+			};
+			c.push(v), p.push(v);
+		}
+		return c;
+	}
+}
+function Ie(e, t, n, r, i) {
+	let a = [...t].sort((e, t) => e.lodLevel - t.lodLevel), o = a.length, s = new Uint32Array(a.reduce((e, t) => e + t.indices.length, 0)), c = new Float32Array(o * 16), l = new Uint32Array(o * 4), u = /* @__PURE__ */ new Map();
+	a.forEach((e, t) => u.set(e, t));
+	let d = new Uint32Array(o + 1), f = [];
+	a.forEach((e, t) => {
+		d[t] = f.length;
+		for (let t of e.replacements) f.push(u.get(t));
+	}), d[o] = f.length;
+	let p = new Uint32Array(a.reduce((e, t) => e + t.vertices.length, 0)), m = new Uint32Array(s.length / 3), h = 0, g = 0, _ = {
+		leafTriangles: 0,
+		leafMeshlets: 0,
+		rootTriangles: 0,
+		rootMeshlets: 0,
+		lodLevels: n,
+		voxelLevels: r,
+		buildMs: i
+	};
+	a.forEach((e, t) => {
+		s.set(e.indices, h), p.set(e.vertices, g);
+		let n = e.localTriangles;
+		for (let e = 0, t = h / 3; e < n.length; e += 3, t++) m[t] = n[e] | n[e + 1] << 8 | n[e + 2] << 16;
+		let r = t * 16;
+		c.set(e.lodSphere, r), c.set(e.parentSphere, r + 4), c[r + 8] = e.error, c[r + 9] = e.parentError, c.set(e.cullSphere, r + 12);
+		let i = e.indices.length / 3, a = t * 4;
+		l[a + 0] = i, l[a + 1] = h, l[a + 2] = e.lodLevel, l[a + 3] = g, h += e.indices.length, g += e.vertices.length, e.lodLevel === 0 && (_.leafTriangles += i, _.leafMeshlets += 1), e.parentError >= 1e30 && (_.rootTriangles += i, _.rootMeshlets += 1);
+	});
+	let v = Ge(a.filter((e) => e.lodLevel === 0).map((e) => e.cullSphere)), y = a.length ? a[a.length - 1].lodLevel + 1 : 0, b = new Uint32Array(y * 2), x = new Float32Array(y * 2), S = new Float32Array(y * 2);
+	for (let e = 0; e < y; e++) x[e * 2] = Infinity, x[e * 2 + 1] = 0, S[e * 2] = 0, S[e * 2 + 1] = Infinity;
+	a.forEach((e, t) => {
+		let n = e.lodLevel;
+		b[n * 2 + 1] === 0 && (b[n * 2] = t), b[n * 2 + 1]++, x[n * 2] = Math.min(x[n * 2], e.error), x[n * 2 + 1] = Math.max(x[n * 2 + 1], e.parentError), S[n * 2] = Math.max(S[n * 2], e.error), S[n * 2 + 1] = Math.min(S[n * 2 + 1], e.parentError);
+	});
+	let C = Ge([...a.map((e) => e.lodSphere), ...a.filter((e) => e.parentError < ve).map((e) => e.parentSphere)]), w = Ge(a.map((e) => e.cullSphere));
+	return {
+		positions: e.positions,
+		normals: e.normals,
+		colors: e.colors ?? null,
+		uvs: e.uvs ?? null,
+		indices: s,
+		meshletCount: o,
+		meshletBounds: c,
+		meshletInfo: l,
+		replacementStart: d,
+		replacementIndices: Uint32Array.from(f),
+		meshletVertices: p,
+		meshletTriangles: m,
+		levelRanges: b,
+		levelErrors: x,
+		levelGuardErrors: S,
+		lodBoundsSphere: C,
+		cullBoundsSphere: w,
+		boundingSphere: v,
+		stats: _
+	};
+}
+function W(e, t, n) {
+	let r = (e) => {
+		let t = [
+			Infinity,
+			Infinity,
+			Infinity
+		], r = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		];
+		for (let i = 0; i < e.length; i++) {
+			let a = e[i] * 3;
+			for (let e = 0; e < 3; e++) {
+				let i = n[a + e];
+				i < t[e] && (t[e] = i), i > r[e] && (r[e] = i);
+			}
+		}
+		return {
+			min: t,
+			max: r
+		};
+	}, i = r(e);
+	if (t.length === 0) return Math.max(i.max[0] - i.min[0], i.max[1] - i.min[1], i.max[2] - i.min[2]) / 2;
+	let a = r(t), o = 0;
+	for (let e = 0; e < 3; e++) o = Math.max(o, a.min[e] - i.min[e], i.max[e] - a.max[e]);
+	return o;
+}
+var Le = /* @__PURE__ */ new Int32Array();
+function G(e, t) {
+	let n = t.length / 3;
+	Le.length < n && (Le = new Int32Array(n).fill(-1));
+	let r = new Uint32Array(e.length), i = new Uint32Array(e.length), a = 0;
+	for (let t = 0; t < e.length; t++) {
+		let n = e[t], o = Le[n];
+		o < 0 && (o = a++, Le[n] = o, r[o] = n), i[t] = o;
+	}
+	let o = r.subarray(0, a), s = new Float32Array(a * 3);
+	for (let e = 0; e < a; e++) {
+		let n = o[e];
+		Le[n] = -1, s[e * 3 + 0] = t[n * 3 + 0], s[e * 3 + 1] = t[n * 3 + 1], s[e * 3 + 2] = t[n * 3 + 2];
+	}
+	return {
+		indices: i,
+		positions: s,
+		toGlobal: o
+	};
+}
+var Re = /* @__PURE__ */ new Float64Array(1024), K = /* @__PURE__ */ new Uint8Array(1024), ze = /* @__PURE__ */ new Int32Array(512);
+function Be(e, t) {
+	let n = e.length, r = Re.length;
+	if (r < n * 2) {
+		for (; r < n * 2;) r <<= 1;
+		Re = new Float64Array(r), K = new Uint8Array(r), ze = new Int32Array(r / 2);
+	}
+	let i = r - 1, a = 0;
+	for (let n = 0; n < e.length; n += 3) for (let r = 0; r < 3; r++) {
+		let o = t[e[n + r]], s = t[e[n + (r + 1) % 3]], c = Ve(o, s), l = (Math.imul(o < s ? o : s, 2654435761) ^ Math.imul(o < s ? s : o, 2246822507)) & i;
+		for (; K[l] !== 0 && Re[l] !== c;) l = l + 1 & i;
+		K[l] === 0 && (Re[l] = c, ze[a++] = l), K[l] < 255 && K[l]++;
+	}
+	let o = [];
+	for (let e = 0; e < a; e++) {
+		let t = ze[e];
+		K[t] === 1 && o.push(Re[t]), K[t] = 0;
+	}
+	return o;
+}
+var Ve = (e, t) => e < t ? e * 67108864 + t : t * 67108864 + e;
+function He(e) {
+	let t = new Uint32Array(e.reduce((e, t) => e + t.indices.length, 0)), n = 0;
+	for (let r of e) t.set(r.indices, n), n += r.indices.length;
+	return t;
+}
+var Ue = (e) => e.reduce((e, t) => e + t.indices.length / 3, 0);
+function We(e, t) {
+	let n = [
+		Infinity,
+		Infinity,
+		Infinity
+	], r = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (let i = 0; i < e.length; i++) {
+		let a = e[i] * 3;
+		for (let e = 0; e < 3; e++) {
+			let i = t[a + e];
+			i < n[e] && (n[e] = i), i > r[e] && (r[e] = i);
+		}
+	}
+	let i = (n[0] + r[0]) / 2, a = (n[1] + r[1]) / 2, o = (n[2] + r[2]) / 2, s = 0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n] * 3, c = t[r] - i, l = t[r + 1] - a, u = t[r + 2] - o;
+		s = Math.max(s, c * c + l * l + u * u);
+	}
+	return [
+		i,
+		a,
+		o,
+		Math.sqrt(s)
+	];
+}
+function Ge(t) {
+	if (t.length === 1) return [...t[0]];
+	let n = new Float32Array(t.length * 3), r = new Float32Array(t.length);
+	t.forEach((e, t) => {
+		n.set([
+			e[0],
+			e[1],
+			e[2]
+		], t * 3), r[t] = e[3];
+	});
+	let i = e.computeSphereBounds(n, 3, r, 1), a = i.radius;
+	for (let e of t) {
+		let t = Math.hypot(e[0] - i.centerX, e[1] - i.centerY, e[2] - i.centerZ) + e[3];
+		a = Math.max(a, t);
+	}
+	return [
+		i.centerX,
+		i.centerY,
+		i.centerZ,
+		a * 1.0001
+	];
+}
+//#endregion
+//#region src/core/io/serialize.ts
+var Ke = 1, qe = 1329940310, q = 16, Je = {
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array
+}, Ye = {
+	positions: { strides: [12] },
+	normals: { strides: [12] },
+	colors: { strides: [12] },
+	uvs: { strides: [8] },
+	tangents: { strides: [16] },
+	meshletBounds: {
+		strides: [64],
+		deflateRaw: !0
+	},
+	meshletInfo: { strides: [16] }
+}, J = class extends Error {
+	constructor(e) {
+		super(`three-virtual-geometry: ${e}`), this.name = "VirtualMeshFormatError";
+	}
+};
+async function Xe(e, t = {}) {
+	let r = t.compress ?? !0;
+	r && await n.ready;
+	let i = e, a = Object.keys(i).filter((e) => i[e] !== void 0 && typeof i[e] != "function"), o = [], s = [], c = {}, l = 0;
+	for (let n of a) {
+		let a = i[n];
+		if (!ArrayBuffer.isView(a)) {
+			c[n] = a;
+			continue;
+		}
+		let u = a.constructor.name;
+		if (!(u in Je)) throw new J(`cannot serialize field "${n}" of type ${u}`);
+		let d = a, f, p;
+		n === "indices" && !t.keepIndices && tt(e) ? (p = {
+			name: n,
+			type: u,
+			length: d.length,
+			encoding: "meshlet-indices"
+		}, f = /* @__PURE__ */ new Uint8Array()) : r ? {entry: p, blob: f} = await $e(n, u, d, e, t.deflate ?? !0) : (p = {
+			name: n,
+			type: u,
+			length: d.length,
+			encoding: "raw"
+		}, f = ct(d)), o.push({
+			...p,
+			offset: l,
+			byteLength: f.length
+		}), s.push(f), l += st(f.length);
+	}
+	let u = {
+		generator: "three-virtual-geometry",
+		keys: a,
+		fields: o,
+		values: c
+	}, d = new TextEncoder().encode(JSON.stringify(u, mt)), f = st(d.length), p = new Uint8Array(q + f + l);
+	p.set(d, q), p.fill(32, q + d.length, q + f);
+	let m = q + f;
+	o.forEach((e, t) => p.set(s[t], m + e.offset));
+	let h = new DataView(p.buffer);
+	return h.setUint32(0, qe, !0), h.setUint32(4, 1, !0), h.setUint32(8, d.length, !0), h.setUint32(12, ut(p, q), !0), p;
+}
+async function Ze(e) {
+	let n = ArrayBuffer.isView(e) ? new Uint8Array(e.buffer, e.byteOffset, e.byteLength) : new Uint8Array(e);
+	n.byteOffset % 4 != 0 && (n = n.slice());
+	let r = new DataView(n.buffer, n.byteOffset, n.byteLength);
+	if (n.length < q || r.getUint32(0, !0) !== qe) throw new J("not a three-virtual-geometry geometry file (bad magic bytes)");
+	let i = r.getUint32(4, !0);
+	if (i !== 1) throw new J(`unsupported geometry format version ${i} (this build reads version 1); re-bake the file`);
+	let a = r.getUint32(8, !0), o = q + st(a);
+	if (o > n.length || n.length % 4 != 0) throw new J("geometry file is truncated");
+	let s;
+	try {
+		s = JSON.parse(new TextDecoder().decode(n.subarray(q, q + a)), ht);
+	} catch {
+		throw new J("geometry file is corrupt or truncated (unreadable header)");
+	}
+	if (!s || !Array.isArray(s.fields) || !Array.isArray(s.keys) || typeof s.values != "object") throw new J("geometry file is corrupt (malformed header)");
+	let c = n.subarray(o), l = {}, u = [...s.fields].sort((e, t) => nt(e.encoding) - nt(t.encoding));
+	u.some((e) => e.encoding !== "raw") && await t.ready;
+	for (let e of u) {
+		if (!Je[e.type] || !Number.isInteger(e.length) || e.length < 0) throw new J(`geometry file is corrupt (field "${e.name}")`);
+		if (e.offset % 4 != 0 || e.offset + e.byteLength > c.length) throw new J(`geometry file is truncated (field "${e.name}")`);
+	}
+	if (ut(n, q) !== r.getUint32(12, !0)) throw new J("geometry file is corrupt (checksum mismatch)");
+	let d = (e, t) => t instanceof J ? t : new J(`geometry file is corrupt (field "${e.name}": ${t.message})`), f = await Promise.all(u.map((e) => {
+		let t = c.subarray(e.offset, e.offset + e.byteLength);
+		return e.deflate ? pt(t).catch((t) => Promise.reject(d(e, t))) : t;
+	}));
+	for (let e = 0; e < u.length; e++) try {
+		l[u[e].name] = await rt({
+			...u[e],
+			deflate: !1
+		}, f[e], l);
+	} catch (t) {
+		throw d(u[e], t);
+	}
+	let p = {};
+	for (let e of s.keys) p[e] = e in l ? l[e] : s.values[e];
+	return p;
+}
+async function Qe(e, t) {
+	if (typeof e != "string" && !(e instanceof URL)) return Ze(e);
+	let n = await fetch(e, t);
+	if (!n.ok) throw Error(`three-virtual-geometry: failed to load ${e} (HTTP ${n.status})`);
+	return Ze(await n.arrayBuffer());
+}
+async function $e(e, t, r, i, a) {
+	let o = ct(r), s = {
+		name: e,
+		type: t,
+		length: r.length
+	}, c = Ye[e] ?? {}, l = {
+		entry: {
+			...s,
+			encoding: "raw"
+		},
+		blob: o
+	}, u = [l], d = e === "meshletTriangles" && r instanceof Uint32Array ? et(r, i.meshletInfo) : null;
+	if (d) u.push({
+		entry: {
+			...s,
+			encoding: "meshlet-triangles"
+		},
+		blob: d
+	});
+	else if (o.length % 4 == 0 && o.length > 0) {
+		let e = (c.strides ?? [Math.max(4, r.BYTES_PER_ELEMENT)]).filter((e) => e % 4 == 0 && e <= 256 && o.length % e === 0);
+		for (let t of e) {
+			let e = n.encodeVertexBufferLevel(o, o.length / t, t, 2, 1);
+			u.push({
+				entry: {
+					...s,
+					encoding: "meshopt-vertex",
+					stride: t
+				},
+				blob: e
+			});
+		}
+	}
+	if (u.sort((e, t) => e.blob.length - t.blob.length), a && dt() && o.length >= 64) {
+		let e = c.deflateRaw && u[0] !== l ? [u[0], l] : [u[0]];
+		for (let t of e) u.push({
+			entry: {
+				...t.entry,
+				deflate: !0
+			},
+			blob: await ft(t.blob)
+		});
+		u.sort((e, t) => e.blob.length - t.blob.length);
+	}
+	for (let e of u) if (lt(ct(await rt({
+		...e.entry,
+		offset: 0,
+		byteLength: e.blob.length
+	}, e.blob, { meshletInfo: i.meshletInfo })), o)) return e;
+	return l;
+}
+function et(e, r) {
+	if (!(r instanceof Uint32Array)) return null;
+	let i = new Uint32Array(e.length * 3), a = new Uint8Array(e.length);
+	for (let t = 0; t < r.length; t += 4) {
+		let n = r[t], o = r[t + 1] / 3, s = r[t + 3];
+		if (o + n > e.length) return null;
+		for (let t = o; t < o + n; t++) {
+			let n = e[t];
+			if (a[t] || n >>> 24) return null;
+			a[t] = 1, i[t * 3] = s + (n & 255), i[t * 3 + 1] = s + (n >> 8 & 255), i[t * 3 + 2] = s + (n >> 16 & 255);
+		}
+	}
+	if (!a.every((e) => e === 1)) return null;
+	let o = n.encodeIndexBuffer(ct(i), i.length, 4), s = new Uint32Array(i.length);
+	t.decodeIndexBuffer(ct(s), i.length, 4, o);
+	let c = new Uint8Array(Math.ceil(e.length / 4));
+	for (let t = 0; t < e.length; t++) {
+		let e = i[t * 3], n = i[t * 3 + 1], r = i[t * 3 + 2], a = s[t * 3], o = s[t * 3 + 1], l = s[t * 3 + 2], u;
+		if (e === a && n === o && r === l) u = 0;
+		else if (e === o && n === l && r === a) u = 1;
+		else if (e === l && n === a && r === o) u = 2;
+		else return null;
+		c[t >> 2] |= u << (t & 3) * 2;
+	}
+	let l = new Uint8Array(4 + st(o.length) + c.length);
+	return new DataView(l.buffer).setUint32(0, o.length, !0), l.set(o, 4), l.set(c, 4 + st(o.length)), l;
+}
+function tt(e) {
+	let { indices: t, meshletInfo: n, meshletVertices: r, meshletTriangles: i } = e;
+	if (!(t instanceof Uint32Array && n instanceof Uint32Array && r instanceof Uint32Array && i instanceof Uint32Array)) return !1;
+	try {
+		return lt(ct(ot(t.length, n, r, i)), ct(t));
+	} catch {
+		return !1;
+	}
+}
+var nt = (e) => e === "meshlet-triangles" ? 1 : e === "meshlet-indices" ? 2 : 0;
+async function rt(e, n, r) {
+	let i = Je[e.type], a = new i(e.length), o = ct(a), s = e.deflate ? await pt(n) : n;
+	switch (e.encoding) {
+		case "raw":
+			if (s.length !== o.length) throw new J(`geometry file is corrupt (field "${e.name}" has the wrong size)`);
+			o.set(s);
+			break;
+		case "meshopt-vertex": {
+			let n = e.stride ?? 0;
+			if (n <= 0 || n % 4 != 0 || o.length % n !== 0) throw new J(`geometry file is corrupt (field "${e.name}" stride)`);
+			t.decodeVertexBuffer(o, o.length / n, n, s);
+			break;
+		}
+		case "meshlet-triangles":
+			at(a, s, it(r, "meshletInfo", e.name));
+			break;
+		case "meshlet-indices":
+			a.set(ot(e.length, it(r, "meshletInfo", e.name), it(r, "meshletVertices", e.name), it(r, "meshletTriangles", e.name)));
+			break;
+		default: throw new J(`unknown encoding "${e.encoding}" for field "${e.name}"`);
+	}
+	return a;
+}
+function it(e, t, n) {
+	let r = e[t];
+	if (!(r instanceof Uint32Array)) throw new J(`geometry file is corrupt ("${n}" needs "${t}")`);
+	return r;
+}
+function at(e, n, r) {
+	let i = new DataView(n.buffer, n.byteOffset, n.byteLength).getUint32(0, !0), a = 4 + st(i);
+	if (a + Math.ceil(e.length / 4) > n.length) throw Error("truncated triangle data");
+	let o = new Uint32Array(e.length * 3);
+	t.decodeIndexBuffer(ct(o), o.length, 4, n.subarray(4, 4 + i));
+	let s = n.subarray(a);
+	for (let t = 0; t < r.length; t += 4) {
+		let n = r[t], i = r[t + 1] / 3, a = r[t + 3];
+		if (i + n > e.length) throw Error("meshlet range out of bounds");
+		for (let t = i; t < i + n; t++) {
+			let n = s[t >> 2] >> (t & 3) * 2 & 3, r = o[t * 3] - a, i = o[t * 3 + 1] - a, c = o[t * 3 + 2] - a, [l, u, d] = n === 0 ? [
+				r,
+				i,
+				c
+			] : n === 1 ? [
+				i,
+				c,
+				r
+			] : [
+				c,
+				r,
+				i
+			];
+			if ((l | u | d) >>> 8) throw Error("meshlet-local vertex id out of range");
+			e[t] = l | u << 8 | d << 16;
+		}
+	}
+}
+function ot(e, t, n, r) {
+	let i = new Uint32Array(e);
+	for (let a = 0; a < t.length; a += 4) {
+		let o = t[a], s = t[a + 1], c = t[a + 3];
+		if (s + o * 3 > e || s / 3 + o > r.length) throw new J("geometry file is corrupt (meshlet range out of bounds)");
+		for (let e = 0; e < o; e++) {
+			let t = r[s / 3 + e];
+			for (let r = 0; r < 3; r++) {
+				let a = c + (t >> 8 * r & 255);
+				if (a >= n.length) throw new J("geometry file is corrupt (meshlet vertex out of bounds)");
+				i[s + e * 3 + r] = n[a];
+			}
+		}
+	}
+	return i;
+}
+var st = (e) => e + 3 & -4;
+function ct(e) {
+	return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+function lt(e, t) {
+	if (e.length !== t.length) return !1;
+	if (e.byteOffset % 4 == 0 && t.byteOffset % 4 == 0 && e.length % 4 == 0) {
+		let n = new Uint32Array(e.buffer, e.byteOffset, e.length / 4), r = new Uint32Array(t.buffer, t.byteOffset, t.length / 4);
+		for (let e = 0; e < n.length; e++) if (n[e] !== r[e]) return !1;
+		return !0;
+	}
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+function ut(e, t) {
+	let n = new Uint32Array(e.buffer, e.byteOffset + t, e.length - t >> 2), r = 2166136261 ^ n.length;
+	for (let e = 0; e < n.length; e++) r = Math.imul(r ^ n[e], 16777619), r ^= r >>> 15;
+	return r >>> 0;
+}
+var dt = () => typeof CompressionStream < "u" && typeof DecompressionStream < "u";
+async function ft(e) {
+	let t = new Blob([e]).stream().pipeThrough(new CompressionStream("deflate-raw"));
+	return new Uint8Array(await new Response(t).arrayBuffer());
+}
+async function pt(e) {
+	if (typeof DecompressionStream > "u") throw new J("this environment cannot decompress the geometry file (no DecompressionStream)");
+	let t = new Blob([e]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
+	return new Uint8Array(await new Response(t).arrayBuffer());
+}
+function mt(e, t) {
+	if (typeof t == "number" && !Number.isFinite(t)) return { $number: String(t) };
+	if (ArrayBuffer.isView(t)) throw new J(`typed array nested inside field "${e}" cannot be serialized; store it as a top-level field`);
+	return t;
+}
+function ht(e, t) {
+	if (t && typeof t == "object" && !Array.isArray(t)) {
+		let e = Object.keys(t);
+		if (e.length === 1 && e[0] === "$number") return Number(t.$number);
+	}
+	return t;
+}
+//#endregion
+//#region src/core/io/cache.ts
+var gt = 3, _t = "three-virtual-geometry-cache", Y = "meshes", X = "meta", vt = 536870912, yt = 3e3;
+async function bt(e, t = {}) {
+	let { cache: n, ...r } = t;
+	if (n?.store === !1 || !Ct()) return Fe(e, r);
+	let i = performance.now(), a = await St(e, r, n?.key).catch(() => null), o = a ? await Tt() : null;
+	if (!o || !a) return Fe(e, r);
+	let s = await Et(o, a);
+	if (s) try {
+		let e = await Ze(s);
+		return e.stats && (e.stats.buildMs = performance.now() - i), Ot(o, a), await r.onProgress?.(1), e;
+	} catch {
+		kt(o, a);
+	}
+	let c = await Fe(e, r);
+	try {
+		Dt(o, a, await Xe(c, { deflate: !1 }));
+	} catch {}
+	return c;
+}
+async function xt() {
+	if (!Ct()) return;
+	let e = await Tt();
+	e && await new Promise((t) => {
+		try {
+			let n = e.transaction([Y, X], "readwrite");
+			n.objectStore(Y).clear(), n.objectStore(X).clear(), n.oncomplete = n.onerror = n.onabort = () => t();
+		} catch {
+			t();
+		}
+	});
+}
+async function St(e, t = {}, n) {
+	let r = "v3.1";
+	if (n !== void 0) return `${r}:key:${n}`;
+	let i = globalThis.crypto?.subtle;
+	if (!i) throw Error("crypto.subtle unavailable");
+	let a = e, o = Object.keys(a).filter((e) => a[e] !== void 0 && a[e] !== null).sort(), s = [], c = [];
+	for (let e of o) {
+		let t = a[e];
+		ArrayBuffer.isView(t) ? (s.push([
+			e,
+			t.constructor.name,
+			t.byteLength
+		]), c.push(i.digest("SHA-256", t))) : s.push([e, t]);
+	}
+	let l = Object.entries(t).filter(([, e]) => e !== void 0 && typeof e != "function").sort(([e], [t]) => e < t ? -1 : 1), u = new TextEncoder().encode(JSON.stringify({
+		versions: r,
+		source: s,
+		options: l
+	})), d = await Promise.all(c), f = new Uint8Array(u.length + d.length * 32);
+	f.set(u), d.forEach((e, t) => f.set(new Uint8Array(e), u.length + t * 32));
+	let p = new Uint8Array(await i.digest("SHA-256", f));
+	return `${r}:sha256:${Array.from(p, (e) => e.toString(16).padStart(2, "0")).join("")}`;
+}
+function Ct() {
+	try {
+		return typeof indexedDB < "u" && indexedDB !== null;
+	} catch {
+		return !1;
+	}
+}
+var wt = null;
+function Tt() {
+	return wt ??= new Promise((e) => {
+		let t = setTimeout(() => e(null), yt), n = (n) => {
+			clearTimeout(t), e(n);
+		};
+		try {
+			let e = indexedDB.open(_t, 1);
+			e.onupgradeneeded = () => {
+				let t = e.result;
+				t.objectStoreNames.contains(Y) || t.createObjectStore(Y), t.objectStoreNames.contains(X) || t.createObjectStore(X);
+			}, e.onsuccess = () => {
+				let t = e.result;
+				t.onversionchange = () => {
+					t.close(), wt = Promise.resolve(null);
+				}, n(t);
+			}, e.onerror = e.onblocked = () => n(null);
+		} catch {
+			n(null);
+		}
+	}), wt;
+}
+function Et(e, t) {
+	return new Promise((n) => {
+		try {
+			let r = e.transaction(Y, "readonly").objectStore(Y).get(t);
+			r.onsuccess = () => {
+				let e = r.result;
+				n(e instanceof ArrayBuffer ? new Uint8Array(e) : e instanceof Uint8Array ? e : null);
+			}, r.onerror = () => n(null);
+		} catch {
+			n(null);
+		}
+	});
+}
+function Dt(e, t, n) {
+	return new Promise((r) => {
+		try {
+			let i = e.transaction([Y, X], "readwrite");
+			i.objectStore(Y).put(n.buffer.byteLength === n.length ? n.buffer : n.slice().buffer, t), i.objectStore(X).put({
+				size: n.length,
+				lastUsed: Date.now()
+			}, t), i.oncomplete = () => r(), i.onerror = i.onabort = () => r();
+		} catch {
+			r();
+		}
+	}).then(() => At(e, t));
+}
+function Ot(e, t) {
+	try {
+		let n = e.transaction(X, "readwrite").objectStore(X), r = n.get(t);
+		r.onsuccess = () => {
+			let e = r.result;
+			e && n.put({
+				...e,
+				lastUsed: Date.now()
+			}, t);
+		};
+	} catch {}
+}
+function kt(e, t) {
+	try {
+		let n = e.transaction([Y, X], "readwrite");
+		n.objectStore(Y).delete(t), n.objectStore(X).delete(t);
+	} catch {}
+}
+function At(e, t) {
+	return new Promise((n) => {
+		try {
+			let r = e.transaction([Y, X], "readwrite"), i = r.objectStore(X), a = i.getAllKeys(), o = i.getAll();
+			o.onsuccess = () => {
+				let e = a.result, n = o.result.map((t, n) => ({
+					key: e[n],
+					...t
+				})), s = n.reduce((e, t) => e + t.size, 0);
+				n.sort((e, t) => e.lastUsed - t.lastUsed);
+				for (let e of n) {
+					if (s <= vt) break;
+					e.key !== t && (r.objectStore(Y).delete(e.key), i.delete(e.key), s -= e.size);
+				}
+			}, r.oncomplete = r.onerror = r.onabort = () => n();
+		} catch {
+			n();
+		}
+	});
+}
+//#endregion
+//#region src/core/runtime/cut.ts
+function jt(e, t, n) {
+	let r = t.viewMatrix, i = e.meshletBounds, a = new Uint8Array(e.meshletCount), o = t.scale ?? 1, s = (e, n, i, a, s) => {
+		if (s >= 5e29) return Infinity;
+		let c = r[0] * e + r[4] * n + r[8] * i + r[12], l = r[1] * e + r[5] * n + r[9] * i + r[13], u = r[2] * e + r[6] * n + r[10] * i + r[14], d = Math.max(Math.hypot(c, l, u) - a * o, t.near);
+		return s * o * t.projScale / d;
+	};
+	for (let t = 0; t < e.meshletCount; t++) {
+		let e = t * 16, r = s(i[e], i[e + 1], i[e + 2], i[e + 3], i[e + 8]), o = s(i[e + 4], i[e + 5], i[e + 6], i[e + 7], i[e + 9]);
+		a[t] = +(r <= n && o > n);
+	}
+	return a;
+}
+function Mt(e, t) {
+	let n = new Int8Array(e.meshletCount).fill(-1), { replacementStart: r, replacementIndices: i } = e, a = (e) => {
+		if (n[e] !== -1) return n[e] === 1;
+		let o = t[e] === 1;
+		for (let t = r[e]; !o && t < r[e + 1]; t++) o = a(i[t]);
+		return n[e] = +!!o, o;
+	}, o = [];
+	for (let t = 0; t < e.meshletCount; t++) e.meshletInfo[t * 4 + 2] === 0 && !a(t) && o.push(t);
+	return o;
+}
+function Nt(e, t) {
+	let n = t.viewMatrix, [r, i, a, o] = e.lodBoundsSphere, s = n[0] * r + n[4] * i + n[8] * a + n[12], c = n[1] * r + n[5] * i + n[9] * a + n[13], l = n[2] * r + n[6] * i + n[10] * a + n[14], u = Math.hypot(s, c, l), d = o * (t.scale ?? 1);
+	return [Math.max(u - d, t.near), Math.max(u + d, t.near)];
+}
+function Pt(e, t, n) {
+	let [r, i] = Nt(e, t), a = (t.scale ?? 1) * t.projScale, o = -1, s = -1, c = e.levelRanges.length / 2;
+	for (let t = 0; t < c; t++) {
+		let c = e.levelErrors[t * 2], l = e.levelErrors[t * 2 + 1], u = c * a / i <= n, d = l >= 5e29 || l * a / r > n;
+		u && d && (o < 0 && (o = t), s = t);
+	}
+	return o < 0 ? [0, 0] : [e.levelRanges[o * 2], e.levelRanges[s * 2] + e.levelRanges[s * 2 + 1]];
+}
+function Ft(e, t, n) {
+	let [r, i] = Nt(e, t), a = ye, o = (t.scale ?? 1) * t.projScale, s = -1, c = -1, l = 0, u = 0, d = e.levelRanges.length / 2;
+	for (let t = 0; t < d; t++) {
+		let d = e.levelErrors[t * 2], f = e.levelErrors[t * 2 + 1], p = d * o / i <= n, m = f >= 5e29 || f * o / r > n;
+		if (!p || !m) continue;
+		s < 0 && (s = t), c = t;
+		let h = e.levelRanges[t * 2 + 1];
+		l += h;
+		let g = e.levelGuardErrors[t * 2], _ = e.levelGuardErrors[t * 2 + 1], v = g * o / r <= n * (1 - a), y = _ >= 5e29 || _ * o / i > n * (1 + a);
+		v && y && (u += h);
+	}
+	if (s < 0) return null;
+	let f = e.levelRanges[s * 2], p = e.levelRanges[c * 2] + e.levelRanges[c * 2 + 1];
+	return l !== p - f || u !== l || l > 4 ? null : [f, p];
+}
+//#endregion
+//#region src/core/runtime/vgMaterial.ts
+var It = V("vec2", "vVgUv");
+function Lt(e) {
+	if (!(e?.isTextureNode !== !0 || e.isCubeTextureNode || e.isTexture3DNode)) return It;
+}
+function Rt(e) {
+	return se(e, It).setUpdateMatrix(!0);
+}
+var zt = [
+	i.RGFormat,
+	i.RED_GREEN_RGTC2_Format,
+	i.RG11_EAC_Format
+];
+function Bt(e, t, n = i.TangentSpaceNormalMap) {
+	let r = Rt(e), a = r.xyz.mul(2).sub(1);
+	if (zt.includes(e.format)) {
+		let e = r.xy.mul(2).sub(1);
+		a = de(e, oe(S(1).sub(e.dot(e)).max(0)));
+	}
+	if (a = de(a.xy.mul(t), a.z), n === i.ObjectSpaceNormalMap) return ce(a);
+	let o = ae.dFdx(), s = ae.dFdy(), c = It.dFdx(), l = It.dFdy(), u = I, d = s.cross(u), f = u.cross(o), p = d.mul(c.x).add(f.mul(l.x)), m = d.mul(c.y).add(f.mul(l.y)), h = p.dot(p).max(m.dot(m)), g = h.equal(0).select(0, h.inverseSqrt());
+	return A(F(p.mul(g)), F(m.mul(g)), u).mul(a).normalize();
+}
+function Vt(e) {
+	let t = e;
+	if (!t.colorNode && (Ht(t.map) || Ht(t.alphaMap))) {
+		let e = H(j, 1);
+		if (Ht(t.map)) {
+			let n = Rt(t.map);
+			e = H(j.mul(n.rgb), n.a);
+		}
+		Ht(t.alphaMap) && (e = H(e.rgb, e.a.mul(Rt(t.alphaMap).g))), t.colorNode = e, t.map = null, t.alphaMap = null;
+	}
+	t.normalNode || (Ht(t.normalMap) ? t.normalNode = Bt(t.normalMap, M("normalScale", "vec2"), t.normalMapType) : Ht(t.bumpMap) && (t.normalNode = m(Rt(t.bumpMap).r, M("bumpScale", "float")))), !t.clearcoatNormalNode && Ht(t.clearcoatNormalMap) && (t.clearcoatNormalNode = Bt(t.clearcoatNormalMap, M("clearcoatNormalScale", "vec2"))), t.contextNode = t.contextNode ? v(t.contextNode, { getUV: Lt }) : v({ getUV: Lt }), e.needsUpdate = !0;
+}
+var Ht = (e) => e?.isTexture === !0, Ut = P, Wt = N, Gt = V("vec3", "vVgWorldNormal"), Kt = V("float", "vVgMeshlet"), qt = V("float", "vVgLod"), Jt = V("float", "vVgInstance"), Yt = V("vec3", "vVgTint"), Xt = Math.ceil(Math.log2(128)), Zt = (1 << Xt) - 1, Qt = 65535, $t = 64, en = 64, tn = 64, nn = 48, Z = 6, Q = 5, $ = 2, rn = .15, an = 1e30, on = 5, sn = 0, cn = 1, ln = 2, un = 3, dn = 4, fn = 12, pn = class {
+	make;
+	itemSize;
+	maxItems;
+	array;
+	attribute;
+	used = 0;
+	constructor(e, t, n, r = Infinity) {
+		this.make = e, this.itemSize = t, this.maxItems = r, this.array = e(Math.max(1, n) * t), this.attribute = new i.StorageBufferAttribute(this.array, t);
+	}
+	get capacity() {
+		return this.array.length / this.itemSize;
+	}
+	reserve(e) {
+		if (this.used + e > this.capacity) return -1;
+		let t = this.used;
+		return this.used += e, t;
+	}
+	grow(e) {
+		let t = this.make(Math.min(Math.max(e, Math.ceil(this.capacity * 1.6)), Math.max(e, this.maxItems)) * this.itemSize);
+		t.set(this.array), this.array = t, this.attribute = new i.StorageBufferAttribute(this.array, this.itemSize);
+	}
+	touch(e, t) {
+		t <= 0 || (this.attribute.addUpdateRange(e * this.itemSize, t * this.itemSize), this.attribute.needsUpdate = !0);
+	}
+}, mn = (e) => new Float32Array(e), hn = (e) => new Uint32Array(e), gn = class {
+	context;
+	entries = [];
+	meshSlots = B(0, "uint");
+	cellCount = B(0, "uint");
+	maxBytes;
+	capacity;
+	vertexData;
+	vertexAttrs;
+	meshletBounds;
+	meshletInfo;
+	meshletVertices;
+	meshletTriangles;
+	meshTable;
+	instances;
+	cells;
+	meshSlotCapacity;
+	levelUsed = 0;
+	countersAttribute;
+	drawArgsAttribute;
+	cameraIndex;
+	shadowIndex;
+	computeNodes = [];
+	positionNode = null;
+	version = 0;
+	needsRebuild = !0;
+	indexBuffersReady = !1;
+	pipelineState = "none";
+	dirty = !0;
+	hasCut = !1;
+	constructor(e, t, n) {
+		this.context = e, this.capacity = t, this.maxBytes = n, this.meshSlotCapacity = 64;
+		let r = (e) => Math.floor(n / e);
+		this.vertexData = new pn(hn, 4, 65536, r(16)), this.vertexAttrs = new pn(hn, 2, 65536, r(8)), this.meshletBounds = new pn(mn, 16, 4096, r(64)), this.meshletInfo = new pn(hn, 4, 4096, r(16)), this.meshletVertices = new pn(hn, 1, 1 << 18, r(4)), this.meshletTriangles = new pn(hn, 1, 1 << 18, r(4)), this.meshTable = new pn(mn, 4, this.meshSlotCapacity * Z + 1024, r(16)), this.meshTable.used = this.meshSlotCapacity * Z, this.instances = new pn(mn, 4, 4096, r(80) * Q), this.cells = new pn(mn, 4, 256, r(16));
+	}
+	static bytesOf(e) {
+		return Math.max(e.positions.length / 3 * 16, e.meshletVertices.length * 4, e.meshletTriangles.length * 4, e.meshletCount * 64);
+	}
+	fits(e, t) {
+		let n = (e, t, n) => (e + t) * n <= this.maxBytes;
+		return n(this.vertexData.used, e.positions.length / 3, 16) && n(this.meshletBounds.used, e.meshletCount, 64) && n(this.meshletVertices.used, e.meshletVertices.length, 4) && n(this.meshletTriangles.used, e.meshletTriangles.length, 4) && n(this.instances.used, t * Q, 16);
+	}
+	add(e, t, n, r) {
+		let i = this.entries.indexOf(null);
+		i === -1 && (i = this.entries.length), i >= this.meshSlotCapacity && this.growMeshSlots(i + 1);
+		let a = e.positions.length / 3, o = e.levelRanges.length / 2, s = t.length / 16, c = Math.ceil(s / 128), l = (e, t) => {
+			let n = e.reserve(t);
+			return n === -1 && (e.grow(e.used + t), this.needsRebuild = !0, n = e.reserve(t)), n;
+		}, u = {
+			slot: i,
+			data: e,
+			vertexBase: l(this.vertexData, a),
+			meshletBase: l(this.meshletBounds, e.meshletCount),
+			meshletVertexBase: l(this.meshletVertices, e.meshletVertices.length),
+			triangleBase: l(this.meshletTriangles, e.meshletTriangles.length),
+			levelBase: 0,
+			levelCount: o,
+			instanceBase: l(this.instances, s * Q) / Q,
+			instanceCount: s,
+			cellBase: l(this.cells, c * $) / $,
+			cellCount: c,
+			uvScale: [1, 1],
+			uvOffset: [0, 0]
+		};
+		return l(this.meshletInfo, e.meshletCount), l(this.vertexAttrs, a), u.levelBase = this.meshSlotCapacity * Z + this.levelUsed, u.levelBase + o * 2 > this.meshTable.capacity && (this.meshTable.grow(u.levelBase + o * 2), this.needsRebuild = !0), this.levelUsed += o * 2, this.meshTable.used = Math.max(this.meshTable.used, u.levelBase + o * 2), this.entries[i] = u, this.writeGeometry(u), this.writeInstances(u, t, n, r), this.writeMeshRecord(u, {
+			maxDrawDistance: an,
+			minPixelRadius: 0,
+			enabled: 1,
+			shadow: 1,
+			occlusion: 0
+		}), this.meshSlots.value = Math.max(this.meshSlots.value, i + 1), this.cellCount.value = this.cells.used / $, this.dirty = !0, u;
+	}
+	remove(e) {
+		this.writeFlags(e, { enabled: 0 }), this.entries[e.slot] = null, this.dirty = !0;
+	}
+	growMeshSlots(e) {
+		let t = this.meshSlotCapacity, n = Math.max(e, t * 2), r = (n - t) * Z, i = t * Z, a = this.meshTable.used + r;
+		a > this.meshTable.capacity && this.meshTable.grow(a);
+		let o = this.meshTable.array;
+		o.copyWithin((i + r) * 4, i * 4, this.meshTable.used * 4), o.fill(0, i * 4, (i + r) * 4), this.meshTable.used += r, this.meshSlotCapacity = n;
+		for (let e of this.entries) e && (e.levelBase += r, o[(e.slot * Z + 3) * 4 + 3] = e.levelBase);
+		this.needsRebuild = !0;
+	}
+	writeGeometry(e) {
+		let t = e.data, n = t.positions.length / 3, r = this.vertexData.array, i = new Float32Array(r.buffer, r.byteOffset, r.length);
+		for (let a = 0; a < n; a++) {
+			let n = (e.vertexBase + a) * 4;
+			i[n] = t.positions[a * 3], i[n + 1] = t.positions[a * 3 + 1], i[n + 2] = t.positions[a * 3 + 2], r[n + 3] = bn(t.normals[a * 3], t.normals[a * 3 + 1], t.normals[a * 3 + 2]);
+		}
+		this.vertexData.touch(e.vertexBase, n);
+		let a = this.vertexAttrs.array, o = t.uvs ? xn(t.uvs) : null;
+		o && (e.uvScale = o.scale, e.uvOffset = o.offset);
+		let s = (e) => Math.round(Math.max(0, Math.min(1, e)) * 255);
+		for (let r = 0; r < n; r++) {
+			let n = (e.vertexBase + r) * 2;
+			a[n] = t.colors ? (s(t.colors[r * 3]) | s(t.colors[r * 3 + 1]) << 8 | s(t.colors[r * 3 + 2]) << 16 | 255 << 24) >>> 0 : 4294967295, a[n + 1] = o ? o.packed[r] : 0;
+		}
+		this.vertexAttrs.touch(e.vertexBase, n), this.meshletBounds.array.set(t.meshletBounds, e.meshletBase * 16), this.meshletBounds.touch(e.meshletBase, t.meshletCount);
+		let c = this.meshletInfo.array;
+		for (let n = 0; n < t.meshletCount; n++) {
+			let r = (e.meshletBase + n) * 4, i = n * 4;
+			c[r] = t.meshletInfo[i], c[r + 1] = t.meshletInfo[i + 1] + e.triangleBase * 3, c[r + 2] = t.meshletInfo[i + 2], c[r + 3] = t.meshletInfo[i + 3] + e.meshletVertexBase;
+		}
+		this.meshletInfo.touch(e.meshletBase, t.meshletCount);
+		let l = this.meshletVertices.array;
+		for (let n = 0; n < t.meshletVertices.length; n++) l[e.meshletVertexBase + n] = t.meshletVertices[n] + e.vertexBase;
+		this.meshletVertices.touch(e.meshletVertexBase, t.meshletVertices.length), this.meshletTriangles.array.set(t.meshletTriangles, e.triangleBase), this.meshletTriangles.touch(e.triangleBase, t.meshletTriangles.length);
+		let u = this.meshTable.array;
+		for (let n = 0; n < e.levelCount; n++) {
+			let r = (e.levelBase + n * 2) * 4;
+			u[r] = t.levelRanges[n * 2] + e.meshletBase, u[r + 1] = t.levelRanges[n * 2 + 1], u[r + 2] = t.levelErrors[n * 2], u[r + 3] = t.levelErrors[n * 2 + 1], u[r + 4] = t.levelGuardErrors[n * 2], u[r + 5] = t.levelGuardErrors[n * 2 + 1], u[r + 6] = 0, u[r + 7] = 0;
+		}
+		this.meshTable.touch(e.levelBase, e.levelCount * 2);
+	}
+	writeMeshRecord(e, t) {
+		let n = this.meshTable.array, r = e.slot * Z * 4;
+		n.set(e.data.boundingSphere, r), n.set(e.data.lodBoundsSphere, r + 4), n.set(e.data.cullBoundsSphere, r + 8), n.set([
+			t.maxDrawDistance,
+			t.minPixelRadius,
+			e.levelCount,
+			e.levelBase
+		], r + 12), n.set([
+			e.uvScale[0],
+			e.uvScale[1],
+			e.uvOffset[0],
+			e.uvOffset[1]
+		], r + 16), n.set([
+			t.enabled,
+			t.shadow,
+			t.occlusion,
+			0
+		], r + 20), this.meshTable.touch(e.slot * Z, Z), this.dirty = !0;
+	}
+	writeFlags(e, t) {
+		let n = this.meshTable.array, r = e.slot * Z * 4, i = (t, i) => {
+			i !== void 0 && n[r + t] !== i && (n[r + t] = i, this.meshTable.touch(e.slot * Z + (t >> 2), 1), this.dirty = !0);
+		};
+		i(12, t.maxDrawDistance), i(13, t.minPixelRadius), i(20, t.enabled), i(21, t.shadow), i(22, t.occlusion);
+	}
+	readFlag(e, t) {
+		return this.meshTable.array[e.slot * Z * 4 + {
+			maxDrawDistance: 12,
+			minPixelRadius: 13,
+			enabled: 20,
+			shadow: 21,
+			occlusion: 22
+		}[t]];
+	}
+	writeInstances(e, t, n, r) {
+		let i = this.instances.array;
+		for (let a = 0; a < e.instanceCount; a++) {
+			let o = r[a], s = (e.instanceBase + a) * Q * 4;
+			i.set(t.subarray(o * 16, o * 16 + 16), s), n ? i.set(n.subarray(o * 4, o * 4 + 3), s + 16) : i.fill(1, s + 16, s + 19), i[s + 19] = e.slot;
+		}
+		this.instances.touch(e.instanceBase * Q, e.instanceCount * Q);
+		for (let t = 0; t < e.cellCount; t++) this.computeCell(e, t);
+		this.cells.touch(e.cellBase * $, e.cellCount * $);
+	}
+	setMatrix(e, t, n) {
+		n.toArray(this.instances.array, (e.instanceBase + t) * Q * 4);
+	}
+	commitInstances(e, t) {
+		this.instances.touch(e.instanceBase * Q, e.instanceCount * Q);
+		for (let n of t) this.computeCell(e, n), this.cells.touch((e.cellBase + n) * $, $);
+		this.dirty = !0;
+	}
+	computeCell(e, t) {
+		let n = this.instances.array, r = t * 128, i = Math.min(r + 128, e.instanceCount), a = /* @__PURE__ */ new Float64Array(4), o = [
+			Infinity,
+			Infinity,
+			Infinity
+		], s = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		], c = 0;
+		for (let t = r; t < i; t++) {
+			_n(n, (e.instanceBase + t) * Q * 4, e.data.boundingSphere, a);
+			for (let e = 0; e < 3; e++) o[e] = Math.min(o[e], a[e] - a[3]), s[e] = Math.max(s[e], a[e] + a[3]);
+			c = Math.max(c, a[3]);
+		}
+		let l = (o[0] + s[0]) / 2, u = (o[1] + s[1]) / 2, d = (o[2] + s[2]) / 2, f = 0;
+		for (let t = r; t < i; t++) _n(n, (e.instanceBase + t) * Q * 4, e.data.boundingSphere, a), f = Math.max(f, Math.hypot(a[0] - l, a[1] - u, a[2] - d) + a[3]);
+		let p = (e.cellBase + t) * $ * 4;
+		this.cells.array.set([
+			l,
+			u,
+			d,
+			f * 1.0001 + .001,
+			c * 1.0001 + 1e-4,
+			e.slot,
+			e.instanceBase + r,
+			i - r
+		], p);
+	}
+	prepare(e) {
+		if (this.ensureBuilt(), this.indexBuffersReady) return;
+		let t = e.backend;
+		t.createIndexAttribute(this.cameraIndex), t.createIndexAttribute(this.shadowIndex), this.indexBuffersReady = !0;
+	}
+	ensureBuilt() {
+		this.needsRebuild && this.build();
+	}
+	build() {
+		this.needsRebuild = !1, this.indexBuffersReady = !1, this.pipelineState = "none", this.hasCut = !1, this.version++;
+		for (let e of this.computeNodes) e.dispose();
+		let e = this.context, t = this.capacity, n = this.meshSlotCapacity, r = t.meshlets, m = Math.floor(this.instances.capacity / Q), h = Math.floor(this.cells.capacity / $), g = t.triangles * 3, _ = t.shadowTriangles * 3, v = (e, t) => R(e.attribute, t, e.capacity), b = v(this.vertexData, "uvec4").toReadOnly(), x = v(this.vertexAttrs, "uvec2").toReadOnly(), C = v(this.meshletBounds, "vec4").toReadOnly(), w = v(this.meshletInfo, "uvec4").toReadOnly(), E = v(this.meshletVertices, "uint").toReadOnly(), D = v(this.meshletTriangles, "uint").toReadOnly(), ee = v(this.meshTable, "vec4").toReadOnly(), A = v(this.instances, "vec4").toReadOnly(), j = v(this.cells, "vec4").toReadOnly();
+		this.countersAttribute = new i.StorageBufferAttribute(new Uint32Array(fn + 2 * n * 2), 1), this.drawArgsAttribute = new i.IndirectStorageBufferAttribute(new Uint32Array(2 * n * 5), 1), this.cameraIndex = new i.StorageBufferAttribute(new Uint32Array(g), 1), this.shadowIndex = new i.StorageBufferAttribute(new Uint32Array(_), 1);
+		let M = new i.StorageBufferAttribute(new Uint32Array(h * 4), 4), F = new i.StorageBufferAttribute(new Uint32Array(m * 2 * 4), 4), I = new i.StorageBufferAttribute(new Uint32Array(r * 2 * 4), 4), ae = () => new i.IndirectStorageBufferAttribute(/* @__PURE__ */ new Uint32Array(3), 3), oe = ae(), se = [ae(), ae()], ce = [ae(), ae()], B = R(this.countersAttribute, "uint", this.countersAttribute.count).toAtomic(), V = R(this.drawArgsAttribute, "uint", this.drawArgsAttribute.count), de = R(this.cameraIndex, "uint", g), ge = R(this.shadowIndex, "uint", _), _e = R(M, "uvec4", h), be = R(M, "uvec4", h).toReadOnly(), xe = R(F, "uvec4", m * 2), Se = R(I, "uvec4", r * 2), Ce = R(I, "uvec4", r * 2).toReadOnly(), we = R(oe, "uint", 3), Te = se.map((e) => R(e, "uint", 3)), Ee = ce.map((e) => R(e, "uint", 3)), U = (e, t) => B.element(2 + e * on + t), De = (e, t) => B.element(z(fn + e * n * 2).add(t.mul(2))), Oe = (e, t) => B.element(z(fn + e * n * 2 + 1).add(t.mul(2))), ke = [g, _], Ae = [de, ge], je = e.errorThreshold.mul(e.shadowErrorScale), Me = [e.errorThreshold, je], Ne = e.minPixelRadius, Pe = e.occlusion, Fe = (e, t) => A.element(e.mul(Q).add(t)), Ie = (e) => {
+			let t = [
+				0,
+				1,
+				2,
+				3
+			].map((t) => Fe(e, t).toVar());
+			return {
+				model: te(t[0], t[1], t[2], t[3]).toVar(),
+				scale: N(O(t[0].xyz), N(O(t[1].xyz), O(t[2].xyz))).toVar(),
+				columns: t
+			};
+		}, W = (e, t) => ee.element(e.mul(Z).add(t)), Le = (t, n, r, i) => {
+			let a = e.viewMatrix.mul(t.mul(H(r.xyz, 1))), o = N(O(a.xyz).sub(r.w.mul(n)), e.near), s = i.mul(n).div(o).mul(e.projScale);
+			return L(i.greaterThanEqual(ve * .5), S(ve), s);
+		}, G = (t, n) => {
+			let r = S(1e30);
+			for (let i of e.frustumPlanes) {
+				let a = y(i.xyz, t).add(i.w);
+				n !== !1 && (a = a.add(N(y(i.xyz, e.shadowSweep), 0).mul(n === !0 ? 1 : L(n, S(1), S(0))))), r = P(r, a);
+			}
+			return r;
+		}, Re = (t, n, r) => {
+			let i = e.viewMatrix.mul(H(n, 1)).xyz.toVar(), a = i.z.abs().mul(e.errorThreshold).div(e.projScale);
+			return t.and(Pe.activeNode.equal(1)).and(Pe.occluded(i, r.add(a)));
+		}, K = (e, t) => {
+			e.element(0).assign(Ut(t, z(Qt))), e.element(1).assign(t.add(65534).div(Qt)), e.element(2).assign(z(1));
+		}, ze = a(() => {
+			let e = T;
+			o(e.lessThan(z(fn)), () => {
+				d(B.element(e), z(0));
+			}), o(e.lessThan(this.meshSlots.mul(4)), () => {
+				let t = e.div(this.meshSlots.mul(2)), r = e.mod(this.meshSlots.mul(2));
+				d(B.element(z(fn).add(t.mul(n * 2)).add(r)), z(0));
+			});
+		})().compute(Math.max(fn, n * 4), [64]), Be = a(() => {
+			o(T.greaterThanEqual(this.cellCount), () => {
+				c();
+			});
+			let t = T.toVar(), n = j.element(t.mul($)).toVar(), r = j.element(t.mul($).add(1)).toVar(), i = z(r.y).toVar(), a = W(i, 5).toVar();
+			o(a.x.equal(0), () => {
+				c();
+			});
+			let s = n.xyz.toVar(), u = n.w.toVar();
+			o(e.frustumCulling.equal(1).and(G(s, a.y.greaterThan(.5)).lessThan(u.negate())), () => {
+				c();
+			});
+			let d = W(i, 3).toVar(), f = N(Ne, d.y), p = r.x, m = O(e.viewMatrix.mul(H(s, 1)).xyz).toVar().sub(u).toVar();
+			o(m.greaterThan(p).and(p.mul(e.projScale).div(N(m, 1e-6)).lessThan(f)), () => {
+				c();
+			}), o(m.greaterThan(d.x), () => {
+				c();
+			});
+			let h = l(B.element(0), z(1)).toVar();
+			_e.element(h).assign(ue(i, z(r.z), z(r.w), t));
+		})().compute(h, [$t]), Ve = a(() => {
+			K(we, u(B.element(0)).toVar());
+		})().compute(1), He = pe("vec4", 96), Ue = (t, n, i, a, c, u, d, f, p, h) => {
+			let g = Me[t], _ = z(4294967295).toVar(), v = z(0).toVar(), y = z(0).toVar(), b = z(0).toVar();
+			s({
+				start: z(0),
+				end: i,
+				type: "uint",
+				condition: "<"
+			}, ({ i: e }) => {
+				let t = He.element(e.mul(2)).toVar(), n = He.element(e.mul(2).add(1)).toVar(), r = z(t.x).toVar(), i = z(t.y).toVar(), a = t.z.mul(h).lessThanEqual(g).and(t.w.greaterThanEqual(ve * .5).or(t.w.mul(p).greaterThan(g))), s = n.x.mul(p).lessThanEqual(g.mul(1 - ye)).and(n.y.greaterThanEqual(ve * .5).or(n.y.mul(h).greaterThan(g.mul(1 + ye))));
+				o(a, () => {
+					_.assign(Ut(_, r)), v.assign(Wt(v, r.add(i))), y.addAssign(i), o(s, () => {
+						b.addAssign(i);
+					});
+				});
+			});
+			let x = d.mul(H(c.xyz, 1)).xyz.toVar(), S = c.w.mul(f).toVar(), C = y.greaterThan(z(0)).and(y.equal(v.sub(_))).and(b.equal(y)).and(y.lessThanEqual(z(4))).and(e.frustumCulling.equal(0).or(G(x, t === 1).greaterThanEqual(S))).toVar();
+			o(v.greaterThan(_), () => {
+				l(U(t, ln), z(1)), o(C, () => {
+					let e = l(U(t, sn), y).toVar();
+					for (let i = 0; i < 4; i++) o(z(i).lessThan(y).and(e.add(i).lessThan(z(r))), () => {
+						let a = _.add(i).toVar(), o = w.element(a).x.toVar(), s = l(De(t, n), o.mul(3)).toVar();
+						Se.element(e.add(i + t * r)).assign(ue(u, a, s, o));
+					});
+				}).Else(() => {
+					let e = l(U(t, un), z(1)).toVar(), r = n.bitOr(L(a, z(2147483648), z(0)));
+					xe.element(e.add(t * m)).assign(ue(u, _, v, r));
+				});
+			});
+		}, We = a(() => {
+			let t = he.x.add(he.y.mul(ie.x)).toVar(), n = t.lessThan(u(B.element(0))).toVar(), r = be.element(Ut(t, z(h - 1))).toVar(), i = r.x, a = W(i, 3).toVar(), d = L(n, Ut(z(a.z), z(nn)), z(0)).toVar(), f = z(a.w).toVar();
+			s({
+				start: k.x,
+				end: d.mul(2),
+				type: "uint",
+				condition: "<",
+				update: $t
+			}, ({ i: e }) => {
+				He.element(e).assign(ee.element(f.add(e)));
+			}), me(), o(n.not(), () => {
+				c();
+			});
+			let m = W(i, 0).toVar(), g = W(i, 1).toVar(), _ = W(i, 2).toVar(), v = W(i, 5).toVar(), y = v.y.greaterThan(.5), b = v.z.greaterThan(.5), x = N(Ne, a.y).toVar(), S = a.x.toVar(), C = r.y.add(r.z);
+			s({
+				start: r.y.add(k.x),
+				end: C,
+				type: "uint",
+				condition: "<",
+				update: $t
+			}, ({ i: t }) => {
+				let n = t.toVar(), { model: r, scale: a } = Ie(n), s = r.mul(H(m.xyz, 1)).xyz.toVar(), c = m.w.mul(a).toVar(), u = e.frustumCulling.equal(0), f = u.or(G(s, !1).greaterThanEqual(c.negate())).toVar(), h = y.and(u.or(G(s, !0).greaterThanEqual(c.negate()))).toVar(), v = O(e.viewMatrix.mul(H(s, 1)).xyz).toVar(), C = v.greaterThan(c).and(c.mul(e.projScale).div(v).lessThan(x)), w = v.sub(c).greaterThan(S), T = f.or(h).and(C.not()).and(w.not());
+				o(T, () => {
+					o(f.and(Re(b, s, c)), () => {
+						f.assign(p(!1)), l(B.element(1), z(1));
+					});
+					let t = e.viewMatrix.mul(r.mul(H(g.xyz, 1))), u = O(t.xyz).toVar(), m = g.w.mul(a), v = a.mul(e.projScale).div(N(u.sub(m), e.near)).toVar(), y = a.mul(e.projScale).div(N(u.add(m), e.near)).toVar();
+					o(f, () => {
+						Ue(0, i, d, b, _, n, r, a, v, y);
+					}), o(h, () => {
+						Ue(1, i, d, p(!1), _, n, r, a, v, y);
+					});
+				});
+			});
+		})().compute(oe, [$t]), Ge = (t) => [a(() => {
+			K(Te[t], u(U(t, un)).toVar());
+		})().compute(1), a(() => {
+			let n = he.x.add(he.y.mul(ie.x)).toVar();
+			o(n.greaterThanEqual(u(U(t, un))), () => {
+				c();
+			});
+			let i = xe.element(n.add(t * m)).toVar(), a = i.x, d = i.w.bitAnd(2147483647).toVar(), f = i.w.shiftRight(31).equal(1), { model: p, scale: h } = Ie(a);
+			s({
+				start: i.y.add(k.x),
+				end: i.z,
+				type: "uint",
+				condition: "<",
+				update: en
+			}, ({ i: n }) => {
+				let i = n, s = i.mul(4).toVar(), c = C.element(s.add(3)), u = p.mul(H(c.xyz, 1)).xyz, m = e.frustumCulling.equal(0).or(G(u, t === 1).greaterThanEqual(c.w.mul(h).negate()));
+				t === 0 && (m = m.and(Re(f, u, c.w.mul(h)).not()));
+				let g = C.element(s.add(2)), _ = Le(p, h, C.element(s), g.x), v = Le(p, h, C.element(s.add(1)), g.y);
+				o(m.and(_.lessThanEqual(Me[t])).and(v.greaterThan(Me[t])), () => {
+					let e = l(U(t, sn), z(1)).toVar();
+					o(e.lessThan(z(r)), () => {
+						let n = w.element(i).x.toVar(), o = l(De(t, d), n.mul(3)).toVar();
+						Se.element(e.add(t * r)).assign(ue(a, i, o, n));
+					});
+				});
+			});
+		})().compute(se[t], [en])], Ke = (e) => a(() => {
+			let t = z(0).toVar(), i = z(ke[e]);
+			s({
+				start: z(0),
+				end: this.meshSlots,
+				type: "uint",
+				condition: "<"
+			}, ({ i: r }) => {
+				let a = u(De(e, r)).toVar();
+				d(Oe(e, r), t);
+				let o = L(t.lessThan(i), i.sub(t), z(0)), s = z(e * n * 5).add(r.mul(5)).toVar();
+				V.element(s).assign(Ut(a, o)), V.element(s.add(1)).assign(z(1)), V.element(s.add(2)).assign(t), V.element(s.add(3)).assign(z(0)), V.element(s.add(4)).assign(z(0)), t.addAssign(a);
+			}), d(U(e, dn), t);
+			let a = Ut(u(U(e, sn)), z(r)).toVar();
+			d(U(e, cn), a), K(Ee[e], a);
+		})().compute(1), qe = (e) => a(() => {
+			let t = he.x.add(he.y.mul(ie.x)).toVar();
+			o(t.greaterThanEqual(u(U(e, cn))), () => {
+				c();
+			});
+			let n = t.add(e * r).toVar(), i = Ce.element(n).toVar(), a = z(Fe(i.x, 4).w).toVar(), l = u(Oe(e, a)).toVar(), d = w.element(i.y).y.div(3).toVar(), f = n.shiftLeft(Xt).toVar(), p = Ae[e];
+			s({
+				start: k.x,
+				end: i.w,
+				type: "uint",
+				condition: "<",
+				update: tn
+			}, ({ i: t }) => {
+				let n = l.add(i.z).add(t.mul(3)).toVar();
+				o(n.add(2).lessThan(z(ke[e])), () => {
+					let e = D.element(d.add(t)).toVar();
+					p.element(n).assign(f.bitOr(e.bitAnd(255))), p.element(n.add(1)).assign(f.bitOr(e.shiftRight(8).bitAnd(255))), p.element(n.add(2)).assign(f.bitOr(e.shiftRight(16).bitAnd(255)));
+				});
+			});
+		})().compute(ce[e], [tn]);
+		this.computeNodes = [
+			ze,
+			Be,
+			Ve,
+			We,
+			...Ge(0),
+			...Ge(1),
+			Ke(0),
+			Ke(1),
+			qe(0),
+			qe(1)
+		], this.positionNode = a(() => {
+			let t = fe.shiftRight(Xt), n = fe.bitAnd(Zt), r = Ce.element(t).toVar(), i = r.x, a = r.y, o = w.element(a).toVar(), s = E.element(o.w.add(n)).toVar(), { model: c, columns: l } = Ie(i), u = Fe(i, 4).toVar(), d = z(u.w).toVar(), p = W(d, 3), m = W(d, 4).toVar(), h = b.element(s).toVar(), g = x.element(s).toVar(), _ = f(h.xyz, "vec3"), v = p.x, y = l[3].xyz, C = O(e.viewMatrix.mul(H(y, 1)).xyz), T = v.sub(C).div(v.mul(rn)).clamp(0, 1), D = y.add(c.mul(H(_, 0)).xyz.mul(T)), k = re(c.mul(H(vn(h.w), 0)).xyz);
+			return ne.assign(k), Gt.assign(k), Kt.assign(S(a)), qt.assign(S(o.z)), Jt.assign(S(i)), Yt.assign(u.xyz.mul(yn(g.x).xyz)), It.assign(le(g.y).mul(m.xy).add(m.zw)), D;
+		})();
+	}
+	async readCounters(e) {
+		let t = new Uint32Array(await e.getArrayBufferAsync(this.countersAttribute)), n = this.meshSlotCapacity, r = (e) => ({
+			selected: t[2 + e * on + sn],
+			drawn: t[2 + e * on + cn],
+			survived: t[2 + e * on + ln],
+			requestedTriangles: t[2 + e * on + dn] / 3
+		});
+		return {
+			camera: r(0),
+			shadow: r(1),
+			occluded: t[1],
+			perMesh: (e, r) => t[fn + (e * n + r) * 2] / 3
+		};
+	}
+	drawArgsOffset(e, t) {
+		return (e * this.meshSlotCapacity + t) * 20;
+	}
+	dispose() {
+		for (let e of this.computeNodes) e.dispose();
+		this.computeNodes = [];
+	}
+};
+function _n(e, t, n, r) {
+	let [i, a, o, s] = n;
+	r[0] = e[t] * i + e[t + 4] * a + e[t + 8] * o + e[t + 12], r[1] = e[t + 1] * i + e[t + 5] * a + e[t + 9] * o + e[t + 13], r[2] = e[t + 2] * i + e[t + 6] * a + e[t + 10] * o + e[t + 14];
+	let c = Math.hypot(e[t], e[t + 1], e[t + 2]), l = Math.hypot(e[t + 4], e[t + 5], e[t + 6]), u = Math.hypot(e[t + 8], e[t + 9], e[t + 10]);
+	r[3] = s * Math.max(c, l, u);
+}
+function vn(e) {
+	let t = f(e, "int"), n = S(t.shiftLeft(16).shiftRight(16)).div(32767), r = S(t.shiftRight(16)).div(32767), i = S(1).sub(n.abs()).sub(r.abs()), a = Wt(i.negate(), 0), o = n.add(L(n.greaterThanEqual(0), a.negate(), a)), s = r.add(L(r.greaterThanEqual(0), a.negate(), a));
+	return re(de(o, s, i));
+}
+function yn(e) {
+	return H(S(e.bitAnd(255)), S(e.shiftRight(8).bitAnd(255)), S(e.shiftRight(16).bitAnd(255)), S(e.shiftRight(24))).div(255);
+}
+function bn(e, t, n) {
+	let r = Math.abs(e) + Math.abs(t) + Math.abs(n) || 1, i = e / r, a = t / r;
+	if (n < 0) {
+		let e = (1 - Math.abs(a)) * (i >= 0 ? 1 : -1), t = (1 - Math.abs(i)) * (a >= 0 ? 1 : -1);
+		i = e, a = t;
+	}
+	return (Math.round(Math.max(-1, Math.min(1, i)) * 32767) & 65535 | (Math.round(Math.max(-1, Math.min(1, a)) * 32767) & 65535) << 16) >>> 0;
+}
+function xn(e) {
+	let t = e.length / 2, n = [Infinity, Infinity], r = [-Infinity, -Infinity];
+	for (let t = 0; t < e.length; t++) {
+		let i = t & 1;
+		e[t] < n[i] && (n[i] = e[t]), e[t] > r[i] && (r[i] = e[t]);
+	}
+	t === 0 && (n[0] = n[1] = r[0] = r[1] = 0);
+	let i = [r[0] - n[0] || 1, r[1] - n[1] || 1], a = new Uint32Array(t), o = (e, t) => Math.round(Math.max(0, Math.min(1, (e - n[t]) / i[t])) * 65535);
+	for (let n = 0; n < t; n++) a[n] = (o(e[n * 2], 0) | o(e[n * 2 + 1], 1) << 16) >>> 0;
+	return {
+		packed: a,
+		scale: i,
+		offset: [n[0], n[1]]
+	};
+}
+function Sn(e) {
+	return e &= 1023, e = (e | e << 16) & 50331903, e = (e | e << 8) & 50393103, e = (e | e << 4) & 51130563, e = (e | e << 2) & 153391689, e;
+}
+function Cn(e, t) {
+	let n = e.length / 16, r = /* @__PURE__ */ new Float64Array(4), i = new Float64Array(n * 3), a = [
+		Infinity,
+		Infinity,
+		Infinity
+	], o = [
+		-Infinity,
+		-Infinity,
+		-Infinity
+	];
+	for (let s = 0; s < n; s++) {
+		_n(e, s * 16, t, r);
+		for (let e = 0; e < 3; e++) i[s * 3 + e] = r[e], a[e] = Math.min(a[e], r[e]), o[e] = Math.max(o[e], r[e]);
+	}
+	let s = Math.max(o[0] - a[0], o[1] - a[1], o[2] - a[2], 1e-9), c = new Uint32Array(n);
+	for (let e = 0; e < n; e++) {
+		let t = (t) => Math.min(1023, Math.max(0, Math.floor((i[e * 3 + t] - a[t]) / s * 1024)));
+		c[e] = (Sn(t(0)) | Sn(t(1)) << 1 | Sn(t(2)) << 2) >>> 0;
+	}
+	return wn(c);
+}
+function wn(e) {
+	let t = e.length, n = Uint32Array.from({ length: t }, (e, t) => t), r = new Uint32Array(t), i = /* @__PURE__ */ new Uint32Array(32768);
+	for (let a of [0, 15]) {
+		i.fill(0);
+		for (let n = 0; n < t; n++) i[e[n] >>> a & 32767]++;
+		let o = 0;
+		for (let e = 0; e < i.length; e++) {
+			let t = i[e];
+			i[e] = o, o += t;
+		}
+		for (let o = 0; o < t; o++) {
+			let t = n[o];
+			r[i[e[t] >>> a & 32767]++] = t;
+		}
+		[n, r] = [r, n];
+	}
+	return n;
+}
+//#endregion
+//#region src/core/runtime/VirtualMesh.ts
+var Tn = /* @__PURE__ */ new WeakMap();
+function En(e) {
+	let t = Tn.get(e);
+	return t ? t.clone() : (Tn.set(e, e.clone()), e);
+}
+function Dn() {
+	let e = new i.BufferGeometry();
+	return e.setAttribute("position", new i.BufferAttribute(/* @__PURE__ */ new Float32Array(3), 3)), e.setAttribute("normal", new i.BufferAttribute(/* @__PURE__ */ new Float32Array(3), 3)), e;
+}
+var On = class extends i.Mesh {
+	isVirtualMesh = !0;
+	data;
+	instanceCount;
+	fullDetailTriangles;
+	pool;
+	entry;
+	cameraGeometry = Dn();
+	shadowGeometry = Dn();
+	lastShadowFrame = 0;
+	occluder;
+	occlusionCulling = !0;
+	gpuIndexOf;
+	gpuToInput;
+	dirtyCells = /* @__PURE__ */ new Set();
+	drawingShadow = !1;
+	poolVersion = -1;
+	context;
+	get maxDrawDistance() {
+		let e = this.pool.readFlag(this.entry, "maxDrawDistance");
+		return e >= 1e30 ? Infinity : e;
+	}
+	set maxDrawDistance(e) {
+		this.pool.writeFlags(this.entry, { maxDrawDistance: Number.isFinite(e) ? Math.max(0, e) : an });
+	}
+	get minPixelRadius() {
+		return this.pool.readFlag(this.entry, "minPixelRadius");
+	}
+	set minPixelRadius(e) {
+		this.pool.writeFlags(this.entry, { minPixelRadius: Math.max(0, e) });
+	}
+	get capacity() {
+		return {
+			meshlets: this.pool.capacity.meshlets,
+			triangles: this.pool.capacity.triangles
+		};
+	}
+	constructor(e, t, n, r, a = {}) {
+		n = En(n);
+		let o = Dn();
+		super(o, n), this.context = e, this.data = t, this.frustumCulled = !1, this.instanceCount = r.matrices.length / 16, this.fullDetailTriangles = t.stats.leafTriangles * this.instanceCount, this.occluder = n.side !== i.DoubleSide && !n.transparent && n.alphaTest === 0 && !n.alphaHash, this.gpuToInput = Cn(r.matrices, t.boundingSphere), this.gpuIndexOf = new Uint32Array(this.instanceCount);
+		for (let e = 0; e < this.instanceCount; e++) this.gpuIndexOf[this.gpuToInput[e]] = e;
+		e.register(this, r), a.maxDrawDistance !== void 0 && (this.maxDrawDistance = a.maxDrawDistance), a.minPixelRadius !== void 0 && (this.minPixelRadius = a.minPixelRadius), Vt(n);
+		let s = H(n.colorNode ?? j).toVar(), c = (e) => de(w(e), w(e.add(17.17)), w(e.add(43.43))), l = L(e.debugMode.equal(be.meshlets), c(Kt.add(Jt.mul(.618))), L(e.debugMode.equal(be.lodLevel), c(qt.add(3)), c(Jt)));
+		n.colorNode = H(L(e.debugMode.equal(be.shaded), s.xyz.mul(Yt), l), s.w), n.side === i.DoubleSide && !n.normalNode && (n.normalNode = re(h.mul(H(Gt, 0)).xyz.mul(x))), this.syncPool(), this.geometry = this.cameraGeometry, o.dispose(), this.onBeforeShadow = (t, n, r, i) => {
+			this.lastShadowFrame = e.frameCount, e.noteShadowCamera(i), this.drawingShadow = !0, this.geometry = this.shadowGeometry;
+		};
+		let u = this.onBeforeRender;
+		this.onBeforeRender = (...e) => {
+			this.drawingShadow ? this.drawingShadow = !1 : this.geometry = this.cameraGeometry, u.apply(this, e);
+		};
+	}
+	syncPool() {
+		let e = this.pool;
+		this.poolVersion !== e.version && e.positionNode && (this.poolVersion = e.version, this.cameraGeometry.setIndex(e.cameraIndex), this.cameraGeometry.setIndirect(e.drawArgsAttribute, e.drawArgsOffset(0, this.entry.slot)), this.shadowGeometry.setIndex(e.shadowIndex), this.shadowGeometry.setIndirect(e.drawArgsAttribute, e.drawArgsOffset(1, this.entry.slot)), this.material.positionNode = e.positionNode, this.material.needsUpdate = !0);
+	}
+	markCutDirty() {
+		this.pool.dirty = !0;
+	}
+	setMatrixAt(e, t) {
+		let n = this.gpuIndexOf[e];
+		this.pool.setMatrix(this.entry, n, t), this.dirtyCells.add(Math.floor(n / 128));
+	}
+	commitInstances() {
+		this.pool.commitInstances(this.entry, this.dirtyCells), this.dirtyCells.clear();
+	}
+	dispose(e) {
+		this.visible = !1, (e ?? this.context).unregister(this), this.removeFromParent();
+	}
+	async readStats(e) {
+		let t = await this.pool.readCounters(e);
+		return {
+			drawnTriangles: t.perMesh(0, this.entry.slot),
+			shadowTriangles: t.perMesh(1, this.entry.slot)
+		};
+	}
+}, kn = {
+	MeshPhysicalMaterial: [i.MeshPhysicalMaterial, i.MeshPhysicalNodeMaterial],
+	MeshStandardMaterial: [i.MeshStandardMaterial, i.MeshStandardNodeMaterial],
+	MeshPhongMaterial: [i.MeshPhongMaterial, i.MeshPhongNodeMaterial],
+	MeshLambertMaterial: [i.MeshLambertMaterial, i.MeshLambertNodeMaterial],
+	MeshBasicMaterial: [i.MeshBasicMaterial, i.MeshBasicNodeMaterial],
+	MeshToonMaterial: [i.MeshToonMaterial, i.MeshToonNodeMaterial],
+	MeshMatcapMaterial: [i.MeshMatcapMaterial, i.MeshMatcapNodeMaterial],
+	MeshNormalMaterial: [i.MeshNormalMaterial, i.MeshNormalNodeMaterial]
+}, An = [
+	["isMeshPhysicalMaterial", "MeshPhysicalMaterial"],
+	["isMeshStandardMaterial", "MeshStandardMaterial"],
+	["isMeshPhongMaterial", "MeshPhongMaterial"],
+	["isMeshLambertMaterial", "MeshLambertMaterial"],
+	["isMeshBasicMaterial", "MeshBasicMaterial"],
+	["isMeshToonMaterial", "MeshToonMaterial"],
+	["isMeshMatcapMaterial", "MeshMatcapMaterial"],
+	["isMeshNormalMaterial", "MeshNormalMaterial"]
+];
+function jn(e) {
+	let t = e, n = kn[e.type] ? e.type : An.find(([e]) => t[e] === !0)?.[1];
+	return n ? kn[n] : null;
+}
+function Mn(e) {
+	return e.isNodeMaterial === !0 || jn(e) !== null;
+}
+function Nn(e) {
+	if (e.isNodeMaterial) return e;
+	let t = jn(e);
+	if (!t) return null;
+	let [n, r] = t, i = new r(), a = i.defines;
+	return n.prototype.copy.call(i, e), i.defines = a, i;
+}
+//#endregion
+//#region src/source.ts
+var Pn = 1e-6, Fn = 1e-4;
+function In(e, t = {}) {
+	let n = e.attributes.position, r = t.uvs ?? !0 ? e.attributes.uv : void 0, a = t.colors ? e.attributes.color : void 0, o = t.normals === "keep" ? e.attributes.normal : void 0, s = e.index, c = s ? s.count : n.count, l = Math.max(0, Math.min(c, t.range?.start ?? 0)), u = Math.floor((Math.min(c, l + (t.range?.count ?? c)) - l) / 3) * 3, d = (e) => s ? s.getX(l + e) : l + e, f = Rn(u, d, [{
+		attribute: n,
+		size: 3,
+		tolerance: Pn
+	}]), p = Ln(f.firstVertex, n, 3), m = null;
+	if (!o) {
+		let e = new i.BufferGeometry();
+		e.setAttribute("position", new i.BufferAttribute(p, 3)), e.setIndex(new i.BufferAttribute(f.indices, 1)), e.computeVertexNormals(), m = e.attributes.normal.array;
+	}
+	if (!r && !a && !o) return {
+		positions: p,
+		normals: m,
+		indices: f.indices
+	};
+	let h = [{
+		attribute: n,
+		size: 3,
+		tolerance: Pn
+	}];
+	r && h.push({
+		attribute: r,
+		size: 2,
+		tolerance: Pn
+	}), o && h.push({
+		attribute: o,
+		size: 3,
+		tolerance: Fn
+	}), a && h.push({
+		attribute: a,
+		size: 3,
+		tolerance: Fn
+	});
+	let g = Rn(u, d, h), _ = {
+		positions: Ln(g.firstVertex, n, 3),
+		normals: /* @__PURE__ */ new Float32Array(),
+		indices: g.indices
+	};
+	if (o) {
+		_.normals = Ln(g.firstVertex, o, 3);
+		for (let e = 0; e < _.normals.length; e += 3) {
+			let t = Math.hypot(_.normals[e], _.normals[e + 1], _.normals[e + 2]) || 1;
+			_.normals[e] /= t, _.normals[e + 1] /= t, _.normals[e + 2] /= t;
+		}
+	} else {
+		_.normals = new Float32Array(g.firstVertex.length * 3);
+		for (let e = 0; e < g.firstVertex.length; e++) {
+			let t = f.indices[g.firstCorner[e]];
+			_.normals.set(m.subarray(t * 3, t * 3 + 3), e * 3);
+		}
+	}
+	return r && (_.uvs = Ln(g.firstVertex, r, 2)), a && (_.colors = Ln(g.firstVertex, a, 3)), _;
+}
+function Ln(e, t, n) {
+	let r = new Float32Array(e.length * n);
+	for (let i = 0; i < e.length; i++) for (let a = 0; a < n; a++) r[i * n + a] = t.getComponent(e[i], a);
+	return r;
+}
+function Rn(e, t, n) {
+	let r = n.reduce((e, t) => e + t.size, 0), i = n.map(({ tolerance: e }) => {
+		let t = 10 ** Math.log10(1 / e);
+		return {
+			multiplier: t,
+			additive: e * .5 * t
+		};
+	}), a = 1;
+	for (; a < e * 2;) a <<= 1;
+	let o = a - 1, s = new Int32Array(a).fill(-1), c = new Float64Array(e * r), l = new Float64Array(r), u = new Uint32Array(e), d = new Uint32Array(e), f = new Uint32Array(e), p = 0;
+	for (let a = 0; a < e; a++) {
+		let e = t(a), m = 0, h = 0;
+		for (let t = 0; t < n.length; t++) {
+			let { attribute: r, size: a } = n[t], { multiplier: o, additive: s } = i[t];
+			for (let t = 0; t < a; t++, h++) l[h] = Math.trunc(r.getComponent(e, t) * o + s), m = m ^ Math.imul(l[h] | 0, zn[h % zn.length]) | 0;
+		}
+		for (m &= o;;) {
+			let t = s[m];
+			if (t < 0) {
+				s[m] = p, c.set(l, p * r), u[p] = e, d[p] = a, f[a] = p++;
+				break;
+			}
+			let n = !0;
+			for (let e = 0; e < r && n; e++) n = c[t * r + e] === l[e];
+			if (n) {
+				f[a] = t;
+				break;
+			}
+			m = m + 1 & o;
+		}
+	}
+	return {
+		indices: f,
+		firstVertex: u.slice(0, p),
+		firstCorner: d.slice(0, p)
+	};
+}
+var zn = [
+	73856093,
+	19349663,
+	83492791,
+	2654435761,
+	2246822519,
+	3266489917,
+	668265263,
+	374761393,
+	1181783497,
+	3735928559,
+	2028178513
+];
+function Bn(e) {
+	let t = e.reduce((e, t) => e + t.mesh.positions.length / 3, 0), n = e.reduce((e, t) => e + t.mesh.indices.length, 0), r = new Float32Array(t * 3), a = new Float32Array(t * 3), o = new Float32Array(t * 3), s = e.some((e) => e.mesh.uvs) ? new Float32Array(t * 2) : null, c = new Uint32Array(n), l = new i.Color(), u = 0, d = 0;
+	for (let { mesh: t, color: n = 16777215 } of e) {
+		let e = t.positions.length / 3;
+		if (r.set(t.positions, u * 3), a.set(t.normals, u * 3), s && t.uvs && s.set(t.uvs, u * 2), t.colors) o.set(t.colors, u * 3);
+		else {
+			l.set(n);
+			for (let t = 0; t < e; t++) o.set([
+				l.r,
+				l.g,
+				l.b
+			], (u + t) * 3);
+		}
+		for (let e = 0; e < t.indices.length; e++) c[d + e] = t.indices[e] + u;
+		u += e, d += t.indices.length;
+	}
+	return s ? {
+		positions: r,
+		normals: a,
+		colors: o,
+		uvs: s,
+		indices: c
+	} : {
+		positions: r,
+		normals: a,
+		colors: o,
+		indices: c
+	};
+}
+//#endregion
+//#region src/core/import/fromObject3D.ts
+var Vn = bt, Hn = /* @__PURE__ */ new WeakSet();
+function Un(e) {
+	let t = e;
+	if (!t.isMesh) return "not a mesh";
+	if (t.isVirtualMesh) return "already a VirtualMesh";
+	if (t.isSkinnedMesh) return "skinned";
+	if (t.isBatchedMesh) return "batched";
+	let n = t.geometry;
+	if (!n?.attributes?.position || n.isInstancedBufferGeometry) return "unsupported geometry";
+	let r = n.morphAttributes;
+	return (r.position?.length ?? 0) > 0 || (r.normal?.length ?? 0) > 0 || (t.morphTargetInfluences?.length ?? 0) > 0 ? "morph targets" : (Array.isArray(t.material) ? t.material : [t.material]).some((e) => !e || !Mn(e)) ? "material without a node equivalent" : null;
+}
+function Wn(e, t) {
+	e.updateWorldMatrix(!0, !0);
+	let n = /* @__PURE__ */ new Map(), r = [], a = [], o = new i.Matrix4(), s = new i.Matrix4(), c = new i.Color();
+	e.traverse((e) => {
+		if (!e.isMesh || Hn.has(e)) return;
+		let i = e, l = Un(i) ?? (t && !t(i) ? "filtered out" : null);
+		if (l) {
+			a.push({
+				object: i,
+				reason: l
+			});
+			return;
+		}
+		let u = i.geometry, d = Array.isArray(i.material) ? i.material : [i.material], f = Gn(u, Array.isArray(i.material));
+		if (f.length === 0) return;
+		r.push(i);
+		let p = i.isInstancedMesh ? i : null, m = p ? p.count : 1, h = Kn(i);
+		for (let { start: e, count: t, materialIndex: r } of f) {
+			let a = d[r];
+			if (!a) continue;
+			let l = a.vertexColors === !0 && u.attributes.color !== void 0, f = [
+				u.id,
+				e,
+				t,
+				a.uuid,
+				i.castShadow,
+				i.receiveShadow,
+				h,
+				i.renderOrder,
+				i.layers.mask
+			].join(":"), g = n.get(f);
+			g || (g = {
+				geometry: u,
+				range: {
+					start: e,
+					count: t
+				},
+				material: a,
+				matrices: /* @__PURE__ */ new Float32Array(),
+				colors: null,
+				instances: [],
+				vertexColors: l,
+				castShadow: i.castShadow,
+				receiveShadow: i.receiveShadow,
+				visible: h,
+				renderOrder: i.renderOrder,
+				layers: i.layers.mask,
+				name: i.name,
+				userData: { ...i.userData },
+				matrixList: [],
+				colorList: null
+			}, n.set(f, g));
+			for (let e = 0; e < m; e++) {
+				p ? (p.getMatrixAt(e, o), s.multiplyMatrices(i.matrixWorld, o)) : s.copy(i.matrixWorld), g.matrixList.push(...s.elements);
+				let t = !!p?.instanceColor;
+				t && p.getColorAt(e, c), t && !g.colorList && (g.colorList = Array(g.instances.length * 4).fill(1)), g.colorList && (t ? g.colorList.push(c.r, c.g, c.b, 1) : g.colorList.push(1, 1, 1, 1)), g.instances.push({
+					object: i,
+					index: p ? e : -1
+				});
+			}
+		}
+	});
+	let l = [];
+	for (let { matrixList: e, colorList: t, ...r } of n.values()) r.matrices = Float32Array.from(e), r.colors = t ? Float32Array.from(t) : null, l.push(r);
+	return {
+		groups: l,
+		meshes: r,
+		skipped: a
+	};
+}
+function Gn(e, t) {
+	let n = e.index ? e.index.count : e.attributes.position.count, r = Math.max(0, e.drawRange.start), i = Math.min(n, r + e.drawRange.count), a = t ? e.groups : [{
+		start: 0,
+		count: n,
+		materialIndex: 0
+	}], o = [];
+	for (let e of a) {
+		let t = Math.max(e.start, r), n = Math.min(e.start + e.count, i);
+		n - t >= 3 && o.push({
+			start: t,
+			count: n - t,
+			materialIndex: e.materialIndex ?? 0
+		});
+	}
+	return o;
+}
+function Kn(e) {
+	for (let t = e; t; t = t.parent) if (!t.visible) return !1;
+	return !0;
+}
+var qn = class {
+	context;
+	object = new i.Group();
+	meshes = [];
+	groups;
+	skipped;
+	stats = {
+		sourceMeshes: 0,
+		instances: 0,
+		uniqueGeometries: 0,
+		buildMs: 0
+	};
+	hidden = /* @__PURE__ */ new Map();
+	detached = /* @__PURE__ */ new Map();
+	constructor(e, t) {
+		this.context = e, this.object.name = "VirtualGeometryImport", this.groups = t.groups, this.skipped = t.skipped, this.stats.sourceMeshes = t.meshes.length, this.stats.instances = t.groups.reduce((e, t) => e + t.instances.length, 0);
+	}
+	hide(e, t) {
+		let n = /* @__PURE__ */ new Set();
+		for (let t of e) Hn.add(t), t.children.length === 0 && t.parent ? (this.detached.set(t, t.parent), n.add(t.parent), t.parent.remove(t)) : (this.hidden.has(t) || this.hidden.set(t, t.layers.mask), t.layers.disableAll());
+		for (let e of n) for (; e !== t && e.children.length === 0 && e.parent && (e.type === "Group" || e.type === "Object3D");) {
+			let t = e.parent;
+			this.detached.set(e, t), t.remove(e), e = t;
+		}
+	}
+	worldMatrixOf(e) {
+		let t = this.detached.get(e);
+		return t ? (e.updateMatrix(), e.matrixWorld.multiplyMatrices(this.worldMatrixOf(t), e.matrix)) : (e.updateWorldMatrix(!0, !1), e.matrixWorld);
+	}
+	syncTransforms() {
+		let e = new i.Matrix4(), t = new i.Matrix4(), n = /* @__PURE__ */ new Set();
+		this.groups.forEach((r, i) => {
+			let a = this.meshes[i];
+			r.instances.forEach(({ object: r, index: i }, o) => {
+				n.has(r) || (this.worldMatrixOf(r), n.add(r)), i >= 0 ? (r.getMatrixAt(i, t), e.multiplyMatrices(r.matrixWorld, t)) : e.copy(r.matrixWorld), a.setMatrixAt(o, e);
+			}), a.commitInstances();
+		});
+	}
+	dispose() {
+		for (let e of this.meshes) e.dispose(this.context), e.material.dispose(), e.geometry.dispose();
+		this.meshes.length = 0;
+		for (let [e, t] of this.hidden) e.layers.mask = t, Hn.delete(e);
+		this.hidden.clear();
+		for (let [e, t] of this.detached) t.add(e), Hn.delete(e);
+		this.detached.clear(), this.object.removeFromParent();
+	}
+};
+async function Jn(e, t, n = {}) {
+	let r = performance.now(), i = n.builder ?? Vn, a = Wn(t, n.filter), o = new qn(e, a), s = /* @__PURE__ */ new Map(), c = (e) => `${e.geometry.id}:${e.range.start}:${e.range.count}:${e.vertexColors}`;
+	for (let e of o.groups) {
+		let t = c(e);
+		s.has(t) || s.set(t, {
+			group: e,
+			triangles: e.range.count / 3
+		});
+	}
+	o.stats.uniqueGeometries = s.size;
+	let l = [...s.values()].reduce((e, t) => e + t.triangles, 0) || 1, u = 0;
+	for (let e of s.values()) {
+		let { geometry: t, range: r, vertexColors: a } = e.group;
+		e.data = await i(In(t, {
+			range: r,
+			colors: a,
+			normals: t.attributes.normal ? "keep" : "compute"
+		}), {
+			...n.build,
+			onProgress: (t) => n.onProgress?.((u + t * e.triangles) / l)
+		}), u += e.triangles;
+	}
+	let d = /* @__PURE__ */ new Map(), f = [], p = /* @__PURE__ */ new Set();
+	for (let t of o.groups) {
+		let r = Yn(t, n, d);
+		if (!r) {
+			for (let { object: e } of t.instances) p.add(e);
+			continue;
+		}
+		let i = typeof n.mesh == "function" ? n.mesh(t) : n.mesh, a = e.createMesh(s.get(c(t)).data, r, {
+			matrices: t.matrices,
+			colors: t.colors ?? void 0
+		}, i);
+		a.matrixAutoUpdate = !1, a.matrixWorldAutoUpdate = !1, a.name = t.name, a.userData = { ...t.userData }, a.castShadow = t.castShadow, a.receiveShadow = t.receiveShadow, a.visible = t.visible, a.renderOrder = t.renderOrder, a.layers.mask = t.layers, o.meshes.push(a), f.push(t), o.object.add(a);
+	}
+	return o.groups = f, (n.replace ?? !0) && (o.hide(a.meshes.filter((e) => !p.has(e)), t), t.add(o.object)), await n.onProgress?.(1), o.stats.buildMs = performance.now() - r, o;
+}
+function Yn(e, t, n) {
+	let r = e.material, i = !!(r.normalMap && e.geometry.attributes.tangent && r.normalMap.flipY === !1), a = `${r.uuid}:${i}`;
+	if (n.has(a)) return n.get(a);
+	let o;
+	if (t.material ? o = t.material(r, e) : (o = Nn(r), o === r && (o = r.clone())), o && i) {
+		let e = o.normalScale;
+		e && (o.normalScale = e.clone().setY(-e.y));
+	}
+	return n.set(a, o), o;
+}
+//#endregion
+//#region src/core/runtime/OcclusionCulling.ts
+var Xn = 68, Zn = 64, Qn = 64, $n = [], er = (e) => e.reduce((e, t) => e + t, 0) / e.length, tr = P, nr = N, rr = class {
+	enabled = !0;
+	auto = !0;
+	autoProbeFrames = 40;
+	autoHoldFrames = 900;
+	autoChoice = !1;
+	phase = "hold";
+	phaseFrames = this.autoHoldFrames - 120;
+	samples = [];
+	offMean = 0;
+	lastTick = 0;
+	resolutionScale = .5;
+	maxSize;
+	active = !1;
+	activeNode = B(0, "uint");
+	depthScene = new i.Scene();
+	proxies = /* @__PURE__ */ new Map();
+	projection;
+	near;
+	levelCapacity;
+	levelOffsets = [];
+	hzbAttribute;
+	hzbWrite;
+	hzbRead;
+	buildNodes = [];
+	renderTarget = null;
+	width = 0;
+	height = 0;
+	levels = 0;
+	bufferSize = new i.Vector2();
+	constructor(e, t, n = 1024) {
+		this.maxSize = Math.max(1, Math.min(32768, n)), this.projection = e, this.near = t;
+		let r = this.maxSize, a = Xn, o = 0;
+		for (; this.levelOffsets.push(a), a += r * r, o++, r !== 1;) r = Math.ceil(r / 2);
+		this.levelCapacity = o, this.hzbAttribute = new i.StorageBufferAttribute(new Float32Array(a), 1), this.hzbWrite = R(this.hzbAttribute, "float", a), this.hzbRead = R(this.hzbAttribute, "float", a).toReadOnly();
+	}
+	occluded(e, t) {
+		let n = this.projection, r = e.z.negate(), i = r.sub(t).toVar(), a = r.add(t), o = e.x.sub(t), s = e.x.add(t), c = e.y.sub(t), l = e.y.add(t), u = n.element(0).x, d = n.element(1).y, f = tr(o.div(i), o.div(a)).mul(u).sub(n.element(2).x), p = nr(s.div(i), s.div(a)).mul(u).sub(n.element(2).x), m = tr(c.div(i), c.div(a)).mul(d).sub(n.element(2).y), h = nr(l.div(i), l.div(a)).mul(d).sub(n.element(2).y), v = n.element(3).z.div(i).sub(n.element(2).z), y = i.lessThanEqual(this.near), x = this.hzbRead, w = x.element(1), T = x.element(2), E = S(0), D = _(C(f.mul(.5).add(.5).mul(w)), E, w.sub(1)), O = _(C(p.mul(.5).add(.5).mul(w)), E, w.sub(1)), k = _(C(S(.5).sub(h.mul(.5)).mul(T)), E, T.sub(1)), A = _(C(S(.5).sub(m.mul(.5)).mul(T)), E, T.sub(1)), te = nr(O.sub(D), A.sub(k)).add(1), j = tr(g(ee(te)), x.element(Zn).sub(1)), M = z(j).mul(4), N = b(j), P = x.element(M), F = x.element(M.add(1)), ne = x.element(M.add(2)), I = (e, t) => {
+			let n = _(C(e.div(N)), E, F.sub(1)), r = _(C(t.div(N)), E, ne.sub(1));
+			return x.element(z(P.add(r.mul(F)).add(n)));
+		}, re = nr(nr(I(D, k), I(O, k)), nr(I(D, A), I(O, A)));
+		return y.not().and(v.lessThan(1)).and(v.greaterThan(re.add(1e-6)));
+	}
+	tick(e) {
+		let t = this.lastTick ? e - this.lastTick : 0;
+		this.lastTick = e, this.auto && this.enabled && (this.phaseFrames++, this.phase !== "hold" && this.phaseFrames > 5 && t > 0 && t < 250 && this.samples.push(t), this.phase === "probeOff" && this.samples.length >= this.autoProbeFrames ? (this.offMean = er(this.samples), this.next("probeOn")) : this.phase === "probeOn" && this.samples.length >= this.autoProbeFrames ? (this.autoChoice = er(this.samples) < this.offMean * .97, this.next("hold")) : this.phase === "hold" && this.phaseFrames >= this.autoHoldFrames && this.next("probeOff"));
+	}
+	next(e) {
+		this.phase = e, this.phaseFrames = 0, this.samples = [];
+	}
+	autoWanted() {
+		return this.phase === "probeOn" || this.phase === "hold" && this.autoChoice;
+	}
+	proxyOf(e) {
+		let t = this.proxies.get(e);
+		t || (t = new i.Mesh(e.cameraGeometry, new i.MeshBasicNodeMaterial({ colorWrite: !1 })), t.frustumCulled = !1, this.depthScene.add(t), this.proxies.set(e, t));
+		let n = t.material;
+		return n.positionNode !== e.pool.positionNode && (n.positionNode = e.pool.positionNode, n.needsUpdate = !0), t;
+	}
+	unregisterMesh(e) {
+		let t = this.proxies.get(e);
+		t && (this.proxies.delete(e), t.removeFromParent(), t.material.dispose());
+	}
+	wantsFrame(e, t, n) {
+		let r = e, i = t.isPerspectiveCamera && !r.reversedDepthBuffer && !r.logarithmicDepthBuffer;
+		return this.enabled && i && (!this.auto || this.autoWanted());
+	}
+	beginFrame(e, t, n) {
+		let r = !1;
+		for (let e of n) {
+			let t = e.visible && e.occluder && e.pool.hasCut && !!e.pool.positionNode;
+			if (!t && !this.proxies.has(e)) continue;
+			let n = this.proxyOf(e);
+			n.visible = t, r ||= t;
+		}
+		if (this.active = r, this.activeNode.value = +!!r, !r) return $n;
+		e.getDrawingBufferSize(this.bufferSize);
+		let i = Math.min(this.resolutionScale, this.maxSize / Math.max(this.bufferSize.x, this.bufferSize.y)), a = Math.max(1, Math.round(this.bufferSize.x * i)), o = Math.max(1, Math.round(this.bufferSize.y * i));
+		(a !== this.width || o !== this.height) && this.resize(a, o);
+		let s = e.getRenderTarget();
+		return e.setRenderTarget(this.renderTarget), e.render(this.depthScene, t), e.setRenderTarget(s), this.buildNodes;
+	}
+	resize(e, t) {
+		let n = this.buildNodes;
+		this.renderTarget?.dispose();
+		let r = new i.DepthTexture(e, t);
+		r.type = i.FloatType, this.renderTarget = new i.RenderTarget(e, t, {
+			depthBuffer: !0,
+			depthTexture: r
+		}), this.width = e, this.height = t;
+		let s = this.hzbAttribute.array;
+		s.fill(0, 0, Xn);
+		let l = e, u = t, d = 0;
+		for (let e = 0; e < this.levelCapacity && (s[e * 4] = this.levelOffsets[e], s[e * 4 + 1] = l, s[e * 4 + 2] = u, d++, l !== 1 || u !== 1); e++) l = Math.max(1, Math.ceil(l / 2)), u = Math.max(1, Math.ceil(u / 2));
+		this.levels = d, s[Zn] = d, this.hzbAttribute.needsUpdate = !0;
+		let f = se(r), p = this.hzbWrite, m = a(() => {
+			let e = T, t = z(p.element(1)), n = z(p.element(2));
+			o(e.greaterThanEqual(t.mul(n)), () => {
+				c();
+			});
+			let r = e.mod(t), i = e.div(t), a = z(p.element(0)).toVar();
+			p.element(a.add(e)).assign(f.load(D(E(r), E(i))));
+		})().compute(e * t, [Qn]);
+		this.buildNodes = [m], l = e, u = t;
+		for (let e = 1; e < d; e++) l = Math.max(1, Math.ceil(l / 2)), u = Math.max(1, Math.ceil(u / 2)), this.buildNodes.push(a(() => {
+			let t = T, n = z(p.element(e * 4)).toVar(), r = z(p.element(e * 4 + 1)), i = z(p.element(e * 4 + 2));
+			o(t.greaterThanEqual(r.mul(i)), () => {
+				c();
+			});
+			let a = t.mod(r), s = t.div(r), l = z(p.element((e - 1) * 4)).toVar(), u = z(p.element((e - 1) * 4 + 1)), d = z(p.element((e - 1) * 4 + 2)), f = a.mul(2), m = s.mul(2), h = tr(f.add(1), u.sub(1)), g = tr(m.add(1), d.sub(1)), _ = l.add(m.mul(u)), v = l.add(g.mul(u)), y = nr(nr(p.element(_.add(f)), p.element(_.add(h))), nr(p.element(v.add(f)), p.element(v.add(h))));
+			p.element(n.add(t)).assign(y);
+		})().compute(l * u, [Qn]));
+		for (let e of n) e.dispose();
+	}
+	dispose() {
+		this.renderTarget?.dispose(), this.renderTarget = null;
+		for (let e of [...this.proxies.keys()]) this.unregisterMesh(e);
+	}
+}, ir = 44, ar = new i.Vector3();
+function or(e, t) {
+	return Math.min(64, e * Math.min(2, Math.max(1.04, Math.sqrt(t / .85))));
+}
+var sr = class {
+	viewMatrix = B(new i.Matrix4());
+	projectionMatrix = B(new i.Matrix4());
+	projScale = B(1);
+	near = B(.1);
+	errorThreshold = B(1);
+	triangleBudget = 0;
+	thresholdRange = [.5, 3];
+	lastStats = null;
+	statsInterval = 10;
+	frameCount = 0;
+	guardBase = null;
+	outOfBand = 0;
+	guardWritten = NaN;
+	statsPending = !1;
+	frustumCulling = B(1, "uint");
+	debugMode = B(0, "uint");
+	minPixelRadius = B(.7);
+	frustumPlanes = Array.from({ length: 6 }, () => B(new i.Vector4()));
+	shadowSweep = B(new i.Vector3());
+	autoShadowSweep = !0;
+	shadowErrorScale = B(3);
+	detectedSweep = new i.Vector3();
+	detectedSweepFrame = -Infinity;
+	occlusion = new rr(this.projectionMatrix, this.near);
+	freeze = !1;
+	autoUpdate = !0;
+	errorInCssPixels = !0;
+	meshes = [];
+	pools = [];
+	capacity;
+	maxPoolBytes;
+	constructor(e = {}) {
+		this.capacity = {
+			triangles: e.maxTriangles ?? 1e7,
+			shadowTriangles: e.maxShadowTriangles ?? 4e6,
+			meshlets: Math.min(e.maxMeshlets ?? 1 << 20, 1 << 24)
+		}, this.maxPoolBytes = e.maxPoolBytes ?? 125829120;
+	}
+	frustum = new i.Frustum();
+	projScreen = new i.Matrix4();
+	size = new i.Vector2();
+	computeList = [];
+	dispatchedPools = [];
+	skippedFrames = 0;
+	cutInputs = new Float64Array(ir).fill(NaN);
+	cutInputsScratch = new Float64Array(ir);
+	sceneHooks = /* @__PURE__ */ new WeakMap();
+	autoCall = -1;
+	autoCamera = null;
+	manualCall = -1;
+	manualCamera = null;
+	updatingAuto = !1;
+	add(e, t) {
+		return Jn(this, e, t);
+	}
+	createMesh(e, t, n, r) {
+		return new On(this, e, t, n, r);
+	}
+	asyncCompile = !0;
+	compilePool(e, t) {
+		t.pipelineState = "compiling";
+		let n = t.version, r = () => {
+			t.version === n && (t.pipelineState = "ready", t.dirty = !0);
+		};
+		e.compileComputeAsync(t.computeNodes).then(r, r);
+	}
+	preparePools(e) {
+		for (let t of this.pools) t.prepare(e);
+		for (let e of this.meshes) e.syncPool();
+	}
+	async compileAsync(e, t, n) {
+		this.preparePools(e);
+		let r = this.pools.filter((e) => e.pipelineState !== "ready");
+		for (let e of r) e.pipelineState = "compiling";
+		await Promise.all(r.map((t) => e.compileComputeAsync(t.computeNodes).catch(() => void 0)));
+		for (let e of r) e.pipelineState = "ready", e.dirty = !0;
+		await e.compileAsync(t, n);
+	}
+	noteShadowCamera(e) {
+		if (this.detectedSweepFrame === this.frameCount) return;
+		let t = e;
+		if (!t.isOrthographicCamera) return;
+		let n = Math.max(t.top - t.bottom, t.right - t.left) / t.zoom;
+		e.getWorldDirection(this.detectedSweep).multiplyScalar(n), this.detectedSweepFrame = this.frameCount;
+	}
+	register(e, t) {
+		let n = t.matrices.length / 16;
+		if (gn.bytesOf(e.data) > this.maxPoolBytes) throw Error(`VirtualGeometry: a single mesh needs more than maxPoolBytes (${this.maxPoolBytes} bytes) of GPU buffer`);
+		let r = this.pools.find((t) => t.fits(e.data, n));
+		r || (r = new gn(this, this.capacity, this.maxPoolBytes), this.pools.push(r)), e.pool = r, e.entry = r.add(e.data, t.matrices, t.colors, e.gpuToInput), r.ensureBuilt(), this.meshes.push(e), e.onBeforeRender = (e, t, n) => this.autoUpdateFor(e, t, n, !1);
+	}
+	autoUpdateFor(e, t, n, r) {
+		if (!this.autoUpdate || this.meshes.length === 0 || t.overrideMaterial && t.overrideMaterial.isShadowPassMaterial) return;
+		if (!r && t.isScene) {
+			if (t.onBeforeRender === this.sceneHooks.get(t)) return;
+			let e = t.onBeforeRender, n = this, r = function(t, r, i, ...a) {
+				n.autoUpdateFor(t, r, i, !0), e.call(this, t, r, i, ...a);
+			};
+			t.onBeforeRender = r, this.sceneHooks.set(t, r);
+		}
+		let i = e.info.render.calls;
+		if ((n !== this.autoCamera || i !== this.autoCall) && (n !== this.manualCamera || i !== this.manualCall + 1)) {
+			this.autoCall = i, this.autoCamera = n, this.updatingAuto = !0;
+			try {
+				this.update(e, n);
+			} finally {
+				this.updatingAuto = !1;
+			}
+		}
+	}
+	unregister(e) {
+		let t = this.meshes.indexOf(e);
+		t !== -1 && (this.meshes.splice(t, 1), e.pool.remove(e.entry), this.occlusion.unregisterMesh(e));
+	}
+	dispose() {
+		for (let e of [...this.meshes]) e.dispose(this);
+		for (let e of this.pools) e.dispose();
+		this.pools.length = 0, this.occlusion.dispose();
+	}
+	update(e, t) {
+		if (this.updatingAuto || (this.manualCall = e.info.render.calls, this.manualCamera = t), this.freeze) return;
+		this.occlusion.tick(performance.now()), t.updateMatrixWorld(), this.viewMatrix.value.copy(t.matrixWorldInverse), this.projectionMatrix.value.equals(t.projectionMatrix) || this.projectionMatrix.value.copy(t.projectionMatrix), e.getDrawingBufferSize(this.size);
+		let n = this.size.y / (this.errorInCssPixels ? e.getPixelRatio() : 1), r = t.projectionMatrix.elements[5] * n * .5;
+		this.projScale.value !== r && (this.projScale.value = r), this.near.value !== t.near && (this.near.value = t.near), this.projScreen.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse), this.frustum.setFromProjectionMatrix(this.projScreen, i.WebGPUCoordinateSystem);
+		for (let e = 0; e < 6; e++) {
+			let { normal: t, constant: n } = this.frustum.planes[e], r = this.frustumPlanes[e].value;
+			(r.x !== t.x || r.y !== t.y || r.z !== t.z || r.w !== n) && r.set(t.x, t.y, t.z, n);
+		}
+		if (this.autoShadowSweep) {
+			let e = this.frameCount - this.detectedSweepFrame <= 2 ? this.detectedSweep : ar;
+			this.shadowSweep.value.equals(e) || this.shadowSweep.value.copy(e);
+		}
+		let a = this.occlusion.wantsFrame(e, t, this.frameCount);
+		for (let e of this.meshes) e.pool.writeFlags(e.entry, {
+			enabled: +!!e.visible,
+			shadow: e.castShadow && this.frameCount - e.lastShadowFrame <= 2 ? 1 : 0,
+			occlusion: a && e.occlusionCulling ? 1 : 0
+		});
+		if (this.cutInputsChanged(t, e.getPixelRatio())) for (let e of this.pools) e.dirty = !0;
+		this.preparePools(e);
+		let o = this.computeList;
+		o.length = 0;
+		let s = this.dispatchedPools;
+		s.length = 0;
+		for (let t of this.pools) if (t.dirty && t.entries.length !== 0) {
+			if (t.pipelineState !== "ready") {
+				if (this.asyncCompile) {
+					t.pipelineState === "none" && this.compilePool(e, t);
+					continue;
+				}
+				t.pipelineState = "ready";
+			}
+			for (let e of t.computeNodes) o.push(e);
+			s.push(t);
+		}
+		if (o.length > 0) {
+			let n = a ? this.occlusion.beginFrame(e, t, this.meshes) : [];
+			n.length && o.unshift(...n), e.compute(o);
+			for (let e of s) e.dirty = !1, e.hasCut = !0;
+		} else this.skippedFrames++;
+		this.frameCount++, this.meshes.length > 0 && !this.statsPending && this.frameCount % this.statsInterval === 0 && (this.statsPending = !0, this.readStats(e).then((e) => {
+			this.lastStats = e, this.adaptThreshold(e);
+		}).finally(() => this.statsPending = !1));
+	}
+	cutInputsChanged(e, t) {
+		let n = this.cutInputsScratch, r = 0;
+		for (let t = 0; t < 16; t++) n[r++] = e.matrixWorldInverse.elements[t];
+		for (let t = 0; t < 16; t++) n[r++] = e.projectionMatrix.elements[t];
+		n[r++] = e.near, n[r++] = this.size.x, n[r++] = this.size.y, n[r++] = t, n[r++] = +!!this.errorInCssPixels, n[r++] = this.errorThreshold.value, n[r++] = this.minPixelRadius.value, n[r++] = this.frustumCulling.value, n[r++] = this.debugMode.value;
+		let i = this.shadowSweep.value;
+		n[r++] = i.x, n[r++] = i.y, n[r++] = i.z;
+		for (let e = 0; e < ir; e++) if (n[e] !== this.cutInputs[e]) return this.cutInputs.set(n), !0;
+		return !1;
+	}
+	adaptThreshold(e) {
+		let t = this.errorThreshold.value, n = e.capacityUse;
+		if (this.triangleBudget <= 0) {
+			this.guardCapacity(e, t);
+			return;
+		}
+		this.guardBase = null;
+		let [r, i] = this.thresholdRange;
+		if (e.overflow || n > .9) {
+			this.errorThreshold.value = or(t, n);
+			return;
+		}
+		if (e.drawnTriangles <= 0) return;
+		let a = e.drawnTriangles / this.triangleBudget;
+		if (Math.abs(a - 1) < .2) {
+			this.outOfBand = 0;
+			return;
+		}
+		if (++this.outOfBand < 3) return;
+		let o = t * Math.min(1.03, Math.max(.97, Math.sqrt(a)));
+		o = t > i ? Math.max(i, Math.min(o, t * .97)) : Math.min(i, Math.max(r, o)), !(o < t && n * (t / o) ** 2 > .85) && (this.errorThreshold.value = o);
+	}
+	guardCapacity(e, t) {
+		t !== this.guardWritten && (this.guardBase = null);
+		let n = t;
+		if (e.overflow || e.capacityUse > .9) this.guardBase ??= t, n = or(t, e.capacityUse);
+		else if (this.guardBase !== null && t > this.guardBase) {
+			let r = Math.max(this.guardBase, t * .97);
+			e.capacityUse * (t / r) ** 2 <= .85 && (n = r), n === this.guardBase && (this.guardBase = null);
+		}
+		n !== t && (this.errorThreshold.value = n), this.guardWritten = this.errorThreshold.value;
+	}
+	async readStats(e) {
+		let t = {
+			drawnMeshlets: 0,
+			drawnTriangles: 0,
+			fullDetailTriangles: 0,
+			instances: 0,
+			visibleInstances: 0,
+			requestedTriangles: 0,
+			overflow: !1,
+			capacityUse: 0,
+			occludedInstances: 0,
+			shadowTriangles: 0
+		};
+		for (let e of this.meshes) e.visible && (t.fullDetailTriangles += e.fullDetailTriangles, t.instances += e.instanceCount);
+		for (let n of this.pools) {
+			if (!n.hasCut) continue;
+			let r = await n.readCounters(e), i = n.capacity;
+			t.drawnMeshlets += r.camera.drawn, t.drawnTriangles += Math.min(r.camera.requestedTriangles, i.triangles), t.requestedTriangles += r.camera.requestedTriangles, t.visibleInstances += r.camera.survived, t.occludedInstances += r.occluded, t.shadowTriangles += Math.min(r.shadow.requestedTriangles, i.shadowTriangles), (r.camera.selected > i.meshlets || r.camera.requestedTriangles > i.triangles) && (t.overflow = !0), (r.shadow.selected > i.meshlets || r.shadow.requestedTriangles > i.shadowTriangles) && (t.overflow = !0), t.capacityUse = Math.max(t.capacityUse, r.camera.requestedTriangles / i.triangles, r.camera.selected / i.meshlets, r.shadow.requestedTriangles / i.shadowTriangles, r.shadow.selected / i.meshlets);
+		}
+		return t;
+	}
+};
+//#endregion
+export { ge as MAX_MESHLET_TRIANGLES, _e as MAX_MESHLET_VERTICES, gt as VG_BUILD_VERSION, be as VG_DEBUG_MODES, Ke as VG_FORMAT_VERSION, sr as VirtualGeometry, qn as VirtualGeometryImport, On as VirtualMesh, J as VirtualMeshFormatError, Vt as bindVirtualGeometryTextures, Fe as buildVirtualMesh, bt as buildVirtualMeshCached, Mn as canConvertToNodeMaterial, xt as clearVirtualMeshCache, Wn as collectVirtualGeometryGroups, Ze as decodeVirtualMesh, Xe as encodeVirtualMesh, In as fromBufferGeometry, Ft as instanceGuaranteedRange, Pt as instanceMeshletRange, Qe as loadVirtualMesh, Bn as mergeSources, xe as partitionMeshlets, jt as selectCut, Nn as toNodeMaterial, Mt as verifyCutCoverage, Bt as vgNormalMap, Rt as vgTexture, It as vgUv, Gt as vgWorldNormal, St as virtualMeshCacheKey, Jn as virtualMeshesFromObject3D };
+
+//# sourceMappingURL=index.js.map