rayzee 9.4.1 → 9.5.0

package/dist/PhysicalSky-Dv2PMFGW.js

@@ -0,0 +1,1219 @@
+import { n as e } from "./BidirectionalIntegrator-C5PKjJoT.js";
+import { dt as t, i as n, nn as r } from "./SolarLimb-ken-JbDK.js";
+import { r as i } from "./WorkingMatrix-C6y233hT.js";
+import { StorageInstancedBufferAttribute as a } from "three/webgpu";
+import { Fn as o, If as s, Loop as c, Return as l, abs as u, acos as d, asin as f, atan as p, clamp as m, cos as h, dot as g, exp as _, float as v, floor as y, instanceIndex as b, int as x, log as S, max as C, min as w, mix as T, select as E, sin as D, smoothstep as O, sqrt as k, step as A, storage as j, tan as M, uint as N, uniform as P, vec2 as ee, vec3 as F, vec4 as I } from "three/tsl";
+import { ClampToEdgeWrapping as te, DataTexture as ne, EquirectangularReflectionMapping as re, FloatType as ie, LinearFilter as ae, LinearSRGBColorSpace as oe, RGBAFormat as se, RepeatWrapping as ce, Vector3 as le, Vector4 as ue } from "three";
+//#region src/Processor/AtmosphereModel.js
+var L = 6360, R = 6420, de = 1.2, fe = .9, pe = .76, me = 1.3, he = 380, z = 25, ge = 1 / 32, _e = [
+	1.11776,
+	1.14259,
+	1.01249,
+	1.14716,
+	1.72765,
+	1.73054,
+	1.6887,
+	1.61253,
+	1.91198,
+	2.03474,
+	2.02042,
+	2.02212,
+	1.93377,
+	1.95809,
+	1.91686,
+	1.8298,
+	1.8685,
+	1.8931,
+	1.85149,
+	1.8504,
+	1.8341,
+	1.8345,
+	1.8147,
+	1.78158,
+	1.7533,
+	1.6965,
+	1.68194,
+	1.64654,
+	1.6048,
+	1.52143,
+	1.55622,
+	1.5113,
+	1.474,
+	1.4482,
+	1.41018,
+	1.36775,
+	1.34188,
+	1.31429,
+	1.28303,
+	1.26758,
+	1.2367,
+	1.2082,
+	1.18737,
+	1.14683,
+	1.12362,
+	1.1058,
+	1.07124,
+	1.04992
+], ve = [
+	118e-29,
+	2182e-31,
+	2818e-31,
+	6636e-31,
+	1527e-30,
+	2763e-30,
+	552e-29,
+	8451e-30,
+	1582e-29,
+	2316e-29,
+	3669e-29,
+	4924e-29,
+	7752e-29,
+	9016e-29,
+	148e-27,
+	1602e-28,
+	2139e-28,
+	2755e-28,
+	3091e-28,
+	35e-26,
+	4266e-28,
+	4672e-28,
+	4398e-28,
+	4701e-28,
+	5019e-28,
+	4305e-28,
+	374e-27,
+	3215e-28,
+	2662e-28,
+	2238e-28,
+	1852e-28,
+	1473e-28,
+	1209e-28,
+	9423e-29,
+	7455e-29,
+	6566e-29,
+	5105e-29,
+	415e-28,
+	4228e-29,
+	3237e-29,
+	2451e-29,
+	2801e-29,
+	2534e-29,
+	1624e-29,
+	1465e-29,
+	2078e-29,
+	1383e-29,
+	7105e-30
+], ye = [
+	1299e-7,
+	3917e-9,
+	6061e-7,
+	2321e-7,
+	6965e-9,
+	.001086,
+	4149e-7,
+	1239e-8,
+	.001946,
+	7416e-7,
+	2202e-8,
+	.003486,
+	.001368,
+	39e-6,
+	.006450001,
+	.002236,
+	64e-6,
+	.01054999,
+	.004243,
+	12e-5,
+	.02005001,
+	.00765,
+	217e-6,
+	.03621,
+	.01431,
+	396e-6,
+	.06785001,
+	.02319,
+	64e-5,
+	.1102,
+	.04351,
+	.00121,
+	.2074,
+	.07763,
+	.00218,
+	.3713,
+	.13438,
+	.004,
+	.6456,
+	.21477,
+	.0073,
+	1.0390501,
+	.2839,
+	.0116,
+	1.3856,
+	.3285,
+	.01684,
+	1.62296,
+	.34828,
+	.023,
+	1.74706,
+	.34806,
+	.0298,
+	1.7826,
+	.3362,
+	.038,
+	1.77211,
+	.3187,
+	.048,
+	1.7441,
+	.2908,
+	.06,
+	1.6692,
+	.2511,
+	.0739,
+	1.5281,
+	.19536,
+	.09098,
+	1.28764,
+	.1421,
+	.1126,
+	1.0419,
+	.09564,
+	.13902,
+	.8129501,
+	.05795001,
+	.1693,
+	.6162,
+	.03201,
+	.20802,
+	.46518,
+	.0147,
+	.2586,
+	.3533,
+	.0049,
+	.323,
+	.272,
+	.0024,
+	.4073,
+	.2123,
+	.0093,
+	.503,
+	.1582,
+	.0291,
+	.6082,
+	.1117,
+	.06327,
+	.71,
+	.07824999,
+	.1096,
+	.7932,
+	.05725001,
+	.1655,
+	.862,
+	.04216,
+	.2257499,
+	.9148501,
+	.02984,
+	.2904,
+	.954,
+	.0203,
+	.3597,
+	.9803,
+	.0134,
+	.4334499,
+	.9949501,
+	.008749999,
+	.5120501,
+	1,
+	.005749999,
+	.5945,
+	.995,
+	.0039,
+	.6784,
+	.9786,
+	.002749999,
+	.7621,
+	.952,
+	.0021,
+	.8425,
+	.9154,
+	.0018,
+	.9163,
+	.87,
+	.001650001,
+	.9786,
+	.8163,
+	.0014,
+	1.0263,
+	.757,
+	.0011,
+	1.0567,
+	.6949,
+	.001,
+	1.0622,
+	.631,
+	8e-4,
+	1.0456,
+	.5668,
+	6e-4,
+	1.0026,
+	.503,
+	34e-5,
+	.9384,
+	.4412,
+	24e-5,
+	.8544499,
+	.381,
+	19e-5,
+	.7514,
+	.321,
+	1e-4,
+	.6424,
+	.265,
+	4999999e-11,
+	.5419,
+	.217,
+	3e-5,
+	.4479,
+	.175,
+	2e-5,
+	.3608,
+	.1382,
+	1e-5,
+	.2835,
+	.107,
+	0,
+	.2187,
+	.0816,
+	0,
+	.1649,
+	.061,
+	0,
+	.1212,
+	.04458,
+	0,
+	.0874,
+	.032,
+	0,
+	.0636,
+	.0232,
+	0,
+	.04677,
+	.017,
+	0,
+	.0329,
+	.01192,
+	0,
+	.0227,
+	.00821,
+	0,
+	.01584,
+	.005723,
+	0,
+	.01135916,
+	.004102,
+	0,
+	.008110916,
+	.002929,
+	0,
+	.005790346,
+	.002091,
+	0,
+	.004109457,
+	.001484,
+	0,
+	.002899327,
+	.001047,
+	0,
+	.00204919,
+	74e-5,
+	0,
+	.001439971,
+	52e-5,
+	0,
+	.0009999493,
+	3611e-7,
+	0,
+	.0006900786,
+	2492e-7,
+	0,
+	.0004760213,
+	1719e-7,
+	0,
+	.0003323011,
+	12e-5,
+	0,
+	.0002348261,
+	848e-7,
+	0,
+	.0001661505,
+	6e-5,
+	0,
+	117413e-9,
+	424e-7,
+	0,
+	8307527e-11,
+	3e-5,
+	0,
+	5870652e-11,
+	212e-7,
+	0,
+	4150994e-11,
+	1499e-8,
+	0,
+	2935326e-11,
+	106e-7,
+	0,
+	2067383e-11,
+	74657e-10,
+	0,
+	1455977e-11,
+	52578e-10,
+	0,
+	1025398e-11,
+	37029e-10,
+	0,
+	7221456e-12,
+	26078e-10,
+	0,
+	5085868e-12,
+	18366e-10,
+	0,
+	3581652e-12,
+	12934e-10,
+	0,
+	2522525e-12,
+	9.1093e-7,
+	0,
+	1776509e-12,
+	6.4153e-7,
+	0,
+	1251141e-12,
+	4.5181e-7,
+	0
+], be = [
+	3.2406,
+	-1.5372,
+	-.4986,
+	-.9689,
+	1.8758,
+	.0415,
+	.0557,
+	-.204,
+	1.057
+], xe = 0xe90f62a5dcb760000;
+function Se(e) {
+	let t = (e / 1e3) ** 2;
+	return .002152 * (1.0455996 - 341.29061 / t - .9023085 * t) / (1 + .0027059889 / t - 85.968563 * t);
+}
+function B(e, t, n, r, i = 1, a = 0) {
+	let o = e.length / i, s = (r - t) / n;
+	if (s <= 0) return e[a];
+	if (s >= o - 1) return e[(o - 1) * i + a];
+	let c = Math.floor(s), l = s - c;
+	return e[c * i + a] * (1 - l) + e[(c + 1) * i + a] * l;
+}
+function Ce(e, t) {
+	let n = 0, r = he + e * z;
+	for (let e = 0; e < z; e++) n += t(r + e + .5);
+	return n / z;
+}
+function V(e) {
+	let t = new Float64Array(16);
+	for (let n = 0; n < 16; n++) t[n] = Ce(n, e);
+	return t;
+}
+var we = Float64Array.from({ length: 16 }, (e, t) => he + (t + .5) * z), Te = V((e) => B(_e, 360, 10, e)), Ee = V((e) => Se(e) / 8), De = V((e) => B(ve, 360, 10, e)), Oe = V((e) => (e / 1e3) ** -me), H = (() => {
+	let e = new Float64Array(48);
+	for (let t = 0; t < 16; t++) for (let n = 0; n < 3; n++) e[t * 3 + n] = Ce(t, (e) => B(ye, 360, 5, e, 3, n)) * z;
+	return e;
+})();
+function ke(e = 1) {
+	let t = new Float32Array(48);
+	for (let n = 0; n < 16; n++) {
+		let r = H[n * 3], i = H[n * 3 + 1], a = H[n * 3 + 2];
+		for (let o = 0; o < 3; o++) {
+			let s = be;
+			t[o * 16 + n] = (s[o * 3] * r + s[o * 3 + 1] * i + s[o * 3 + 2] * a) * e;
+		}
+	}
+	return t;
+}
+function Ae(e) {
+	let t = 0, n = 0, r = 0;
+	for (let i = 0; i < 16; i++) t += e[i] * H[i * 3], n += e[i] * H[i * 3 + 1], r += e[i] * H[i * 3 + 2];
+	return [
+		t,
+		n,
+		r
+	];
+}
+function je([e, t, n]) {
+	let r = be;
+	return [
+		r[0] * e + r[1] * t + r[2] * n,
+		r[3] * e + r[4] * t + r[5] * n,
+		r[6] * e + r[7] * t + r[8] * n
+	];
+}
+function Me(e) {
+	return Math.max(0, .0460836582205 * e - .04586025928522);
+}
+function Ne([e, t, n]) {
+	let r = (e, t, n) => {
+		let r = Math.min(Math.max((n - e) / (t - e), 0), 1);
+		return r * r * (3 - 2 * r);
+	};
+	return Float64Array.from(we, (i) => {
+		let a = 1 - r(470, 520, i), o = r(560, 610, i);
+		return n * a + e * o + t * (1 - a - o);
+	});
+}
+function Pe({ airDensity: e = 1, turbidity: t = 2, ozone: n = 300, groundAlbedo: r = [
+	.3,
+	.3,
+	.3
+] } = {}) {
+	let i = Me(t) / de, a = n * xe / (15 * 1e3) * 1e3, o = new Float64Array(16), s = new Float64Array(16), c = new Float64Array(16), l = new Float64Array(16);
+	for (let t = 0; t < 16; t++) o[t] = Ee[t] * e, s[t] = Oe[t] * i, c[t] = s[t] * fe, l[t] = De[t] * a;
+	return {
+		rayleigh: o,
+		mieScattering: c,
+		mieExtinction: s,
+		ozone: l,
+		albedo: Ne(r)
+	};
+}
+var Fe = (e) => Math.exp(-e / 8), Ie = (e) => Math.exp(-e / de), Le = (e) => Math.max(0, 1 - Math.abs(e - 25) / 15);
+function Re(e) {
+	let t = Math.max(e, 0);
+	return Math.sqrt(t * (2 * L + t)) / (L + t);
+}
+function ze(e, t, n = 1024) {
+	let r = Math.max(e, 0), i = L + r, a = i * t, o = r * (2 * L + r);
+	if (t < 0 && a * a >= o) return null;
+	let s = -a + Math.sqrt(a * a + (R - i) * (R + i)), c = 0, l = 0, u = 0;
+	for (let e = 0; e < n; e++) {
+		let t = s * (e / n) ** 2, r = s * ((e + 1) / n) ** 2, d = .5 * (t + r), f = (o + d * (d + 2 * a)) / (Math.sqrt(i * i + d * (d + 2 * a)) + L), p = r - t;
+		c += Fe(f) * p, l += Ie(f) * p, u += Le(f) * p;
+	}
+	return [
+		c,
+		l,
+		u
+	];
+}
+function Be(e, t) {
+	let n = new Float64Array(16);
+	if (!t) return n;
+	let [r, i, a] = t;
+	for (let t = 0; t < 16; t++) n[t] = Math.exp(-(e.rayleigh[t] * r + e.mieExtinction[t] * i + e.ozone[t] * a));
+	return n;
+}
+function Ve(e) {
+	let t = Math.sin(e / 2);
+	return 4 * Math.PI * t * t;
+}
+function He({ direction: e, altitude: t, angularDiameter: n, strength: r = 1, coefficients: i }) {
+	let a = n / 2, o = Ve(a), s = Re(t), [c, l, u] = e, d = Math.sin(a), f = new Float64Array(16), p = 0, m = (e) => {
+		if (e < -s) return;
+		let n = Be(i, ze(t, e, 512));
+		for (let e = 0; e < 16; e++) f[e] += n[e];
+		p++;
+	};
+	if (l - d > .1) m(l);
+	else {
+		let e = Math.sqrt(Math.max(0, 1 - l * l));
+		for (let t = 0; t < 48; t++) {
+			let n = (t + .5) / 48, r = -1, i = 1;
+			for (let e = 0; e < 30; e++) {
+				let e = .5 * (r + i);
+				(Math.asin(e) + e * Math.sqrt(1 - e * e) + Math.PI / 2) / Math.PI < n ? r = e : i = e;
+			}
+			m(l + .5 * (r + i) * d * e);
+		}
+	}
+	let h = new Float64Array(16), g = l - d > .1 ? 1 : 48;
+	if (p > 0) for (let e = 0; e < 16; e++) h[e] = Te[e] * r / o * f[e] / p;
+	return {
+		radiance: je(Ae(h)).map((e) => Math.max(0, e * ge)),
+		visibleFraction: p / g,
+		solidAngle: o,
+		direction: [
+			c,
+			l,
+			u
+		]
+	};
+}
+var Ue = (e) => 3 / (16 * Math.PI) * (1 + e * e);
+function We(e, t = pe) {
+	let n = t * t;
+	return 3 / (8 * Math.PI) * (1 - n) / (2 + n) * (1 + e * e) / (1 + n - 2 * t * e) ** 1.5;
+}
+function Ge(e, t, n, r, i = 8) {
+	let a = n * r, o = e * t, s = new Float32Array(2 * o * a);
+	return [Ue, (e) => We(e)].forEach((c, l) => {
+		for (let u = 0; u < o; u++) {
+			let d = -1 + 2 * Math.floor(u / t) / (e - 1), f = u % t * Math.PI / (t - 1), p = Math.sqrt(Math.max(0, 1 - d * d)), m = (l * o + u) * a, h = 0;
+			for (let e = 0; e < a; e++) {
+				let t = Math.floor(e / r), a = e % r, o = 0;
+				for (let e = 0; e < i; e++) {
+					let s = -1 + 2 * (t + (e + .5) / i) / n, l = Math.sqrt(Math.max(0, 1 - s * s));
+					for (let e = 0; e < i; e++) {
+						let t = Math.PI * (a + (e + .5) / i) / r;
+						o += c(d * s + p * l * Math.cos(f - t)) + c(d * s + p * l * Math.cos(f + t));
+					}
+				}
+				s[m + e] = o, h += o;
+			}
+			for (let e = 0; e < a; e++) s[m + e] /= h;
+		}
+	}), s;
+}
+var U = Math.sqrt(R * R - L * L), W = R - L, G = Math.PI, K = [
+	0,
+	1,
+	2,
+	3
+], q = (e) => K.map(e);
+function Ke(e) {
+	return {
+		r: _(e.mul(-1 / 8)),
+		m: _(e.mul(-1 / de)),
+		o: C(v(0), v(1).sub(u(e.sub(25)).div(15)))
+	};
+}
+function qe(e, t) {
+	return q((n) => e.rayleigh[n].mul(t.r).add(e.mieExtinction[n].mul(t.m)).add(e.ozone[n].mul(t.o)));
+}
+function Je(e, t) {
+	return q((n) => {
+		let r = e[n].mul(t), i = _(r.negate()), a = v(1).sub(i).div(C(r, 1e-12));
+		return {
+			weight: T(v(1).sub(r.mul(.5)), a, A(.001, r)).mul(t),
+			transmittance: i
+		};
+	});
+}
+function Ye(e, t, n, r, i, a = 1, o = 0) {
+	let s = m(r, 0, t - 1), c = m(i, 0, n - 1), l = y(s), u = y(c), d = s.sub(l), f = c.sub(u), p = N(l), h = N(u), g = w(p.add(1), N(t - 1)), _ = w(h.add(1), N(n - 1)), v = (n, r) => e.element(r.mul(t).add(n).mul(a).add(o));
+	return T(T(v(p, h), v(g, h), d), T(v(p, _), v(g, _), d), f);
+}
+function Xe(e, t) {
+	let n = e.add(L), r = k(C(e.mul(e.add(2 * L)), 0)), i = n.mul(t), a = i.negate().add(k(C(i.mul(i).add(U * U).sub(r.mul(r)), 0))), o = v(W).sub(e), s = r.add(U);
+	return {
+		x: a.sub(o).div(C(s.sub(o), 1e-6)).mul(255),
+		y: r.div(U).mul(63),
+		rho: r,
+		r: n
+	};
+}
+function J(e, t, n, r, i) {
+	let a = Xe(n, r), o = Ye(e, 256, 64, a.x, a.y).xyz, s = O(i.negate(), i, r.add(a.rho.div(a.r)));
+	return q((e) => _(t.rayleigh[e].mul(o.x).add(t.mieExtinction[e].mul(o.y)).add(t.ozone[e].mul(o.z)).negate()).mul(s));
+}
+var Ze = (e) => v(e).div(15).pow(2).mul(W), Qe = (e) => k(m(e.div(W), 0, 1)).mul(15), Y = -3 * G / 180, X = 15 * G / 180, Z = .5 + Math.atan((-G / 2 - Y) / X) / G, $e = .5 + Math.atan((G / 2 - Y) / X) / G, et = (e, t) => D(m(M(v(e).div(t - 1).mul($e - Z).add(Z - .5).mul(G)).mul(X).add(Y), -G / 2, G / 2)), tt = (e, t) => p(f(m(e, -1, 1)).sub(Y).div(X)).div(G).add(.5 - Z).div($e - Z).mul(t - 1), nt = 1e-30, Q = (e) => S(C(e, I(nt)));
+function rt(e, t, n, r, i) {
+	let a = [
+		[m(tt(n, 64), 0, 63), 64],
+		[m(Qe(t), 0, 15), 16],
+		[m(r.add(1).mul(.5 * 15), 0, 15), 16],
+		[m(d(m(i, -1, 1)).mul(7 / G), 0, 7), 8]
+	].map(([e, t]) => {
+		let n = y(e), r = e.sub(n).toVar(), i = N(n).toVar();
+		return {
+			t: r,
+			i0: i,
+			i1: w(i.add(1), N(t - 1)).toVar()
+		};
+	}), o = [
+		128,
+		8192,
+		8,
+		1
+	], s = [];
+	for (let e = 0; e < 16; e++) {
+		let t = N(0);
+		a.forEach((n, r) => {
+			t = t.add((e >> r & 1 ? n.i1 : n.i0).mul(o[r]));
+		}), s.push(t.mul(8).toVar());
+	}
+	return Array.from({ length: 8 }, (t, n) => {
+		let r = s.map((t) => e.element(t.add(n)));
+		for (let e = 0; e < 4; e++) {
+			let t = [];
+			for (let n = 0; n < r.length; n += 2) t.push(T(r[n], r[n + 1], a[e].t));
+			r = t;
+		}
+		return _(r[0]);
+	});
+}
+function it(e, t) {
+	let n = tt(t, 128);
+	return q((t) => _(Ye(e, 128, 1, n, v(0), 4, t)));
+}
+function at(e, t) {
+	let n = e.add(L).toVar(), r = n.mul(t).toVar(), i = e.mul(e.add(2 * L)).toVar(), a = r.mul(r).sub(i), o = t.lessThan(0).and(a.greaterThanEqual(0)).toVar(), s = i.div(C(r.negate().add(k(C(a, 0))), 1e-9)), c = r.negate().add(k(C(r.mul(r).add(v(R).sub(n).mul(n.add(R))), 0)));
+	return {
+		r: n,
+		b: r,
+		cGround: i,
+		hitsGround: o,
+		tMax: o.select(s, c).toVar()
+	};
+}
+var ot = (e, t, n) => e.sub(t.mul(n)).div(C(k(v(1).sub(t.mul(t)).mul(v(1).sub(n.mul(n)))), 1e-4));
+function st(e, t, n, r) {
+	let i = t.mul(t.add(e.b.mul(2))), a = k(e.r.mul(e.r).add(i));
+	return {
+		h: C(e.cGround.add(i).div(a.add(L)), 0),
+		muS: m(e.r.mul(n).add(t.mul(r)).div(a), -1, 1),
+		mu: m(e.b.add(t).div(a), -1, 1)
+	};
+}
+var ct = (e) => e.mul(e).add(1).mul(3 / (16 * G));
+function lt(e, t) {
+	let n = t * t, r = 3 / (8 * G) * (1 - n) / (2 + n), i = C(v(1 + n).sub(e.mul(2 * t)), 1e-6);
+	return e.mul(e).add(1).mul(r).div(i.mul(k(i)));
+}
+function ut({ transmittance: e }, t = 256) {
+	let n = 256 * 64;
+	return o(() => {
+		let r = b;
+		s(r.greaterThanEqual(N(n)), () => {
+			l();
+		});
+		let i = v(r.mod(256)).div(255), a = v(r.div(256)).div(63).mul(U).toVar(), o = k(a.mul(a).add(L * L)).toVar(), u = v(R).sub(o), d = a.add(U), f = u.add(i.mul(d.sub(u))).toVar(), p = m(v(U * U).sub(a.mul(a)).sub(f.mul(f)).div(C(o.mul(f).mul(2), 1e-9)), -1, 1).toVar(), h = a.mul(a).toVar(), g = o.mul(p).mul(2).toVar(), _ = F(0).toVar();
+		c({
+			start: x(0),
+			end: x(t),
+			type: "int",
+			condition: "<"
+		}, ({ i: e }) => {
+			let n = v(e).div(t), r = v(e).add(1).div(t), i = f.mul(n.mul(n)), a = f.mul(r.mul(r)), s = i.add(a).mul(.5), c = s.mul(s.add(g)), l = Ke(C(h.add(c).div(k(o.mul(o).add(c)).add(L)), 0));
+			_.addAssign(F(l.r, l.m, l.o).mul(a.sub(i)));
+		}), e.element(r).assign(I(_, 0));
+	})().compute(n, [64]);
+}
+var dt = 4 * G / 128;
+function ft(e, t, n, r) {
+	let i = v(e).add(v(n.div(r)).add(.5).div(r)).div(16).mul(2).sub(1), a = k(C(v(1).sub(i.mul(i)), 0)), o = v(t).add(v(n.mod(r)).add(.5).div(r)).mul(G / 8);
+	return F(a.mul(h(o)), i, a.mul(D(o)));
+}
+function pt(e, t) {
+	let n = tt(t, 64);
+	return q((t) => Ye(e, 64, 1, n, v(0), 4, t));
+}
+function mt(e, { first: t, out: n, cellSamples: r = 2, steps: i = 20 }) {
+	let { transmittance: a, transfer: u, multipleScattering: d, groundE: f, coefficients: p, sunSinRadius: h, mieG: _ } = e, y = 1024 * 128, S = r * r;
+	return o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(y)), () => {
+			l();
+		});
+		let o = e.mod(128), w = e.div(128), T = et(w.mod(64), 64).toVar(), E = C(Ze(w.div(64)), .001).toVar(), D = F(k(C(v(1).sub(T.mul(T)), 0)), T, 0).toVar(), O = q(() => I(0).toVar()), A = t ? q(() => I(0).toVar()) : null;
+		c({
+			start: x(0),
+			end: x(S),
+			type: "int",
+			condition: "<",
+			name: "ray"
+		}, ({ ray: e }) => {
+			let n = ft(o.div(8), o.mod(8), e, r).toVar(), l = g(n, D).toVar(), u = t ? ct(l).toVar() : null, y = t ? lt(l, _).toVar() : null, b = t ? null : Array.from({ length: 8 }, () => I(0).toVar()), S = at(E, n.y), w = q(() => I(1).toVar());
+			c({
+				start: x(0),
+				end: x(i),
+				type: "int",
+				condition: "<"
+			}, ({ i: e }) => {
+				let n = v(e).div(i), r = v(e).add(1).div(i), o = S.tMax.mul(n.mul(n)), c = S.tMax.mul(r.mul(r)).sub(o), f = st(S, o.add(c.mul(.5)), T, l), m = Ke(f.h), g = q((e) => p.rayleigh[e].mul(m.r)), _ = q((e) => p.mieScattering[e].mul(m.m)), x = Je(qe(p, m), c), C;
+				if (t) {
+					let e = J(a, p, f.h, f.muS, h);
+					C = q((t) => e[t].mul(g[t].mul(u).add(_[t].mul(y))));
+				} else s(e.mod(2).equal(0), () => {
+					let e = rt(d, f.h, f.muS, f.mu, ot(l, f.mu, f.muS));
+					for (let t = 0; t < 8; t++) b[t].assign(e[t]);
+				}), C = q((e) => g[e].mul(b[e]).add(_[e].mul(b[4 + e])));
+				for (let e of K) O[e].addAssign(w[e].mul(C[e]).mul(x[e].weight)), A && A[e].addAssign(w[e].mul(g[e].add(_[e])).mul(x[e].weight)), w[e].mulAssign(x[e].transmittance);
+			}), s(S.hitsGround, () => {
+				let e = m(S.r.mul(T).add(S.tMax.mul(l)).div(L), -1, 1), n;
+				if (t) {
+					let t = J(a, p, v(0), e, h);
+					n = q((n) => t[n].mul(C(e, 0)));
+				} else n = pt(f, e);
+				for (let e of K) O[e].addAssign(w[e].mul(n[e]).mul(p.albedo[e]).mul(1 / G));
+			});
+		});
+		for (let t of K) n.element(e.mul(4).add(t)).assign(O[t].div(S)), A && u.element(e.mul(4).add(t)).assign(A[t].div(S));
+	})().compute(y, [64]);
+}
+function ht(e, { incoming: t, stage: n }) {
+	let { transfer: r, phaseCells: i, multipleScattering: a, psiSum: u, groundE: d } = e, f = 1024 * 128, p = n === "last";
+	return o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(f)), () => {
+			l();
+		});
+		let o = e.mod(128), m = e.div(128), h = m.mul(128), g = null;
+		if (p) {
+			let e = q(() => I(0).toVar());
+			c({
+				start: x(0),
+				end: x(128),
+				type: "int",
+				condition: "<"
+			}, ({ i: t }) => {
+				for (let n of K) e[n].addAssign(r.element(h.add(N(t)).mul(4).add(n)));
+			}), g = q((t) => {
+				let n = w(e[t].div(128), .95);
+				return n.div(v(1).sub(n)).toVar();
+			});
+		}
+		for (let r = 0; r < 2; r++) {
+			let s = q(() => I(0).toVar());
+			c({
+				start: x(0),
+				end: x(32),
+				type: "int",
+				condition: "<"
+			}, ({ i: e }) => {
+				let n = i.element(N(r * 128).add(o).mul(32).add(N(e))).toVar();
+				for (let r = 0; r < 4; r++) {
+					let i = h.add(N(e).mul(4).add(r)).mul(4), a = n.element(x(r));
+					for (let e of K) s[e].addAssign(t.element(i.add(e)).mul(a));
+				}
+			});
+			for (let t of K) {
+				let i = e.mul(8).add(r * 4 + t);
+				n === "first" ? (u.element(i).assign(s[t]), a.element(i).assign(Q(s[t]))) : n === "middle" ? (u.element(i).addAssign(s[t]), a.element(i).assign(Q(s[t]))) : a.element(i).assign(Q(u.element(i).add(s[t].mul(g[t].add(1)))));
+			}
+		}
+		p || s(m.lessThan(N(64)).and(o.equal(N(0))), () => {
+			let e = q(() => I(0).toVar());
+			c({
+				start: x(128 / 2),
+				end: x(128),
+				type: "int",
+				condition: "<"
+			}, ({ i: n }) => {
+				let r = v(N(n).div(8)).add(.5).div(16).mul(2).sub(1);
+				for (let i of K) e[i].addAssign(t.element(h.add(N(n)).mul(4).add(i)).mul(r));
+			});
+			for (let t of K) d.element(m.mul(4).add(t)).assign(e[t].mul(dt));
+		});
+	})().compute(f, [64]);
+}
+var gt = 4;
+function _t({ transmittance: e, multipleScattering: t, coefficients: n, sunSinRadius: r, mieG: i }, a, o, l, u) {
+	let d = q(() => I(0).toVar()), f = q(() => I(1).toVar()), p = t ? Array.from({ length: 8 }, () => I(0).toVar()) : null, m = ct(l).toVar(), h = lt(l, i).toVar(), g = a.tMax;
+	return c({
+		start: x(0),
+		end: x(u),
+		type: "int",
+		condition: "<"
+	}, ({ i }) => {
+		let c = v(i).div(u), _ = v(i).add(1).div(u), y = g.mul(c.mul(c)), b = g.mul(_.mul(_)).sub(y), x = st(a, y.add(b.mul(.5)), o, l), S = Ke(x.h), C = q((e) => n.rayleigh[e].mul(S.r)), w = q((e) => n.mieScattering[e].mul(S.m)), T = J(e, n, x.h, x.muS, r), E = Je(qe(n, S), b);
+		p && s(i.mod(gt).equal(0), () => {
+			let e = rt(t, x.h, x.muS, x.mu, ot(l, x.mu, x.muS));
+			for (let t = 0; t < 8; t++) p[t].assign(e[t]);
+		});
+		for (let e of K) {
+			let t = T[e].mul(C[e].mul(m).add(w[e].mul(h)));
+			p && (t = t.add(C[e].mul(p[e])).add(w[e].mul(p[4 + e]))), d[e].addAssign(f[e].mul(t).mul(E[e].weight)), f[e].mulAssign(E[e].transmittance);
+		}
+	}), {
+		L: d,
+		throughput: f
+	};
+}
+function vt(e, { sqrtDirections: t = 12, steps: n = 32 } = {}) {
+	let { irradiance: r } = e, i = t * t, a = v(.001);
+	return o(() => {
+		let o = b;
+		s(o.greaterThanEqual(N(128)), () => {
+			l();
+		});
+		let u = et(o, 128).toVar(), d = F(k(C(v(1).sub(u.mul(u)), 0)), u, 0).toVar(), f = q(() => I(0).toVar());
+		c({
+			start: x(0),
+			end: x(i),
+			type: "int",
+			condition: "<",
+			name: "dirIndex"
+		}, ({ dirIndex: r }) => {
+			let i = v(r.div(t)).add(.5).div(t), o = v(r.mod(t)).add(.5).div(t), s = k(i), c = o.mul(2 * G), l = F(s.mul(h(c)), k(C(v(1).sub(i), 0)), s.mul(D(c))).toVar(), { L: p } = _t(e, at(a, l.y), u, g(l, d), n);
+			for (let e of K) f[e].addAssign(p[e]);
+		});
+		for (let e of K) r.element(o.mul(4).add(e)).assign(Q(f[e].mul(G / i)));
+	})().compute(128, [64]);
+}
+var yt = (e) => v(e).div(255).pow(2).mul(G);
+function bt(e, { width: t, height: n, steps: r = 40, multipleScattering: i = !0 }) {
+	let { sky: a, skyRows: c, irradiance: d, coefficients: f, rgb: _, sunDirection: x, altitude: S, sunSinRadius: E, transmittance: O } = e, A = i ? e : {
+		...e,
+		multipleScattering: null
+	}, j = 256 * n;
+	return [o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(j)), () => {
+			l();
+		});
+		let t = v(1).sub(v(e.div(256)).add(.5).div(n)).mul(G), i = h(t).toVar(), a = C(S, .001).toVar(), o = x.y.toVar(), u = D(t).mul(h(yt(e.mod(256)))).mul(k(C(v(1).sub(o.mul(o)), 0))).add(i.mul(o)).toVar(), p = at(a, i), { L: y, throughput: w } = _t(A, p, o, u, r);
+		s(p.hitsGround, () => {
+			let e = m(p.r.mul(o).add(p.tMax.mul(u)).div(L), -1, 1).toVar(), t = J(O, f, v(0), e, E), n = it(d, e);
+			for (let r of K) y[r].addAssign(w[r].mul(f.albedo[r]).mul(1 / G).mul(t[r].mul(C(e, 0)).add(n[r])));
+		});
+		let T = q((e) => y[e].mul(f.solar[e])), M = (e) => T.reduce((t, n, r) => t.add(g(n, _[e * 4 + r])), v(0));
+		c.element(e).assign(I(C(F(M(0), M(1), M(2)), F(0)), 1));
+	})().compute(j, [64]), o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(t * n)), () => {
+			l();
+		});
+		let r = v(e.mod(t)).add(.5).div(t).sub(.5).mul(2 * G).sub(p(x.z, x.x)), i = k(u(p(D(r), h(r))).div(G)).mul(255).toVar(), o = w(y(i), 254).toVar(), d = e.div(t).mul(256).add(N(o)).toVar();
+		a.element(e).assign(T(c.element(d), c.element(d.add(1)), i.sub(o)));
+	})().compute(t * n, [64])];
+}
+//#endregion
+//#region src/TSL/EnvironmentCDF.js
+var $ = (e) => Math.ceil((e + 1) * 16 / 256) * 64;
+function xt(e, t, n) {
+	let r = x(0).toVar(), i = x(e - 1).toVar();
+	return c({
+		start: x(0),
+		end: x(Math.ceil(Math.log2(e)) + 1),
+		type: "int",
+		condition: "<",
+		name: "step"
+	}, () => {
+		s(r.lessThan(i), () => {
+			let e = r.add(i).div(2).toVar();
+			s(t(e).lessThanEqual(n), () => {
+				r.assign(e.add(1));
+			}).Else(() => {
+				i.assign(e);
+			});
+		});
+	}), r;
+}
+function St({ pixels: e, rows: n, prefix: r, stats: i, cdf: a, width: u, height: d }) {
+	let f = $(u), p = (e, t, n) => N(t).mul(N(f)).add(N(e).mul(N(4))).add(N(n)), m = (e) => D(v(e).add(.5).mul(Math.PI / d)), h = (n, r, i) => g(e.element(n.mul(u).add(r)).xyz, t).mul(i), _ = () => s(b.greaterThan(N(0)), () => {
+		l();
+	}), y = o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(d)), () => {
+			l();
+		});
+		let t = m(e).toVar(), r = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(u),
+			type: "int",
+			condition: "<"
+		}, ({ i: n }) => {
+			r.addAssign(h(e, N(n), t));
+		}), n.element(e).assign(I(r, 0, 0, 0));
+	})().compute(d, [64]), S = o(() => {
+		_();
+		let e = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(d),
+			type: "int",
+			condition: "<"
+		}, ({ i: t }) => {
+			e.addAssign(n.element(t).x);
+		}), i.element(0).assign(I(e, e.div(u * d), 0, 0));
+	})().compute(1, [1]), w = o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(d)), () => {
+			l();
+		});
+		let t = m(e).toVar(), a = i.element(0).y.toVar(), o = v(0).toVar(), f = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(u),
+			type: "int",
+			condition: "<"
+		}, ({ i: n }) => {
+			let i = h(e, N(n), t).toVar();
+			o.addAssign(i), f.addAssign(C(i.sub(a), 0)), r.element(e.mul(u).add(N(n))).assign(ee(o, f));
+		}), n.element(e).assign(I(o, f, 0, 0));
+	})().compute(d, [64]), T = o(() => {
+		_();
+		let e = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(d),
+			type: "int",
+			condition: "<"
+		}, ({ i: t }) => {
+			e.addAssign(n.element(t).y);
+		});
+		let t = i.element(0).toVar();
+		i.element(1).assign(E(e.greaterThan(0), I(e, t.y, 1, 0), I(t.x, 0, 0, 0)));
+	})().compute(1, [1]), O = () => i.element(0).x.mul(1e-4 / (u * d)), k = o(() => {
+		let e = b;
+		s(e.greaterThanEqual(N(d)), () => {
+			l();
+		});
+		let t = O().toVar(), o = i.element(1).z.greaterThan(0).toVar(), f = n.element(e).toVar(), m = E(o, f.y, f.x).add(t.mul(u)).toVar(), h = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(u),
+			type: "int",
+			condition: "<"
+		}, ({ i: n }) => {
+			let i = r.element(e.mul(u).add(N(n))).toVar(), s = E(o, i.y, i.x).add(t.mul(v(n).add(1))).div(C(m, 1e-30)), c = E(m.greaterThan(0), E(n.equal(x(u - 1)), v(1), s), v(0)).toVar();
+			a.element(p(n, e, 0)).assign(c), a.element(p(n, e, 1)).assign(h), h.assign(c);
+		});
+	})().compute(d, [64]), A = o(() => {
+		_();
+		let e = O().mul(u).toVar(), t = i.element(1).z.greaterThan(0).toVar(), r = (r) => {
+			let i = n.element(r);
+			return E(t, i.y, i.x).add(e);
+		}, o = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(d),
+			type: "int",
+			condition: "<"
+		}, ({ i: e }) => {
+			o.addAssign(r(e));
+		});
+		let s = v(0).toVar(), l = v(0).toVar();
+		c({
+			start: x(0),
+			end: x(d),
+			type: "int",
+			condition: "<"
+		}, ({ i: e }) => {
+			s.addAssign(r(e));
+			let t = E(e.equal(x(d - 1)), v(1), s.div(C(o, 1e-30))), n = E(o.greaterThan(0), t, v(0)).toVar();
+			a.element(p(u, e, 0)).assign(n), a.element(p(u, e, 1)).assign(l), l.assign(n);
+		});
+	})().compute(1, [1]), j = 2 * u * d;
+	return [
+		y,
+		S,
+		w,
+		T,
+		k,
+		A,
+		o(() => {
+			let e = b;
+			s(e.greaterThanEqual(N(j + 2 * d)), () => {
+				l();
+			}), s(e.lessThan(N(j)), () => {
+				let t = e.mod(2 * u).toVar(), n = e.div(2 * u).toVar(), r = xt(u, (e) => a.element(p(e, n, 0)), v(t).div(2 * u));
+				a.element(p(t.shiftRight(N(1)), n, N(2).add(t.bitAnd(N(1))))).assign(v(r));
+			}).Else(() => {
+				let t = e.sub(N(j)).toVar(), n = xt(d, (e) => a.element(p(u, e, 0)), v(t).div(2 * d));
+				a.element(p(u, t.shiftRight(N(1)), N(2).add(t.bitAnd(N(1))))).assign(v(n));
+			});
+		})().compute(j + 2 * d, [64])
+	];
+}
+//#endregion
+//#region src/Processor/PhysicalSky.js
+var Ct = /* @__PURE__ */ e({ PhysicalSky: () => Tt });
+function wt(e, t, n) {
+	let r = new ne(null, e, t, n, ie);
+	return r.source.dataReady = !1, r.needsUpdate = !0, r._isPhysicalSky = !0, r;
+}
+var Tt = class {
+	constructor(e = 1024, t = 512, n = {}) {
+		this.width = e, this.height = t, this._quality = n, this.lastRenderTime = 0, this._texture = wt(e, t, se), this._texture.mapping = re, this._texture.colorSpace = oe, this._texture.minFilter = ae, this._texture.magFilter = ae, this._texture.wrapS = ce, this._texture.wrapT = te, this._texture.generateMipmaps = !1, this._cdfTexture = wt(e + 1, t, se), this._rec709Weights = ke(ge), this._attrs = null, this._kernels = null, this._airKey = null, this._transmittanceBuilt = !1;
+	}
+	_init() {
+		let e = (e) => Array.from({ length: e }, () => P(new ue())), t = e(24);
+		this._uniforms = {
+			coefficient: t,
+			rgb: e(12),
+			sunDirection: P(new le(0, 1, 0)),
+			altitude: P(.05),
+			sunSinRadius: P(.0046)
+		};
+		let n = (e) => r(e, 4);
+		this._attrs = {
+			transmittance: n(256 * 64),
+			incomingA: n(1024 * 128 * 4),
+			incomingB: n(1024 * 128 * 4),
+			transfer: n(1024 * 128 * 4),
+			multipleScattering: n(1024 * 128 * 8),
+			psiSum: n(1024 * 128 * 8),
+			groundE: n(256),
+			irradiance: n(512),
+			sky: n(this.width * this.height),
+			skyRows: n(256 * this.height),
+			cdfRows: n(this.height),
+			cdfPrefix: r(this.width * this.height, 2),
+			cdfStats: n(2),
+			cdf: r($(this.width) * this.height, 1),
+			phaseCells: new a(Ge(16, 8, 16, 8), 4)
+		};
+		let i = (e, t = "vec4") => j(this._attrs[e], t, this._attrs[e].count), o = (e) => t.slice(e * 4, e * 4 + 4), s = {
+			transmittance: i("transmittance"),
+			transfer: i("transfer"),
+			psiSum: i("psiSum"),
+			groundE: i("groundE"),
+			phaseCells: i("phaseCells"),
+			multipleScattering: i("multipleScattering"),
+			irradiance: i("irradiance"),
+			sky: i("sky"),
+			skyRows: i("skyRows"),
+			coefficients: {
+				rayleigh: o(0),
+				mieScattering: o(1),
+				mieExtinction: o(2),
+				ozone: o(3),
+				solar: o(4),
+				albedo: o(5)
+			},
+			rgb: this._uniforms.rgb,
+			sunDirection: this._uniforms.sunDirection,
+			altitude: this._uniforms.altitude,
+			sunSinRadius: this._uniforms.sunSinRadius,
+			mieG: pe
+		}, c = this._quality, l = i("incomingA"), u = i("incomingB");
+		this._kernels = {
+			transmittance: ut(s),
+			air: [
+				mt(s, {
+					first: !0,
+					out: l,
+					...c.incoming
+				}),
+				ht(s, {
+					incoming: l,
+					stage: "first"
+				}),
+				mt(s, {
+					first: !1,
+					out: u,
+					...c.incoming
+				}),
+				ht(s, {
+					incoming: u,
+					stage: "middle"
+				}),
+				mt(s, {
+					first: !1,
+					out: l,
+					...c.incoming
+				}),
+				ht(s, {
+					incoming: l,
+					stage: "last"
+				}),
+				vt(s, c.irradiance)
+			],
+			sky: bt(s, {
+				width: this.width,
+				height: this.height,
+				...c.sky
+			}),
+			cdf: St({
+				pixels: s.sky,
+				rows: i("cdfRows"),
+				prefix: i("cdfPrefix", "vec2"),
+				stats: i("cdfStats"),
+				cdf: i("cdf", "float"),
+				width: this.width,
+				height: this.height
+			})
+		}, this._setSpectrum(4, Te);
+	}
+	_setColorWeights() {
+		let e = this._rec709Weights, t = i(), n = [
+			0,
+			0,
+			0,
+			0
+		];
+		for (let r = 0; r < 3; r++) for (let i = 0; i < 4; i++) {
+			for (let a = 0; a < 4; a++) {
+				let o = i * 4 + a;
+				n[a] = t ? t[r * 3] * e[o] + t[r * 3 + 1] * e[16 + o] + t[r * 3 + 2] * e[32 + o] : e[r * 16 + o];
+			}
+			this._uniforms.rgb[r * 4 + i].value.fromArray(n);
+		}
+	}
+	_copyToTextures(e) {
+		let t = e.backend;
+		e.initTexture(this._texture), e.initTexture(this._cdfTexture);
+		let n = t.device.createCommandEncoder({ label: "PhysicalSky" });
+		n.copyBufferToTexture({
+			buffer: t.get(this._attrs.sky).buffer,
+			bytesPerRow: this.width * 16,
+			rowsPerImage: this.height
+		}, { texture: t.get(this._texture).texture }, [this.width, this.height]), n.copyBufferToTexture({
+			buffer: t.get(this._attrs.cdf).buffer,
+			bytesPerRow: $(this.width) * 4,
+			rowsPerImage: this.height
+		}, { texture: t.get(this._cdfTexture).texture }, [this.width + 1, this.height]), t.device.queue.submit([n.finish()]);
+	}
+	_setSpectrum(e, t) {
+		for (let n = 0; n < 4; n++) this._uniforms.coefficient[e * 4 + n].value.set(t[n * 4], t[n * 4 + 1], t[n * 4 + 2], t[n * 4 + 3]);
+	}
+	bake(e, t) {
+		let n = performance.now();
+		this._kernels || this._init();
+		let r = {
+			airDensity: t.airDensity,
+			turbidity: t.turbidity,
+			ozone: t.ozone,
+			groundAlbedo: [...t.groundAlbedo]
+		}, i = Pe(r), a = Math.max(t.altitude, 1) / 1e3, o = t.sunAngularDiameter / 2, s = this._uniforms;
+		s.sunDirection.value.fromArray(t.sunDirection).normalize(), s.altitude.value = a, s.sunSinRadius.value = Math.sin(o), this._setColorWeights();
+		let c = [];
+		this._transmittanceBuilt ||= (c.push(this._kernels.transmittance), !0);
+		let l = JSON.stringify([r, s.sunSinRadius.value]);
+		l !== this._airKey && (this._setSpectrum(0, i.rayleigh), this._setSpectrum(1, i.mieScattering), this._setSpectrum(2, i.mieExtinction), this._setSpectrum(3, i.ozone), this._setSpectrum(5, i.albedo), c.push(...this._kernels.air), this._airKey = l), c.push(...this._kernels.sky, ...this._kernels.cdf), e.compute(c), this._copyToTextures(e);
+		let u = e.getArrayBufferAsync(this._attrs.cdfStats).then((e) => {
+			let t = new Float32Array(e);
+			return {
+				totalSum: t[4],
+				radianceIntegral: 2 * Math.PI * Math.PI * t[0] / (this.width * this.height)
+			};
+		}), d = He({
+			direction: [
+				s.sunDirection.value.x,
+				s.sunDirection.value.y,
+				s.sunDirection.value.z
+			],
+			altitude: a,
+			angularDiameter: t.sunAngularDiameter,
+			strength: t.sunStrength ?? 1,
+			coefficients: i
+		});
+		return d.cosHalfAngle = Math.cos(o), d.sinHalfAngle = Math.sin(o), d.horizonSin = Re(a), this.lastRenderTime = performance.now() - n, {
+			texture: this._texture,
+			cdfTexture: this._cdfTexture,
+			sun: d,
+			stats: u
+		};
+	}
+	async readBack(e) {
+		let [t, n, r] = await Promise.all([
+			"sky",
+			"cdf",
+			"cdfStats"
+		].map((t) => e.getArrayBufferAsync(this._attrs[t])));
+		return {
+			pixels: new Float32Array(t),
+			cdf: new Float32Array(n),
+			cdfStride: $(this.width),
+			stats: new Float32Array(r)
+		};
+	}
+	getLastRenderTime() {
+		return this.lastRenderTime;
+	}
+	dispose(e = null) {
+		for (let e of Object.values(this._kernels ?? {}).flat()) e.dispose();
+		for (let t of Object.values(this._attrs ?? {})) n(e, t);
+		this._kernels = null, this._attrs = null, this._texture.dispose(), this._cdfTexture.dispose();
+	}
+};
+//#endregion
+export { Ct as n, Tt as t };