@roomle/web-sdk 3.6.0-alpha.2 → 3.6.0-alpha.4

package/lib/scene-renderer-D8HkTFeZ.mjs

@@ -0,0 +1,3826 @@
+import { $n as e, $t as t, At as n, B as r, Bt as i, Cr as a, Dt as o, E as s, Ft as c, H as l, Hr as u, Ht as d, It as f, Kt as p, Lr as m, M as h, Mt as g, N as _, Nt as v, Or as y, P as b, Pt as x, Rr as S, Rt as C, St as w, U as T, Ut as E, Vt as D, X as O, Xn as ee, Y as te, Zt as k, br as ne, d as re, dr as A, g as j, gt as M, h as N, jr as ie, kr as P, l as ae, lr as F, o as I, p as L, pn as R, qn as oe, tn as se, ur as z, vt as ce, w as le, wr as ue, zr as B } from "./three.core-CLIofecG.mjs";
+import { P as V } from "./threejs-utils-jEzvlJF1.mjs";
+import { h as de } from "./common-utils-DMSTohiS.mjs";
+import { n as fe, r as pe, t as me } from "./decorate-C1QnXPYw.mjs";
+import "./dimensioning-helper-Fwpt1HTT.mjs";
+//#region \0rolldown/runtime.js
+var he = Object.create, H = Object.defineProperty, ge = Object.getOwnPropertyDescriptor, _e = Object.getOwnPropertyNames, ve = Object.getPrototypeOf, ye = Object.prototype.hasOwnProperty, be = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), xe = (e, t) => {
+	let n = {};
+	for (var r in e) H(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || H(n, Symbol.toStringTag, { value: "Module" }), n;
+}, Se = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = _e(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !ye.call(e, s) && s !== n && H(e, s, {
+		get: ((e) => t[e]).bind(null, s),
+		enumerable: !(r = ge(t, s)) || r.enumerable
+	});
+	return e;
+}, Ce = (e, t, n) => (n = e == null ? {} : he(ve(e)), Se(t || !e || !e.__esModule ? H(n, "default", {
+	value: e,
+	enumerable: !0
+}) : n, e)), we = {
+	uniforms: {
+		tDiffuse: { value: null },
+		colorTransform: { value: new v() },
+		colorBase: { value: new B(0, 0, 0, 0) },
+		multiplyChannels: { value: 0 },
+		uvTransform: { value: new g() }
+	},
+	vertexShader: "\n        varying vec2 vUv;\n        uniform mat3 uvTransform;\n\n        void main() {\n            vUv = (uvTransform * vec3(uv, 1.0)).xy;\n            gl_Position = (projectionMatrix * modelViewMatrix * vec4(position, 1.0)).xyww;\n        }",
+	fragmentShader: "\n        uniform sampler2D tDiffuse;\n        uniform mat4 colorTransform;\n        uniform vec4 colorBase;\n        uniform float multiplyChannels;\n        varying vec2 vUv;\n\n        void main() {\n            vec4 color = texture2D(tDiffuse, vUv);\n            #if PREMULTIPLIED_ALPHA == 1\n              if (color.a > 0.0) color.rgb /= color.a;\n            #endif\n            color = colorTransform * color + colorBase;\n            color.rgb = mix(color.rgb, vec3(color.r * color.g * color.b), multiplyChannels);\n            #if LINEAR_TO_SRGB == 1\n              color.rgb = mix(color.rgb * 12.92, 1.055 * pow(color.rgb, vec3(0.41666)) - 0.055, step(0.0031308, color.rgb));\n            #endif\n            gl_FragColor = color;\n        }"
+}, Te = new v(), Ee = new v().set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0), De = new v().set(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0), Oe = new v().set(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1);
+new v().set(0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1), new v().set(0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+var U = new v().set(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1), W = new B(0, 0, 0, 0), G = new B(0, 0, 0, 1), K = new g(), q = new g().set(1, 0, 0, 0, -1, 1, 0, 0, 1), ke = {
+	DEFAULT: "default",
+	ADDITIVE: "additive"
+}, Ae = class extends z {
+	constructor(e, t = ke.ADDITIVE, n = !1, r = !1) {
+		let i = t === ke.ADDITIVE ? {
+			blendSrc: 208,
+			blendDst: 200,
+			blendEquation: 100,
+			blendSrcAlpha: 206,
+			blendDstAlpha: 200,
+			blendEquationAlpha: 100
+		} : {};
+		super({
+			uniforms: y.clone(we.uniforms),
+			vertexShader: we.vertexShader,
+			fragmentShader: we.fragmentShader,
+			defines: {
+				LINEAR_TO_SRGB: n ? 1 : 0,
+				PREMULTIPLIED_ALPHA: r ? 1 : 0
+			},
+			transparent: !0,
+			depthTest: !1,
+			depthWrite: !1,
+			...i
+		}), this.update(e);
+	}
+	update(e) {
+		return e?.texture !== void 0 && (this.uniforms.tDiffuse.value = e?.texture), e?.colorTransform !== void 0 && (this.uniforms.colorTransform.value = e?.colorTransform), e?.colorBase !== void 0 && (this.uniforms.colorBase.value = e?.colorBase), e?.multiplyChannels !== void 0 && (this.uniforms.multiplyChannels.value = e?.multiplyChannels), e?.uvTransform !== void 0 && (this.uniforms.uvTransform.value = e?.uvTransform), e?.blending !== void 0 && (this.blending = e?.blending), e?.blendSrc !== void 0 && (this.blendSrc = e?.blendSrc), e?.blendDst !== void 0 && (this.blendDst = e?.blendDst), e?.blendEquation !== void 0 && (this.blendEquation = e?.blendEquation), e?.blendSrcAlpha !== void 0 && (this.blendSrcAlpha = e?.blendSrcAlpha), e?.blendDstAlpha !== void 0 && (this.blendDstAlpha = e?.blendDstAlpha), e?.blendEquationAlpha !== void 0 && (this.blendEquationAlpha = e?.blendEquationAlpha), this;
+	}
+}, je = {
+	uniforms: {
+		tDiffuse: { value: null },
+		rangeMin: { value: new m(1 / 512, 1 / 512) },
+		rangeMax: { value: new m(1 / 512, 1 / 512) }
+	},
+	vertexShader: "\n    varying vec2 vUv;\n    void main() {\n        vUv = uv;\n        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n    }",
+	fragmentShader: "\n    uniform sampler2D tDiffuse;\n    uniform vec2 rangeMin;\n    uniform vec2 rangeMax;\n    varying vec2 vUv;\n\n    void main() {\n        vec4 baseColor = texture2D(tDiffuse, vUv);\n        vec2 blur = mix(rangeMax, rangeMin, baseColor.a);\n        vec4 sum = vec4( 0.0 );\n        sum += texture2D(tDiffuse, vUv - 1.0 * blur) * 0.051;\n        sum += texture2D(tDiffuse, vUv - 0.75 * blur) * 0.0918;\n        sum += texture2D(tDiffuse, vUv - 0.5 * blur) * 0.12245;\n        sum += texture2D(tDiffuse, vUv - 0.25 * blur) * 0.1531;\n        sum += baseColor * 0.1633;\n        sum += texture2D(tDiffuse, vUv + 0.25 * blur) * 0.1531;\n        sum += texture2D(tDiffuse, vUv + 0.5 * blur) * 0.12245;\n        sum += texture2D(tDiffuse, vUv + 0.75 * blur) * 0.0918;\n        sum += texture2D(tDiffuse, vUv + 1.0 * blur) * 0.051;\n        gl_FragColor = sum;\n    }"
+};
+new m(.1, .9), new m(.1, .9);
+var Me = "varying vec2 vUv;\n  void main() {\n      vUv = uv;\n      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n  }", Ne = "uniform sampler2D tDepth;\n  uniform vec4 depthFilter;\n  uniform float cameraNear;\n  uniform float cameraFar;\n  varying vec2 vUv;\n\n  #include <packing>\n\n  float getLinearDepth(const in vec2 screenPosition) {\n      float fragCoordZ = dot(texture2D(tDepth, screenPosition), depthFilter);\n      #if PERSPECTIVE_CAMERA == 1\n          float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);\n          return viewZToOrthographicDepth(viewZ, cameraNear, cameraFar);\n      #else\n          return fragCoordZ;\n      #endif\n  }\n\n  void main() {\n      float depth = getLinearDepth(vUv);\n      gl_FragColor = vec4(vec3(1.0 - depth), 1.0);\n  }", Pe = class e extends z {
+	static {
+		this._linearDepthShader = {
+			uniforms: {
+				tDepth: { value: null },
+				depthFilter: { value: new B(1, 0, 0, 0) },
+				cameraNear: { value: .1 },
+				cameraFar: { value: 1 }
+			},
+			defines: {
+				PERSPECTIVE_CAMERA: 1,
+				ALPHA_DEPTH: 0
+			},
+			vertexShader: Me,
+			fragmentShader: Ne
+		};
+	}
+	constructor(t) {
+		super({
+			defines: Object.assign({}, e._linearDepthShader.defines),
+			uniforms: y.clone(e._linearDepthShader.uniforms),
+			vertexShader: e._linearDepthShader.vertexShader,
+			fragmentShader: e._linearDepthShader.fragmentShader,
+			blending: 0
+		}), this.update(t);
+	}
+	update(e) {
+		if (e?.depthTexture !== void 0 && (this.uniforms.tDepth.value = e?.depthTexture), e?.camera !== void 0) {
+			let t = e?.camera || e?.camera;
+			this.uniforms.cameraNear.value = t.near, this.uniforms.cameraFar.value = t.far;
+		}
+		return e?.depthFilter !== void 0 && (this.uniforms.depthFilter.value = e?.depthFilter), this;
+	}
+}, Fe = class {
+	constructor() {
+		this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
+	}
+	setSize() {}
+	render() {
+		console.error("THREE.Pass: .render() must be implemented in derived pass.");
+	}
+	dispose() {}
+}, Ie = new k(-1, 1, 1, -1, 0, 1), Le = new class extends ae {
+	constructor() {
+		super(), this.setAttribute("position", new l([
+			-1,
+			3,
+			0,
+			-1,
+			-1,
+			0,
+			3,
+			-1,
+			0
+		], 3)), this.setAttribute("uv", new l([
+			0,
+			2,
+			0,
+			0,
+			2,
+			0
+		], 2));
+	}
+}(), Re = class {
+	constructor(e) {
+		this._mesh = new x(Le, e);
+	}
+	dispose() {
+		this._mesh.geometry.dispose();
+	}
+	render(e) {
+		e.render(this._mesh, Ie);
+	}
+	get material() {
+		return this._mesh.material;
+	}
+	set material(e) {
+		this._mesh.material = e;
+	}
+}, ze = class {
+	constructor(e = Math) {
+		this.grad3 = [
+			[
+				1,
+				1,
+				0
+			],
+			[
+				-1,
+				1,
+				0
+			],
+			[
+				1,
+				-1,
+				0
+			],
+			[
+				-1,
+				-1,
+				0
+			],
+			[
+				1,
+				0,
+				1
+			],
+			[
+				-1,
+				0,
+				1
+			],
+			[
+				1,
+				0,
+				-1
+			],
+			[
+				-1,
+				0,
+				-1
+			],
+			[
+				0,
+				1,
+				1
+			],
+			[
+				0,
+				-1,
+				1
+			],
+			[
+				0,
+				1,
+				-1
+			],
+			[
+				0,
+				-1,
+				-1
+			]
+		], this.grad4 = [
+			[
+				0,
+				1,
+				1,
+				1
+			],
+			[
+				0,
+				1,
+				1,
+				-1
+			],
+			[
+				0,
+				1,
+				-1,
+				1
+			],
+			[
+				0,
+				1,
+				-1,
+				-1
+			],
+			[
+				0,
+				-1,
+				1,
+				1
+			],
+			[
+				0,
+				-1,
+				1,
+				-1
+			],
+			[
+				0,
+				-1,
+				-1,
+				1
+			],
+			[
+				0,
+				-1,
+				-1,
+				-1
+			],
+			[
+				1,
+				0,
+				1,
+				1
+			],
+			[
+				1,
+				0,
+				1,
+				-1
+			],
+			[
+				1,
+				0,
+				-1,
+				1
+			],
+			[
+				1,
+				0,
+				-1,
+				-1
+			],
+			[
+				-1,
+				0,
+				1,
+				1
+			],
+			[
+				-1,
+				0,
+				1,
+				-1
+			],
+			[
+				-1,
+				0,
+				-1,
+				1
+			],
+			[
+				-1,
+				0,
+				-1,
+				-1
+			],
+			[
+				1,
+				1,
+				0,
+				1
+			],
+			[
+				1,
+				1,
+				0,
+				-1
+			],
+			[
+				1,
+				-1,
+				0,
+				1
+			],
+			[
+				1,
+				-1,
+				0,
+				-1
+			],
+			[
+				-1,
+				1,
+				0,
+				1
+			],
+			[
+				-1,
+				1,
+				0,
+				-1
+			],
+			[
+				-1,
+				-1,
+				0,
+				1
+			],
+			[
+				-1,
+				-1,
+				0,
+				-1
+			],
+			[
+				1,
+				1,
+				1,
+				0
+			],
+			[
+				1,
+				1,
+				-1,
+				0
+			],
+			[
+				1,
+				-1,
+				1,
+				0
+			],
+			[
+				1,
+				-1,
+				-1,
+				0
+			],
+			[
+				-1,
+				1,
+				1,
+				0
+			],
+			[
+				-1,
+				1,
+				-1,
+				0
+			],
+			[
+				-1,
+				-1,
+				1,
+				0
+			],
+			[
+				-1,
+				-1,
+				-1,
+				0
+			]
+		], this.p = [];
+		for (let t = 0; t < 256; t++) this.p[t] = Math.floor(e.random() * 256);
+		this.perm = [];
+		for (let e = 0; e < 512; e++) this.perm[e] = this.p[e & 255];
+		this.simplex = [
+			[
+				0,
+				1,
+				2,
+				3
+			],
+			[
+				0,
+				1,
+				3,
+				2
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				2,
+				3,
+				1
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				1,
+				2,
+				3,
+				0
+			],
+			[
+				0,
+				2,
+				1,
+				3
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				3,
+				1,
+				2
+			],
+			[
+				0,
+				3,
+				2,
+				1
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				1,
+				3,
+				2,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				1,
+				2,
+				0,
+				3
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				1,
+				3,
+				0,
+				2
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				2,
+				3,
+				0,
+				1
+			],
+			[
+				2,
+				3,
+				1,
+				0
+			],
+			[
+				1,
+				0,
+				2,
+				3
+			],
+			[
+				1,
+				0,
+				3,
+				2
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				2,
+				0,
+				3,
+				1
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				2,
+				1,
+				3,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				2,
+				0,
+				1,
+				3
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				3,
+				0,
+				1,
+				2
+			],
+			[
+				3,
+				0,
+				2,
+				1
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				3,
+				1,
+				2,
+				0
+			],
+			[
+				2,
+				1,
+				0,
+				3
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				3,
+				1,
+				0,
+				2
+			],
+			[
+				0,
+				0,
+				0,
+				0
+			],
+			[
+				3,
+				2,
+				0,
+				1
+			],
+			[
+				3,
+				2,
+				1,
+				0
+			]
+		];
+	}
+	noise(e, t) {
+		let n, r, i, a = .5 * (Math.sqrt(3) - 1), o = (e + t) * a, s = Math.floor(e + o), c = Math.floor(t + o), l = (3 - Math.sqrt(3)) / 6, u = (s + c) * l, d = s - u, f = c - u, p = e - d, m = t - f, h, g;
+		p > m ? (h = 1, g = 0) : (h = 0, g = 1);
+		let _ = p - h + l, v = m - g + l, y = p - 1 + 2 * l, b = m - 1 + 2 * l, x = s & 255, S = c & 255, C = this.perm[x + this.perm[S]] % 12, w = this.perm[x + h + this.perm[S + g]] % 12, T = this.perm[x + 1 + this.perm[S + 1]] % 12, E = .5 - p * p - m * m;
+		E < 0 ? n = 0 : (E *= E, n = E * E * this._dot(this.grad3[C], p, m));
+		let D = .5 - _ * _ - v * v;
+		D < 0 ? r = 0 : (D *= D, r = D * D * this._dot(this.grad3[w], _, v));
+		let O = .5 - y * y - b * b;
+		return O < 0 ? i = 0 : (O *= O, i = O * O * this._dot(this.grad3[T], y, b)), 70 * (n + r + i);
+	}
+	noise3d(e, t, n) {
+		let r, i, a, o, s = (e + t + n) * (1 / 3), c = Math.floor(e + s), l = Math.floor(t + s), u = Math.floor(n + s), d = 1 / 6, f = (c + l + u) * d, p = c - f, m = l - f, h = u - f, g = e - p, _ = t - m, v = n - h, y, b, x, S, C, w;
+		g >= _ ? _ >= v ? (y = 1, b = 0, x = 0, S = 1, C = 1, w = 0) : g >= v ? (y = 1, b = 0, x = 0, S = 1, C = 0, w = 1) : (y = 0, b = 0, x = 1, S = 1, C = 0, w = 1) : _ < v ? (y = 0, b = 0, x = 1, S = 0, C = 1, w = 1) : g < v ? (y = 0, b = 1, x = 0, S = 0, C = 1, w = 1) : (y = 0, b = 1, x = 0, S = 1, C = 1, w = 0);
+		let T = g - y + d, E = _ - b + d, D = v - x + d, O = g - S + 2 * d, ee = _ - C + 2 * d, te = v - w + 2 * d, k = g - 1 + 3 * d, ne = _ - 1 + 3 * d, re = v - 1 + 3 * d, A = c & 255, j = l & 255, M = u & 255, N = this.perm[A + this.perm[j + this.perm[M]]] % 12, ie = this.perm[A + y + this.perm[j + b + this.perm[M + x]]] % 12, P = this.perm[A + S + this.perm[j + C + this.perm[M + w]]] % 12, ae = this.perm[A + 1 + this.perm[j + 1 + this.perm[M + 1]]] % 12, F = .6 - g * g - _ * _ - v * v;
+		F < 0 ? r = 0 : (F *= F, r = F * F * this._dot3(this.grad3[N], g, _, v));
+		let I = .6 - T * T - E * E - D * D;
+		I < 0 ? i = 0 : (I *= I, i = I * I * this._dot3(this.grad3[ie], T, E, D));
+		let L = .6 - O * O - ee * ee - te * te;
+		L < 0 ? a = 0 : (L *= L, a = L * L * this._dot3(this.grad3[P], O, ee, te));
+		let R = .6 - k * k - ne * ne - re * re;
+		return R < 0 ? o = 0 : (R *= R, o = R * R * this._dot3(this.grad3[ae], k, ne, re)), 32 * (r + i + a + o);
+	}
+	noise4d(e, t, n, r) {
+		let i = this.grad4, a = this.simplex, o = this.perm, s = (Math.sqrt(5) - 1) / 4, c = (5 - Math.sqrt(5)) / 20, l, u, d, f, p, m = (e + t + n + r) * s, h = Math.floor(e + m), g = Math.floor(t + m), _ = Math.floor(n + m), v = Math.floor(r + m), y = (h + g + _ + v) * c, b = h - y, x = g - y, S = _ - y, C = v - y, w = e - b, T = t - x, E = n - S, D = r - C, O = w > T ? 32 : 0, ee = w > E ? 16 : 0, te = T > E ? 8 : 0, k = w > D ? 4 : 0, ne = T > D ? 2 : 0, re = E > D ? 1 : 0, A = O + ee + te + k + ne + re, j = a[A][0] >= 3 ? 1 : 0, M = a[A][1] >= 3 ? 1 : 0, N = a[A][2] >= 3 ? 1 : 0, ie = a[A][3] >= 3 ? 1 : 0, P = a[A][0] >= 2 ? 1 : 0, ae = a[A][1] >= 2 ? 1 : 0, F = a[A][2] >= 2 ? 1 : 0, I = a[A][3] >= 2 ? 1 : 0, L = a[A][0] >= 1 ? 1 : 0, R = a[A][1] >= 1 ? 1 : 0, oe = a[A][2] >= 1 ? 1 : 0, se = a[A][3] >= 1 ? 1 : 0, z = w - j + c, ce = T - M + c, le = E - N + c, ue = D - ie + c, B = w - P + 2 * c, V = T - ae + 2 * c, de = E - F + 2 * c, fe = D - I + 2 * c, pe = w - L + 3 * c, me = T - R + 3 * c, he = E - oe + 3 * c, H = D - se + 3 * c, ge = w - 1 + 4 * c, _e = T - 1 + 4 * c, ve = E - 1 + 4 * c, ye = D - 1 + 4 * c, be = h & 255, xe = g & 255, Se = _ & 255, Ce = v & 255, we = o[be + o[xe + o[Se + o[Ce]]]] % 32, Te = o[be + j + o[xe + M + o[Se + N + o[Ce + ie]]]] % 32, Ee = o[be + P + o[xe + ae + o[Se + F + o[Ce + I]]]] % 32, De = o[be + L + o[xe + R + o[Se + oe + o[Ce + se]]]] % 32, Oe = o[be + 1 + o[xe + 1 + o[Se + 1 + o[Ce + 1]]]] % 32, U = .6 - w * w - T * T - E * E - D * D;
+		U < 0 ? l = 0 : (U *= U, l = U * U * this._dot4(i[we], w, T, E, D));
+		let W = .6 - z * z - ce * ce - le * le - ue * ue;
+		W < 0 ? u = 0 : (W *= W, u = W * W * this._dot4(i[Te], z, ce, le, ue));
+		let G = .6 - B * B - V * V - de * de - fe * fe;
+		G < 0 ? d = 0 : (G *= G, d = G * G * this._dot4(i[Ee], B, V, de, fe));
+		let K = .6 - pe * pe - me * me - he * he - H * H;
+		K < 0 ? f = 0 : (K *= K, f = K * K * this._dot4(i[De], pe, me, he, H));
+		let q = .6 - ge * ge - _e * _e - ve * ve - ye * ye;
+		return q < 0 ? p = 0 : (q *= q, p = q * q * this._dot4(i[Oe], ge, _e, ve, ye)), 27 * (l + u + d + f + p);
+	}
+	_dot(e, t, n) {
+		return e[0] * t + e[1] * n;
+	}
+	_dot3(e, t, n, r) {
+		return e[0] * t + e[1] * n + e[2] * r;
+	}
+	_dot4(e, t, n, r, i) {
+		return e[0] * t + e[1] * n + e[2] * r + e[3] * i;
+	}
+}, Be = (e, t) => {
+	e.left = t.min.x, e.right = t.max.x, e.bottom = t.min.y, e.top = t.max.y, e.near = Math.min(-t.min.z, -t.max.z), e.far = Math.max(-t.min.z, -t.max.z), e.updateProjectionMatrix();
+}, Ve = (e, t) => {
+	let r = Math.min(-t.min.z, -t.max.z), i = Math.max(-t.min.z, -t.max.z);
+	if (r < .001) return;
+	let a = Math.max(Math.abs(t.min.x), Math.abs(t.max.x)), o = Math.max(Math.abs(t.min.y), Math.abs(t.max.y));
+	e.aspect = a / o, e.fov = n.radToDeg(Math.atan2(o, r) * 2), e.near = r, e.far = i, e.updateProjectionMatrix();
+}, He = class {
+	constructor() {
+		this.bounds = new I(new S(-1, -1, -1), new S(1, 1, 1)), this.size = new S(2, 2, 2), this.center = new S(0, 0, 0), this.maxSceneDistanceFromCenter = Math.sqrt(3), this.maxSceneDistanceFrom0 = Math.sqrt(3);
+	}
+	updateFromBox(e) {
+		this.bounds !== e && this.bounds.copy(e), this.bounds.getSize(this.size), this.bounds.getCenter(this.center), this.maxSceneDistanceFromCenter = this.size.length() / 2, this.maxSceneDistanceFrom0 = new S(Math.max(Math.abs(this.bounds.min.x), Math.abs(this.bounds.max.x)), Math.max(Math.abs(this.bounds.min.y), Math.abs(this.bounds.max.y)), Math.max(Math.abs(this.bounds.min.z), Math.abs(this.bounds.max.z))).length();
+	}
+	updateCameraViewVolumeFromBounds(e) {
+		e.updateMatrixWorld();
+		let n = this.bounds.clone().applyMatrix4(e.matrixWorldInverse);
+		e instanceof k ? Be(e, n) : e instanceof t && Ve(e, n);
+	}
+	getNearAndFarForPerspectiveCamera(e, t = 1) {
+		let n = e.clone().sub(this.center).length();
+		return [Math.max(.01, n - this.maxSceneDistanceFromCenter - .01), n + this.maxSceneDistanceFromCenter * t + .01];
+	}
+}, Ue = (e) => V(e) ? e.capabilities.maxSamples : 16, We = class {
+	changed(e) {
+		let t = !this._lastCameraProjection?.equals(e.projectionMatrix) || !this._lastCameraWorld?.equals(e.matrixWorld);
+		return this._lastCameraProjection = e.projectionMatrix.clone(), this._lastCameraWorld = e.matrixWorld.clone(), t;
+	}
+}, Ge = (e) => {
+	let t = Math.floor(e) % 2 == 0 ? Math.floor(e) + 1 : Math.floor(e), n = t * t, r = Array(n).fill(0), i = Math.floor(t / 2), a = t - 1;
+	for (let e = 1; e <= n;) {
+		if (i === -1 && a === t ? (a = t - 2, i = 0) : (a === t && (a = 0), i < 0 && (i = t - 1)), r[i * t + a] !== 0) {
+			a -= 2, i++;
+			continue;
+		} else r[i * t + a] = e++;
+		a++, i--;
+	}
+	return r;
+}, Ke = (t) => {
+	let n = new ze(), r = Math.floor(t) % 2 == 0 ? Math.floor(t) + 1 : Math.floor(t), i = Ge(r), a = i.length, o = new Uint8Array(a * 4);
+	for (let e = 0; e < a; ++e) {
+		let r = i[e], s = 2 * Math.PI * r / a, c = new S(Math.cos(s), Math.sin(s), 0).normalize();
+		o[e * 4] = (c.x * .5 + .5) * 255, o[e * 4 + 1] = (c.y * .5 + .5) * 255, o[e * 4 + 2] = 127, o[e * 4 + 3] = (n.noise(e / t, e % t) * .5 + .5) * 255;
+	}
+	let c = new s(o, r, r);
+	return c.wrapS = e, c.wrapT = e, c.needsUpdate = !0, c;
+}, qe = class {
+	constructor() {
+		this._originalClearColor = new N(), this._originalClearAlpha = 0, this._originalAutoClear = !1, this._originalRenderTarget = null, this._screenSpaceQuad = new Re(void 0), this._emptyScene = new F(), this._defaultCamera = new t();
+	}
+	renderWithOverrideMaterial(e, t, n, r, i, a, o) {
+		this._backup(e), this._prepareRenderer(e, i, a, o);
+		let s = t.overrideMaterial;
+		t.overrideMaterial = r, e.render(t, n), t.overrideMaterial = s, this._restore(e);
+	}
+	clear(e, t, n, r) {
+		this._backup(e), this._prepareRenderer(e, t, n, r), e.render(this._emptyScene, this._defaultCamera), this._restore(e);
+	}
+	render(e, t, n, r, i, a) {
+		this._backup(e), this._prepareRenderer(e, r, i, a), e.render(t, n), this._restore(e);
+	}
+	renderScreenSpace(e, t, n, r, i) {
+		this._backup(e), this._prepareRenderer(e, n, r, i), this._screenSpaceQuad.material = t, this._screenSpaceQuad.render(e), this._restore(e);
+	}
+	_prepareRenderer(e, t, n, r) {
+		e.setRenderTarget(t), e.autoClear = !1, n != null && (e.setClearColor(n), e.setClearAlpha(r || 0), e.clear());
+	}
+	_backup(e) {
+		e.getClearColor(this._originalClearColor), this._originalClearAlpha = e.getClearAlpha(), this._originalAutoClear = e.autoClear, this._originalRenderTarget = e.getRenderTarget();
+	}
+	_restore(e) {
+		e.setClearColor(this._originalClearColor), e.setClearAlpha(this._originalClearAlpha), e.setRenderTarget(this._originalRenderTarget), e.autoClear = this._originalAutoClear;
+	}
+}, Je = class {
+	constructor(e, t) {
+		this._passRenderer = t?.passRenderer ?? new qe(), this._blurMaterial = new z(e ?? je), this._blurMaterial.depthTest = !1;
+	}
+	dispose() {
+		this._blurMaterial.dispose();
+	}
+	render(e, t, n, r) {
+		this._blurMaterial.uniforms.tDiffuse.value = t[0].texture, this._blurMaterial.uniforms.rangeMin.value.x = n[0], this._blurMaterial.uniforms.rangeMin.value.y = 0, this._blurMaterial.uniforms.rangeMax.value.x = r[0], this._blurMaterial.uniforms.rangeMax.value.y = 0, this._passRenderer.renderScreenSpace(e, this._blurMaterial, t[1]), this._blurMaterial.uniforms.tDiffuse.value = t[1].texture, this._blurMaterial.uniforms.rangeMin.value.x = 0, this._blurMaterial.uniforms.rangeMin.value.y = n[1], this._blurMaterial.uniforms.rangeMax.value.x = 0, this._blurMaterial.uniforms.rangeMax.value.y = r[1], this._passRenderer.renderScreenSpace(e, this._blurMaterial, t[2]);
+	}
+}, Ye = class e extends x {
+	static {
+		this.alphaMap = !0;
+	}
+	constructor(t, n) {
+		super(new se(1, 1, 10, 10), new d({
+			color: e.alphaMap ? 0 : 16777215,
+			transparent: !0,
+			depthWrite: !1,
+			polygonOffset: !0,
+			name: "ShadowGroundPlaneMaterial"
+		})), this.name = "ShadowGroundPlane", this.userData.isFloor = !0, this.renderOrder = 1, this.receiveShadow = !1, this.layers.disableAll(), n && this.updateMaterial(n), this.setShadowMap(t);
+	}
+	setVisibility(e) {
+		this.visible = e, this.setVisibilityLayers(e);
+	}
+	setVisibilityLayers(e) {
+		e ? this.layers.enableAll() : this.layers.disableAll();
+	}
+	setDepthWrite(e) {
+		let t = this.material;
+		t.depthWrite = e, t.transparent = !e, t.needsUpdate = !0, this.setVisibility(e);
+	}
+	setReceiveShadow(e) {
+		this.receiveShadow = e, this.setVisibility(e);
+	}
+	setShadowMap(t) {
+		let n = this.material;
+		e.alphaMap ? (n.alphaMap = t, n.map = null, n.color.set(0)) : (n.alphaMap = null, n.map = t, n.color.set(16777215)), n.needsUpdate = !0;
+	}
+	updateMaterial(e) {
+		let t = this.material;
+		e.opacity && t.opacity !== e.opacity && (t.opacity = e.opacity), e.polygonOffset && t.polygonOffsetFactor !== e.polygonOffset && (t.polygonOffset = !0, t.polygonOffsetFactor = e.polygonOffset, t.polygonOffsetUnits = e.polygonOffset), t.needsUpdate = !0;
+	}
+}, J = class extends Fe {
+	get renderPassManager() {
+		return this._renderPassManager;
+	}
+	get renderCacheManager() {
+		return this._renderPassManager.renderCacheManager;
+	}
+	get scene() {
+		return this._renderPassManager.scene;
+	}
+	get camera() {
+		return this._renderPassManager.camera;
+	}
+	get gBufferTextures() {
+		return this._renderPassManager.gBufferRenderPass;
+	}
+	get passRenderer() {
+		return this._renderPassManager.passRenderer;
+	}
+	constructor(e) {
+		super(), this._renderPassManager = e;
+	}
+	render(e, t, n, r, i) {
+		this.renderPass(e);
+	}
+}, Y = {
+	INPUT_RGB_NORMAL: "inputRgbNormal",
+	FLOAT_BUFFER_NORMAL: "floatBufferNormal",
+	CONSTANT_Z: "constantZ"
+}, X = {
+	SEPARATE_BUFFER: "separateBuffer",
+	NORMAL_VECTOR_ALPHA: "normalVectorAlpha"
+}, Xe = {
+	SSAO: 0,
+	SAO: 1,
+	N8AO: 2,
+	HBAO: 3,
+	GTAO: 4
+}, Ze = (e, t) => {
+	let n = Qe(e, t), r = "vec4[SAMPLES](";
+	for (let t = 0; t < e; t++) {
+		let i = n[t];
+		r += `vec4(${i.x}, ${i.y}, ${i.z}, ${i.w})${t < e - 1 ? "," : ")"}`;
+	}
+	return r;
+}, Qe = (e, t) => {
+	let n = [];
+	for (let r = 0; r < e; r++) {
+		let i = r * Math.PI * (3 - Math.sqrt(5)), a = .01 + r / (e - 1) * .99, o = t ? Math.sqrt(1 - a * a) : 1 - a, s = Math.cos(i) * o, c = Math.sin(i) * o, l = Math.floor(e / 4), u = 1 - (Math.floor(r / 4) + r % 4 * l) / e;
+		u = .1 + .9 * u, n.push(new B(s, c, a, u));
+	}
+	return n;
+}, $e = {
+	name: "AOShader",
+	defines: {
+		PERSPECTIVE_CAMERA: 1,
+		SAMPLES: 16,
+		SAMPLE_VECTORS: Ze(16, !1),
+		NORMAL_VECTOR_TYPE: 1,
+		DEPTH_SWIZZLING: "x",
+		AO_ALGORITHM: Xe.GTAO,
+		NV_ALIGNED_SAMPLES: 1,
+		SCREEN_SPACE_RADIUS: 0,
+		SCREEN_SPACE_RADIUS_SCALE: 100,
+		SCENE_CLIP_BOX: 0,
+		NORMAL_VECTOR_ANTIALIAS: 2,
+		DEPTH_BUFFER_ANTIALIAS: 1
+	},
+	uniforms: {
+		tNormal: { value: null },
+		tDepth: { value: null },
+		tNoise: { value: null },
+		resolution: { value: new m() },
+		cameraNear: { value: null },
+		cameraFar: { value: null },
+		cameraProjectionMatrix: { value: new v() },
+		cameraProjectionMatrixInverse: { value: new v() },
+		cameraWorldMatrix: { value: new v() },
+		radius: { value: 1 },
+		distanceExponent: { value: 1 },
+		thickness: { value: 1 },
+		distanceFallOff: { value: 1 },
+		bias: { value: .001 },
+		scale: { value: 1 },
+		sceneBoxMin: { value: new S(-1, -1, -1) },
+		sceneBoxMax: { value: new S(1, 1, 1) }
+	},
+	vertexShader: "\n\n		varying vec2 vUv;\n\n		void main() {\n			vUv = uv;\n			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n		}",
+	fragmentShader: "\n\n		varying vec2 vUv;\n		uniform highp sampler2D tNormal;\n		uniform highp sampler2D tDepth;\n		uniform sampler2D tNoise;\n		uniform vec2 resolution;\n		uniform float cameraNear;\n		uniform float cameraFar;\n		uniform mat4 cameraProjectionMatrix;\n		uniform mat4 cameraProjectionMatrixInverse;\n		uniform mat4 cameraWorldMatrix;\n		uniform float radius;\n		uniform float distanceExponent;\n		uniform float thickness;\n		uniform float distanceFallOff;\n		uniform float bias;\n		uniform float scale;\n		#if SCENE_CLIP_BOX == 1\n			uniform vec3 sceneBoxMin;\n			uniform vec3 sceneBoxMax;\n		#endif\n\n		#include <common>\n		#include <packing>\n\n		#ifndef FRAGMENT_OUTPUT\n		#define FRAGMENT_OUTPUT vec4(vec3(ao), 1.)\n		#endif\n\n		const vec4 sampleKernel[SAMPLES] = SAMPLE_VECTORS;\n\n		vec3 getViewPosition(const in vec2 screenPosition, const in float depth) {\n			vec4 clipSpacePosition = vec4(vec3(screenPosition, depth) * 2.0 - 1.0, 1.0);\n			vec4 viewSpacePosition = cameraProjectionMatrixInverse * clipSpacePosition;\n			return viewSpacePosition.xyz / viewSpacePosition.w;\n		}\n\n		float getDepth(const vec2 uv) {\n			#if DEPTH_BUFFER_ANTIALIAS == 1\n				vec2 size = vec2(textureSize(tDepth, 0));\n				ivec2 p = ivec2(uv * size);\n				float d0 = texelFetch(tDepth, p, 0).DEPTH_SWIZZLING;\n				vec2 depth = vec2(d0, 1.0);\n				float d1 = texelFetch(tDepth, p + ivec2(1, 0), 0).DEPTH_SWIZZLING;\n				depth += vec2(d1, 1.0) * step(abs(d1 - d0), 0.1);\n				float d2 = texelFetch(tDepth, p - ivec2(1, 0), 0).DEPTH_SWIZZLING;\n				depth += vec2(d2, 1.0) * step(abs(d2 - d0), 0.1);\n				float d3 = texelFetch(tDepth, p + ivec2(0, 1), 0).DEPTH_SWIZZLING;\n				depth += vec2(d3, 1.0) * step(abs(d3 - d0), 0.1);\n				float d4 = texelFetch(tDepth, p - ivec2(0, 1), 0).DEPTH_SWIZZLING;\n				depth += vec2(d4, 1.0) * step(abs(d4 - d0), 0.1);\n				return depth.x / depth.y;\n          	#else\n              	return textureLod(tDepth, uv.xy, 0.0).DEPTH_SWIZZLING;\n          	#endif\n		}\n\n		float fetchDepth(const ivec2 uv) {\n			return texelFetch(tDepth, uv.xy, 0).DEPTH_SWIZZLING;\n		}\n\n		float getViewZ(const in float depth) {\n			#if PERSPECTIVE_CAMERA == 1\n				return perspectiveDepthToViewZ(depth, cameraNear, cameraFar);\n			#else\n				return orthographicDepthToViewZ(depth, cameraNear, cameraFar);\n			#endif\n		}\n\n		vec3 computeNormalFromDepth(const vec2 uv) {\n            vec2 size = vec2(textureSize(tDepth, 0));\n            ivec2 p = ivec2(uv * size);\n            float c0 = fetchDepth(p);\n            float l2 = fetchDepth(p - ivec2(2, 0));\n            float l1 = fetchDepth(p - ivec2(1, 0));\n            float r1 = fetchDepth(p + ivec2(1, 0));\n            float r2 = fetchDepth(p + ivec2(2, 0));\n            float b2 = fetchDepth(p - ivec2(0, 2));\n            float b1 = fetchDepth(p - ivec2(0, 1));\n            float t1 = fetchDepth(p + ivec2(0, 1));\n            float t2 = fetchDepth(p + ivec2(0, 2));\n            float dl = abs((2.0 * l1 - l2) - c0);\n            float dr = abs((2.0 * r1 - r2) - c0);\n            float db = abs((2.0 * b1 - b2) - c0);\n            float dt = abs((2.0 * t1 - t2) - c0);\n            vec3 ce = getViewPosition(uv, c0).xyz;\n            vec3 dpdx = (dl < dr) ?  ce - getViewPosition((uv - vec2(1.0 / size.x, 0.0)), l1).xyz\n                                  : -ce + getViewPosition((uv + vec2(1.0 / size.x, 0.0)), r1).xyz;\n            vec3 dpdy = (db < dt) ?  ce - getViewPosition((uv - vec2(0.0, 1.0 / size.y)), b1).xyz\n                                  : -ce + getViewPosition((uv + vec2(0.0, 1.0 / size.y)), t1).xyz;\n            return normalize(cross(dpdx, dpdy));\n		}\n\n		vec3 getViewNormal(const vec2 uv) {\n			#if NORMAL_VECTOR_TYPE == 2\n				return normalize(textureLod(tNormal, uv, 0.).rgb);\n			#elif NORMAL_VECTOR_TYPE == 1\n				return unpackRGBToNormal(textureLod(tNormal, uv, 0.).rgb);\n			#else\n				return computeNormalFromDepth(uv);\n			#endif\n		}\n\n		vec3 getAntiAliasedViewNormal(const in vec2 screenPosition) {\n			#if NORMAL_VECTOR_TYPE == 2\n				#if NORMAL_VECTOR_ANTIALIAS == 1\n					vec2 uv = screenPosition;\n					vec2 size = vec2(textureSize(tNormal, 0));\n					ivec2 p = ivec2(screenPosition * size);\n					float c0 = texelFetch(tNormal, p, 0).a;\n					float l2 = texelFetch(tNormal, p - ivec2(2, 0), 0).a;\n					float l1 = texelFetch(tNormal, p - ivec2(1, 0), 0).a;\n					float r1 = texelFetch(tNormal, p + ivec2(1, 0), 0).a;\n					float r2 = texelFetch(tNormal, p + ivec2(2, 0), 0).a;\n					float b2 = texelFetch(tNormal, p - ivec2(0, 2), 0).a;\n					float b1 = texelFetch(tNormal, p - ivec2(0, 1), 0).a;\n					float t1 = texelFetch(tNormal, p + ivec2(0, 1), 0).a;\n					float t2 = texelFetch(tNormal, p + ivec2(0, 2), 0).a;\n					float dl = abs((2.0 * l1 - l2) - c0);\n					float dr = abs((2.0 * r1 - r2) - c0);\n					float db = abs((2.0 * b1 - b2) - c0);\n					float dt = abs((2.0 * t1 - t2) - c0);\n					vec3 ce = getViewPosition(uv, c0).xyz;\n					vec3 dpdx = (dl < dr) ?  ce - getViewPosition((uv - vec2(1.0 / size.x, 0.0)), l1).xyz\n										  : -ce + getViewPosition((uv + vec2(1.0 / size.x, 0.0)), r1).xyz;\n					vec3 dpdy = (db < dt) ?  ce - getViewPosition((uv - vec2(0.0, 1.0 / size.y)), b1).xyz\n										  : -ce + getViewPosition((uv + vec2(0.0, 1.0 / size.y)), t1).xyz;\n					return normalize(cross(dpdx, dpdy));\n				#elif NORMAL_VECTOR_ANTIALIAS == 2\n					vec2 size = vec2(textureSize(tNormal, 0));\n					ivec2 p = ivec2(screenPosition * size);\n					vec3 normalVector = texelFetch(tNormal, p, 0).xyz;\n					normalVector += texelFetch(tNormal, p + ivec2(1, 0), 0).xyz;\n					normalVector += texelFetch(tNormal, p - ivec2(1, 0), 0).xyz;\n					normalVector += texelFetch(tNormal, p + ivec2(0, 1), 0).xyz;\n					normalVector += texelFetch(tNormal, p - ivec2(0, 1), 0).xyz;\n					return normalize(normalVector);\n				#else\n					return texture2D(tNormal, screenPosition).xyz;\n				#endif\n			#elif NORMAL_VECTOR_TYPE == 1\n				return unpackRGBToNormal(textureLod(tNormal, screenPosition, 0.).rgb);\n			#else\n				return computeNormalFromDepth(screenPosition);\n			#endif\n		  }\n\n		vec3 getSceneUvAndDepth(vec3 sampleViewPos) {\n			vec4 sampleClipPos = cameraProjectionMatrix * vec4(sampleViewPos, 1.);\n			vec2 sampleUv = sampleClipPos.xy / sampleClipPos.w * 0.5 + 0.5;\n			float sampleSceneDepth = getDepth(sampleUv);\n			return vec3(sampleUv, sampleSceneDepth);\n		}\n\n		float sinusToPlane(vec3 pointOnPlane, vec3 planeNormal, vec3 point) {\n			vec3 delta = point - pointOnPlane;\n			float sinV = dot(planeNormal, normalize(delta));\n			return sinV;\n		}\n\n		float getFallOff(float delta, float falloffDistance) {\n			float fallOff = smoothstep(0., 1., 1. - distanceFallOff * abs(delta) / falloffDistance);\n			return fallOff;\n		}\n\n		void main() {\n			float depth = getDepth(vUv.xy);\n			if (depth >= 1.0) {\n				discard;\n				return;\n			}\n			vec3 viewPos = getViewPosition(vUv, depth);\n			vec3 viewNormal = getAntiAliasedViewNormal(vUv);\n\n			float radiusToUse = radius;\n			float distanceFalloffToUse = thickness;\n			#if SCREEN_SPACE_RADIUS == 1\n			    float radiusScale = getViewPosition(vec2(0.5 + float(SCREEN_SPACE_RADIUS_SCALE) / resolution.x, 0.0), depth).x;\n				radiusToUse *= radiusScale;\n				distanceFalloffToUse *= radiusScale;\n			#endif\n\n			#if SCENE_CLIP_BOX == 1\n				vec3 worldPos = (cameraWorldMatrix * vec4(viewPos, 1.0)).xyz;\n      			float boxDistance = length(max(vec3(0.0), max(sceneBoxMin - worldPos, worldPos - sceneBoxMax)));\n				if (boxDistance > radiusToUse) {\n					discard;\n					return;\n				}\n			#endif\n\n			vec2 noiseResolution = vec2(textureSize(tNoise, 0));\n			vec2 noiseUv = vUv * resolution / noiseResolution;\n			vec4 noiseTexel = textureLod(tNoise, noiseUv, 0.0);\n			vec3 randomVec = noiseTexel.xyz * 2.0 - 1.0;\n\n			#if NV_ALIGNED_SAMPLES == 1\n  				vec3 tangent = normalize(randomVec - viewNormal * dot(randomVec, viewNormal));\n      			vec3 bitangent = cross(viewNormal, tangent);\n      			mat3 kernelMatrix = mat3(tangent, bitangent, viewNormal);\n			#else\n				vec3 tangent = normalize(vec3(randomVec.xy, 0.));\n				vec3 bitangent = vec3(-tangent.y, tangent.x, 0.);\n				mat3 kernelMatrix = mat3(tangent, bitangent, vec3(0., 0., 1.));\n			#endif\n\n		#if AO_ALGORITHM == 4\n			const int DIRECTIONS = SAMPLES < 30 ? 3 : 5;\n			const int STEPS = (SAMPLES + DIRECTIONS - 1) / DIRECTIONS;\n		#elif AO_ALGORITHM == 3\n			const int DIRECTIONS = SAMPLES < 16 ? 3 : 5;\n			const int STEPS = (SAMPLES + DIRECTIONS - 1) / DIRECTIONS;\n		#else\n			const int DIRECTIONS = SAMPLES;\n			const int STEPS = 1;\n		#endif\n\n			float ao = 0.0, totalWeight = 0.0;\n			for (int i = 0; i < DIRECTIONS; ++i) {\n\n			#if AO_ALGORITHM == 4\n				float angle = float(i) / float(DIRECTIONS) * PI;\n				vec4 sampleDir = vec4(cos(angle), sin(angle), 0., 0.5 + 0.5 * noiseTexel.w);\n			#elif AO_ALGORITHM == 3\n				float angle = float(i) / float(DIRECTIONS) * 2. * PI;\n				vec4 sampleDir = vec4(cos(angle), sin(angle), 0., 0.5 + 0.5 * noiseTexel.w);\n			#else\n				vec4 sampleDir = sampleKernel[i];\n			#endif\n				sampleDir.xyz = normalize(kernelMatrix * sampleDir.xyz);\n\n				vec3 viewDir = normalize(-viewPos.xyz);\n				vec3 sliceBitangent = normalize(cross(sampleDir.xyz, viewDir));\n				vec3 sliceTangent = cross(sliceBitangent, viewDir);\n				vec3 normalInSlice = normalize(viewNormal - sliceBitangent * dot(viewNormal, sliceBitangent));\n\n			#if (AO_ALGORITHM == 3 || AO_ALGORITHM == 4)\n				vec3 tangentToNormalInSlice = cross(normalInSlice, sliceBitangent);\n				#if AO_ALGORITHM == 4\n					vec2 cosHorizons = vec2(dot(viewDir, tangentToNormalInSlice), dot(viewDir, -tangentToNormalInSlice));\n				#else\n					vec2 cosHorizons = vec2(dot(viewDir, tangentToNormalInSlice));\n				#endif\n				for (int j = 0; j < STEPS; ++j) {\n					vec3 sampleViewOffset = sampleDir.xyz * radiusToUse * sampleDir.w * pow(float(j + 1) / float(STEPS), distanceExponent);\n					vec3 sampleViewPos = viewPos + sampleViewOffset;\n			#else\n					vec3 sampleViewPos = viewPos + sampleDir.xyz * radiusToUse * pow(sampleDir.w, distanceExponent);\n			#endif\n\n					vec3 sampleSceneUvDepth = getSceneUvAndDepth(sampleViewPos);\n					vec3 sampleSceneViewPos = getViewPosition(sampleSceneUvDepth.xy, sampleSceneUvDepth.z);\n					float sceneSampleDist = abs(sampleSceneViewPos.z);\n					float sampleDist = abs(sampleViewPos.z);\n\n				#if (AO_ALGORITHM == 3 || AO_ALGORITHM == 4)\n					// HBAO || GTAO\n					vec3 viewDelta = sampleSceneViewPos - viewPos;\n					if (abs(viewDelta.z) < thickness) {\n						vec2 clipRangeCheck = step(0., sampleSceneUvDepth.xy) * step(sampleSceneUvDepth.xy, vec2(1.));\n						float sampleCosHorizon = dot(viewDir, normalize(viewDelta));\n						cosHorizons.x += max(0., (sampleCosHorizon - cosHorizons.x) * mix(1., 2. / float(j + 2), distanceFallOff) * clipRangeCheck.x * clipRangeCheck.y);\n					}\n					#if AO_ALGORITHM == 4\n						sampleSceneUvDepth = getSceneUvAndDepth(viewPos - sampleViewOffset);\n						sampleSceneViewPos = getViewPosition(sampleSceneUvDepth.xy, sampleSceneUvDepth.z);\n						viewDelta = sampleSceneViewPos - viewPos;\n						if (abs(viewDelta.z) < thickness) {\n							vec2 clipRangeCheck = step(0., sampleSceneUvDepth.xy) * step(sampleSceneUvDepth.xy, vec2(1.));\n							float sampleCosHorizon = dot(viewDir, normalize(viewDelta));\n							cosHorizons.y += max(0., (sampleCosHorizon - cosHorizons.y) * mix(1., 2. / float(j + 2), distanceFallOff) * clipRangeCheck.x * clipRangeCheck.y);\n						}\n					#endif\n				#elif AO_ALGORITHM == 2\n					// N8AO\n					float weight = dot(viewNormal, sampleDir.xyz);\n					float occlusion = weight * step(sceneSampleDist + bias, sampleDist);\n				#elif AO_ALGORITHM == 1\n					// SAO\n					vec3 viewDelta = sampleSceneViewPos - viewPos;\n					float minResolution = 0.; // ?\n					float scaledViewDist = length( viewDelta ) / scale;\n					float weight = 1.;\n					float occlusion = max(0., (dot(viewNormal, viewDelta) - minResolution) / scaledViewDist - bias) / (1. + scaledViewDist * scaledViewDist );\n				#else\n					// SSAO\n					float weight = 1.;\n					float occlusion = step(sceneSampleDist + bias, sampleDist);\n				#endif\n\n		#if AO_ALGORITHM == 4\n				}\n				// GTAO\n				vec2 sinHorizons = sqrt(1. - cosHorizons * cosHorizons);\n				float nx = dot(normalInSlice, sliceTangent);\n				float ny = dot(normalInSlice, viewDir);\n				float nxb = 1. / 2. * (acos(cosHorizons.y) - acos(cosHorizons.x) + sinHorizons.x * cosHorizons.x - sinHorizons.y * cosHorizons.y);\n				float nyb = 1. / 2. * (2. - cosHorizons.x * cosHorizons.x - cosHorizons.y * cosHorizons.y);\n				float occlusion = nx * nxb + ny * nyb;\n				ao += occlusion;\n			}\n			ao = clamp(ao / float(DIRECTIONS), 0., 1.);\n		#elif AO_ALGORITHM == 3\n				}\n				totalWeight += 1.;\n				ao += max(0., cosHorizons.x - max(0., cosHorizons.y));\n			}\n			ao /= totalWeight + 1. - step(0., totalWeight);\n			ao = clamp(1. - ao, 0., 1.);\n		#else\n\n				float fallOff = getFallOff(sceneSampleDist - sampleDist, distanceFalloffToUse);\n				occlusion *= fallOff;\n				vec2 diff = (vUv - sampleSceneUvDepth.xy) * resolution;\n				occlusion *= step(1., dot(diff, diff));\n				vec2 clipRangeCheck = step(0., sampleSceneUvDepth.xy) * step(sampleSceneUvDepth.xy, vec2(1.));\n				occlusion *= clipRangeCheck.x * clipRangeCheck.y;\n				weight *= clipRangeCheck.x * clipRangeCheck.y;\n				totalWeight += weight;\n				ao += occlusion;\n			}\n			ao /= totalWeight + 1. - step(0., totalWeight);\n			ao = clamp(1. - ao, 0., 1.);\n		#endif\n\n		#if SCENE_CLIP_BOX == 1\n			ao = mix(ao, 1., smoothstep(0., radiusToUse, boxDistance));\n		#endif\n		#if AO_ALGORITHM != 1\n			ao = pow(ao, scale);\n		#endif\n			gl_FragColor = FRAGMENT_OUTPUT;\n		}"
+}, et = {
+	resolutionScale: 1,
+	algorithm: Xe.SSAO,
+	samples: 32,
+	radius: .25,
+	distanceExponent: 2,
+	thickness: .5,
+	distanceFallOff: .5,
+	scale: 1,
+	bias: .01,
+	screenSpaceRadius: !1
+}, tt = class {
+	get texture() {
+		return this._renderTarget ? this._renderTarget?.texture : null;
+	}
+	constructor(e, t, n, r, i) {
+		this.needsUpdate = !0, this.parameters = { ...et }, this._width = 0, this._height = 0, this._samples = 0, this._gBufferAntiAliasing = !1, this._normalVectorSourceType = Y.FLOAT_BUFFER_NORMAL, this._depthValueSourceType = X.NORMAL_VECTOR_ALPHA, this._modulateRedChannel = !1, this.depthTexture = null, this.normalTexture = null, this._noiseTexture = null, this._renderTarget = null, this._passRenderer = new qe(), this._sceneClipBox = new I(new S(-1, -1, -1), new S(1, 1, 1)), this._sceneScale = 1, this._width = e, this._height = t, this._samples = n, this._gBufferAntiAliasing = r, this._normalVectorSourceType = i?.normalVectorSourceType || Y.FLOAT_BUFFER_NORMAL, this._depthValueSourceType = i?.depthValueSourceType || X.NORMAL_VECTOR_ALPHA, this._modulateRedChannel = i?.modulateRedChannel || !1, i?.aoParameters && (this.parameters = i.aoParameters), i && this.updateTextures(i);
+	}
+	_getNoiseTexture(t = 64) {
+		if (!this._noiseTexture) {
+			let n = new ze(), r = new Uint8Array(t * t * 4);
+			for (let e = 0; e < t; e++) for (let i = 0; i < t; i++) {
+				let a = e, o = i;
+				r[(e * t + i) * 4] = (n.noise(a, o) + 1) * 127.5, r[(e * t + i) * 4 + 1] = (n.noise(a + t, o) + 1) * 127.5, r[(e * t + i) * 4 + 2] = (n.noise(a, o + t) + 1) * 127.5, r[(e * t + i) * 4 + 3] = (n.noise(a + t, o + t) + 1) * 127.5;
+			}
+			this._noiseTexture = new s(r, t, t, R, P), this._noiseTexture.wrapS = e, this._noiseTexture.wrapT = e, this._noiseTexture.needsUpdate = !0;
+		}
+		return this._noiseTexture;
+	}
+	_getMaterial(e, t) {
+		let n = t;
+		return this._aoMaterial || (this._aoMaterial = this._newAoMaterial(), n = !0), n && (this._updateShader(this._aoMaterial, e), this._aoMaterial.needsUpdate = !0), this._updateUniforms(this._aoMaterial, e, n), this._aoMaterial;
+	}
+	_newAoMaterial() {
+		let e = new z({
+			defines: Object.assign({}, $e.defines),
+			uniforms: y.clone($e.uniforms),
+			vertexShader: $e.vertexShader,
+			fragmentShader: $e.fragmentShader,
+			depthTest: !1,
+			depthWrite: !1
+		});
+		return this._modulateRedChannel && (e.blending = 5, e.blendEquation = 103, e.blendEquationAlpha = null, e.blendSrc = 201, e.blendSrcAlpha = null, e.blendDst = 201, e.blendDstAlpha = null), e.defines.FRAGMENT_OUTPUT = this._modulateRedChannel ? "vec4(ao, 1., 1., 1.)" : void 0, e.uniforms.tNoise.value = Ke(5), e;
+	}
+	_updateShader(e, t) {
+		e.defines.PERSPECTIVE_CAMERA = t.isPerspectiveCamera ? 1 : 0, e.defines.SAMPLES = this.parameters.samples, e.defines.SAMPLE_VECTORS = Ze(this.parameters.samples, this.parameters.algorithm === Xe.SSAO), e.defines.NORMAL_VECTOR_TYPE = this._normalVectorSourceType === Y.FLOAT_BUFFER_NORMAL ? 2 : 1, e.defines.DEPTH_SWIZZLING = this._depthValueSourceType === X.NORMAL_VECTOR_ALPHA ? "a" : "x", e.defines.AO_ALGORITHM = this.parameters.algorithm, e.defines.NV_ALIGNED_SAMPLES = this.parameters.algorithm === Xe.HBAO || this.parameters.algorithm === Xe.GTAO ? 0 : 1, e.defines.SCREEN_SPACE_RADIUS = this.parameters.screenSpaceRadius ? 1 : 0, e.defines.SCENE_CLIP_BOX = 1, e.defines.NORMAL_VECTOR_ANTIALIAS = this._gBufferAntiAliasing ? 2 : 0, e.defines.DEPTH_BUFFER_ANTIALIAS = this._gBufferAntiAliasing ? 1 : 0;
+	}
+	_updateUniforms(e, t, n) {
+		let r = this.parameters.screenSpaceRadius ? 1 : this._sceneScale, i = this._depthValueSourceType === X.NORMAL_VECTOR_ALPHA ? this.normalTexture : this.depthTexture;
+		e.uniforms.tNormal.value = this.normalTexture, e.uniforms.tDepth.value = i, e.uniforms.resolution.value.set(this._width, this._height), e.uniforms.cameraProjectionMatrix.value.copy(t.projectionMatrix), e.uniforms.cameraProjectionMatrixInverse.value.copy(t.projectionMatrixInverse), e.uniforms.cameraWorldMatrix.value.copy(t.matrixWorld);
+		let a = t;
+		e.uniforms.cameraNear.value = a.near, e.uniforms.cameraFar.value = a.far, n && (e.uniforms.radius.value = this.parameters.radius * r, e.uniforms.distanceExponent.value = this.parameters.distanceExponent, e.uniforms.thickness.value = this.parameters.thickness * r, e.uniforms.distanceFallOff.value = this.parameters.distanceFallOff, e.uniforms.scale.value = this.parameters.scale, this._sceneClipBox && (e.uniforms.sceneBoxMin.value.copy(this._sceneClipBox.min), e.uniforms.sceneBoxMax.value.copy(this._sceneClipBox.max)));
+	}
+	_getRenderTargets() {
+		return this._renderTarget ||= new u(this._width, this._height, {
+			samples: this._samples,
+			magFilter: this._samples > 1 ? w : p,
+			minFilter: this._samples > 1 ? w : p
+		}), this._renderTarget;
+	}
+	dispose() {
+		this._noiseTexture?.dispose(), this._aoMaterial?.dispose(), this._renderTarget?.dispose();
+	}
+	setSize(e, t) {
+		this._width = e, this._height = t, this._renderTarget?.setSize(e, t), this.needsUpdate = !0;
+	}
+	updateBounds(e, t) {
+		this._sceneClipBox = new I().copy(e), this._sceneScale = t ?? 1, this.needsUpdate = !0;
+	}
+	updateParameters(e) {
+		for (let t in e) this.parameters.hasOwnProperty(t) && (this.parameters[t] = e[t], this.needsUpdate = !0);
+	}
+	updateTextures(e) {
+		e.depthTexture && (this.depthTexture = e.depthTexture, this.needsUpdate = !0), e.normalTexture && (this.normalTexture = e.normalTexture, this.needsUpdate = !0);
+	}
+	clear(e, t) {
+		this._passRenderer.clear(e, t || this._getRenderTargets(), 16777215, 1);
+	}
+	render(e, t, n, r) {
+		let i = this._getMaterial(t, this.needsUpdate);
+		this.needsUpdate = !1, this._passRenderer.renderScreenSpace(e, i, r || this._getRenderTargets());
+	}
+}, nt = {
+	uniforms: {
+		tDiffuse: { value: null },
+		intensity: { value: new m(1, 1) }
+	},
+	vertexShader: "\n          varying vec2 vUv;\n\n          void main() {\n              vUv = uv;\n              gl_Position = (projectionMatrix * modelViewMatrix * vec4(position, 1.0)).xyww;\n          }",
+	fragmentShader: "\n          uniform sampler2D tDiffuse;\n          uniform vec2 intensity;\n          varying vec2 vUv;\n\n          void main() {\n              vec4 textureColor = texture2D(tDiffuse, vUv);\n              vec2 aoAndShadow = vec2(1.0) - intensity + intensity * textureColor.rg;\n              gl_FragColor = vec4(vec3(aoAndShadow.r * aoAndShadow.g), 1.0);\n          }"
+}, rt = class extends z {
+	constructor(e) {
+		super({
+			uniforms: y.clone(nt.uniforms),
+			vertexShader: nt.vertexShader,
+			fragmentShader: nt.fragmentShader,
+			transparent: !0,
+			depthTest: !1,
+			depthWrite: !1,
+			blendSrc: 208,
+			blendDst: 200,
+			blendEquation: 100,
+			blendSrcAlpha: 206,
+			blendDstAlpha: 200,
+			blendEquationAlpha: 100
+		}), this._intensity = new m(1, 1), this.uniforms.intensity.value = this._intensity, this.update(e);
+	}
+	update(e) {
+		return e?.texture !== void 0 && (this.uniforms.tDiffuse.value = e.texture), e?.blending !== void 0 && (this.blending = e.blending), e?.aoIntensity !== void 0 && (this._intensity.x = e.aoIntensity), e?.shadowIntensity !== void 0 && (this._intensity.y = e.shadowIntensity), this;
+	}
+}, it = (e, t, n, r) => {
+	let i = at(e, t, n, r), a = "vec3[SAMPLES](";
+	for (let t = 0; t < e; t++) {
+		let n = i[t];
+		a += `vec3(${n.x}, ${n.y}, ${n.z})${t < e - 1 ? "," : ")"}`;
+	}
+	return a;
+}, at = (e, t, n, r) => {
+	let i = [];
+	for (let a = 0; a < e; a++) {
+		let o = 2 * Math.PI * t * a / e, s = (1 + (n - 1) * (a / (e - 1)) ** r) / n;
+		i.push(new S(Math.cos(o), Math.sin(o), s));
+	}
+	return i;
+}, ot = {
+	name: "PoissonDenoiseShader",
+	defines: {
+		SAMPLES: 16,
+		SAMPLE_VECTORS: it(16, 2.89, 4, 1.3),
+		NV_ALIGNED_SAMPLES: 0,
+		SAMPLE_DISTRIBUTION: 0,
+		DEPTH_VALUE_SOURCE: 0,
+		LUMINANCE_WEIGHTED: 1,
+		LUMINANCE_TYPE: "float",
+		SAMPLE_LUMINANCE: "dot(vec3(0.2125, 0.7154, 0.0721), a)",
+		SCENE_CLIP_BOX: 0,
+		FRAGMENT_OUTPUT: "vec4(vec3(denoised), 1.)"
+	},
+	uniforms: {
+		tDiffuse: { value: null },
+		tNormal: { value: null },
+		tDepth: { value: null },
+		tNoise: { value: null },
+		resolution: { value: new m() },
+		cameraProjectionMatrix: { value: new v() },
+		cameraProjectionMatrixInverse: { value: new v() },
+		cameraWorldMatrix: { value: new v() },
+		lumaPhi: { value: 5 },
+		depthPhi: { value: 1 },
+		normalPhi: { value: 1 },
+		radius: { value: 10 },
+		radiusExponent: { value: 1.3 },
+		iteration: { value: 0 },
+		noOfIterations: { value: 2 },
+		sceneBoxMin: { value: new S(-1, -1, -1) },
+		sceneBoxMax: { value: new S(1, 1, 1) }
+	},
+	vertexShader: "\nvarying vec2 vUv;\nvoid main() {\n    vUv = uv;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",
+	fragmentShader: "\nvarying vec2 vUv;\nuniform sampler2D tDiffuse;\nuniform sampler2D tNormal;\nuniform sampler2D tDepth;\nuniform sampler2D tNoise;\nuniform vec2 resolution;\nuniform mat4 cameraProjectionMatrix;\nuniform mat4 cameraProjectionMatrixInverse;\nuniform mat4 cameraWorldMatrix;\nuniform float lumaPhi;\nuniform float depthPhi;\nuniform float normalPhi;\nuniform float radius;\nuniform float radiusExponent;\nuniform int iteration;\nuniform int noOfIterations;\n#if SCENE_CLIP_BOX == 1\n    uniform vec3 sceneBoxMin;\n    uniform vec3 sceneBoxMax;\n#endif\n\n#include <common>\n#include <packing>\n\n#if LUMINANCE_WEIGHTED == 1  \n\n#ifndef LUMINANCE_TYPE\n#define LUMINANCE_TYPE float\n#endif\n#ifndef SAMPLE_LUMINANCE\n#define SAMPLE_LUMINANCE dot(vec3(0.2125, 0.7154, 0.0721), a)\n#endif\n#define WEIGHT_TYPE LUMINANCE_TYPE\n\n#else\n#define WEIGHT_TYPE float\n#endif\n\n#ifndef FRAGMENT_OUTPUT\n#define FRAGMENT_OUTPUT vec4(vec3(denoised), 1.)\n#endif\n\nLUMINANCE_TYPE getLuminance(const in vec3 a) {\n    return SAMPLE_LUMINANCE;\n}\n\nconst vec3 poissonDisk[SAMPLES] = SAMPLE_VECTORS;\n\nvec3 getViewPosition(const in vec2 screenPosition, const in float depth) {\n    vec4 clipSpacePosition = vec4(vec3(screenPosition, depth) * 2.0 - 1.0, 1.0);\n    vec4 viewSpacePosition = cameraProjectionMatrixInverse * clipSpacePosition;\n    return viewSpacePosition.xyz / viewSpacePosition.w;\n}\n\nfloat getDepth(const vec2 uv) {\n#if DEPTH_VALUE_SOURCE == 1    \n    return textureLod(tDepth, uv.xy, 0.0).a;\n#else\n    return textureLod(tDepth, uv.xy, 0.0).r;\n#endif\n}\n\nfloat fetchDepth(const ivec2 uv) {\n#if DEPTH_VALUE_SOURCE == 1    \n    return texelFetch(tDepth, uv.xy, 0).a;\n#else\n    return texelFetch(tDepth, uv.xy, 0).r;\n#endif\n}\n\nvec3 computeNormalFromDepth(const vec2 uv) {\n    vec2 size = vec2(textureSize(tDepth, 0));\n    ivec2 p = ivec2(uv * size);\n    float c0 = fetchDepth(p);\n    float l2 = fetchDepth(p - ivec2(2, 0));\n    float l1 = fetchDepth(p - ivec2(1, 0));\n    float r1 = fetchDepth(p + ivec2(1, 0));\n    float r2 = fetchDepth(p + ivec2(2, 0));\n    float b2 = fetchDepth(p - ivec2(0, 2));\n    float b1 = fetchDepth(p - ivec2(0, 1));\n    float t1 = fetchDepth(p + ivec2(0, 1));\n    float t2 = fetchDepth(p + ivec2(0, 2));\n    float dl = abs((2.0 * l1 - l2) - c0);\n    float dr = abs((2.0 * r1 - r2) - c0);\n    float db = abs((2.0 * b1 - b2) - c0);\n    float dt = abs((2.0 * t1 - t2) - c0);\n    vec3 ce = getViewPosition(uv, c0).xyz;\n    vec3 dpdx = (dl < dr) ?  ce - getViewPosition((uv - vec2(1.0 / size.x, 0.0)), l1).xyz\n                : -ce + getViewPosition((uv + vec2(1.0 / size.x, 0.0)), r1).xyz;\n    vec3 dpdy = (db < dt) ?  ce - getViewPosition((uv - vec2(0.0, 1.0 / size.y)), b1).xyz\n                : -ce + getViewPosition((uv + vec2(0.0, 1.0 / size.y)), t1).xyz;\n    return normalize(cross(dpdx, dpdy));\n}\n\nvec3 getViewNormal(const vec2 uv) {\n#if NORMAL_VECTOR_TYPE == 2\n    return normalize(textureLod(tNormal, uv, 0.).rgb);\n#elif NORMAL_VECTOR_TYPE == 1\n    return unpackRGBToNormal(textureLod(tNormal, uv, 0.).rgb);\n#else\n    return computeNormalFromDepth(uv);\n#endif\n}\n\nvoid denoiseSample(in vec3 center, in vec3 viewNormal, in vec3 viewPos, in vec2 sampleUv, inout vec3 denoised, inout WEIGHT_TYPE totalWeight) {\n    vec4 sampleTexel = textureLod(tDiffuse, sampleUv, 0.0);\n    float sampleDepth = getDepth(sampleUv);\n    vec3 sampleNormal = getViewNormal(sampleUv);\n    vec3 neighborColor = sampleTexel.rgb;\n    vec3 viewPosSample = getViewPosition(sampleUv, sampleDepth);\n    \n    float normalDiff = dot(viewNormal, sampleNormal);\n    float normalSimilarity = pow(max(normalDiff, 0.), normalPhi);\n    float depthDiff = abs(dot(normalize(viewPos - viewPosSample), viewNormal));\n    float depthSimilarity = max(1. - depthDiff / depthPhi, 0.);\n    #if LUMINANCE_WEIGHTED == 1  \n      LUMINANCE_TYPE lumaDiff = abs(getLuminance(neighborColor) - getLuminance(center));\n      LUMINANCE_TYPE lumaSimilarity = max(1. - lumaDiff / lumaPhi, 0.);\n      LUMINANCE_TYPE w = lumaSimilarity * depthSimilarity * normalSimilarity;\n    #else\n      WEIGHT_TYPE w = depthSimilarity * normalSimilarity;\n    #endif\n\n    denoised += w * neighborColor;\n    totalWeight += w;\n}\n\nvoid main() {\n    float depth = fetchDepth(ivec2(vec2(textureSize(tDepth, 0)) * vUv.xy));	\n    vec3 viewNormal = getViewNormal(vUv);	\n    if (depth == 1. || dot(viewNormal, viewNormal) == 0.) {\n        discard;\n        return;\n    }\n    vec4 texel = textureLod(tDiffuse, vUv, 0.0);\n    vec3 center = texel.rgb;\n    vec3 viewPos = getViewPosition(vUv, depth);\n\n    #if SCENE_CLIP_BOX == 1\n      vec3 worldPos = (cameraWorldMatrix * vec4(viewPos, 1.0)).xyz;\n          float boxDistance = length(max(vec3(0.0), max(sceneBoxMin - worldPos, worldPos - sceneBoxMax)));\n      if (boxDistance > radius * 2.) {\n        discard;\n        return;\n      }\n		#endif\n\n    vec2 noiseResolution = vec2(textureSize(tNoise, 0));\n    vec2 noiseUv = vUv * resolution / noiseResolution;\n    vec4 noiseTexel = textureLod(tNoise, noiseUv, 0.0);\n    vec2 noiseVec = vec2(sin(noiseTexel[iteration % 4] * 2. * PI), cos(noiseTexel[iteration % 4] * 2. * PI));\n    #if SAMPLE_DISTRIBUTION == 1\n      vec3 randomVec = normalize(vec3(noiseVec.xy, 0.));\n      vec3 tangent = normalize(randomVec - viewNormal * dot(randomVec, viewNormal));\n      vec3 bitangent = cross(viewNormal, tangent);\n      mat3 kernelMatrix = mat3(tangent, bitangent, viewNormal);\n    #else\n      mat2 rotationMatrix = mat2(noiseVec.x, -noiseVec.y, noiseVec.x, noiseVec.y);\n    #endif\n\n    WEIGHT_TYPE totalWeight = WEIGHT_TYPE(1.);\n    vec3 denoised = texel.rgb;\n    for (int i = 0; i < SAMPLES; i++) {\n        vec3 sampleDir = poissonDisk[i];\n    #if SAMPLE_DISTRIBUTION == 1\n        vec3 offsetViewPos = viewPos + normalize(kernelMatrix * vec3(sampleDir.xy, 0.)) * sampleDir.z * radius * radius;\n        vec4 samplePointNDC = cameraProjectionMatrix * vec4(offsetViewPos, 1.0); \n        vec2 sampleUv = (samplePointNDC.xy / samplePointNDC.w * 0.5 + 0.5);\n    #else\n        vec2 offset = rotationMatrix * sampleDir.xy * (1. + sampleDir.z * (radius - 1.));\n        offset *= mix(vec2(1.0), sqrt(1.0 - viewNormal.xy * viewNormal.xy), float(iteration) / float(noOfIterations-1));\n        offset *= max(1.0, 1.0 / length(offset));\n        vec2 sampleUv = vUv + offset / resolution;\n    #endif\n        denoiseSample(center, viewNormal, viewPos, sampleUv, denoised, totalWeight);\n    }\n\n    denoised /= totalWeight + 1.0 - step(0.0, totalWeight);\n    gl_FragColor = FRAGMENT_OUTPUT;\n}"
+}, st = {
+	iterations: 2,
+	samples: 16,
+	rings: 2.89,
+	radiusExponent: 1.3,
+	radius: 4,
+	lumaPhi: 10,
+	depthPhi: 2.5,
+	normalPhi: .5,
+	nvOrientatedSamples: !1
+}, ct = class {
+	get texture() {
+		return this.parameters.iterations > 0 && this._renderTargets.length > 0 ? this._renderTargets[this._outputRenderTargetIndex].texture : this._inputTexture;
+	}
+	set inputTexture(e) {
+		this._inputTexture = e;
+	}
+	constructor(e, t, n, r) {
+		this.needsUpdate = !0, this.parameters = { ...st }, this._width = 0, this._height = 0, this._samples = 0, this._normalVectorSourceType = Y.FLOAT_BUFFER_NORMAL, this._depthValueSourceType = X.NORMAL_VECTOR_ALPHA, this._inputTexture = null, this.depthTexture = null, this.normalTexture = null, this._noiseTexture = null, this._renderTargets = [], this._outputRenderTargetIndex = 0, this._passRenderer = new qe(), this._rgInputTexture = !1, this._luminanceWeighted = !0, this._width = e, this._height = t, this._samples = n, this._normalVectorSourceType = r?.normalVectorSourceType || Y.FLOAT_BUFFER_NORMAL, this._depthValueSourceType = r?.depthValueSourceType || X.NORMAL_VECTOR_ALPHA, this._inputTexture = r?.inputTexture || null, this.depthTexture = r?.depthTexture || null, this.normalTexture = r?.normalTexture || null, this._rgInputTexture = r?.rgInputTexture || !1, this._luminanceWeighted = r?.luminanceWeighted === !0, this._luminanceType = r?.luminanceType || "vec3", this._sampleLuminance = r?.sampleLuminance || "a", this._fragmentOutput = r?.fragmentOutput || "vec4(denoised.xyz, 1.)", r?.poissonDenoisePassParameters && (this.parameters = r.poissonDenoisePassParameters), r && this.updateTextures(r);
+	}
+	_getNoiseTexture(t = 64) {
+		if (!this._noiseTexture) {
+			let n = new ze(), r = new Uint8Array(t * t * 4);
+			for (let e = 0; e < t; e++) for (let i = 0; i < t; i++) {
+				let a = e, o = i;
+				r[(e * t + i) * 4] = (n.noise(a, o) + 1) * 127.5, r[(e * t + i) * 4 + 1] = (n.noise(a + t, o) + 1) * 127.5, r[(e * t + i) * 4 + 2] = (n.noise(a, o + t) + 1) * 127.5, r[(e * t + i) * 4 + 3] = (n.noise(a + t, o + t) + 1) * 127.5;
+			}
+			this._noiseTexture = new s(r, t, t, R, P), this._noiseTexture.wrapS = e, this._noiseTexture.wrapT = e, this._noiseTexture.needsUpdate = !0;
+		}
+		return this._noiseTexture;
+	}
+	_getMaterial(e, t) {
+		let n = t;
+		return this._pdMaterial || (this._pdMaterial = new z({
+			defines: Object.assign({}, ot.defines),
+			uniforms: y.clone(ot.uniforms),
+			vertexShader: ot.vertexShader,
+			fragmentShader: ot.fragmentShader,
+			depthTest: !1,
+			depthWrite: !1
+		}), this._pdMaterial.uniforms.tNoise.value = this._getNoiseTexture(), n = !0), n && this._updateShader(this._pdMaterial), this._updateUniforms(this._pdMaterial, e, n), this._pdMaterial;
+	}
+	_updateShader(e) {
+		e.defines.SAMPLES = this.parameters.samples, e.defines.SAMPLE_VECTORS = it(this.parameters.samples, this.parameters.rings, this.parameters.radius, this.parameters.radiusExponent), e.defines.SAMPLE_DISTRIBUTION = this.parameters.nvOrientatedSamples ? 1 : 0, e.defines.NORMAL_VECTOR_TYPE = this._normalVectorSourceType === Y.FLOAT_BUFFER_NORMAL ? 2 : 1, e.defines.DEPTH_VALUE_SOURCE = this._depthValueSourceType === X.NORMAL_VECTOR_ALPHA ? 1 : 0, e.needsUpdate = !0, e.defines.LUMINANCE_WEIGHTED = this._luminanceWeighted ? 1 : 0, e.defines.LUMINANCE_TYPE = this._luminanceType, e.defines.SAMPLE_LUMINANCE = this._sampleLuminance, e.defines.FRAGMENT_OUTPUT = this._fragmentOutput, e.defines.SCENE_CLIP_BOX = this._sceneClipBox ? 1 : 0, e.needsUpdate = !0;
+	}
+	_updateUniforms(e, t, n) {
+		let r = this._depthValueSourceType === X.NORMAL_VECTOR_ALPHA ? this.normalTexture : this.depthTexture;
+		e.uniforms.tDiffuse.value = this._inputTexture, e.uniforms.tNormal.value = this.normalTexture, e.uniforms.tDepth.value = r, e.uniforms.resolution.value.set(this._width, this._height), e.uniforms.cameraProjectionMatrix.value.copy(t.projectionMatrix), e.uniforms.cameraProjectionMatrixInverse.value.copy(t.projectionMatrixInverse), e.uniforms.cameraWorldMatrix.value.copy(t.matrixWorld), n && (e.uniforms.lumaPhi.value = this.parameters.lumaPhi, e.uniforms.depthPhi.value = this.parameters.depthPhi, e.uniforms.normalPhi.value = this.parameters.normalPhi, e.uniforms.radius.value = this.parameters.radius, e.uniforms.radiusExponent.value = this.parameters.radiusExponent, this._sceneClipBox && (e.uniforms.sceneBoxMin.value.copy(this._sceneClipBox.min), e.uniforms.sceneBoxMax.value.copy(this._sceneClipBox.max)));
+	}
+	_getRenderTargets() {
+		return this._renderTargets.length < 2 && (this._renderTargets = [new u(this._width, this._height, {
+			samples: this._samples,
+			format: R,
+			type: O,
+			magFilter: p,
+			minFilter: p
+		}), new u(this._width, this._height, {
+			samples: this._samples,
+			format: R,
+			type: O,
+			magFilter: p,
+			minFilter: p
+		})]), this._renderTargets;
+	}
+	dispose() {
+		this._noiseTexture?.dispose(), this._pdMaterial?.dispose(), this._renderTargets.forEach((e) => e.dispose());
+	}
+	setSize(e, t) {
+		this._width = e, this._height = t, this._renderTargets.forEach((n) => n.setSize(e, t)), this.needsUpdate = !0;
+	}
+	updateBounds(e) {
+		this._sceneClipBox = new I().copy(e), this.needsUpdate = !0;
+	}
+	updateParameters(e) {
+		for (let t in e) this.parameters.hasOwnProperty(t) && (this.parameters[t] = e[t], this.needsUpdate = !0);
+	}
+	updateTextures(e) {
+		e.inputTexture && (this._inputTexture = e.inputTexture, this.needsUpdate = !0), e.depthTexture && (this.depthTexture = e.depthTexture, this.needsUpdate = !0), e.normalTexture && (this.normalTexture = e.normalTexture, this.needsUpdate = !0);
+	}
+	render(e, t) {
+		let n = this._getMaterial(t, this.needsUpdate);
+		this.needsUpdate = !1;
+		let r = this._getRenderTargets();
+		n.uniforms.iteration.value = this.parameters.iterations;
+		for (let t = 0; t < this.parameters.iterations; t++) {
+			let i = r[(t + 1) % 2];
+			this._outputRenderTargetIndex = t % 2;
+			let a = r[this._outputRenderTargetIndex];
+			n.uniforms.tDiffuse.value = t === 0 ? this._inputTexture : i.texture, n.uniforms.iteration.value = t, this._passRenderer.renderScreenSpace(e, n, a, 16777215, 1);
+		}
+	}
+	renderToTarget(e, t, n) {
+		let r = this._getMaterial(t, this.needsUpdate);
+		this.needsUpdate = !1, this._passRenderer.renderScreenSpace(e, r, n, 16777215, 1);
+	}
+}, Z = {
+	OFF: "off",
+	HARD: "hard",
+	POISSON: "poisson",
+	FULL: "full"
+}, lt = { shadowRadius: .05 }, Q = {
+	enabled: !0,
+	applyToMaterial: !0,
+	aoIntensity: .5,
+	shadowIntensity: .35,
+	aoOnGround: !0,
+	shadowOnGround: !1,
+	alwaysUpdate: !1,
+	progressiveDenoiseIterations: 0
+}, ut = class extends J {
+	static {
+		this.shadowTransform = new v().set(0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1);
+	}
+	get aoAndSoftShadowRenderTarget() {
+		return this._aoAndSoftShadowRenderTarget = this._aoAndSoftShadowRenderTarget ?? new u(this._width, this._height, {
+			samples: this._samples,
+			format: 1030,
+			magFilter: this._samples > 1 ? 1006 : 1003,
+			minFilter: this._samples > 1 ? 1006 : 1003
+		}), this._aoAndSoftShadowRenderTarget;
+	}
+	get aoRenderPass() {
+		return this._aoPass ||= new tt(this._width, this._height, this._samples, !this.parameters.applyToMaterial, {
+			normalVectorSourceType: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? Y.FLOAT_BUFFER_NORMAL : Y.INPUT_RGB_NORMAL,
+			depthValueSourceType: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? X.NORMAL_VECTOR_ALPHA : X.SEPARATE_BUFFER,
+			modulateRedChannel: !0,
+			aoParameters: this.parameters.ao
+		}), this._aoPass;
+	}
+	get softShadowPass() {
+		if (!this._softShadowPass) this._softShadowPass = new ct(this._width, this._height, this._samples, {
+			inputTexture: void 0,
+			depthTexture: this.gBufferTextures.depthBufferTexture,
+			normalTexture: this.gBufferTextures.gBufferTexture,
+			normalVectorSourceType: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? Y.FLOAT_BUFFER_NORMAL : Y.INPUT_RGB_NORMAL,
+			depthValueSourceType: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? X.NORMAL_VECTOR_ALPHA : X.SEPARATE_BUFFER,
+			rgInputTexture: !0,
+			luminanceWeighted: !1,
+			fragmentOutput: "vec4(1.0, denoised.x, 0.0, 1.0)",
+			poissonDenoisePassParameters: {
+				iterations: 1,
+				samples: 16,
+				rings: 2.89,
+				radiusExponent: 1,
+				radius: this.parameters.shadow.shadowRadius,
+				lumaPhi: 10,
+				depthPhi: .1,
+				normalPhi: 4,
+				nvOrientatedSamples: !0
+			}
+		});
+		else {
+			let e = this._softShadowPass;
+			e.depthTexture = this.gBufferTextures.depthBufferTexture, e.normalTexture = this.gBufferTextures.gBufferTexture;
+		}
+		return this._softShadowPass;
+	}
+	get fadeRenderTarget() {
+		return this._fadeRenderTarget = this._fadeRenderTarget ?? new u(this._width, this._height, {
+			samples: this._samples,
+			format: 1030,
+			magFilter: this._samples > 1 ? 1006 : 1003,
+			minFilter: this._samples > 1 ? 1006 : 1003
+		}), this._fadeRenderTarget;
+	}
+	get denoisePass() {
+		if (!this._poissonDenoisePass) this._poissonDenoisePass = new ct(this._width, this._height, this._samples, {
+			inputTexture: this.aoAndSoftShadowRenderTarget.texture,
+			depthTexture: this.gBufferTextures.depthBufferTexture,
+			normalTexture: this.gBufferTextures.gBufferTexture,
+			normalVectorSourceType: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? Y.FLOAT_BUFFER_NORMAL : Y.INPUT_RGB_NORMAL,
+			depthValueSourceType: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? X.NORMAL_VECTOR_ALPHA : X.SEPARATE_BUFFER,
+			rgInputTexture: !0,
+			luminanceWeighted: !1,
+			fragmentOutput: "vec4(denoised.xy, vec2(fract(depth * 1024.0), floor(depth * 1024.0)))",
+			poissonDenoisePassParameters: this.parameters.poissonDenoise
+		});
+		else {
+			let e = this._poissonDenoisePass;
+			e.depthTexture = this.gBufferTextures.depthBufferTexture, e.normalTexture = this.gBufferTextures.gBufferTexture;
+		}
+		return this._poissonDenoisePass;
+	}
+	get denoiseRenderTargetTexture() {
+		return this.denoisePass ? this.denoisePass.texture : null;
+	}
+	get finalTexture() {
+		return this._finalTexture;
+	}
+	constructor(e, t, n, r, i) {
+		super(e), this.needsUpdate = !0, this.renderToRenderTarget = !1, this.shadowAndAoPassSettings = {
+			shadowMapTexture: null,
+			shadowBlurType: Z.FULL,
+			shadowFadeInBlurType: Z.FULL,
+			shadowFadeInMix: 0,
+			noOStaticFrames: 0
+		}, this._cameraUpdate = new We(), this._finalTexture = null, this._onlyHardShadow = !1, this._width = t, this._height = n, this._samples = r, this.parameters = {
+			enabled: i?.enabled ?? Q.enabled,
+			applyToMaterial: i?.applyToMaterial ?? Q.applyToMaterial,
+			aoIntensity: i?.aoIntensity ?? Q.aoIntensity,
+			shadowIntensity: i?.shadowIntensity ?? Q.shadowIntensity,
+			aoOnGround: i?.aoOnGround ?? Q.aoOnGround,
+			shadowOnGround: i?.shadowOnGround ?? Q.shadowOnGround,
+			alwaysUpdate: i?.alwaysUpdate ?? Q.alwaysUpdate,
+			progressiveDenoiseIterations: i?.progressiveDenoiseIterations ?? Q.progressiveDenoiseIterations,
+			shadow: { ...lt },
+			ao: { ...et },
+			poissonDenoise: { ...st }
+		}, this._copyMaterial = new Ae(), this._blendMaterial = new Ae({}, ke.DEFAULT), this._blendAoAndShadowMaterial = new rt();
+	}
+	dispose() {
+		super.dispose(), this._aoAndSoftShadowRenderTarget?.dispose(), this._softShadowPass?.dispose(), this._aoPass?.dispose(), this._fadeRenderTarget?.dispose(), this._poissonDenoisePass?.dispose(), this._copyMaterial?.dispose(), this._blendMaterial?.dispose(), this._blendAoAndShadowMaterial?.dispose();
+	}
+	setSize(e, t) {
+		this._width = e, this._height = t, this._aoAndSoftShadowRenderTarget?.setSize(e, t), this._softShadowPass?.setSize(e, t), this._aoPass?.setSize(e, t), this._fadeRenderTarget?.setSize(e, t), this._poissonDenoisePass?.setSize(this._width, this._height), this.needsUpdate = !0;
+	}
+	updateParameters(e) {
+		e.enabled !== void 0 && (this.parameters.enabled = e.enabled), e.applyToMaterial !== void 0 && (this.parameters.applyToMaterial = e.applyToMaterial), e.aoIntensity !== void 0 && (this.parameters.aoIntensity = e.aoIntensity), e.shadowIntensity !== void 0 && (this.parameters.shadowIntensity = e.shadowIntensity), e.aoOnGround !== void 0 && (this.parameters.aoOnGround = e.aoOnGround), e.shadowOnGround !== void 0 && (this.parameters.shadowOnGround = e.shadowOnGround), e.alwaysUpdate !== void 0 && (this.parameters.alwaysUpdate = e.alwaysUpdate), this._updatePassParameters(e);
+	}
+	_updatePassParameters(e) {
+		if (e?.shadow) {
+			for (let t in e.shadow) this.parameters.shadow.hasOwnProperty(t) && (this.parameters.shadow[t] = e.shadow[t]);
+			this._softShadowPass && (this._softShadowPass.needsUpdate = !0);
+		}
+		if (e?.ao) {
+			for (let t in e.ao) this.parameters.ao.hasOwnProperty(t) && (this.parameters.ao[t] = e.ao[t]);
+			this._aoPass && this._aoPass?.updateParameters(e?.ao);
+		}
+		if (e?.poissonDenoise) if (this._poissonDenoisePass) this._poissonDenoisePass?.updateParameters(e?.poissonDenoise);
+		else for (let t in e.poissonDenoise) this.parameters.poissonDenoise.hasOwnProperty(t) && (this.parameters.poissonDenoise[t] = e.poissonDenoise[t]);
+	}
+	updateBounds(e, t) {
+		this._softShadowPass?.updateBounds(e.bounds), this._aoPass?.updateBounds(e.bounds, t);
+	}
+	_getRenderConditions(e = Z.FULL, t = 0, n = 0) {
+		let r = e === Z.POISSON && t > .001, i = e === Z.HARD && t > .001 && t < .999;
+		return {
+			fadeInPoissonShadow: r,
+			fadeInHardShadow: i,
+			onlyHardShadow: e === Z.HARD && !i,
+			progressiveDenoise: !r && !i && n > 1 && n <= this.parameters.progressiveDenoiseIterations + 1
+		};
+	}
+	renderPass(e) {
+		if (!this._setRenderState()) return;
+		let t = this._getRenderConditions(this.shadowAndAoPassSettings.shadowFadeInBlurType, this.shadowAndAoPassSettings.shadowFadeInMix, this.shadowAndAoPassSettings.noOStaticFrames), n = !1;
+		!t.onlyHardShadow && this.shadowAndAoPassSettings.shadowBlurType === Z.FULL && this._evaluateIfUpdateIsNeeded(this.camera) && (this._renderShadowAndAo(e, this.scene, this.camera, this.shadowAndAoPassSettings.shadowMapTexture), n = !0);
+		let r = t.onlyHardShadow ? this.shadowAndAoPassSettings.shadowMapTexture : this.denoiseRenderTargetTexture;
+		t.fadeInPoissonShadow && (r = this._renderDynamicShadow(e, this.aoAndSoftShadowRenderTarget.texture, this.shadowAndAoPassSettings.shadowMapTexture, this.shadowAndAoPassSettings.shadowFadeInMix), n = !0), n ? r = this._renderDenoise(e, this.camera, t.fadeInPoissonShadow, !1) : t.progressiveDenoise && (r = this._renderDenoise(e, this.camera, !1, !0)), t.fadeInHardShadow && (r = this._renderDynamicShadow(e, this.denoiseRenderTargetTexture, this.shadowAndAoPassSettings.shadowMapTexture, this.shadowAndAoPassSettings.shadowFadeInMix)), this._finalTexture = r, this._onlyHardShadow = t.onlyHardShadow, this.renderToRenderTarget && this.renderToTarget(e);
+	}
+	_setRenderState() {
+		return !this.parameters.enabled || !(this.parameters.ao.algorithm !== null || this.parameters.shadowIntensity >= .01) ? !1 : (this.needsUpdate && (this._aoPass && (this._aoPass.needsUpdate = !0), this._poissonDenoisePass && (this._poissonDenoisePass.needsUpdate = !0)), !0);
+	}
+	_evaluateIfUpdateIsNeeded(e) {
+		e.updateProjectionMatrix();
+		let t = this.parameters.alwaysUpdate || this.needsUpdate || e != null && this._cameraUpdate.changed(e);
+		return this.needsUpdate = !1, t;
+	}
+	_renderShadowAndAo(e, t, n, r) {
+		let i = this.parameters.ao.algorithm !== null && this.parameters.aoIntensity > .01;
+		i || this._aoPass?.clear(e, this.aoAndSoftShadowRenderTarget), this._renderSoftShadow(e, n, r), i && this._renderAo(e, t, n);
+	}
+	_renderAo(e, t, n) {
+		let r = this.gBufferTextures.depthBufferTexture, i = this.gBufferTextures.gBufferTexture, a = this._aoAndSoftShadowRenderTarget, o = e.autoClear;
+		e.autoClear = !1;
+		let s = this.aoRenderPass;
+		s.depthTexture = r, s.normalTexture = i, s.render(e, n, t, a), e.autoClear = o;
+	}
+	_renderSoftShadow(e, t, n) {
+		let r = this.softShadowPass;
+		r.parameters.radius = this.parameters.shadow.shadowRadius, r.inputTexture = n, this.softShadowPass.renderToTarget(e, t, this.aoAndSoftShadowRenderTarget);
+	}
+	_renderDynamicShadow(e, t, n, r = 1) {
+		let i = r < .999;
+		return i && (this._copyMaterial.update({
+			texture: t,
+			blending: 0,
+			colorTransform: Te,
+			colorBase: W,
+			multiplyChannels: 0
+		}), this.passRenderer.renderScreenSpace(e, this._copyMaterial, this.fadeRenderTarget)), r > .001 && (this._blendMaterial.update({
+			texture: n,
+			blending: i ? 5 : 0,
+			colorTransform: new v().set(0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, i ? r : 1),
+			multiplyChannels: 0
+		}), this.passRenderer.renderScreenSpace(e, this._blendMaterial, this.fadeRenderTarget)), this.fadeRenderTarget.texture;
+	}
+	_renderDenoise(e, t, n, r) {
+		let i = this.denoisePass;
+		return i.inputTexture = n ? this.fadeRenderTarget.texture : r ? i.texture : this.aoAndSoftShadowRenderTarget.texture, i.render(e, t), i.texture;
+	}
+	renderToTarget(e) {
+		let t = this._onlyHardShadow ? this.parameters.shadowIntensity : this.parameters.aoIntensity, n = this._onlyHardShadow ? 0 : this.parameters.shadowIntensity;
+		this.passRenderer.renderScreenSpace(e, this._blendAoAndShadowMaterial.update({
+			texture: this._finalTexture,
+			blending: 5,
+			aoIntensity: t,
+			shadowIntensity: n
+		}), e.getRenderTarget());
+	}
+}, dt = class {
+	get isOutlinePassActivated() {
+		return this.outlinePassActivated;
+	}
+	get outlinePass() {
+		return this._renderPassManager.outlinePass;
+	}
+	constructor(e, t, n) {
+		this._effectComposer = null, this.outlinePassActivated = !1, this._renderPassManager = e, this._effectComposer = t, this.parameters = {
+			enabled: !0,
+			edgeStrength: 2,
+			edgeGlow: 1,
+			edgeThickness: 2,
+			pulsePeriod: 0,
+			usePatternTexture: !1,
+			visibleEdgeColor: 16777215,
+			hiddenEdgeColor: 16777215,
+			...n
+		};
+	}
+	updateParameters(e) {
+		for (let t in e) this.parameters.hasOwnProperty(t) && (this.parameters[t] = e[t]);
+	}
+	applyParameters() {
+		this.outlinePass && (this.outlinePass.edgeStrength = this.parameters.edgeStrength, this.outlinePass.edgeGlow = this.parameters.edgeGlow, this.outlinePass.edgeThickness = this.parameters.edgeThickness, this.outlinePass.pulsePeriod = this.parameters.pulsePeriod, this.outlinePass.usePatternTexture = this.parameters.usePatternTexture, this.outlinePass.visibleEdgeColor.set(this.parameters.visibleEdgeColor), this.outlinePass.hiddenEdgeColor.set(this.parameters.hiddenEdgeColor));
+	}
+	activateOutline(e, t) {
+		if (!this.parameters.enabled) {
+			this.deactivateOutline();
+			return;
+		}
+		let n = this.outlinePass?.renderCamera && t.isPerspectiveCamera !== this.outlinePass.renderCamera.isPerspectiveCamera;
+		this.outlinePass && (this.outlinePass.renderScene = e, this.outlinePass.renderCamera = t), !(!n && this.outlinePassActivated) && ((n || !this.outlinePass) && this._renderPassManager.createOutlinePass(), this.applyParameters(), this._effectComposer && this._effectComposer.addPass(this.outlinePass), this.outlinePassActivated = !0);
+	}
+	deactivateOutline() {
+		this.outlinePassActivated &&= (this.outlinePass && this._effectComposer && this._effectComposer.removePass(this.outlinePass), !1);
+	}
+	updateOutline(e, t, n) {
+		n.length > 0 ? (this.activateOutline(e, t), this.outlinePass && (this.outlinePass.selectedObjects = n)) : this.deactivateOutline();
+	}
+}, ft = {
+	DEFAULT: "default",
+	BRIGHT: "bright"
+}, pt = {
+	shadowType: "PCFShadowMap",
+	shAndAoPassParameters: {
+		aoIntensity: .3,
+		shadow: { shadowRadius: .1 },
+		ao: {
+			algorithm: Xe.SSAO,
+			samples: 32,
+			radius: .02,
+			distanceExponent: 2,
+			thickness: .1,
+			distanceFallOff: 1,
+			bias: .01
+		},
+		poissonDenoise: {
+			iterations: 2,
+			samples: 16,
+			rings: 2.89,
+			radius: 4,
+			radiusExponent: 1.3,
+			depthPhi: 2.5,
+			normalPhi: .5
+		}
+	},
+	groundReflectionParameters: { brightness: .5 }
+}, mt = (...e) => {
+	if (e.length === 0) return null;
+	if (e.length === 1) return e[0];
+	let t = e[0];
+	for (let n = 1; n < e.length; n++) t = de(t, e[n]);
+	return t;
+}, ht = (e) => e ? { groundReflectionParameters: { enabled: !1 } } : null, gt = (e) => !e || e === ft.DEFAULT ? null : e === ft.BRIGHT ? pt : null, $ = (e) => Math.max(0, Math.min(1, e)), _t = (e) => {
+	let t = {
+		shAndAoPassParameters: {
+			ao: {},
+			shadow: {}
+		},
+		groundReflectionParameters: {},
+		bakedGroundContactShadowParameters: {}
+	};
+	return vt(t, e), yt(t, e), bt(t, e), t;
+}, vt = (e, t) => {
+	t.aoIntensity !== void 0 && (e.shAndAoPassParameters.aoIntensity = $(t.aoIntensity)), t.aoExtent !== void 0 && (e.shAndAoPassParameters.ao.radius = $(t.aoExtent) * .3, e.shAndAoPassParameters.ao.thickness = .1 + $(t.aoExtent) * .2);
+}, yt = (e, t) => {
+	t.shBakedOnGround ? (e.bakedGroundContactShadowParameters.enabled = !0, e.shAndAoPassParameters.shadowIntensity = 0, t.shadowIntensity !== void 0 && (e.bakedGroundContactShadowParameters.opacity = $(t.shadowIntensity)), t.shadowIntensity !== void 0 && (e.bakedGroundContactShadowParameters.blurMax = $(t.shadowIntensity) * .1, e.bakedGroundContactShadowParameters.blurMin = e.bakedGroundContactShadowParameters.blurMax * .01)) : (t.shBakedOnGround !== void 0 && (e.bakedGroundContactShadowParameters.enabled = !1), t.shadowIntensity !== void 0 && (e.shAndAoPassParameters.shadowIntensity = $(t.shadowIntensity)), t.shadowSoftening !== void 0 && (e.shAndAoPassParameters.shadow.shadowRadius = .001 + $(t.shadowSoftening) * .2));
+}, bt = (e, t) => {
+	t.grReflectIntensity !== void 0 && (e.groundReflectionParameters.enabled = t.grReflectIntensity > 0, e.groundReflectionParameters.intensity = $(t.grReflectIntensity)), t.grReflectFadeOut !== void 0 && (e.groundReflectionParameters.fadeOutDistance = (1 - $(t.grReflectFadeOut)) * 4);
+}, xt = (e, t) => Array.isArray(e) ? e.some((e) => xt(e, t)) : e.transparent && e.opacity < t || e.alphaTest > 0, St = (e) => Array.isArray(e) ? e.some((e) => St(e)) : e instanceof d && e.transmission > 0, Ct = class {
+	constructor(e) {
+		this.needsUpdate = !0, this._cache = null, this._cache = e;
+	}
+	dispose() {
+		this._cache?.dispose();
+	}
+	clear() {
+		this._cache?.clear(), this.needsUpdate = !0;
+	}
+	update(e) {
+		!this.needsUpdate || !this._cache || (e.traverse((e) => {
+			e.isLine || e.isPoints ? this._cache?.addLineOrPoint(e) : e.isMesh ? this._cache?.addMesh(e) : this._cache?.addObject(e);
+		}), this.needsUpdate = !1);
+	}
+	onBeforeRender() {
+		this._cache?.onBeforeRender();
+	}
+	onAfterRender() {
+		this._cache?.onAfterRender();
+	}
+}, wt = class {
+	constructor() {
+		this._cacheMap = /* @__PURE__ */ new Map();
+	}
+	dispose() {
+		this._cacheMap.forEach((e) => {
+			e.dispose();
+		});
+	}
+	registerCache(e, t) {
+		this._cacheMap.set(e, new Ct(t));
+	}
+	clearCache() {
+		this._cacheMap.forEach((e) => {
+			e.clear();
+		});
+	}
+	clearObjectCache(e) {
+		let t = this._cacheMap.get(e);
+		t && t.clear();
+	}
+	onBeforeRender(e, t) {
+		let n = this._cacheMap.get(e);
+		n && (n.update(t), n.onBeforeRender());
+	}
+	onAfterRender(e) {
+		let t = this._cacheMap.get(e);
+		t && t.onAfterRender();
+	}
+	render(e, t, n) {
+		let r = this._cacheMap.get(e);
+		r && (r.update(t), r.onBeforeRender()), n(), r && r.onAfterRender();
+	}
+}, Tt = class {
+	constructor(e) {
+		this._visibilityCache = /* @__PURE__ */ new Map(), this._isObjectInvisible = e;
+	}
+	dispose() {
+		this._visibilityCache.clear();
+	}
+	clear() {
+		this._visibilityCache.clear();
+	}
+	addLineOrPoint(e) {
+		this._visibilityCache.set(e, e.visible);
+	}
+	addMesh(e) {
+		this._isObjectInvisible && this._isObjectInvisible(e) && this._visibilityCache.set(e, e.visible);
+	}
+	addObject(e) {
+		this._isObjectInvisible && this._isObjectInvisible(e) && this._visibilityCache.set(e, e.visible);
+	}
+	onBeforeRender() {
+		this._visibilityCache.forEach((e, t) => {
+			t.visible = !1;
+		});
+	}
+	onAfterRender() {
+		this._visibilityCache.forEach((e, t) => {
+			t.visible = e;
+		});
+	}
+}, Et = class {
+	constructor(e) {
+		this._depthWriteCache = /* @__PURE__ */ new Set(), this._doNotWriteDepth = e;
+	}
+	dispose() {
+		this._depthWriteCache.clear();
+	}
+	clear() {
+		this._depthWriteCache.clear();
+	}
+	addLineOrPoint(e) {}
+	addObject(e) {}
+	addMesh(e) {
+		this._doNotWriteDepth && this._doNotWriteDepth(e) && e.material instanceof E && e.material.depthWrite && this._depthWriteCache.add(e.material);
+	}
+	onBeforeRender() {
+		this._depthWriteCache.forEach((e) => {
+			e.depthWrite = !1;
+		});
+	}
+	onAfterRender() {
+		this._depthWriteCache.forEach((e) => {
+			e.depthWrite = !0;
+		});
+	}
+}, Dt = class {
+	constructor() {
+		this._objectCache = /* @__PURE__ */ new Map();
+	}
+	clear() {
+		this._objectCache.clear();
+	}
+	onBeforeRender() {
+		this._objectCache.forEach((e, t) => {
+			t instanceof x && (t.material !== e.originalObjectData.material && t.material !== e.updateObjectData.material && (e.originalObjectData.material = t.material), t.receiveShadow !== e.originalObjectData.receiveShadow && (e.originalObjectData.receiveShadow = t.receiveShadow), t.castShadow !== e.originalObjectData.castShadow && (e.originalObjectData.castShadow = t.castShadow), t.visible !== e.originalObjectData.visible && (e.originalObjectData.visible = t.visible)), this._updateObject(t, e.updateObjectData);
+		});
+	}
+	onAfterRender() {
+		this._objectCache.forEach((e, t) => {
+			this._updateObject(t, e.originalObjectData);
+		});
+	}
+	addToCache(e, t) {
+		this._objectCache.set(e, {
+			originalObjectData: {
+				visible: e.visible,
+				castShadow: e.castShadow,
+				receiveShadow: e instanceof x ? e.receiveShadow : void 0,
+				material: e instanceof x ? e.material : void 0
+			},
+			updateObjectData: t
+		});
+	}
+	_updateObject(e, t) {
+		t.visible !== void 0 && (e.visible = t.visible), t.castShadow !== void 0 && (e.castShadow = t.castShadow), e instanceof x && t.receiveShadow !== void 0 && (e.receiveShadow = t.receiveShadow), e instanceof x && t.material !== void 0 && (e.material = t.material);
+	}
+}, Ot = (e) => {
+	if (!e.isMesh || !e.castShadow && !e.userData?.meshId) return !1;
+	let t = e.material;
+	return !t.transparent || t.opacity > .5;
+}, kt = class extends J {
+	static {
+		this.addTestMesh = !1;
+	}
+	get shadowGroundPlane() {
+		let e = this._sharedShadowGroundPlane;
+		return e ||= (this._shadowGroundPlane ??= new Ye(this.renderTarget.texture, this.parameters), this._shadowGroundPlane), e.parent !== this._groundGroup && this._groundGroup.add(e), e;
+	}
+	constructor(e, t, n, r) {
+		super(e), this.limitPlaneSize = !0, this.needsUpdate = !0, this.noNeedOfUpdateCount = 0, this._blurScale = 1, this._shadowScale = 1, this._groundGroup = n, this.shadowMapSize = r.shadowMapSize ?? 2048, this.parameters = this._getDefaultParameters(r), this._groundShadowFar = this.parameters.cameraFar, this._renderer = t, this.renderCacheManager?.registerCache(this, new Tt((e) => e.isMesh && !Ot(e) || e.name !== void 0 && ["Ground", "Floor"].includes(e.name))), this.renderTarget = new u(this.shadowMapSize, this.shadowMapSize), this.renderTarget.texture.generateMipmaps = !1, this._renderTargetBlur = new u(this.shadowMapSize, this.shadowMapSize), this._renderTargetBlur.texture.generateMipmaps = !1, this._sharedShadowGroundPlane = r?.sharedShadowGroundPlane, this.shadowGroundPlane.setShadowMap(this.renderTarget.texture), this.shadowGroundPlane.updateMaterial(this.parameters), this._groundContactCamera = new At(), this._groundGroup.add(this._groundContactCamera), this._depthMaterial = new f(), this._depthMaterial.userData.fadeoutBias = { value: this.parameters.fadeoutBias }, this._depthMaterial.userData.fadeoutFalloff = { value: this.parameters.fadeoutFalloff }, this._depthMaterial.onBeforeCompile = (e) => {
+			e.uniforms.fadeoutBias = this._depthMaterial.userData.fadeoutBias, e.uniforms.fadeoutFalloff = this._depthMaterial.userData.fadeoutFalloff, e.fragmentShader = `
+              uniform float fadeoutBias;
+              uniform float fadeoutFalloff;
+              ${e.fragmentShader.replace("gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );", Ye.alphaMap ? "gl_FragColor = vec4(clamp(pow(1.0 + fadeoutBias - fragCoordZ, 1.0/(1.0-fadeoutFalloff)), 0.0, 1.0));" : "gl_FragColor = vec4(vec3(0.0), clamp(pow(1.0 + fadeoutBias - fragCoordZ, 1.0/(1.0-fadeoutFalloff)), 0.0, 1.0));")}
+          `;
+		}, this._depthMaterial.side = 2, this._depthMaterial.depthTest = !0, this._depthMaterial.depthWrite = !0, this._blurPass = new Je(je, {
+			...r,
+			passRenderer: this.renderPassManager.passRenderer
+		}), this.updatePlaneAndShadowCamera();
+	}
+	_getDefaultParameters(e) {
+		return {
+			enabled: !0,
+			cameraHelper: !1,
+			alwaysUpdate: !1,
+			fadeIn: !1,
+			blurMin: .001,
+			blurMax: .1,
+			fadeoutFalloff: .9,
+			fadeoutBias: .03,
+			opacity: .5,
+			maximumPlaneSize: 40,
+			planeSize: 10,
+			cameraFar: 3,
+			hardLayers: null,
+			softLayers: null,
+			polygonOffset: 2,
+			excludeGroundObjects: !0,
+			...e
+		};
+	}
+	dispose() {
+		this.renderTarget.dispose(), this._renderTargetBlur.dispose(), this._blurPass.dispose(), this._depthMaterial.dispose();
+	}
+	updateParameters(e) {
+		for (let t in e) this.parameters.hasOwnProperty(t) && (this.parameters[t] = e[t]);
+		e.cameraFar !== void 0 && (this._groundShadowFar = this.parameters.cameraFar);
+	}
+	applyParameters() {
+		this.shadowGroundPlane.updateMaterial(this.parameters), this._groundContactCamera.updateCameraHelper(this.parameters.cameraHelper), this._groundContactCamera.far !== this.parameters.cameraFar && this.updatePlaneAndShadowCamera();
+		let e = this.parameters.fadeoutFalloff;
+		this._depthMaterial.userData.fadeoutFalloff.value !== e && (this._depthMaterial.userData.fadeoutFalloff.value = this.parameters.fadeoutFalloff);
+		let t = this.parameters.fadeoutBias / this._groundContactCamera.far;
+		this._depthMaterial.userData.fadeoutBias.value !== t && (this._depthMaterial.userData.fadeoutBias.value = t), this.needsUpdate = !0;
+	}
+	setScale(e, t) {
+		this._blurScale = e, this._shadowScale = t ?? e, this.needsUpdate = !0;
+	}
+	updateBounds(e, t) {
+		this._groundShadowFar = this.parameters.cameraFar, this._groundShadowFar < e.size.z && (this._groundShadowFar = e.size.z * 1.01);
+		let n = Math.max(e.size.x, e.size.z);
+		this.parameters.planeSize = n + 2 * Math.max(this._blurScale, this._shadowScale ?? 1, 1), this.limitPlaneSize && this.parameters.planeSize > this.parameters.maximumPlaneSize ? (this.parameters.planeSize = this.parameters.maximumPlaneSize, this._groundGroup.position.set(0, t ?? 0, 0)) : this._groundGroup.position.set(e.center.x, t ?? 0, e.center.z), this._groundGroup.updateMatrixWorld(), this.updatePlaneAndShadowCamera();
+	}
+	updatePlaneAndShadowCamera() {
+		let e = this.parameters.planeSize;
+		this.shadowGroundPlane.scale.x = e, this.shadowGroundPlane.scale.y = e, this._groundContactCamera.updateCameraFormPlaneSize(e, this._groundShadowFar), this.needsUpdate = !0;
+	}
+	setGroundVisibilityLayers(e) {
+		this.shadowGroundPlane.setVisibilityLayers(e);
+	}
+	renderPass(e) {
+		if (this._groundContactCamera.updateCameraHelper(this.parameters.cameraHelper, this.scene), !this.parameters.enabled) {
+			this.needsUpdate && (this.needsUpdate = !1, this.passRenderer.clear(e, this.renderTarget, 0, 1));
+			return;
+		}
+		if (this.shadowGroundPlane.visible = this.parameters.enabled, this.parameters.alwaysUpdate || this.needsUpdate) this.noNeedOfUpdateCount = 0;
+		else if (this.noNeedOfUpdateCount++, this.noNeedOfUpdateCount >= 10) return;
+		this.needsUpdate = !1;
+		let t = this.shadowGroundPlane.material;
+		t.opacity = this.parameters.alwaysUpdate || !this.parameters.fadeIn ? this.parameters.opacity : this.parameters.opacity * (this.noNeedOfUpdateCount + 2) / 12;
+		let n = this._renderer.getClearAlpha();
+		this._renderer.setClearAlpha(0), this._groundGroup.visible = !1, this.shadowGroundPlane.visible = !1, this._groundContactCamera.setCameraHelperVisibility(!1), this.noNeedOfUpdateCount === 0 ? (this._renderGroundContact(this.scene), this._renderBlur()) : this.noNeedOfUpdateCount === 1 && this._renderBlur(), this._renderReduceBandingBlur(), this._renderer.setRenderTarget(null), this._renderer.setClearAlpha(n), this._groundGroup.visible = !0, this.shadowGroundPlane.visible = this.parameters.enabled, this._groundContactCamera.setCameraHelperVisibility(this.parameters.cameraHelper);
+	}
+	_renderGroundContact(e) {
+		let t = e.background;
+		e.background = null, e.overrideMaterial = this._depthMaterial, this._renderer.setRenderTarget(this.renderTarget), this._renderer.clear();
+		let n = this._renderer.autoClear;
+		this._renderer.autoClear = !1, this.parameters.hardLayers && (this._groundContactCamera.layers.mask = this.parameters.hardLayers.mask, this._groundContactCamera.updateCameraFarPlane(10), this._depthMaterial.userData.fadeoutBias.value = .99, this._renderer.render(e, this._groundContactCamera), this._groundContactCamera.updateCameraFarPlane(this._groundShadowFar), this._depthMaterial.userData.fadeoutBias.value = this.parameters.fadeoutBias / this._groundShadowFar), this._groundContactCamera.layers.enableAll(), this.parameters.softLayers && (this._groundContactCamera.layers.mask = this.parameters.softLayers.mask), this.renderCacheManager ? this.renderCacheManager.render(this, e, () => {
+			this._renderer.render(e, this._groundContactCamera);
+		}) : this._renderer.render(e, this._groundContactCamera), this._renderer.autoClear = n, e.overrideMaterial = null, e.background = t;
+	}
+	_renderBlur() {
+		this._renderBlurPass(this._blurScale * this.parameters.blurMin / this.parameters.planeSize, this._blurScale * this.parameters.blurMax / this.parameters.planeSize);
+	}
+	_renderReduceBandingBlur() {
+		let e = this._blurScale * .01 / this.parameters.planeSize;
+		this._renderBlurPass(e, e);
+	}
+	_renderBlurPass(e, t) {
+		this._blurPass.render(this._renderer, [
+			this.renderTarget,
+			this._renderTargetBlur,
+			this.renderTarget
+		], [e, e], [t, t]);
+	}
+}, At = class extends k {
+	constructor() {
+		super(-1, 1, -1, 1, -1, 1), this.rotation.x = Math.PI;
+	}
+	updateCameraFormPlaneSize(e, t) {
+		this.left = -e / 2, this.right = e / 2, this.top = -e / 2, this.bottom = e / 2, this.near = 0, this.far = t, this.updateProjectionMatrix(), this.cameraHelper?.update();
+	}
+	updateCameraFarPlane(e) {
+		this.far = e, this.updateProjectionMatrix(), this.cameraHelper?.update();
+	}
+	updateCameraHelper(e, t) {
+		e ? (this.cameraHelper = this.cameraHelper ?? new re(this), this.cameraHelper.visible = !0, t?.add(this.cameraHelper)) : this.cameraHelper?.parent && this.cameraHelper?.removeFromParent();
+	}
+	setCameraHelperVisibility(e) {
+		this.cameraHelper && (this.cameraHelper.visible = e);
+	}
+}, jt = "varying vec3 vNormal;\n#if LINEAR_DEPTH == 1\n    varying float vZ;  \n#endif\n\n  void main() {\n      vNormal = normalMatrix * normal;\n      vec4 viewPosition = modelViewMatrix * vec4(position, 1.0);\n      #if LINEAR_DEPTH == 1\n          vZ = viewPosition.z;  \n      #endif\n      gl_Position = projectionMatrix * viewPosition;\n  }", Mt = "varying vec3 vNormal;\n#if LINEAR_DEPTH == 1\n  varying float vZ;  \n  uniform float cameraNear;\n  uniform float cameraFar;\n#endif\n\n  void main() {\n      #if FLOAT_BUFFER == 1\n          vec3 normal = normalize(vNormal);\n      #else\n          vec3 normal = normalize(vNormal) * 0.5 + 0.5;\n      #endif\n      #if LINEAR_DEPTH == 1\n          float depth = (-vZ - cameraNear) / (cameraFar - cameraNear);\n      #else\n          float depth = gl_FragCoord.z;\n      #endif\n      gl_FragColor = vec4(normal, depth);\n  }", Nt = class e extends z {
+	static {
+		this._normalAndDepthShader = {
+			uniforms: {
+				cameraNear: { value: .1 },
+				cameraFar: { value: 1 }
+			},
+			defines: {
+				FLOAT_BUFFER: 0,
+				LINEAR_DEPTH: 0
+			},
+			vertexShader: jt,
+			fragmentShader: Mt
+		};
+	}
+	constructor(t) {
+		super({
+			defines: Object.assign({
+				...e._normalAndDepthShader.defines,
+				FLOAT_BUFFER: t?.floatBufferType ? 1 : 0,
+				LINEAR_DEPTH: t?.linearDepth ? 1 : 0
+			}),
+			uniforms: y.clone(e._normalAndDepthShader.uniforms),
+			vertexShader: e._normalAndDepthShader.vertexShader,
+			fragmentShader: e._normalAndDepthShader.fragmentShader,
+			blending: t?.blending ?? 0
+		}), this.update(t);
+	}
+	update(e) {
+		if (e?.camera !== void 0) {
+			let t = e?.camera || e?.camera;
+			this.uniforms.cameraNear.value = t.near, this.uniforms.cameraFar.value = t.far;
+		}
+		return this;
+	}
+}, Pt = class extends J {
+	set groundDepthWrite(e) {
+		this._gBufferMaterialCache && (this._gBufferMaterialCache.groundDepthWrite = e);
+	}
+	get isFloatGBufferWithRgbNormalAlphaDepth() {
+		return this.floatRgbNormalAlphaDepth;
+	}
+	get gBufferTexture() {
+		return this.depthNormalRenderTarget.texture;
+	}
+	get depthBufferTexture() {
+		return this.copyToSeparateDepthBuffer && this.floatRgbNormalAlphaDepth ? this.separateDeptRenderTarget.texture : this.depthNormalRenderTarget.depthTexture;
+	}
+	get textureWithDepthValue() {
+		return this.floatRgbNormalAlphaDepth ? this.depthNormalRenderTarget.texture : this.depthNormalRenderTarget.depthTexture;
+	}
+	updateGBufferRenderMaterial(e) {
+		return this._gBufferRenderMaterial = this._gBufferRenderMaterial ?? (this.floatRgbNormalAlphaDepth ? new Nt({
+			blending: 0,
+			floatBufferType: !0,
+			linearDepth: !1
+		}) : new i({ blending: 0 })), this._gBufferRenderMaterial instanceof Nt && this._gBufferRenderMaterial.update({ camera: e }), this._gBufferRenderMaterial;
+	}
+	get depthNormalRenderTarget() {
+		if (!this._depthNormalRenderTarget) if (this.floatRgbNormalAlphaDepth) this._depthNormalRenderTarget = new u(this._width * this.parameters.depthNormalScale, this._height * this.parameters.depthNormalScale, {
+			minFilter: this._targetMinificationTextureFilter,
+			magFilter: this._targetMagnificationTextureFilter,
+			type: T,
+			samples: this._samples
+		});
+		else {
+			let e = new _(this._width * this.parameters.depthNormalScale, this._height * this.parameters.depthNormalScale);
+			e.format = h, e.type = ie, this._depthNormalRenderTarget = new u(this._width * this.parameters.depthNormalScale, this._height * this.parameters.depthNormalScale, {
+				minFilter: this._targetMinificationTextureFilter,
+				magFilter: this._targetMagnificationTextureFilter,
+				depthTexture: e
+			});
+		}
+		return this._depthNormalRenderTarget;
+	}
+	get separateDeptRenderTarget() {
+		return this._separateDeptRenderTarget ||= new u(this._width * this.parameters.depthNormalScale, this._height * this.parameters.depthNormalScale, {
+			minFilter: this._targetMinificationTextureFilter,
+			magFilter: this._targetMagnificationTextureFilter,
+			type: T,
+			samples: 0
+		}), this._separateDeptRenderTarget;
+	}
+	constructor(e, t) {
+		super(e), this.floatRgbNormalAlphaDepth = !1, this.linearDepth = !1, this.copyToSeparateDepthBuffer = !1, this.needsUpdate = !0, this.drawGround = !0, this.floatRgbNormalAlphaDepth = t?.capabilities?.isWebGL2 ?? !1, this.renderCacheManager && (this._gBufferMaterialCache = new Ft(), this.renderCacheManager.registerCache(this, this._gBufferMaterialCache)), this.parameters = { depthNormalScale: t?.depthNormalScale ?? 1 }, this._targetMinificationTextureFilter = t?.textureMinificationFilter ?? 1003, this._targetMagnificationTextureFilter = t?.textureMagnificationFilter ?? 1003, this._width = t?.width ?? 1024, this._height = t?.height ?? 1024, this._samples = t?.samples ?? 0, this._shared = t?.shared ?? !1;
+	}
+	dispose() {
+		super.dispose(), this._gBufferRenderMaterial?.dispose(), this._depthNormalRenderTarget?.dispose();
+	}
+	setSize(e, t) {
+		this._width = e, this._height = t, this._depthNormalRenderTarget?.setSize(this._width * this.parameters.depthNormalScale, this._height * this.parameters.depthNormalScale);
+	}
+	renderPass(e) {
+		this._shared && !this.needsUpdate || (this.needsUpdate = !1, this.renderPassManager.setGroundVisibility(this.drawGround), this.renderCacheManager ? this.renderCacheManager.render(this, this.scene, () => {
+			this._renderGBuffer(e, this.scene, this.camera);
+		}) : this._renderGBuffer(e, this.scene, this.camera), this.renderPassManager.setGroundVisibility(!1), this.floatRgbNormalAlphaDepth && this.copyToSeparateDepthBuffer && this._copyDepthToSeparateDepthTexture(e, this.depthNormalRenderTarget));
+	}
+	_renderGBuffer(e, t, n) {
+		this.passRenderer.renderWithOverrideMaterial(e, t, n, this.updateGBufferRenderMaterial(n), this.depthNormalRenderTarget, 7829503, 1);
+	}
+	getCopyMaterial(e) {
+		return this._copyMaterial ??= new Ae(), this._copyMaterial.update(e);
+	}
+	_copyDepthToSeparateDepthTexture(e, t) {
+		this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+			texture: t.texture,
+			blending: 0,
+			colorTransform: De,
+			colorBase: G,
+			multiplyChannels: 0,
+			uvTransform: K
+		}), this.separateDeptRenderTarget);
+	}
+}, Ft = class extends Dt {
+	set groundDepthWrite(e) {
+		this._groundDepthWrite = e;
+	}
+	constructor() {
+		super(), this._groundDepthWrite = !0;
+	}
+	dispose() {}
+	addLineOrPoint(e) {
+		this.addToCache(e, { visible: !1 });
+	}
+	addMesh(e) {
+		e.userData.isFloor ? this.addToCache(e, { visible: this._groundDepthWrite }) : e.visible && (xt(e.material, .7) || St(e.material)) && this.addToCache(e, { visible: !1 });
+	}
+	addObject(e) {
+		e.name === "dimensioning" && this.addToCache(e, { visible: !1 });
+	}
+}, It = class extends J {
+	get reflectionRenderTarget() {
+		return this._reflectionRenderTarget = this._reflectionRenderTarget ?? this._newRenderTarget(!0), this._reflectionRenderTarget;
+	}
+	get intensityRenderTarget() {
+		return this._intensityRenderTarget = this._intensityRenderTarget ?? this._newRenderTarget(!1), this._intensityRenderTarget;
+	}
+	get blurRenderTarget() {
+		return this._blurRenderTarget = this._blurRenderTarget ?? this._newRenderTarget(!1), this._blurRenderTarget;
+	}
+	constructor(e, t, n, r, i) {
+		super(e), this.reflectionFadeInScale = 1, this._width = t, this._height = n, this._samples = r ?? 1, this.parameters = {
+			enabled: !1,
+			intensity: .25,
+			fadeOutDistance: 1,
+			fadeOutExponent: 4,
+			brightness: 1,
+			blurHorizontal: 3,
+			blurVertical: 6,
+			blurAscent: 0,
+			groundLevel: 0,
+			groundReflectionScale: 1,
+			renderTargetDownScale: 4,
+			...i
+		}, this._copyMaterial = new Ae({}, ke.ADDITIVE, !0, !0), this._updateCopyMaterial(null), this._reflectionIntensityMaterial = new zt({
+			width: this._width / this.parameters.renderTargetDownScale,
+			height: this._height / this.parameters.renderTargetDownScale
+		}), this._blurPass = new Je(je, {
+			...i,
+			passRenderer: this.renderPassManager.passRenderer
+		});
+	}
+	_newRenderTarget(e) {
+		let t = this._width / this.parameters.renderTargetDownScale, n = this._height / this.parameters.renderTargetDownScale, r = {};
+		return e ? (r.depthTexture = new _(t, n), r.samples = this._samples) : r.samples = 1, new u(t, n, {
+			format: R,
+			...r
+		});
+	}
+	dispose() {
+		super.dispose(), this._reflectionRenderTarget?.dispose(), this._intensityRenderTarget?.dispose(), this._blurRenderTarget?.dispose(), this._blurPass.dispose(), this._reflectionIntensityMaterial.dispose(), this._copyMaterial.dispose();
+	}
+	setSize(e, t) {
+		this._width = e, this._height = t, this._reflectionRenderTarget?.setSize(this._width / this.parameters.renderTargetDownScale, this._height / this.parameters.renderTargetDownScale), this._intensityRenderTarget?.setSize(this._width / this.parameters.renderTargetDownScale, this._height / this.parameters.renderTargetDownScale), this._blurRenderTarget?.setSize(this._width / this.parameters.renderTargetDownScale, this._height / this.parameters.renderTargetDownScale), this._reflectionIntensityMaterial?.update({
+			width: this._width / this.parameters.renderTargetDownScale,
+			height: this._height / this.parameters.renderTargetDownScale
+		});
+	}
+	updateParameters(e) {
+		for (let t in e) this.parameters.hasOwnProperty(t) && (this.parameters[t] = e[t]);
+	}
+	updateBounds(e, t) {
+		this.parameters.groundLevel = e, this.parameters.groundReflectionScale = t;
+	}
+	_updateCopyMaterial(e, t = 1) {
+		let n = this.parameters.intensity * t, r = this.parameters.brightness;
+		this._copyMaterial.update({
+			texture: e?.texture ?? void 0,
+			colorTransform: new v().set(r, 0, 0, 0, 0, r, 0, 0, 0, 0, r, 0, 0, 0, 0, n),
+			multiplyChannels: 0,
+			uvTransform: q
+		}), this._copyMaterial.depthTest = !0, this._copyMaterial.depthWrite = !1;
+	}
+	renderPass(e) {
+		if (!this.parameters.enabled || !(this.camera instanceof t)) return;
+		let n = this._createGroundReflectionCamera(this.camera);
+		this.renderCacheManager.render("groundReflection", this.scene, () => {
+			this._renderGroundReflection(e, this.scene, n, this.reflectionRenderTarget);
+		}), this._renderGroundReflectionIntensity(e, n, this.intensityRenderTarget), (this.parameters.blurHorizontal > 0 || this.parameters.blurVertical > 0) && this.blurReflection(e, this.camera, [
+			this.intensityRenderTarget,
+			this.blurRenderTarget,
+			this.intensityRenderTarget
+		]), this._updateCopyMaterial(this.intensityRenderTarget, this.reflectionFadeInScale), this.passRenderer.renderScreenSpace(e, this._copyMaterial, e.getRenderTarget());
+	}
+	_renderGroundReflection(e, t, n, r) {
+		let i = e.getRenderTarget();
+		r && (e.setRenderTarget(r), this.passRenderer.clear(e, r, 0, 0)), e.render(t, n), r && e.setRenderTarget(i);
+	}
+	_renderGroundReflectionIntensity(e, t, n) {
+		let r = e.getRenderTarget();
+		e.setRenderTarget(n), this.passRenderer.renderScreenSpace(e, this._reflectionIntensityMaterial.update({
+			texture: this.reflectionRenderTarget.texture,
+			depthTexture: this.reflectionRenderTarget.depthTexture,
+			camera: t,
+			groundLevel: this.parameters.groundLevel,
+			fadeOutDistance: this.parameters.fadeOutDistance * this.parameters.groundReflectionScale,
+			fadeOutExponent: this.parameters.fadeOutExponent
+		}), e.getRenderTarget()), e.setRenderTarget(r);
+	}
+	blurReflection(e, t, n) {
+		let r = new S(t.matrixWorld.elements[4], t.matrixWorld.elements[5], t.matrixWorld.elements[6]), i = this.parameters.blurHorizontal / this._width, a = this.parameters.blurVertical / this._height * Math.abs(r.dot(new S(0, 0, 1)));
+		this._blurPass.render(e, n, [i * 4, a * 4], [i * 4 * (1 + this.parameters.blurAscent), a * 4 * (1 + this.parameters.blurAscent)]);
+	}
+	_createGroundReflectionCamera(e) {
+		let t = e.clone(), n = t;
+		return n._offset &&= {
+			left: n._offset.left,
+			top: 1 - n._offset.bottom,
+			right: n._offset.right,
+			bottom: 1 - n._offset.top
+		}, t.position.set(e.position.x, -e.position.y + 2 * this.parameters.groundLevel, e.position.z), t.rotation.set(-e.rotation.x, e.rotation.y, -e.rotation.z), t.updateMatrixWorld(), t.updateProjectionMatrix(), t;
+	}
+}, Lt = "\n  varying vec2 vUv;\n  void main() {\n      vUv = uv;\n      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }", Rt = "\n  uniform sampler2D tDiffuse;\n  uniform sampler2D tDepth;\n  uniform vec2 resolution;\n  uniform float cameraNear;\n  uniform float cameraFar;\n  uniform mat4 cameraProjectionMatrix;\n  uniform mat4 cameraInverseProjectionMatrix;\n  uniform mat4 inverseViewMatrix;\n  uniform float groundLevel;\n  uniform float fadeOutDistance;\n  uniform float fadeOutExponent;\n  varying vec2 vUv;\n\n  #include <packing>\n\n  float getDepth(const in vec2 screenPosition) {\n    return texture2D(tDepth, screenPosition).x;\n  }\n\n  float getLinearDepth(const in vec2 screenPosition) {\n    #if PERSPECTIVE_CAMERA == 1\n        float fragCoordZ = texture2D(tDepth, screenPosition).x;\n        float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);\n        return viewZToOrthographicDepth(viewZ, cameraNear, cameraFar);\n    #else\n        return texture2D(tDepth, screenPosition).x;\n    #endif\n  }\n\n  float getViewZ(const in float depth) {\n    #if PERSPECTIVE_CAMERA == 1\n        return perspectiveDepthToViewZ(depth, cameraNear, cameraFar);\n    #else\n        return 0.0;//orthographicDepthToViewZ(depth, cameraNear, cameraFar);\n    #endif\n  }\n\n  vec3 getViewPosition(const in vec2 screenPosition, const in float depth, const in float viewZ ) {\n    float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];\n    vec4 clipPosition = vec4((vec3(screenPosition, depth) - 0.5) * 2.0, 1.0);\n    clipPosition *= clipW;\n    return (cameraInverseProjectionMatrix * clipPosition).xyz;\n  }\n\n  void main() {\n    float verticalBias = 1.5 / resolution.y;\n    vec2 uv = vUv.xy + vec2(0.0, verticalBias);\n    float depth = getDepth(uv);\n    float viewZ = getViewZ(depth);\n    vec4 worldPosition = inverseViewMatrix * vec4(getViewPosition(uv, depth, viewZ), 1.0);\n    float distance = worldPosition.y - groundLevel;\n    vec2 diffuseTextureSize = vec2(textureSize(tDiffuse, 0 ));\n    vec4 fragColor = texelFetch(tDiffuse, ivec2(uv * diffuseTextureSize), 0).rgba;\n    #if LINEAR_TO_SRGB == 1\n      fragColor.rgb = mix(fragColor.rgb * 12.92, 1.055 * pow(fragColor.rgb, vec3(0.41666)) - 0.055, step(0.0031308, fragColor.rgb));\n    #endif\n    float fadeOutAlpha = pow(clamp(1.0 - distance / fadeOutDistance, 0.0, 1.0), fadeOutExponent);\n    fragColor.a *= fadeOutAlpha * step(depth, 0.9999);\n    #if PREMULTIPLIED_ALPHA == 1\n      gl_FragColor = vec4(fragColor.rgb * fragColor.a, fragColor.a);\n    #else\n      gl_FragColor = fragColor;\n    #endif\n  }", zt = class e extends z {
+	static {
+		this.shader = {
+			uniforms: {
+				tDiffuse: { value: null },
+				tDepth: { value: null },
+				resolution: { value: new m() },
+				cameraNear: { value: .1 },
+				cameraFar: { value: 1 },
+				cameraProjectionMatrix: { value: new v() },
+				cameraInverseProjectionMatrix: { value: new v() },
+				inverseViewMatrix: { value: new v() },
+				groundLevel: { value: 0 },
+				fadeOutDistance: { value: 1 },
+				fadeOutExponent: { value: 1 }
+			},
+			defines: {
+				PERSPECTIVE_CAMERA: 1,
+				LINEAR_TO_SRGB: 0,
+				PREMULTIPLIED_ALPHA: 1
+			},
+			vertexShader: Lt,
+			fragmentShader: Rt
+		};
+	}
+	constructor(t) {
+		super({
+			defines: Object.assign({}, e.shader.defines),
+			uniforms: y.clone(e.shader.uniforms),
+			vertexShader: e.shader.vertexShader,
+			fragmentShader: e.shader.fragmentShader,
+			blending: 0
+		}), this.update(t);
+	}
+	update(e) {
+		if (e?.texture !== void 0 && (this.uniforms.tDiffuse.value = e?.texture), e?.depthTexture !== void 0 && (this.uniforms.tDepth.value = e?.depthTexture), e?.width || e?.height) {
+			let t = e?.width ?? this.uniforms.resolution.value.x, n = e?.height ?? this.uniforms.resolution.value.y;
+			this.uniforms.resolution.value.set(t, n);
+		}
+		if (e?.camera !== void 0) {
+			let t = e?.camera || e?.camera;
+			this.uniforms.cameraNear.value = t.near, this.uniforms.cameraFar.value = t.far, this.uniforms.cameraProjectionMatrix.value.copy(t.projectionMatrix), this.uniforms.cameraInverseProjectionMatrix.value.copy(t.projectionMatrixInverse), this.uniforms.inverseViewMatrix.value.copy(t.matrixWorld);
+		}
+		return e?.groundLevel !== void 0 && (this.uniforms.groundLevel.value = e?.groundLevel), e?.fadeOutDistance !== void 0 && (this.uniforms.fadeOutDistance.value = e?.fadeOutDistance), e?.fadeOutExponent !== void 0 && (this.uniforms.fadeOutExponent.value = e?.fadeOutExponent), this;
+	}
+}, Bt = class extends M {
+	constructor(e, t) {
+		let n = [
+			1,
+			1,
+			0,
+			-1,
+			1,
+			0,
+			-1,
+			-1,
+			0,
+			1,
+			-1,
+			0,
+			1,
+			1,
+			0
+		], r = new ae();
+		r.setAttribute("position", new l(n, 3)), r.computeBoundingSphere();
+		let i = new ce({ fog: !1 });
+		super(r, i), this.light = e, this.color = t, this.type = "RectAreaLightHelper";
+		let a = [
+			1,
+			1,
+			0,
+			-1,
+			1,
+			0,
+			-1,
+			-1,
+			0,
+			1,
+			1,
+			0,
+			-1,
+			-1,
+			0,
+			1,
+			-1,
+			0
+		], o = new ae();
+		o.setAttribute("position", new l(a, 3)), o.computeBoundingSphere(), this.add(new x(o, new c({
+			side: 1,
+			fog: !1
+		})));
+	}
+	updateMatrixWorld() {
+		if (this.scale.set(.5 * this.light.width, .5 * this.light.height, 1), this.color !== void 0) this.material.color.set(this.color), this.children[0].material.color.set(this.color);
+		else {
+			this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);
+			let e = this.material.color, t = Math.max(e.r, e.g, e.b);
+			t > 1 && e.multiplyScalar(1 / t), this.children[0].material.color.copy(this.material.color);
+		}
+		this.matrixWorld.extractRotation(this.light.matrixWorld).scale(this.scale).copyPosition(this.light.matrixWorld), this.children[0].matrixWorld.copy(this.matrixWorld);
+	}
+	dispose() {
+		this.geometry.dispose(), this.material.dispose(), this.children[0].geometry.dispose(), this.children[0].material.dispose();
+	}
+}, Vt = class e extends C {
+	static {
+		this._enableGroundBoundary = !1;
+	}
+	static {
+		this._shadowFadeOut = new m(.1, 20);
+	}
+	static {
+		this._sceneBoxMin = new S(-1, -1, -1);
+	}
+	static {
+		this._sceneBoxMax = new S(1, 1, 1);
+	}
+	static {
+		this._distributionProperties = new B(1, 1, 1, 1);
+	}
+	constructor(e) {
+		super(e), this.customProgramCacheKey = this._customProgramCacheKey, this.onBeforeCompile = this._onBeforeCompile;
+	}
+	static setShadowParameters(t, n, r, i, a, o, s) {
+		this._enableGroundBoundary = t, e._distributionProperties.set(n, r, i, a), e._shadowFadeOut.set(o, s);
+	}
+	static setBoundingBox(t) {
+		e._sceneBoxMin.copy(t.min), e._sceneBoxMax.copy(t.max);
+	}
+	_customProgramCacheKey() {
+		return e._enableGroundBoundary ? "GROUND_BOUNDARY" : "NO_GROUND_BOUNDARY";
+	}
+	_onBeforeCompile(t, n) {
+		t.vertexShader = Ht, t.fragmentShader = Ut, t.defines = Object.assign({
+			...t.defines,
+			DYNAMIC_SHADOW_RADIUS: "",
+			GROUND_BOUNDARY: e._enableGroundBoundary ? 1 : 0
+		});
+		let r = t.uniforms;
+		r && (r.distributionProperties = { value: e._distributionProperties }, r.shadowFadeOut = { value: e._shadowFadeOut }, r.sceneBoxMin = { value: e._sceneBoxMin }, r.sceneBoxMax = { value: e._sceneBoxMax });
+	}
+}, Ht = "\n#define LAMBERT\n\nvarying vec3 vViewPosition;\nvarying vec3 vWorldPosition;\n\n#include <common>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\nvoid main() {\n  #include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n	#include <normal_vertex>\n\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <displacementmap_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n\n	vViewPosition = - mvPosition.xyz;\n\n	#include <worldpos_vertex>\n	#include <shadowmap_vertex>\n\n#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n  vWorldPosition = worldPosition.xyz;\n#else\n  vWorldPosition = (modelMatrix * vec4(transformed, 1.)).xyz;\n#endif\n}\n", Ut = "\n#define LAMBERT\n\nuniform vec3 diffuse;\nuniform float opacity;\n\nvarying vec3 vViewPosition;\nvarying vec3 vWorldPosition;\n\n#ifdef DYNAMIC_SHADOW_RADIUS\n  uniform vec2 shadowFadeOut;\n  #define fadeOutDistance shadowFadeOut.x\n  #define fadeOutBlur shadowFadeOut.y\n  uniform vec3 sceneBoxMin;\n  uniform vec3 sceneBoxMax;\n#endif\nuniform vec4 distributionProperties;\n#define directionalDependency distributionProperties.x\n#define directionalExponent distributionProperties.y\n#define groundBoundary distributionProperties.z\n#define groundMapScale distributionProperties.w\n\n#include <common>\n#include <packing>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\nvec2 getShadowDynamicScale() {\n  vec2 dynamicScale = vec2(0.0, 1.0);\n#ifdef DYNAMIC_SHADOW_RADIUS\n  if (fadeOutDistance > 0.0) {\n    vec3 boxDistanceVec = max(vec3(0.0), max(sceneBoxMin - vWorldPosition, vWorldPosition - sceneBoxMax));\n    float boxDistance = length(boxDistanceVec);\n    float shadowBase = clamp(boxDistance / fadeOutDistance, 0.0, 1.0);\n    dynamicScale = vec2(shadowBase, 1.0 - shadowBase);\n  }\n#endif\n  return dynamicScale;\n}\n\n\n#if defined( SHADOWMAP_TYPE_PCF )\nfloat getShadowDynamicRadius(sampler2DShadow shadowMap, float shadowBias, float shadowRadius, vec4 shadowCoord, vec2 shadowScale) {\n#else\nfloat getShadowDynamicRadius(sampler2D shadowMap, float shadowBias, float shadowRadius, vec4 shadowCoord, vec2 shadowScale) {\n#endif\n  float dynamicRadius = shadowRadius;\n#ifdef DYNAMIC_SHADOW_RADIUS\n  shadowCoord.xyz /= shadowCoord.w;\n  shadowCoord.z += shadowBias;\n  bool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n  bool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n  if (frustumTest && fadeOutDistance > 0.0) {\n    dynamicRadius = shadowRadius + fadeOutBlur * max(0.0, shadowScale.x);\n  }\n#endif\n  return dynamicRadius;\n}\n\nvoid main() {\n\n	#include <clipping_planes_fragment>\n\n	vec4 diffuseColor = vec4( diffuse, opacity );\n\n	#include <logdepthbuf_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <alphahash_fragment>\n	#include <normal_fragment_begin>\n	#include <normal_fragment_maps>\n\n	// accumulation\n\n	vec3 geometryPosition = - vViewPosition;\n  vec3 geometryNormal = normal;\n  vec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n\n  vec3 accumulatedShadowLight = vec3(0.0);\n  vec3 directionDependentShadowLight = vec3(1.0);\n  float groundDistance = clamp((vWorldPosition.y - sceneBoxMin.y) * 100.0, 0.0, 1.0);\n  vec2 dynamicScale = getShadowDynamicScale();\n\n  #if ( NUM_DIR_LIGHTS > 0 )\n    DirectionalLight directionalLight;\n    #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n      DirectionalLightShadow directionalLightShadow;\n    #endif\n\n    IncidentLight directLight;\n    vec3 incidentLightSum = vec3(0.0);\n    vec3 incidentShadowLight = vec3(0.0);\n    float groundShadowFactor = 1.;\n    float shadowFactor;\n    float dynamicRadius;\n    float dotNL;\n\n  #pragma unroll_loop_start\n    for ( int i = 0 ; i < NUM_DIR_LIGHTS; i ++ ) {\n      directionalLight = directionalLights[ i ];\n      getDirectionalLightInfo( directionalLight, directLight );\n\n      #if defined( USE_SHADOWMAP ) && ( GROUND_BOUNDARY == 1 && UNROLLED_LOOP_INDEX == 0 )\n\n        directionalLightShadow = directionalLightShadows[ i ];\n        dynamicRadius = fadeOutDistance * groundMapScale;\n        groundShadowFactor = groundDistance < 0.5 ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, dynamicRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\n      #elif defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\n        directionalLightShadow = directionalLightShadows[ i ];\n        dynamicRadius = getShadowDynamicRadius(directionalShadowMap[i], directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[i], dynamicScale);\n        shadowFactor = ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, dynamicRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n        accumulatedShadowLight += directLight.color * shadowFactor * saturate(min(dotNL * 10.0 + 0.9, 1.0));\n        dotNL = dot(dot(geometryNormal, geometryPosition) >= 0.0 ? -geometryNormal : geometryNormal, directLight.direction);\n        incidentLightSum += directLight.color;\n        incidentShadowLight += directLight.color * mix(1.0, shadowFactor, pow(clamp(dotNL, 0.0, 1.0), directionalExponent));\n\n      #endif\n    }\n  #pragma unroll_loop_end\n\n    directionDependentShadowLight = incidentShadowLight / ( incidentLightSum + 1. - step(0., incidentLightSum) );\n  #else\n    accumulatedShadowLight = vec3(1.0);\n  #endif\n\n	// modulation\n\n	vec3 outgoingLight = mix(accumulatedShadowLight, directionDependentShadowLight, max(directionalDependency, 1.0 - groundDistance));\n  #if GROUND_BOUNDARY == 1\n    float groundWeight = 1. - groundShadowFactor + groundDistance - (1. - groundShadowFactor) * groundDistance;\n    outgoingLight = mix(vec3(1.), outgoingLight, mix(dynamicScale.y, groundWeight, groundBoundary));\n  #else\n    outgoingLight = mix(vec3(1.), outgoingLight, dynamicScale.y);\n  #endif\n\n	#include <opaque_fragment>\n	#include <premultiplied_alpha_fragment>\n}\n", Wt = {
+	DIRECTION_LIGHT_SHADOW: "DirectionalLightShadow",
+	SPOT_LIGHT_SHADOW: "SpotLightShadow"
+}, Gt = {
+	alwaysUpdate: !1,
+	enableShadowMap: !0,
+	enableGroundBoundary: !0,
+	layers: null,
+	shadowLightSourceType: Wt.DIRECTION_LIGHT_SHADOW,
+	maximumNumberOfLightSources: -1,
+	directionalDependency: 1,
+	directionalExponent: 1,
+	groundBoundary: 1,
+	fadeOutDistance: .1,
+	fadeOutBlur: 5
+}, Kt = class extends J {
+	get shadowTexture() {
+		return this._shadowRenderTarget.texture;
+	}
+	set shadowOnGround(e) {
+		this._shadowMapPassOverrideMaterialCache.shadowOnGround = e;
+	}
+	constructor(e, t, n) {
+		super(e), this.needsUpdate = !1, this.drawGround = !0, this.shadowTypeNeedsUpdate = !0, this.shadowConfiguration = new Yt(), this._shadowLightSources = [], this._shadowScale = 1, this._groundMapScale = 1, this._cameraUpdate = new We(), this._viewportSize = new m(t.x, t.y), this._samples = n?.samples ?? 0, this._shadowMapSize = n?.shadowMapSize ?? 1024, this.parameters = this._getScreenSpaceShadowMapParameters(n), this.castShadow = this.parameters.enableShadowMap, this._shadowMapPassOverrideMaterialCache = new Jt(), this.renderCacheManager?.registerCache(this, this._shadowMapPassOverrideMaterialCache);
+		let r = this._samples;
+		this._shadowRenderTarget = new u(this._viewportSize.x, this._viewportSize.y, {
+			samples: r,
+			format: ee,
+			magFilter: this._samples > 0 ? w : p,
+			minFilter: this._samples > 0 ? w : p
+		});
+	}
+	_getScreenSpaceShadowMapParameters(e) {
+		return {
+			...Gt,
+			...e
+		};
+	}
+	dispose() {
+		super.dispose(), this._shadowLightSources.forEach((e) => e.dispose()), this._shadowRenderTarget.dispose(), this._shadowMapPassOverrideMaterialCache.dispose();
+	}
+	updateParameters(e) {
+		for (let t in e) this.parameters.hasOwnProperty(t) && (this.parameters[t] = e[t]);
+	}
+	updateBounds(e, t) {
+		let n = this._shadowScale;
+		if (this._shadowScale = t, Math.abs(n - this._shadowScale) > 1e-5 && (this.shadowTypeNeedsUpdate = !0), this._shadowLightSources.forEach((t) => t.updateBounds(e)), this._shadowLightSources.length > 0) {
+			let e = this._shadowLightSources[0].getShadowLight().shadow?.camera;
+			e instanceof k && (this._groundMapScale = 2 * this._shadowMapSize / (Math.abs(e.right - e.left) + Math.abs(e.top - e.bottom)));
+		} else this._groundMapScale = 1;
+		this._shadowMapPassOverrideMaterialCache.setBoundingBox(e.bounds);
+	}
+	forceShadowUpdate() {
+		this._shadowLightSources.forEach((e) => e.forceShadowUpdate()), this.needsUpdate = !0;
+	}
+	getShadowLightSources() {
+		return this._shadowLightSources.map((e) => e.getShadowLight());
+	}
+	findShadowLightSource(e) {
+		return this._shadowLightSources.find((t) => t.getOriginalLight() === e)?.getShadowLight();
+	}
+	addRectAreaLight(e, t) {
+		let n = new Zt(e, {
+			shadowMapSize: this._shadowMapSize,
+			shadowLightSourceType: this.parameters.shadowLightSourceType
+		});
+		this._shadowLightSources.push(n), n.addTo(t), n.updatePositionAndTarget(), this.needsUpdate = !0;
+	}
+	updateRectAreaLights(e, t) {
+		let n = this._shadowLightSources;
+		this._shadowLightSources = this._createShadowLightSourceArray(!1);
+		for (let r of n) {
+			if (r instanceof Zt) {
+				let t = r.getRectAreaLight();
+				e.includes(t) && (r.updatePositionAndTarget(), this._shadowLightSources.push(r));
+			}
+			r.removeFrom(t), r.dispose();
+		}
+		e.forEach((e) => {
+			this._shadowLightSources.find((t) => t instanceof Zt && t.getRectAreaLight() === e) || this.addRectAreaLight(e, t);
+		}), this.needsUpdate = !0, this.shadowTypeNeedsUpdate = !0;
+	}
+	createShadowFromLightSources(e, t) {
+		for (let t of this._shadowLightSources) t.removeFrom(e), t.dispose();
+		this._shadowLightSources = this._createShadowLightSourceArray(!0);
+		let n = 1 / (t.length > 0 ? Math.max(...t.map((e) => e.maxIntensity)) : 1);
+		this._addShadowFromLightSources(t, n), this._shadowLightSources.forEach((t) => {
+			t.addTo(e), t.updatePositionAndTarget();
+		}), this.needsUpdate = !0, this.shadowTypeNeedsUpdate = !0;
+	}
+	_addShadowFromLightSources(e, t) {
+		e.forEach((e) => {
+			let n = e.maxIntensity * t;
+			if (n >= .1 && e.position.z >= 0) {
+				let t = new Qt(new S(e.position.x, e.position.z, e.position.y).multiplyScalar(7), n, {
+					shadowMapSize: this._shadowMapSize,
+					shadowLightSourceType: this.parameters.shadowLightSourceType
+				});
+				this._shadowLightSources.push(t);
+			}
+		});
+	}
+	_createShadowLightSourceArray(e) {
+		let t = [];
+		if (e) {
+			let e = new $t(new S(0, 7, 0), { shadowMapSize: this._shadowMapSize });
+			t.push(e);
+		}
+		return this.parameters.enableGroundBoundary = e, t;
+	}
+	setSize(e, t) {
+		this._viewportSize = new m(e, t), this._shadowRenderTarget.setSize(this._viewportSize.x, this._viewportSize.y);
+	}
+	updatePositionAndTarget() {
+		this._shadowLightSources.forEach((e) => e.updatePositionAndTarget());
+	}
+	renderPass(e) {
+		if (!(this.needsUpdate || this.parameters.alwaysUpdate || this._cameraUpdate.changed(this.camera))) return;
+		this.needsUpdate = !1, this.shadowTypeNeedsUpdate && (this.shadowTypeNeedsUpdate = !1, this.needsUpdate = !0, this._updateShadowType(e));
+		let t = this.scene.background, n = this.scene.environment, r = this.camera.layers.mask;
+		this.scene.environment = null, this.scene.background = null, this.parameters.layers && (this.camera.layers.mask = this.parameters.layers.mask), this.renderPassManager.setGroundVisibility(this.drawGround), this._renderSimpleShadowMapFromShadowLightSources(e, this.scene, this.camera), this.renderPassManager.setGroundVisibility(!1), this.camera.layers.mask = r, this.scene.environment = n, this.scene.background = t;
+	}
+	_renderSimpleShadowMapFromShadowLightSources(e, t, n) {
+		this._shadowMapPassOverrideMaterialCache.setShadowParameters(this.parameters.enableGroundBoundary, this.parameters.directionalDependency, this.parameters.directionalExponent, this.parameters.groundBoundary, this._groundMapScale, this.parameters.fadeOutDistance * this._shadowScale, this.parameters.fadeOutBlur);
+		let r = this._getSortedShadowLightSources();
+		r.length === 0 ? this.passRenderer.clear(e, this._shadowRenderTarget, 16777215, 1) : (this._setShadowLightSourcesIntensity(r), this.renderCacheManager?.render(this, t, () => {
+			this.passRenderer.render(e, t, n, this._shadowRenderTarget, 16777215, 1);
+		}), this._shadowLightSources.forEach((e) => e.finishRenderShadow()));
+	}
+	_getSortedShadowLightSources() {
+		let e = [];
+		return this._shadowLightSources.forEach((t) => e.push(...t.prepareRenderShadow())), e.sort((e, t) => e.light.castShadow && !t.light.castShadow || e.groundShadow && !t.groundShadow ? -1 : !e.light.castShadow && t.light.castShadow || !e.groundShadow && t.groundShadow ? 1 : t.intensity - e.intensity), e;
+	}
+	_setShadowLightSourcesIntensity(e) {
+		let t = 0, n = this.parameters.maximumNumberOfLightSources, r = 0;
+		e.forEach((e) => {
+			(n < 0 || r < n) && (t += e.groundShadow ? 0 : e.intensity, e.groundShadow || r++);
+		}), r = 0, e.forEach((e) => {
+			(this.parameters.enableGroundBoundary || !e.groundShadow) && (n < 0 || r < n) ? (e.light.visible = !0, e.light.intensity = e.groundShadow ? e.intensity : e.intensity / t, e.light.castShadow &&= this.castShadow) : (e.light.visible = !1, e.light.intensity = 0, e.light.castShadow = !1), e.groundShadow || r++;
+		});
+	}
+	_updateShadowType(e) {
+		e.shadowMap.type = this.shadowConfiguration.currentConfiguration.type;
+		let t = this.parameters.enableShadowMap && this.shadowConfiguration.currentConfiguration.castShadow;
+		e.shadowMap.enabled = t, e.shadowMap.needsUpdate = !0, this.castShadow = t && this.shadowConfiguration.currentConfiguration.castShadow, this._shadowLightSources.forEach((e) => e._updateShadowType(this.shadowConfiguration.currentConfiguration, this._shadowScale));
+	}
+	switchType(e) {
+		return this.shadowConfiguration.switchType(e) ? (this.needsUpdate = !0, this.shadowTypeNeedsUpdate = !0, !0) : !1;
+	}
+}, qt = {
+	DEFAULT: "default",
+	UNLIT: "unlit",
+	EMISSIVE: "emissive",
+	SHADOW: "shadow"
+}, Jt = class e extends Dt {
+	static {
+		this.useModifiedMaterial = !0;
+	}
+	set shadowOnGround(e) {
+		this._shadowOnGround = e;
+	}
+	constructor() {
+		super(), this._boundingBoxSet = !1, this._shadowOnGround = !0, this._shadowObjectMaterial = this._createShadowMaterial(qt.DEFAULT), this._unlitMaterial = this._createShadowMaterial(qt.UNLIT), this._emissiveMaterial = this._createShadowMaterial(qt.EMISSIVE), this._receiveShadowMaterial = this._createShadowMaterial(qt.SHADOW);
+	}
+	dispose() {
+		this._shadowObjectMaterial.dispose(), this._unlitMaterial.dispose(), this._emissiveMaterial.dispose(), this._receiveShadowMaterial.dispose();
+	}
+	setShadowParameters(e, t, n, r, i, a, o) {
+		Vt.setShadowParameters(e, t, n, r, i, a, o);
+	}
+	setBoundingBox(e) {
+		this._boundingBoxSet = !0, Vt.setBoundingBox(e);
+	}
+	_createShadowMaterial(t) {
+		let n;
+		return n = t === qt.EMISSIVE || t === qt.UNLIT ? new c({
+			color: 16777215,
+			side: 2
+		}) : t === qt.SHADOW ? new A({ side: 2 }) : e.useModifiedMaterial ? this._createCustomerShadowMaterial() : new D({
+			color: 16777215,
+			shininess: 0,
+			polygonOffsetFactor: 0,
+			polygonOffsetUnits: 0,
+			side: 2
+		}), n;
+	}
+	_createCustomerShadowMaterial() {
+		return new Vt({ side: 2 });
+	}
+	addLineOrPoint(e) {
+		this.addToCache(e, { visible: !1 });
+	}
+	addMesh(e) {
+		e.visible && this._setMeshMaterialAndVisibility(e);
+	}
+	addObject(e) {
+		e.isLight && !e.userData.shadowLightSource && this.addToCache(e, { visible: !1 });
+	}
+	_setMeshMaterialAndVisibility(e) {
+		e.userData.isFloor ? this._setMeshShadowFloorMaterial(e) : e.material && e.receiveShadow && !Array.isArray(e.material) && !(e.material.transparent === !0 && e.material.opacity < .9) ? this._setShadowMaterialForOpaqueObject(e) : xt(e.material, .9) ? this.addToCache(e, { visible: !1 }) : e.receiveShadow ? this.addToCache(e, {
+			castShadow: !1,
+			material: this._receiveShadowMaterial
+		}) : this.addToCache(e, { visible: !1 });
+	}
+	_setShadowMaterialForOpaqueObject(e) {
+		let t = e.material;
+		t instanceof ce || t instanceof c ? this.addToCache(e, { material: this._unlitMaterial }) : t instanceof E ? this._setMeshShadowStandardMaterial(e, t) : this.addToCache(e, { material: e.receiveShadow ? this._shadowObjectMaterial : this._unlitMaterial });
+	}
+	_setMeshShadowStandardMaterial(e, t) {
+		let n = t.emissiveIntensity > 0 && (t.emissive.r > 0 || t.emissive.g > 0 || t.emissive.b > 0);
+		this.addToCache(e, {
+			castShadow: n ? !1 : e.castShadow,
+			material: n ? this._emissiveMaterial : e.receiveShadow ? this._shadowObjectMaterial : this._unlitMaterial
+		});
+	}
+	_setMeshShadowFloorMaterial(e) {
+		this._boundingBoxSet && this._shadowOnGround ? this.addToCache(e, {
+			visible: !0,
+			castShadow: !1,
+			receiveShadow: !0,
+			material: this._shadowObjectMaterial
+		}) : this.addToCache(e, { visible: !1 });
+	}
+}, Yt = class e {
+	constructor() {
+		this.types = new Map([
+			["off", e._noShadow],
+			["BasicShadowMap", e._basicShadow],
+			["PCFShadowMap", e._pcfShadow],
+			["VSMShadowMap", e._vcmShadow]
+		]), this.shadowType = "PCFShadowMap", this.currentConfiguration = this.types.get(this.shadowType) ?? e._defaultType;
+	}
+	static {
+		this._noShadow = {
+			castShadow: !1,
+			type: 1,
+			bias: 0,
+			normalBias: 0,
+			radius: 0
+		};
+	}
+	static {
+		this._basicShadow = {
+			castShadow: !0,
+			type: 0,
+			bias: -5e-5,
+			normalBias: .005,
+			radius: 0
+		};
+	}
+	static {
+		this._pcfShadow = {
+			castShadow: !0,
+			type: 1,
+			bias: -5e-5,
+			normalBias: .01,
+			radius: 4
+		};
+	}
+	static {
+		this._vcmShadow = {
+			castShadow: !0,
+			type: 3,
+			bias: 1e-4,
+			normalBias: 0,
+			radius: 15
+		};
+	}
+	static {
+		this._defaultType = e._pcfShadow;
+	}
+	switchType(t) {
+		return this.types.has(t) ? (this.currentConfiguration = this.types.get(t) ?? e._defaultType, !0) : !1;
+	}
+}, Xt = class {
+	constructor(e, t) {
+		this._isVisibleBackup = !0, this._castShadowBackup = !0, this._shadowMapSize = t?.shadowMapSize ?? 1024, this._blurSamples = t?.blurSamples ?? 8, this._shadowLightSource = e, this._shadowLightSource.visible = !1, this._shadowLightSource.castShadow = !0, this._shadowLightSource.shadow && (this._shadowLightSource.shadow.mapSize = new m(this._shadowMapSize, this._shadowMapSize), this._shadowLightSource.shadow.blurSamples = this._blurSamples, this._shadowLightSource.shadow.autoUpdate = !1), this._shadowLightSource.userData.shadowLightSource = this;
+	}
+	getPosition() {
+		return this._shadowLightSource.position;
+	}
+	getShadowLight() {
+		return this._shadowLightSource;
+	}
+	getOriginalLight() {
+		return null;
+	}
+	dispose() {
+		this._shadowLightSource.dispose();
+	}
+	addTo(e) {
+		e.add(this._shadowLightSource);
+	}
+	removeFrom(e) {
+		e.remove(this._shadowLightSource);
+	}
+	updatePositionAndTarget() {
+		this._updateShadowPositionAndTarget(this.getPosition(), new S(0, 0, 0));
+	}
+	updateBounds(e) {
+		if (this._shadowLightSource instanceof ne) {
+			let t = this._shadowLightSource.shadow.camera, n = e.bounds.clone().applyMatrix4(t.matrixWorldInverse), r = Math.max(.001, Math.min(-n.min.z, -n.max.z)), i = Math.max(-n.min.z, -n.max.z), a = Math.max(Math.abs(n.min.x), Math.abs(n.max.x)), o = Math.max(Math.abs(n.min.y), Math.abs(n.max.y)), s = Math.atan2(Math.hypot(o, a) * 1.05, r);
+			t.aspect = 1, t.near = r, t.far = i, this._shadowLightSource.angle = s;
+		} else if (this._shadowLightSource.shadow) {
+			let t = this._shadowLightSource.shadow.camera;
+			e.updateCameraViewVolumeFromBounds(t);
+			let n = t;
+			n.far += n.far - n.near, n.updateProjectionMatrix();
+		}
+		this._shadowLightSource.shadow && (this._shadowLightSource.shadow.needsUpdate = !0);
+	}
+	forceShadowUpdate() {
+		this._shadowLightSource.shadow && (this._shadowLightSource.shadow.needsUpdate = !0);
+	}
+	_updateShadowPositionAndTarget(e, t) {
+		if (this._shadowLightSource instanceof ne) {
+			let n = t.clone().sub(e), r = n.length();
+			n.normalize();
+			let i = t.clone().sub(n.clone().multiplyScalar(r * 4));
+			this._shadowLightSource.shadow.camera.position.copy(i), this._shadowLightSource.shadow.camera.position.copy(i), this._shadowLightSource.shadow.camera.lookAt(t), this._shadowLightSource.position.copy(i), this._shadowLightSource.lookAt(t);
+		} else this._shadowLightSource.position.copy(e), this._shadowLightSource.lookAt(t), this._shadowLightSource.shadow?.camera.position.copy(e), this._shadowLightSource.shadow?.camera.lookAt(t);
+		this._shadowLightSource.shadow?.camera.updateMatrixWorld(), this._shadowLightSource.updateMatrixWorld();
+	}
+	_updateShadowType(e, t) {
+		let n = this._shadowLightSource.shadow;
+		n && (n.bias = e.bias, n.normalBias = e.normalBias * t, n.radius = e.radius, n.needsUpdate = !0);
+	}
+	prepareRenderShadow() {
+		return [];
+	}
+	finishRenderShadow() {}
+}, Zt = class extends Xt {
+	constructor(e, t) {
+		let n;
+		switch (t?.shadowLightSourceType) {
+			default:
+			case Wt.DIRECTION_LIGHT_SHADOW:
+				n = new b(16777215, 1);
+				break;
+			case Wt.SPOT_LIGHT_SHADOW:
+				n = new ne(16777215, 1, 0, Math.PI / 4, 0);
+				break;
+		}
+		n.position.copy(e.position), n.lookAt(0, 0, 0), super(n, t), this._rectAreaLight = e, this._rectAreaLight.userData.shadowLightSource = this, t?.addHelper && (this._rectLightHelper = new Bt(this._rectAreaLight), this._rectLightHelper.material.depthWrite = !1, this._rectAreaLight.add(this._rectLightHelper));
+	}
+	getPosition() {
+		return this._rectAreaLight.position;
+	}
+	getRectAreaLight() {
+		return this._rectAreaLight;
+	}
+	getOriginalLight() {
+		return this._rectAreaLight;
+	}
+	prepareRenderShadow() {
+		return this._isVisibleBackup = this._rectAreaLight.visible, this._castShadowBackup = this._shadowLightSource.castShadow, this._shadowLightSource.visible = this._rectAreaLight.visible, this._rectAreaLight.visible = !1, this._shadowLightSource.visible ? [{
+			light: this._shadowLightSource,
+			intensity: this._rectAreaLight.intensity,
+			groundShadow: !1
+		}] : [];
+	}
+	finishRenderShadow() {
+		this._shadowLightSource.visible = !1, this._shadowLightSource.castShadow = this._castShadowBackup, this._rectAreaLight.visible = this._isVisibleBackup;
+	}
+}, Qt = class extends Xt {
+	constructor(e, t, n) {
+		let r = new b(16777215, t);
+		r.position.copy(e), r.lookAt(0, 0, 0), r.updateMatrix(), r.castShadow = !0, super(r, n), this._position = e.clone(), this._intensity = t;
+	}
+	getPosition() {
+		return this._position;
+	}
+	prepareRenderShadow() {
+		return this._castShadowBackup = this._shadowLightSource.castShadow, this._shadowLightSource.visible = !0, [{
+			light: this._shadowLightSource,
+			intensity: this._intensity,
+			groundShadow: !1
+		}];
+	}
+	finishRenderShadow() {
+		this._shadowLightSource.castShadow = this._castShadowBackup, this._shadowLightSource.visible = !1;
+	}
+}, $t = class extends Xt {
+	constructor(e, t) {
+		let n = new b(16777215, 1);
+		n.position.copy(e), n.lookAt(0, 0, 0), n.updateMatrix(), n.castShadow = !0, super(n, t), this._position = e.clone();
+	}
+	getPosition() {
+		return this._position;
+	}
+	prepareRenderShadow() {
+		return this._castShadowBackup = this._shadowLightSource.castShadow, this._shadowLightSource.visible = !0, [{
+			light: this._shadowLightSource,
+			intensity: 1,
+			groundShadow: !0
+		}];
+	}
+	finishRenderShadow() {
+		this._shadowLightSource.castShadow = this._castShadowBackup, this._shadowLightSource.visible = !1;
+	}
+}, en = {
+	name: "CopyShader",
+	uniforms: {
+		tDiffuse: { value: null },
+		opacity: { value: 1 }
+	},
+	vertexShader: "\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vUv = uv;\n			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n		}",
+	fragmentShader: "\n\n		uniform float opacity;\n\n		uniform sampler2D tDiffuse;\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vec4 texel = texture2D( tDiffuse, vUv );\n			gl_FragColor = opacity * texel;\n\n\n		}"
+}, tn = {
+	name: "FXAAShader",
+	uniforms: {
+		tDiffuse: { value: null },
+		resolution: { value: new m(1 / 1024, 1 / 512) }
+	},
+	vertexShader: "\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vUv = uv;\n			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n		}",
+	fragmentShader: "\n\n		uniform sampler2D tDiffuse;\n		uniform vec2 resolution;\n		varying vec2 vUv;\n\n		#define EDGE_STEP_COUNT 6\n		#define EDGE_GUESS 8.0\n		#define EDGE_STEPS 1.0, 1.5, 2.0, 2.0, 2.0, 4.0\n		const float edgeSteps[EDGE_STEP_COUNT] = float[EDGE_STEP_COUNT]( EDGE_STEPS );\n\n		float _ContrastThreshold = 0.0312;\n		float _RelativeThreshold = 0.063;\n		float _SubpixelBlending = 1.0;\n\n		vec4 Sample( sampler2D  tex2D, vec2 uv ) {\n\n			return texture( tex2D, uv );\n\n		}\n\n		float SampleLuminance( sampler2D tex2D, vec2 uv ) {\n\n			return dot( Sample( tex2D, uv ).rgb, vec3( 0.3, 0.59, 0.11 ) );\n\n		}\n\n		float SampleLuminance( sampler2D tex2D, vec2 texSize, vec2 uv, float uOffset, float vOffset ) {\n\n			uv += texSize * vec2(uOffset, vOffset);\n			return SampleLuminance(tex2D, uv);\n\n		}\n\n		struct LuminanceData {\n\n			float m, n, e, s, w;\n			float ne, nw, se, sw;\n			float highest, lowest, contrast;\n\n		};\n\n		LuminanceData SampleLuminanceNeighborhood( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n\n			LuminanceData l;\n			l.m = SampleLuminance( tex2D, uv );\n			l.n = SampleLuminance( tex2D, texSize, uv,  0.0,  1.0 );\n			l.e = SampleLuminance( tex2D, texSize, uv,  1.0,  0.0 );\n			l.s = SampleLuminance( tex2D, texSize, uv,  0.0, -1.0 );\n			l.w = SampleLuminance( tex2D, texSize, uv, -1.0,  0.0 );\n\n			l.ne = SampleLuminance( tex2D, texSize, uv,  1.0,  1.0 );\n			l.nw = SampleLuminance( tex2D, texSize, uv, -1.0,  1.0 );\n			l.se = SampleLuminance( tex2D, texSize, uv,  1.0, -1.0 );\n			l.sw = SampleLuminance( tex2D, texSize, uv, -1.0, -1.0 );\n\n			l.highest = max( max( max( max( l.n, l.e ), l.s ), l.w ), l.m );\n			l.lowest = min( min( min( min( l.n, l.e ), l.s ), l.w ), l.m );\n			l.contrast = l.highest - l.lowest;\n			return l;\n\n		}\n\n		bool ShouldSkipPixel( LuminanceData l ) {\n\n			float threshold = max( _ContrastThreshold, _RelativeThreshold * l.highest );\n			return l.contrast < threshold;\n\n		}\n\n		float DeterminePixelBlendFactor( LuminanceData l ) {\n\n			float f = 2.0 * ( l.n + l.e + l.s + l.w );\n			f += l.ne + l.nw + l.se + l.sw;\n			f *= 1.0 / 12.0;\n			f = abs( f - l.m );\n			f = clamp( f / l.contrast, 0.0, 1.0 );\n\n			float blendFactor = smoothstep( 0.0, 1.0, f );\n			return blendFactor * blendFactor * _SubpixelBlending;\n\n		}\n\n		struct EdgeData {\n\n			bool isHorizontal;\n			float pixelStep;\n			float oppositeLuminance, gradient;\n\n		};\n\n		EdgeData DetermineEdge( vec2 texSize, LuminanceData l ) {\n\n			EdgeData e;\n			float horizontal =\n				abs( l.n + l.s - 2.0 * l.m ) * 2.0 +\n				abs( l.ne + l.se - 2.0 * l.e ) +\n				abs( l.nw + l.sw - 2.0 * l.w );\n			float vertical =\n				abs( l.e + l.w - 2.0 * l.m ) * 2.0 +\n				abs( l.ne + l.nw - 2.0 * l.n ) +\n				abs( l.se + l.sw - 2.0 * l.s );\n			e.isHorizontal = horizontal >= vertical;\n\n			float pLuminance = e.isHorizontal ? l.n : l.e;\n			float nLuminance = e.isHorizontal ? l.s : l.w;\n			float pGradient = abs( pLuminance - l.m );\n			float nGradient = abs( nLuminance - l.m );\n\n			e.pixelStep = e.isHorizontal ? texSize.y : texSize.x;\n\n			if (pGradient < nGradient) {\n\n				e.pixelStep = -e.pixelStep;\n				e.oppositeLuminance = nLuminance;\n				e.gradient = nGradient;\n\n			} else {\n\n				e.oppositeLuminance = pLuminance;\n				e.gradient = pGradient;\n\n			}\n\n			return e;\n\n		}\n\n		float DetermineEdgeBlendFactor( sampler2D  tex2D, vec2 texSize, LuminanceData l, EdgeData e, vec2 uv ) {\n\n			vec2 uvEdge = uv;\n			vec2 edgeStep;\n			if (e.isHorizontal) {\n\n				uvEdge.y += e.pixelStep * 0.5;\n				edgeStep = vec2( texSize.x, 0.0 );\n\n			} else {\n\n				uvEdge.x += e.pixelStep * 0.5;\n				edgeStep = vec2( 0.0, texSize.y );\n\n			}\n\n			float edgeLuminance = ( l.m + e.oppositeLuminance ) * 0.5;\n			float gradientThreshold = e.gradient * 0.25;\n\n			vec2 puv = uvEdge + edgeStep * edgeSteps[0];\n			float pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n			bool pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n\n			for ( int i = 1; i < EDGE_STEP_COUNT && !pAtEnd; i++ ) {\n\n				puv += edgeStep * edgeSteps[i];\n				pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n				pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n\n			}\n\n			if ( !pAtEnd ) {\n\n				puv += edgeStep * EDGE_GUESS;\n\n			}\n\n			vec2 nuv = uvEdge - edgeStep * edgeSteps[0];\n			float nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n			bool nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n\n			for ( int i = 1; i < EDGE_STEP_COUNT && !nAtEnd; i++ ) {\n\n				nuv -= edgeStep * edgeSteps[i];\n				nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n				nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n\n			}\n\n			if ( !nAtEnd ) {\n\n				nuv -= edgeStep * EDGE_GUESS;\n\n			}\n\n			float pDistance, nDistance;\n			if ( e.isHorizontal ) {\n\n				pDistance = puv.x - uv.x;\n				nDistance = uv.x - nuv.x;\n\n			} else {\n\n				pDistance = puv.y - uv.y;\n				nDistance = uv.y - nuv.y;\n\n			}\n\n			float shortestDistance;\n			bool deltaSign;\n			if ( pDistance <= nDistance ) {\n\n				shortestDistance = pDistance;\n				deltaSign = pLuminanceDelta >= 0.0;\n\n			} else {\n\n				shortestDistance = nDistance;\n				deltaSign = nLuminanceDelta >= 0.0;\n\n			}\n\n			if ( deltaSign == ( l.m - edgeLuminance >= 0.0 ) ) {\n\n				return 0.0;\n\n			}\n\n			return 0.5 - shortestDistance / ( pDistance + nDistance );\n\n		}\n\n		vec4 ApplyFXAA( sampler2D  tex2D, vec2 texSize, vec2 uv ) {\n\n			LuminanceData luminance = SampleLuminanceNeighborhood( tex2D, texSize, uv );\n			if ( ShouldSkipPixel( luminance ) ) {\n\n				return Sample( tex2D, uv );\n\n			}\n\n			float pixelBlend = DeterminePixelBlendFactor( luminance );\n			EdgeData edge = DetermineEdge( texSize, luminance );\n			float edgeBlend = DetermineEdgeBlendFactor( tex2D, texSize, luminance, edge, uv );\n			float finalBlend = max( pixelBlend, edgeBlend );\n\n			if (edge.isHorizontal) {\n\n				uv.y += edge.pixelStep * finalBlend;\n\n			} else {\n\n				uv.x += edge.pixelStep * finalBlend;\n\n			}\n\n			return Sample( tex2D, uv );\n\n		}\n\n		void main() {\n\n			gl_FragColor = ApplyFXAA( tDiffuse, resolution.xy, vUv );\n\n		}"
+}, nn = class e extends J {
+	static {
+		this.BlurDirectionX = new m(1, 0);
+	}
+	static {
+		this.BlurDirectionY = new m(0, 1);
+	}
+	static {
+		this.highlightLines = !0;
+	}
+	constructor(e, t, n, r, i, a) {
+		super(e), this.patternTexture = null, this.clearBackground = !1, this.renderScene = n, this.renderCamera = r, this.selectedObjects = i === void 0 ? [] : i, this.visibleEdgeColor = new N(1, 1, 1), this.hiddenEdgeColor = new N(.1, .04, .02), this.edgeGlow = 0, this.usePatternTexture = !1, this.edgeThickness = 1, this.edgeStrength = 3, this.downSampleRatio = a?.downSampleRatio || 2, this.pulsePeriod = 0, this.edgeDetectionFxaa = a?.edgeDetectionFxaa || !1, this._visibilityCache = /* @__PURE__ */ new Map(), this.resolution = t === void 0 ? new m(256, 256) : new m(t.x, t.y);
+		let o = Math.round(this.resolution.x / this.downSampleRatio), s = Math.round(this.resolution.y / this.downSampleRatio);
+		this.renderTargetMaskBuffer = new u(this.resolution.x, this.resolution.y), this.renderTargetMaskBuffer.texture.name = "OutlinePass.mask", this.renderTargetMaskBuffer.texture.generateMipmaps = !1, this.prepareMaskMaterial = this._getPrepareMaskMaterial(this.gBufferTextures?.isFloatGBufferWithRgbNormalAlphaDepth), this.prepareMaskMaterial.side = 2, this.prepareMaskMaterial.fragmentShader = l(this.prepareMaskMaterial.fragmentShader, this.renderCamera), this.edgeDetectionFxaa && (this.fxaaRenderMaterial = new z(tn), this.fxaaRenderMaterial.uniforms.tDiffuse.value = this.renderTargetMaskBuffer.texture, this.fxaaRenderMaterial.uniforms.resolution.value.set(1 / this.resolution.x, 1 / this.resolution.y), this.renderTargetFxaaBuffer = new u(this.resolution.x, this.resolution.y), this.renderTargetFxaaBuffer.texture.name = "OutlinePass.fxaa", this.renderTargetFxaaBuffer.texture.generateMipmaps = !1), this.renderTargetMaskDownSampleBuffer = new u(o, s), this.renderTargetMaskDownSampleBuffer.texture.name = "OutlinePass.depthDownSample", this.renderTargetMaskDownSampleBuffer.texture.generateMipmaps = !1, this.renderTargetBlurBuffer1 = new u(o, s), this.renderTargetBlurBuffer1.texture.name = "OutlinePass.blur1", this.renderTargetBlurBuffer1.texture.generateMipmaps = !1, this.renderTargetBlurBuffer2 = new u(Math.round(o / 2), Math.round(s / 2)), this.renderTargetBlurBuffer2.texture.name = "OutlinePass.blur2", this.renderTargetBlurBuffer2.texture.generateMipmaps = !1, this.edgeDetectionMaterial = this._getEdgeDetectionMaterial(), this.renderTargetEdgeBuffer1 = new u(o, s), this.renderTargetEdgeBuffer1.texture.name = "OutlinePass.edge1", this.renderTargetEdgeBuffer1.texture.generateMipmaps = !1, this.renderTargetEdgeBuffer2 = new u(Math.round(o / 2), Math.round(s / 2)), this.renderTargetEdgeBuffer2.texture.name = "OutlinePass.edge2", this.renderTargetEdgeBuffer2.texture.generateMipmaps = !1, this.separableBlurMaterial1 = this._getSeperableBlurMaterial(4), this.separableBlurMaterial1.uniforms.texSize.value.set(o, s), this.separableBlurMaterial1.uniforms.kernelRadius.value = 1, this.separableBlurMaterial2 = this._getSeperableBlurMaterial(4), this.separableBlurMaterial2.uniforms.texSize.value.set(Math.round(o / 2), Math.round(s / 2)), this.separableBlurMaterial2.uniforms.kernelRadius.value = 4, this.overlayMaterial = this._getOverlayMaterial();
+		let c = en;
+		this.copyUniforms = y.clone(c.uniforms), this.copyUniforms.opacity.value = 1, this.materialCopy = new z({
+			uniforms: this.copyUniforms,
+			vertexShader: c.vertexShader,
+			fragmentShader: c.fragmentShader,
+			blending: 0,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0
+		}), this.enabled = !0, this.needsSwap = !1, this.oldClearColor = new N(), this.oldClearAlpha = 1, this.fsQuad = new Re(void 0), this.tempPulseColor1 = new N(), this.tempPulseColor2 = new N(), this.textureMatrix = new v();
+		function l(e, t) {
+			let n = t.isPerspectiveCamera ? "perspective" : "orthographic";
+			return e.replace(/DEPTH_TO_VIEW_Z/g, n + "DepthToViewZ");
+		}
+	}
+	dispose() {
+		super.dispose(), this.renderTargetMaskBuffer.dispose(), this.renderTargetFxaaBuffer?.dispose(), this.renderTargetMaskDownSampleBuffer.dispose(), this.renderTargetBlurBuffer1.dispose(), this.renderTargetBlurBuffer2.dispose(), this.renderTargetEdgeBuffer1.dispose(), this.renderTargetEdgeBuffer2.dispose(), this.prepareMaskMaterial.dispose(), this.fxaaRenderMaterial?.dispose(), this.edgeDetectionMaterial.dispose(), this.separableBlurMaterial1.dispose(), this.separableBlurMaterial2.dispose(), this.overlayMaterial.dispose(), this.materialCopy.dispose(), this.fsQuad.dispose();
+	}
+	setSize(e, t) {
+		this.renderTargetMaskBuffer.setSize(e, t);
+		let n = Math.round(e / this.downSampleRatio), r = Math.round(t / this.downSampleRatio);
+		this.renderTargetMaskDownSampleBuffer.setSize(n, r), this.renderTargetBlurBuffer1.setSize(n, r), this.renderTargetEdgeBuffer1.setSize(n, r), this.separableBlurMaterial1.uniforms.texSize.value.set(n, r), n = Math.round(n / 2), r = Math.round(r / 2), this.renderTargetBlurBuffer2.setSize(n, r), this.renderTargetEdgeBuffer2.setSize(n, r), this.separableBlurMaterial2.uniforms.texSize.value.set(n, r), this.fxaaRenderMaterial?.uniforms.resolution.value.set(1 / this.resolution.x, 1 / this.resolution.y), this.renderTargetFxaaBuffer?.setSize(e, t);
+	}
+	_canBeHighlighted(t) {
+		return t.isMesh || e.highlightLines && t.isLine;
+	}
+	_changeVisibilityOfSelectedObjects(e) {
+		let t = this._visibilityCache;
+		this.selectedObjects.forEach((n) => n.traverse((n) => {
+			this._canBeHighlighted(n) && (e === !0 ? n.visible = t.get(n) : (t.set(n, n.visible), n.visible = e));
+		}));
+	}
+	_changeVisibilityOfNonSelectedObjects(e) {
+		let t = this._visibilityCache, n = [];
+		this.selectedObjects.forEach((e) => e.traverse((e) => {
+			this._canBeHighlighted(e) && n.push(e);
+		})), this.renderScene.traverse((r) => {
+			if (this._canBeHighlighted(r) || r.isSprite) {
+				if (n.some((e) => e.id === r.id) === !1) {
+					let n = r.visible;
+					(e === !1 || t.get(r) === !0) && (r.visible = e), t.set(r, n);
+				}
+			} else r.isPoints && (e === !0 ? r.visible = t.get(r) : (t.set(r, r.visible), r.visible = e));
+		});
+	}
+	_updateTextureMatrix() {
+		this.textureMatrix.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1), this.textureMatrix.multiply(this.renderCamera.projectionMatrix), this.textureMatrix.multiply(this.renderCamera.matrixWorldInverse);
+	}
+	render(t, n, r, i, a) {
+		if (this.selectedObjects.length > 0) {
+			t.getClearColor(this.oldClearColor), this.oldClearAlpha = t.getClearAlpha();
+			let n = t.autoClear;
+			this.clearBackground && (t.setClearColor(0, 255), t.clear(!0, !1, !1)), t.autoClear = !1, a && t.state.buffers.stencil.setTest(!1), t.setClearColor(16777215, 1), this._changeVisibilityOfSelectedObjects(!1);
+			let i = this.renderScene.background;
+			this.renderScene.background = null, this._changeVisibilityOfSelectedObjects(!0), this._visibilityCache.clear(), this._updateTextureMatrix(), this._changeVisibilityOfNonSelectedObjects(!1), this.renderScene.overrideMaterial = this.prepareMaskMaterial, this.prepareMaskMaterial.uniforms.cameraNearFar.value.set(this.renderCamera.near, this.renderCamera.far), this.prepareMaskMaterial.uniforms.depthTexture.value = this.gBufferTextures.textureWithDepthValue, this.prepareMaskMaterial.uniforms.textureMatrix.value = this.textureMatrix, t.setRenderTarget(this.renderTargetMaskBuffer), t.clear(), t.render(this.renderScene, this.renderCamera), this.renderScene.overrideMaterial = null, this._changeVisibilityOfNonSelectedObjects(!0), this._visibilityCache.clear(), this.renderScene.background = i;
+			let o = this.renderTargetMaskBuffer;
+			if (this.edgeDetectionFxaa && this.fxaaRenderMaterial && this.renderTargetFxaaBuffer && (this.fxaaRenderMaterial.uniforms.tDiffuse.value = this.renderTargetMaskBuffer.texture, this.fsQuad.material = this.fxaaRenderMaterial, t.setRenderTarget(this.renderTargetFxaaBuffer), t.clear(), this.fsQuad.render(t), o = this.renderTargetFxaaBuffer), this.fsQuad.material = this.materialCopy, this.copyUniforms.tDiffuse.value = o.texture, t.setRenderTarget(this.renderTargetMaskDownSampleBuffer), t.clear(), this.fsQuad.render(t), this.tempPulseColor1.copy(this.visibleEdgeColor), this.tempPulseColor2.copy(this.hiddenEdgeColor), this.pulsePeriod > 0) {
+				let e = 1.25 / 2 + Math.cos(performance.now() * .01 / this.pulsePeriod) * .75 / 2;
+				this.tempPulseColor1.multiplyScalar(e), this.tempPulseColor2.multiplyScalar(e);
+			}
+			this.fsQuad.material = this.edgeDetectionMaterial, this.edgeDetectionMaterial.uniforms.maskTexture.value = this.renderTargetMaskDownSampleBuffer.texture, this.edgeDetectionMaterial.uniforms.texSize.value.set(this.renderTargetMaskDownSampleBuffer.width, this.renderTargetMaskDownSampleBuffer.height), this.edgeDetectionMaterial.uniforms.visibleEdgeColor.value = this.tempPulseColor1, this.edgeDetectionMaterial.uniforms.hiddenEdgeColor.value = this.tempPulseColor2, t.setRenderTarget(this.renderTargetEdgeBuffer1), t.clear(), this.fsQuad.render(t), this.fsQuad.material = this.separableBlurMaterial1, this.separableBlurMaterial1.uniforms.colorTexture.value = this.renderTargetEdgeBuffer1.texture, this.separableBlurMaterial1.uniforms.direction.value = e.BlurDirectionX, this.separableBlurMaterial1.uniforms.kernelRadius.value = this.edgeThickness, t.setRenderTarget(this.renderTargetBlurBuffer1), t.clear(), this.fsQuad.render(t), this.separableBlurMaterial1.uniforms.colorTexture.value = this.renderTargetBlurBuffer1.texture, this.separableBlurMaterial1.uniforms.direction.value = e.BlurDirectionY, t.setRenderTarget(this.renderTargetEdgeBuffer1), t.clear(), this.fsQuad.render(t), this.fsQuad.material = this.separableBlurMaterial2, this.separableBlurMaterial2.uniforms.colorTexture.value = this.renderTargetEdgeBuffer1.texture, this.separableBlurMaterial2.uniforms.direction.value = e.BlurDirectionX, t.setRenderTarget(this.renderTargetBlurBuffer2), t.clear(), this.fsQuad.render(t), this.separableBlurMaterial2.uniforms.colorTexture.value = this.renderTargetBlurBuffer2.texture, this.separableBlurMaterial2.uniforms.direction.value = e.BlurDirectionY, t.setRenderTarget(this.renderTargetEdgeBuffer2), t.clear(), this.fsQuad.render(t), this.fsQuad.material = this.overlayMaterial, this.overlayMaterial.uniforms.maskTexture.value = o.texture, this.overlayMaterial.uniforms.edgeTexture1.value = this.renderTargetEdgeBuffer1.texture, this.overlayMaterial.uniforms.edgeTexture2.value = this.renderTargetEdgeBuffer2.texture, this.overlayMaterial.uniforms.patternTexture.value = this.patternTexture, this.overlayMaterial.uniforms.edgeStrength.value = this.edgeStrength, this.overlayMaterial.uniforms.edgeGlow.value = this.edgeGlow, this.overlayMaterial.uniforms.usePatternTexture.value = this.usePatternTexture, a && t.state.buffers.stencil.setTest(!0), t.setRenderTarget(r), this.fsQuad.render(t), t.setClearColor(this.oldClearColor, this.oldClearAlpha), t.autoClear = n;
+		}
+		this.renderToScreen && r && (this.fsQuad.material = this.materialCopy, this.copyUniforms.tDiffuse.value = r.texture, t.setRenderTarget(null), this.fsQuad.render(t));
+	}
+	renderPass(e) {
+		this.render(e, null, null, 0, !1);
+	}
+	_getPrepareMaskMaterial(e) {
+		return new z({
+			uniforms: {
+				depthTexture: { value: null },
+				cameraNearFar: { value: new m(.5, .5) },
+				textureMatrix: { value: null }
+			},
+			defines: { FLOAT_ALPHA_DEPTH: e ? 1 : 0 },
+			vertexShader: "#include <morphtarget_pars_vertex>\n				#include <skinning_pars_vertex>\n\n				varying vec4 projTexCoord;\n				varying vec4 vPosition;\n				uniform mat4 textureMatrix;\n\n				void main() {\n\n					#include <skinbase_vertex>\n					#include <begin_vertex>\n					#include <morphtarget_vertex>\n					#include <skinning_vertex>\n					#include <project_vertex>\n\n					vPosition = mvPosition;\n\n					vec4 worldPosition = vec4( transformed, 1.0 );\n\n					#ifdef USE_INSTANCING\n\n						worldPosition = instanceMatrix * worldPosition;\n\n					#endif\n					\n					worldPosition = modelMatrix * worldPosition;\n\n					projTexCoord = textureMatrix * worldPosition;\n\n				}",
+			fragmentShader: "#include <packing>\n				varying vec4 vPosition;\n				varying vec4 projTexCoord;\n				uniform sampler2D depthTexture;\n				uniform vec2 cameraNearFar;\n\n				void main() {\n\n          #if FLOAT_ALPHA_DEPTH == 1\n					  float depth = texture2DProj( depthTexture, projTexCoord ).w;\n          #else\n            float depth = unpackRGBAToDepth(texture2DProj( depthTexture, projTexCoord ));\n          #endif\n					float viewZ = - DEPTH_TO_VIEW_Z( depth, cameraNearFar.x, cameraNearFar.y );\n					float depthTest = (-vPosition.z > viewZ) ? 1.0 : 0.0;\n					gl_FragColor = vec4(0.0, depthTest, 1.0, 1.0);\n\n				}"
+		});
+	}
+	_getEdgeDetectionMaterial() {
+		return new z({
+			uniforms: {
+				maskTexture: { value: null },
+				texSize: { value: new m(.5, .5) },
+				visibleEdgeColor: { value: new S(1, 1, 1) },
+				hiddenEdgeColor: { value: new S(1, 1, 1) }
+			},
+			vertexShader: "varying vec2 vUv;\n\n				void main() {\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n				}",
+			fragmentShader: "varying vec2 vUv;\n\n				uniform sampler2D maskTexture;\n				uniform vec2 texSize;\n				uniform vec3 visibleEdgeColor;\n				uniform vec3 hiddenEdgeColor;\n\n				void main() {\n					vec2 invSize = 1.0 / texSize;\n					vec4 uvOffset = vec4(1.0, 0.0, 0.0, 1.0) * vec4(invSize, invSize);\n					vec4 c1 = texture2D( maskTexture, vUv + uvOffset.xy);\n					vec4 c2 = texture2D( maskTexture, vUv - uvOffset.xy);\n					vec4 c3 = texture2D( maskTexture, vUv + uvOffset.yw);\n					vec4 c4 = texture2D( maskTexture, vUv - uvOffset.yw);\n					float diff1 = (c1.r - c2.r)*0.5;\n					float diff2 = (c3.r - c4.r)*0.5;\n					float d = length( vec2(diff1, diff2) );\n					float a1 = min(c1.g, c2.g);\n					float a2 = min(c3.g, c4.g);\n					float visibilityFactor = min(a1, a2);\n					vec3 edgeColor = 1.0 - visibilityFactor > 0.001 ? visibleEdgeColor : hiddenEdgeColor;\n					gl_FragColor = vec4(edgeColor, 1.0) * vec4(d);\n				}"
+		});
+	}
+	_getSeperableBlurMaterial(e) {
+		return new z({
+			defines: { MAX_RADIUS: e },
+			uniforms: {
+				colorTexture: { value: null },
+				texSize: { value: new m(.5, .5) },
+				direction: { value: new m(.5, .5) },
+				kernelRadius: { value: 1 }
+			},
+			vertexShader: "varying vec2 vUv;\n\n				void main() {\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n				}",
+			fragmentShader: "#include <common>\n				varying vec2 vUv;\n				uniform sampler2D colorTexture;\n				uniform vec2 texSize;\n				uniform vec2 direction;\n				uniform float kernelRadius;\n\n				float gaussianPdf(in float x, in float sigma) {\n					return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;\n				}\n\n				void main() {\n					vec2 invSize = 1.0 / texSize;\n					float sigma = kernelRadius/2.0;\n					float weightSum = gaussianPdf(0.0, sigma);\n					vec4 diffuseSum = texture2D( colorTexture, vUv) * weightSum;\n					vec2 delta = direction * invSize * kernelRadius/float(MAX_RADIUS);\n					vec2 uvOffset = delta;\n					for( int i = 1; i <= MAX_RADIUS; i ++ ) {\n						float x = kernelRadius * float(i) / float(MAX_RADIUS);\n						float w = gaussianPdf(x, sigma);\n						vec4 sample1 = texture2D( colorTexture, vUv + uvOffset);\n						vec4 sample2 = texture2D( colorTexture, vUv - uvOffset);\n						diffuseSum += ((sample1 + sample2) * w);\n						weightSum += (2.0 * w);\n						uvOffset += delta;\n					}\n					gl_FragColor = diffuseSum/weightSum;\n				}"
+		});
+	}
+	_getOverlayMaterial() {
+		return new z({
+			uniforms: {
+				maskTexture: { value: null },
+				edgeTexture1: { value: null },
+				edgeTexture2: { value: null },
+				patternTexture: { value: null },
+				edgeStrength: { value: 1 },
+				edgeGlow: { value: 1 },
+				usePatternTexture: { value: 0 }
+			},
+			vertexShader: "varying vec2 vUv;\n\n				void main() {\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n				}",
+			fragmentShader: "varying vec2 vUv;\n\n				uniform sampler2D maskTexture;\n				uniform sampler2D edgeTexture1;\n				uniform sampler2D edgeTexture2;\n				uniform sampler2D patternTexture;\n				uniform float edgeStrength;\n				uniform float edgeGlow;\n				uniform bool usePatternTexture;\n\n				void main() {\n					vec4 edgeValue1 = texture2D(edgeTexture1, vUv);\n					vec4 edgeValue2 = texture2D(edgeTexture2, vUv);\n					vec4 maskColor = texture2D(maskTexture, vUv);\n					vec4 patternColor = texture2D(patternTexture, 6.0 * vUv);\n					float visibilityFactor = 1.0 - maskColor.g > 0.0 ? 1.0 : 0.5;\n					vec4 edgeValue = edgeValue1 + edgeValue2 * edgeGlow;\n					vec4 finalColor = edgeStrength * maskColor.r * edgeValue;\n					if(usePatternTexture)\n						finalColor += + visibilityFactor * (1.0 - maskColor.r) * (1.0 - patternColor.r);\n					gl_FragColor = finalColor;\n                }",
+			blending: 2,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0
+		});
+	}
+}, rn = {
+	uniforms: { tDiffuse: { value: null } },
+	vertexShader: "\n          varying vec2 vUv;\n\n          void main() {\n              vUv = uv;\n              gl_Position = (projectionMatrix * modelViewMatrix * vec4(position, 1.0)).xyww;\n          }",
+	fragmentShader: "\n          uniform highp sampler2D tDiffuse;\n          varying vec2 vUv;\n\n          void main() {\n              vec4 textureColor = texture2D(tDiffuse, vUv);\n              float aoPassDepth = dot(textureColor.wz, vec2(1.0/1024.0));\n              gl_FragColor = vec4(vec3(aoPassDepth * aoPassDepth), 1.0);\n          }"
+}, an = class extends z {
+	constructor(e) {
+		super({
+			uniforms: y.clone(rn.uniforms),
+			vertexShader: rn.vertexShader,
+			fragmentShader: rn.fragmentShader,
+			transparent: !0,
+			depthTest: !1,
+			depthWrite: !1,
+			blendSrc: 208,
+			blendDst: 200,
+			blendEquation: 100,
+			blendSrcAlpha: 206,
+			blendDstAlpha: 200,
+			blendEquationAlpha: 100
+		}), this._intensity = new m(1, 1), this.update(e);
+	}
+	update(e) {
+		return e?.texture !== void 0 && (this.uniforms.tDiffuse.value = e.texture), e?.blending !== void 0 && (this.blending = e.blending), this;
+	}
+}, on = (e) => new m(Math.atan2(e.y, e.x) / (2 * Math.PI) + .5, Math.asin(e.z) / Math.PI + .5), sn = class {
+	get colorRenderTarget() {
+		return this._colorRenderTarget = this._colorRenderTarget ?? new u(), this._colorRenderTarget;
+	}
+	environmentMapDecodeTarget(e) {
+		let t = V(e) && e.capabilities.isWebGL2 ? T : P;
+		return this._environmentMapDecodeTarget = this._environmentMapDecodeTarget ?? new u(1, 1, { type: t }), this._environmentMapDecodeTarget;
+	}
+	environmentMapDecodeMaterial(e) {
+		return e ? (this._equirectangularDecodeMaterial = this._equirectangularDecodeMaterial ?? new ln(!0, !1), this._equirectangularDecodeMaterial) : (this._pmremDecodeMaterial = this._pmremDecodeMaterial ?? new ln(!1, !1), this._pmremDecodeMaterial);
+	}
+	get camera() {
+		return this._camera = this._camera ?? new k(-1, 1, 1, -1, -1, 1), this._camera;
+	}
+	scaleTexture(e, t, n, r) {
+		this.colorRenderTarget.setSize(n, r), this._planeMesh = this._planeMesh ?? new x(new se(2, 2), new c({ map: t }));
+		let i = e.getRenderTarget();
+		e.setRenderTarget(this.colorRenderTarget), e.render(this._planeMesh, this.camera), e.setRenderTarget(i);
+		let a = this.environmentMapDecodeTarget(e).texture, o = new Uint8Array(n * r * 4);
+		return e.readRenderTargetPixels(this.colorRenderTarget, 0, 0, n, r, o), {
+			texture: a,
+			pixels: o,
+			sRgbaPixels: !1
+		};
+	}
+	newGrayscaleTexture(e, t, n, r) {
+		let i = this.environmentMapDecodeMaterial(t.name === "PMREM.cubeUv"), a = this.environmentMapDecodeTarget(e);
+		a.setSize(n, r), i.setSourceTexture(t), this._planeMesh = this._planeMesh ?? new x(new se(2, 2), i);
+		let o = e.getRenderTarget();
+		e.setRenderTarget(a), e.render(this._planeMesh, this.camera), e.setRenderTarget(o);
+		let s = a.texture, c = a.texture.type === T, l = c ? new Float32Array(n * r * 4) : new Uint8Array(n * r * 4);
+		return e.readRenderTargetPixels(a, 0, 0, n, r, l), {
+			texture: s,
+			pixels: l,
+			sRgbaPixels: c
+		};
+	}
+}, cn = {
+	uniforms: { tDiffuse: { value: null } },
+	vertexShader: "\n        varying vec2 vUv;\n        void main() {\n            vUv = uv;\n            gl_Position = (projectionMatrix * modelViewMatrix * vec4(position, 1.0)).xyww;\n        }",
+	fragmentShader: "\n        uniform sampler2D tDiffuse;\n        varying vec2 vUv;\n        \n        float getFace( vec3 direction ) {\n          vec3 absDirection = abs( direction );\n          float face = - 1.0;\n          if ( absDirection.x > absDirection.z ) {\n            if ( absDirection.x > absDirection.y )\n              face = direction.x > 0.0 ? 0.0 : 3.0;\n            else\n              face = direction.y > 0.0 ? 1.0 : 4.0;\n          } else {\n            if ( absDirection.z > absDirection.y )\n              face = direction.z > 0.0 ? 2.0 : 5.0;\n            else\n              face = direction.y > 0.0 ? 1.0 : 4.0;\n          }\n          return face;\n        }\n\n        vec2 getUV( vec3 direction, float face ) {\n          vec2 uv;\n          if ( face == 0.0 ) {\n            uv = vec2( direction.z, direction.y ) / abs( direction.x ); // pos x\n          } else if ( face == 1.0 ) {\n            uv = vec2( - direction.x, - direction.z ) / abs( direction.y ); // pos y\n          } else if ( face == 2.0 ) {\n            uv = vec2( - direction.x, direction.y ) / abs( direction.z ); // pos z\n          } else if ( face == 3.0 ) {\n            uv = vec2( - direction.z, direction.y ) / abs( direction.x ); // neg x\n          } else if ( face == 4.0 ) {\n            uv = vec2( - direction.x, direction.z ) / abs( direction.y ); // neg y\n          } else {\n            uv = vec2( direction.x, direction.y ) / abs( direction.z ); // neg z\n          }\n          return 0.5 * ( uv + 1.0 );\n        }\n\n        void main() {\n            #if PMREM_DECODE == 1\n                float altitude = (vUv.y - 0.5) * 3.141593;\n                float azimuth = vUv.x * 2.0 * 3.141593;\n                vec3 direction = vec3(\n                  cos(altitude) * cos(azimuth) * -1.0, \n                  sin(altitude), \n                  cos(altitude) * sin(azimuth) * -1.0\n                );\n                float face = getFace(direction);\n                vec2 uv = getUV(direction, face) / vec2(3.0, 4.0);\n                if (face > 2.5) {\n                    uv.y += 0.25;\n                    face -= 3.0;\n                }\n                uv.x += face / 3.0;\n                vec4 color = texture2D(tDiffuse, uv);\n            #else\n                vec4 color = texture2D(tDiffuse, vUv);\n            #endif    \n            #if GRAYSCALE_CONVERT == 1\n                float grayscale = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));\n                //float grayscale = dot(color.rgb, vec3(1.0/3.0));\n                gl_FragColor = vec4(vec3(grayscale), 1.0);\n            #else\n                gl_FragColor = vec4(color.rgb, 1.0);\n            #endif\n        }"
+}, ln = class extends z {
+	constructor(e, t) {
+		super({
+			uniforms: y.clone(cn.uniforms),
+			vertexShader: cn.vertexShader,
+			fragmentShader: cn.fragmentShader,
+			defines: {
+				PMREM_DECODE: e ? 1 : 0,
+				GRAYSCALE_CONVERT: t ? 1 : 0
+			}
+		});
+	}
+	setSourceTexture(e) {
+		this.uniforms.tDiffuse.value = e;
+	}
+}, un = class {
+	constructor(e) {
+		this.samplePoints = [], this.sampleUVs = [], this.grayscaleTexture = {
+			texture: new a(),
+			pixels: new Uint8Array(),
+			sRgbaPixels: !1
+		}, this.detectorTexture = new a(), this.detectorArray = new Float32Array(), this.lightSamples = [], this.lightGraph = new fn(0), this.lightSources = [], this._grayScale = new S(.2126, .7152, .0722), this._createEquirectangularSamplePoints = (e) => {
+			let t = [];
+			for (let n = 0; n < e; n++) {
+				let r = n * Math.PI * (3 - Math.sqrt(5)), i = 1 - n / (e - 1) * 2, a = Math.sqrt(1 - i * i), o = Math.cos(r) * a, s = Math.sin(r) * a;
+				t.push(new S(o, s, i));
+			}
+			return t;
+		}, this._numberOfSamples = e?.numberOfSamples ?? 1e3, this._width = e?.width ?? 1024, this._height = e?.height ?? 512, this._sampleThreshold = e?.sampleThreshold ?? .707, this.pointDistance = Math.sqrt(4 * Math.PI) / Math.sqrt(this._numberOfSamples), this.pixelDistance = Math.sqrt(2) * Math.PI * 2 / this._width, this.samplePoints = this._createEquirectangularSamplePoints(this._numberOfSamples), this.sampleUVs = this.samplePoints.map((e) => on(e));
+	}
+	detectLightSources(e, t, n) {
+		this.textureData = n, this._textureConverter = this._textureConverter ?? new sn(), this.grayscaleTexture = this._textureConverter.newGrayscaleTexture(e, t, this._width, this._height), this.detectorArray = this._redFromRgbaToNormalizedFloatArray(this.grayscaleTexture.pixels, this.grayscaleTexture.sRgbaPixels), this.detectorTexture = this._grayscaleTextureFromFloatArray(this.detectorArray, this._width, this._height), this.lightSamples = this._filterLightSamples(this._sampleThreshold), this.lightGraph = this._findClusterSegments(this.lightSamples, this._sampleThreshold), this.lightGraph.findConnectedComponents(), this.lightSources = this.createLightSourcesFromLightGraph(this.lightSamples, this.lightGraph), this.lightSources.sort((e, t) => t.maxIntensity - e.maxIntensity);
+	}
+	_redFromRgbaToNormalizedFloatArray(e, t, n) {
+		let r = new Float32Array(e.length / 4), i = 1, a = 0;
+		for (let t = 0; t < e.length / 4; ++t) {
+			let n = new N(...e.slice(t * 4, t * 4 + 3));
+			e instanceof Float32Array && n.convertSRGBToLinear();
+			let o = new S(n.r, n.g, n.b).dot(this._grayScale);
+			i = Math.min(i, o), a = Math.max(a, o), r[t] = o;
+		}
+		if (n) for (let e = 0; e < r.length; ++e) r[e] = (t ? r[e] : (r[e] - i) / (a - i)) ** +n;
+		else if (!t) for (let e = 0; e < r.length; ++e) r[e] = (r[e] - i) / (a - i);
+		return r;
+	}
+	_grayscaleTextureFromFloatArray(e, t, n) {
+		let r = t * n, i = new Uint8Array(4 * r);
+		for (let t = 0; t < r; t++) {
+			let n = e[t] * 255;
+			i[t * 4 + 0] = n, i[t * 4 + 1] = n, i[t * 4 + 2] = n, i[t * 4 + 3] = 255;
+		}
+		let a = new s(i, t, n);
+		return a.needsUpdate = !0, a;
+	}
+	_filterLightSamples(e) {
+		let t = [];
+		for (let n = 0; n < this.sampleUVs.length; n++) {
+			let r = this.sampleUVs[n];
+			this._detectorTextureLuminanceValueFromUV(r) > e && t.push(new dn(this.samplePoints[n], r));
+		}
+		return t;
+	}
+	_detectorTextureLuminanceValueFromUV(e) {
+		let t = Math.floor(e.x * this._width), n = Math.floor(e.y * this._height) * this._width + t;
+		return this.detectorArray[n];
+	}
+	_originalLuminanceValueFromUV(e) {
+		if (!this.textureData || !this.textureData.data || !this.textureData._width || !this.textureData._height) return this._detectorTextureLuminanceValueFromUV(e) * 256;
+		let t = Math.floor(e.x * this.textureData._width), n = Math.floor(e.y * this.textureData._height), r = 0;
+		for (let e = Math.max(0, t - 2); e < Math.max(0, t + 2); ++e) for (let t = Math.max(0, n - 2); t < Math.max(0, n + 2); ++t) {
+			let n = t * this.textureData._width + e, i = (this.textureData.data[n * 4] + this.textureData.data[n * 4 + 1] + this.textureData.data[n * 4 + 2]) / 3;
+			r = Math.max(r, i);
+		}
+		return r;
+	}
+	_findClusterSegments(e, t) {
+		let n = this.pixelDistance * 2, r = this.pointDistance * 1.5, i = new fn(e.length);
+		for (let a = 0; a < e.length; a++) for (let o = a + 1; o < e.length; o++) if (e[a].position.angleTo(e[o].position) < r) {
+			let r = e[o].position.clone().sub(e[a].position), s = Math.floor(r.length() / n), c = !0, l = 0;
+			for (let n = 1; n < s; n++) {
+				let i = r.clone().multiplyScalar(n / s), o = on(e[a].position.clone().add(i).normalize());
+				if (this._detectorTextureLuminanceValueFromUV(o) < t) {
+					if (l++, l > 1) {
+						c = !1;
+						break;
+					}
+				} else l = 0;
+			}
+			c && (i.adjacent[a].push(o), i.adjacent[o].push(a), i.edges.push([a, o]));
+		}
+		return i;
+	}
+	createLightSourcesFromLightGraph(e, t) {
+		let n = t.components.filter((e) => e.length > 1).map((t) => new pn(t.map((t) => e[t])));
+		return n.forEach((e) => e.calculateLightSourceProperties((e) => this._originalLuminanceValueFromUV(e))), n;
+	}
+}, dn = class {
+	constructor(e, t) {
+		this.position = e, this.uv = t;
+	}
+}, fn = class {
+	constructor(e) {
+		this.edges = [], this.adjacent = [], this.components = [], this.noOfNodes = e;
+		for (let t = 0; t < e; t++) this.adjacent.push([]);
+	}
+	findConnectedComponents() {
+		let e = Array(this.noOfNodes).fill(!1);
+		this.components = [];
+		for (let t = 0; t < this.noOfNodes; t++) if (!e[t]) {
+			let n = [];
+			this._dfs(t, e, n), this.components.push(n);
+		}
+		this.components.sort((e, t) => t.length - e.length);
+	}
+	_dfs(e, t, n) {
+		t[e] = !0, n.push(e);
+		for (let r of this.adjacent[e]) t[r] || this._dfs(r, t, n);
+	}
+}, pn = class {
+	constructor(e) {
+		this.position = new S(), this.uv = new m(), this.averageIntensity = 0, this.maxIntensity = 0, this.size = 0, this.lightSamples = e;
+	}
+	calculateLightSourceProperties(e) {
+		this.position = new S(), this.averageIntensity = 0, this.maxIntensity = 0;
+		for (let t of this.lightSamples) {
+			this.position.add(t.position);
+			let n = e(t.uv);
+			this.averageIntensity += n, this.maxIntensity = Math.max(this.maxIntensity, n);
+		}
+		this.averageIntensity /= this.lightSamples.length, this.position.normalize(), this.uv = on(this.position);
+		let t = 0;
+		for (let e of this.lightSamples) t += e.position.distanceTo(this.position);
+		t /= this.lightSamples.length, this.size = t / Math.PI;
+	}
+}, mn = class extends J {
+	constructor(e) {
+		super(e), this.debugOutput = "", this._environmentMapDecodeMaterial = new ln(!0, !1), this._environmentMapDecodeMaterial.blending = 0, this._environmentMapDecodeMaterial.depthTest = !1;
+	}
+	dispose() {
+		this._depthRenderMaterial?.dispose(), this._copyMaterial?.dispose(), this._srgbToLinearCopyMaterial?.dispose();
+	}
+	getCopyMaterial(e) {
+		return this._copyMaterial = this._copyMaterial ?? new Ae(), this._copyMaterial.update(e);
+	}
+	getBlendAoAndShadowMaterial(e) {
+		return this._blendAoAndShadowMaterial = this._blendAoAndShadowMaterial ?? new rt({ blending: 0 }), this._blendAoAndShadowMaterial.update(e);
+	}
+	getBlendAoPassDepthMaterial(e) {
+		return this._blendAoPassDepthMaterial = this._blendAoPassDepthMaterial ?? new an({ blending: 0 }), this._blendAoPassDepthMaterial.update(e);
+	}
+	getSrgbToLinearCopyMaterial(e) {
+		return this._srgbToLinearCopyMaterial = this._copyMaterial ?? new Ae({}, ke.ADDITIVE, !0, !0), this._srgbToLinearCopyMaterial.update(e);
+	}
+	_getDepthRenderMaterial(e) {
+		return this._depthRenderMaterial = this._depthRenderMaterial ?? new Pe({
+			depthTexture: this.gBufferTextures.textureWithDepthValue,
+			depthFilter: this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? new B(0, 0, 0, 1) : new B(1, 0, 0, 0)
+		}), this._depthRenderMaterial.update({ camera: e });
+	}
+	renderPass(e) {
+		switch (this.debugOutput) {
+			default: break;
+			case "lineardepth":
+				this.passRenderer.renderScreenSpace(e, this._getDepthRenderMaterial(this.camera), null);
+				break;
+			case "g-normal":
+				this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.gBufferTextures?.gBufferTexture,
+					blending: 0,
+					colorTransform: new v().set(.5, 0, 0, 0, 0, .5, 0, 0, 0, 0, .5, 0, 0, 0, 0, 0),
+					colorBase: new B(.5, .5, .5, 1),
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null) : this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.gBufferTextures?.gBufferTexture,
+					blending: 0,
+					colorTransform: Ee,
+					colorBase: G,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "g-depth":
+				this.gBufferTextures.isFloatGBufferWithRgbNormalAlphaDepth ? this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.gBufferTextures?.gBufferTexture,
+					blending: 0,
+					colorTransform: De,
+					colorBase: G,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null) : this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.gBufferTextures?.depthBufferTexture,
+					blending: 0,
+					colorTransform: Oe,
+					colorBase: G,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "ssao":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.aoAndSoftShadowRenderTarget.texture,
+					blending: 0,
+					colorTransform: U,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "ssaodenoise":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.denoiseRenderTargetTexture,
+					blending: 0,
+					colorTransform: U,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "shadowmap":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.screenSpaceShadowMapPass.shadowTexture,
+					blending: 0,
+					colorTransform: U,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "shadowsoft":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.aoAndSoftShadowRenderTarget.texture,
+					blending: 0,
+					colorTransform: ut.shadowTransform,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "shadowdenoise":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.denoiseRenderTargetTexture,
+					blending: 0,
+					colorTransform: ut.shadowTransform,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "shadowfadein":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.fadeRenderTarget.texture,
+					blending: 0,
+					colorTransform: ut.shadowTransform,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "shadowandao":
+				this.passRenderer.renderScreenSpace(e, this.getBlendAoAndShadowMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.denoiseRenderTargetTexture,
+					blending: 0,
+					aoIntensity: this.renderPassManager.shadowAndAoPass.parameters.aoIntensity,
+					shadowIntensity: this.renderPassManager.shadowAndAoPass.parameters.shadowIntensity
+				}), null);
+				break;
+			case "shadowandaodepth":
+				this.passRenderer.renderScreenSpace(e, this.getBlendAoPassDepthMaterial({
+					texture: this.renderPassManager.shadowAndAoPass.denoiseRenderTargetTexture,
+					blending: 0
+				}), null);
+				break;
+			case "materialao":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.aoPassMapTexture,
+					blending: 0,
+					colorTransform: Te,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "groundreflection":
+				this.passRenderer.renderScreenSpace(e, this.getSrgbToLinearCopyMaterial({
+					texture: this.renderPassManager.groundReflectionPass.reflectionRenderTarget.texture,
+					blending: 0,
+					colorTransform: Te,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: q
+				}), null);
+				break;
+			case "groundreflectionfinal":
+				this.passRenderer.renderScreenSpace(e, this.getSrgbToLinearCopyMaterial({
+					texture: this.renderPassManager.groundReflectionPass.intensityRenderTarget.texture,
+					blending: 0,
+					colorTransform: Te,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: q
+				}), null);
+				break;
+			case "bakedgroundshadow":
+				this.passRenderer.renderScreenSpace(e, this.getCopyMaterial({
+					texture: this.renderPassManager.bakedGroundContactShadowPass.renderTarget.texture,
+					blending: 0,
+					colorTransform: Te,
+					colorBase: W,
+					multiplyChannels: 0,
+					uvTransform: K
+				}), null);
+				break;
+			case "environmentmap":
+				this._environmentMapDecodeMaterial.setSourceTexture(this.scene.environment), this.passRenderer.renderScreenSpace(e, this._environmentMapDecodeMaterial, null);
+				break;
+			case "lightsourcedetection":
+				if (this.scene.userData?.environmentDefinition) {
+					let t = this.renderPassManager.aspect, n = new k(-1, 1, 1 / t, -1 / t, -1, 1), r = this.scene.userData?.environmentDefinition.createDebugScene(e, this.scene, this.renderPassManager.screenSpaceShadowMapPass.parameters.maximumNumberOfLightSources);
+					r.background = new N(16777215), e.render(r, n);
+				}
+				break;
+		}
+	}
+}, hn = class extends J {
+	constructor(e) {
+		super(e), this.drawGround = !0, this.drawWithDebugMaterial = !1, this.grayDebugMaterial = new E({
+			color: 12632256,
+			side: 2,
+			envMapIntensity: .4
+		});
+	}
+	dispose() {
+		super.dispose(), this.grayDebugMaterial.dispose();
+	}
+	renderPass(e) {
+		this.renderCacheManager.onBeforeRender("floorDepthWrite", this.scene), this.renderPassManager.setGroundVisibility(this.drawGround), this.drawWithDebugMaterial ? this.renderCacheManager.render("debug", this.scene, () => {
+			this.passRenderer.renderWithOverrideMaterial(e, this.scene, this.camera, this.grayDebugMaterial, null, 0, 1);
+		}) : e.render(this.scene, this.camera), this.renderPassManager.setGroundVisibility(!1), this.renderCacheManager.onAfterRender("floorDepthWrite");
+	}
+}, gn = class e {
+	constructor() {
+		this.applyAoAndShadowToAlpha = !1, this._aoPassMapUniform = { value: null }, this._aoPassMapScaleUniform = { value: 1 }, this._aoPassMapIntensityUniform = { value: 1 }, this._shPassMapIntensityUniform = { value: 1 }, this._reflectionPassMapUniform = { value: null }, this._reflectionPassMapScaleUniform = { value: 1 }, this._reflectionPassMapIntensityUniform = { value: 0 }, this.applyReflectionPassMap = !1;
+	}
+	set aoPassMap(e) {
+		this._aoPassMapUniform.value = e;
+	}
+	set aoPassMapScale(e) {
+		this._aoPassMapScaleUniform.value = e;
+	}
+	set aoPassMapIntensity(e) {
+		this._aoPassMapIntensityUniform.value = e;
+	}
+	set shPassMapIntensity(e) {
+		this._shPassMapIntensityUniform.value = e;
+	}
+	set reflectionPassMap(e) {
+		this._reflectionPassMapUniform.value = e;
+	}
+	set reflectionPassMapScale(e) {
+		this._reflectionPassMapScaleUniform.value = e;
+	}
+	set reflectionPassMapIntensity(e) {
+		this._reflectionPassMapIntensityUniform.value = e;
+	}
+	static addPlugin(t) {
+		if (St(t)) return null;
+		if (t.userData.postProcessingMaterialPlugin !== void 0) return t.userData.postProcessingMaterialPlugin instanceof e ? t.userData.postProcessingMaterialPlugin : null;
+		let n = new e();
+		return t.userData.postProcessingMaterialPlugin = n, t.onBeforeCompile = (e, t) => n._onBeforeCompile(e, t), t.customProgramCacheKey = () => n._customProgramCacheKey(), n;
+	}
+	_isEnabled() {
+		return this._aoPassMapUniform.value !== void 0 && this._aoPassMapUniform.value !== null;
+	}
+	_customProgramCacheKey() {
+		let e = "";
+		return this._isEnabled() && (e += "aoPassMap" + (this.applyAoAndShadowToAlpha ? "Alpha" : "")), this.applyReflectionPassMap && (e += "reflectionPassMap"), e;
+	}
+	_onBeforeCompile(e, t) {
+		if (this._isEnabled() || this.applyReflectionPassMap) {
+			let t = this.applyAoAndShadowToAlpha ? "#define USE_APPLY_AO_AND_SHADOW_TO_ALPHA\n" : "";
+			t += this.applyReflectionPassMap ? "#define USE_REFLECTION_PASS_MAP\n" : "", t += _n, e.fragmentShader = e.fragmentShader.replace("#include <aomap_pars_fragment>", t), e.fragmentShader = e.fragmentShader.replace("#include <aomap_fragment>", vn), this._initUniforms(e);
+		}
+	}
+	_initUniforms(e) {
+		e && (e.uniforms.tAoPassMap = this._aoPassMapUniform, e.uniforms.aoPassMapScale = this._aoPassMapScaleUniform, e.uniforms.aoPassMapIntensity = this._aoPassMapIntensityUniform, e.uniforms.shPassMapIntensity = this._shPassMapIntensityUniform, e.uniforms.tReflectionPassMap = this._reflectionPassMapUniform, e.uniforms.reflectionPassMapScale = this._reflectionPassMapScaleUniform, e.uniforms.reflectionPassMapIntensity = this._reflectionPassMapIntensityUniform);
+	}
+}, _n = "\n#ifdef USE_AOMAP\n\n	uniform sampler2D aoMap;\n	uniform float aoMapIntensity;\n\n#endif\n\n	uniform highp sampler2D tAoPassMap;\n  uniform float aoPassMapScale;\n  uniform float aoPassMapIntensity;\n  uniform float shPassMapIntensity;\n  uniform sampler2D tReflectionPassMap;\n  uniform float reflectionPassMapScale;\n  uniform float reflectionPassMapIntensity;\n", vn = "\n#ifndef AOPASSMAP_SWIZZLE\n	#define AOPASSMAP_SWIZZLE rg\n#endif\n\nfloat ambientOcclusion = 1.0;\nfloat shadowValue = 1.0;\n\n#ifdef USE_AOMAP\n\n	// reads channel R, compatible with a combined OcclusionRoughnessMetallic (RGB) texture\n	ambientOcclusion = texture2D( aoMap, vAoMapUv ).r;\n  ambientOcclusion = ( ambientOcclusion - 1.0 ) * aoMapIntensity + 1.0;\n\n#endif\n\n  vec4 aoAndShadowMap = texelFetch( tAoPassMap, ivec2( gl_FragCoord.xy * aoPassMapScale ), 0 );\n  vec2 aoAndShadow = aoAndShadowMap.rg;\n  float depthDelta = abs( dot(aoAndShadowMap.wz, vec2(1.0/1024.0)) - gl_FragCoord.z );\n  const ivec2 aoOffsetArray[8] = ivec2[8](\n    ivec2(1, 0), ivec2(-1, 0), ivec2(0, 1), ivec2(0, -1), ivec2(1, 1), ivec2(-1, 1), ivec2(1, -1), ivec2(-1, -1));\n  for (int aoOffsetI = 0; aoOffsetI < 8; aoOffsetI++) {\n    aoAndShadowMap = texelFetch( tAoPassMap, ivec2( gl_FragCoord.xy * aoPassMapScale ) + aoOffsetArray[aoOffsetI], 0 );\n    float testDepthDelta = abs( dot(aoAndShadowMap.wz, vec2(1.0/1024.0)) - gl_FragCoord.z );\n    if (testDepthDelta < depthDelta) {\n      aoAndShadow = aoAndShadowMap.rg;\n      depthDelta = testDepthDelta;\n    }\n  }\n\n  float aoPassMapValue = aoPassMapIntensity < 0.0 ? 1.0 : max(0.0, (aoAndShadow.r - 1.0) * aoPassMapIntensity + 1.0);\n  shadowValue = shPassMapIntensity < 0.0 ? 1.0 : max(0.0, (aoAndShadow.g - 1.0) * shPassMapIntensity + 1.0);\n\n  #ifdef USE_REFLECTION_PASS_MAP\n\n    ivec2 reflectionPassMapSize = textureSize( tReflectionPassMap, 0 );\n    vec2 reflectionPassMapUv = vec2( gl_FragCoord.x * reflectionPassMapScale, float(reflectionPassMapSize.y) - gl_FragCoord.y * reflectionPassMapScale );\n    vec4 reflectionPassMapColor = texture2D( tReflectionPassMap, reflectionPassMapUv / vec2(reflectionPassMapSize) );\n    if (reflectionPassMapColor.a > 0.0) reflectionPassMapColor.rgb /= reflectionPassMapColor.a;\n    vec3 diffuseReflectionPassMapColor = reflectionPassMapColor.rgb * material.diffuseColor;\n    reflectedLight.indirectDiffuse += diffuseReflectionPassMapColor * reflectionPassMapColor.a * reflectionPassMapIntensity;\n    //reflectedLight.indirectDiffuse = mix(reflectedLight.indirectDiffuse, diffuseReflectionPassMapColor, reflectionPassMapColor.a * reflectionPassMapIntensity);\n\n  #endif\n\n  #if defined ( USE_APPLY_AO_AND_SHADOW_TO_ALPHA )\n    diffuseColor.a = 1.0 - (1.0 - diffuseColor.a) * aoPassMapValue * shadowValue;\n  #else\n    ambientOcclusion = min( ambientOcclusion, aoPassMapValue );\n  #endif\n\n	reflectedLight.indirectDiffuse *= ambientOcclusion * shadowValue;\n\n	#if defined( USE_CLEARCOAT )\n		clearcoatSpecularIndirect *= ambientOcclusion * shadowValue;\n	#endif\n\n	#if defined( USE_SHEEN )\n		sheenSpecularIndirect *= ambientOcclusion * shadowValue;\n	#endif\n\n	#if defined( USE_ENVMAP ) && defined( STANDARD )\n\n		float dotNV = saturate( dot( geometryNormal, geometryViewDir ) );\n\n        float specularOcclusion = computeSpecularOcclusion( dotNV, ambientOcclusion * shadowValue, material.roughness );\n		reflectedLight.indirectSpecular *= specularOcclusion;\n\n    #ifdef USE_REFLECTION_PASS_MAP\n        reflectedLight.indirectSpecular += material.specularColor * reflectionPassMapColor.rgb * reflectionPassMapColor.a * reflectionPassMapIntensity * specularOcclusion;\n    #endif\n\n	#endif\n", yn = class extends Fe {
+	constructor(e, t = "tDiffuse") {
+		super(), this.textureID = t, this.uniforms = null, this.material = null, e instanceof z ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = y.clone(e.uniforms), this.material = new z({
+			name: e.name === void 0 ? "unspecified" : e.name,
+			defines: Object.assign({}, e.defines),
+			uniforms: this.uniforms,
+			vertexShader: e.vertexShader,
+			fragmentShader: e.fragmentShader
+		})), this._fsQuad = new Re(this.material);
+	}
+	render(e, t, n) {
+		this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = n.texture), this._fsQuad.material = this.material, this.renderToScreen ? (e.setRenderTarget(null), this._fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this._fsQuad.render(e));
+	}
+	dispose() {
+		this.material.dispose(), this._fsQuad.dispose();
+	}
+}, bn = {
+	name: "LUTShader",
+	uniforms: {
+		lut: { value: null },
+		lutSize: { value: 0 },
+		tDiffuse: { value: null },
+		intensity: { value: 1 }
+	},
+	vertexShader: "\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vUv = uv;\n			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n		}\n\n	",
+	fragmentShader: "\n\n		uniform float lutSize;\n		uniform sampler3D lut;\n\n		varying vec2 vUv;\n		uniform float intensity;\n		uniform sampler2D tDiffuse;\n		void main() {\n\n			vec4 val = texture2D( tDiffuse, vUv );\n			vec4 lutVal;\n\n			// pull the sample in by half a pixel so the sample begins\n			// at the center of the edge pixels.\n			float pixelWidth = 1.0 / lutSize;\n			float halfPixelWidth = 0.5 / lutSize;\n			vec3 uvw = vec3( halfPixelWidth ) + val.rgb * ( 1.0 - pixelWidth );\n\n\n			lutVal = vec4( texture( lut, uvw ).rgb, val.a );\n\n			gl_FragColor = vec4( mix( val, lutVal, intensity ) );\n\n		}\n\n	"
+}, xn = class extends yn {
+	constructor(e = {}) {
+		super(bn), this.lut = e.lut || null, this.intensity = "intensity" in e ? e.intensity : 1;
+	}
+	set lut(e) {
+		let t = this.material;
+		e !== this.lut && (t.uniforms.lut.value = null, e && (t.uniforms.lutSize.value = e.image.width, t.uniforms.lut.value = e));
+	}
+	get lut() {
+		return this.material.uniforms.lut.value;
+	}
+	set intensity(e) {
+		this.material.uniforms.intensity.value = e;
+	}
+	get intensity() {
+		return this.material.uniforms.intensity.value;
+	}
+}, Sn = class extends o {
+	constructor(e) {
+		super(e), this.type = P;
+	}
+	setType(e) {
+		return this.type = e, this;
+	}
+	load(e, t, n, i) {
+		let a = new r(this.manager);
+		a.setPath(this.path), a.setResponseType("text"), a.load(e, (n) => {
+			try {
+				t(this.parse(n));
+			} catch (t) {
+				i ? i(t) : console.error(t), this.manager.itemError(e);
+			}
+		}, n, i);
+	}
+	parse(e) {
+		let t = /TITLE +"([^"]*)"/, n = /LUT_3D_SIZE +(\d+)/, r = /DOMAIN_MIN +([\d.]+) +([\d.]+) +([\d.]+)/, i = /DOMAIN_MAX +([\d.]+) +([\d.]+) +([\d.]+)/, a = /^([\d.e+-]+) +([\d.e+-]+) +([\d.e+-]+) *$/gm, o = t.exec(e), s = o === null ? null : o[1];
+		if (o = n.exec(e), o === null) throw Error("LUTCubeLoader: Missing LUT_3D_SIZE information");
+		let c = Number(o[1]), l = c ** 3 * 4, u = this.type === 1009 ? new Uint8Array(l) : new Float32Array(l), d = new S(0, 0, 0), f = new S(1, 1, 1);
+		if (o = r.exec(e), o !== null && d.set(Number(o[1]), Number(o[2]), Number(o[3])), o = i.exec(e), o !== null && f.set(Number(o[1]), Number(o[2]), Number(o[3])), d.x > f.x || d.y > f.y || d.z > f.z) throw Error("LUTCubeLoader: Invalid input domain");
+		let p = this.type === 1009 ? 255 : 1, m = 0;
+		for (; (o = a.exec(e)) !== null;) u[m++] = Number(o[1]) * p, u[m++] = Number(o[2]) * p, u[m++] = Number(o[3]) * p, u[m++] = p;
+		let h = new le();
+		return h.image.data = u, h.image.width = c, h.image.height = c, h.image.depth = c, h.type = this.type, h.magFilter = w, h.minFilter = w, h.wrapS = L, h.wrapT = L, h.wrapR = L, h.generateMipmaps = !1, h.needsUpdate = !0, {
+			title: s,
+			size: c,
+			domainMin: d,
+			domainMax: f,
+			texture3D: h
+		};
+	}
+}, Cn = class extends o {
+	constructor(e) {
+		super(e), this.flip = !1;
+	}
+	load(e, t, n, r) {
+		let i = new ue(this.manager);
+		i.setCrossOrigin(this.crossOrigin), i.setPath(this.path), i.load(e, (n) => {
+			try {
+				let e;
+				e = n.image.width < n.image.height ? this._getImageData(n) : this._horz2Vert(n), t(this.parse(e.data, Math.min(n.image.width, n.image.height)));
+			} catch (t) {
+				r ? r(t) : console.error(t), this.manager.itemError(e);
+			}
+		}, n, r);
+	}
+	parse(e, t) {
+		let n = new Uint8Array(e), r = new le();
+		return r.image.data = n, r.image.width = t, r.image.height = t, r.image.depth = t, r.format = R, r.type = P, r.magFilter = w, r.minFilter = w, r.wrapS = L, r.wrapT = L, r.wrapR = L, r.generateMipmaps = !1, r.needsUpdate = !0, {
+			size: t,
+			texture3D: r
+		};
+	}
+	_getImageData(e) {
+		let t = e.image.width, n = e.image.height, r = document.createElement("canvas");
+		r.width = t, r.height = n;
+		let i = r.getContext("2d");
+		return this.flip === !0 && (i.scale(1, -1), i.translate(0, -n)), i.drawImage(e.image, 0, 0), i.getImageData(0, 0, t, n);
+	}
+	_horz2Vert(e) {
+		let t = e.image.height, n = e.image.width, r = document.createElement("canvas");
+		r.width = t, r.height = n;
+		let i = r.getContext("2d");
+		this.flip === !0 && (i.scale(1, -1), i.translate(0, -n));
+		for (let r = 0; r < t; r++) {
+			let a = r * t, o = this.flip ? n - r * t : r * t;
+			i.drawImage(e.image, a, 0, t, t, 0, o, t, t);
+		}
+		return i.getImageData(0, 0, t, n);
+	}
+}, wn = class extends o {
+	constructor(e) {
+		super(e), this.type = P;
+	}
+	setType(e) {
+		return this.type = e, this;
+	}
+	load(e, t, n, i) {
+		let a = new r(this.manager);
+		a.setPath(this.path), a.setResponseType("text"), a.load(e, (n) => {
+			try {
+				t(this.parse(n));
+			} catch (t) {
+				i ? i(t) : console.error(t), this.manager.itemError(e);
+			}
+		}, n, i);
+	}
+	parse(e) {
+		let t = /^[\d ]+$/m, n = /^([\d.e+-]+) +([\d.e+-]+) +([\d.e+-]+) *$/gm, r = t.exec(e);
+		if (r === null) throw Error("LUT3dlLoader: Missing grid information");
+		let i = r[0].trim().split(/\s+/g).map(Number), a = i[1] - i[0], o = i.length, s = o ** 2;
+		for (let e = 1, t = i.length; e < t; ++e) if (a !== i[e] - i[e - 1]) throw Error("LUT3dlLoader: Inconsistent grid size");
+		let c = new Float32Array(o ** 3 * 4), l = 0, u = 0;
+		for (; (r = n.exec(e)) !== null;) {
+			let e = Number(r[1]), t = Number(r[2]), n = Number(r[3]);
+			l = Math.max(l, e, t, n);
+			let i = u % o, a = Math.floor(u / o) % o, d = Math.floor(u / s) % o, f = (i * s + a * o + d) * 4;
+			c[f + 0] = e, c[f + 1] = t, c[f + 2] = n, ++u;
+		}
+		let d = 2 ** Math.ceil(Math.log2(l)), f = this.type === 1009 ? new Uint8Array(c.length) : c, p = this.type === 1009 ? 255 : 1;
+		for (let e = 0, t = f.length; e < t; e += 4) {
+			let t = e + 1, n = e + 2, r = e + 3;
+			f[e] = c[e] / d * p, f[t] = c[t] / d * p, f[n] = c[n] / d * p, f[r] = p;
+		}
+		let m = new le();
+		return m.image.data = f, m.image.width = o, m.image.height = o, m.image.depth = o, m.format = R, m.type = this.type, m.magFilter = w, m.minFilter = w, m.wrapS = L, m.wrapT = L, m.wrapR = L, m.generateMipmaps = !1, m.needsUpdate = !0, {
+			size: o,
+			texture3D: m
+		};
+	}
+}, Tn = {
+	name: "OutputShader",
+	uniforms: {
+		tDiffuse: { value: null },
+		toneMappingExposure: { value: 1 }
+	},
+	vertexShader: "\n		precision highp float;\n\n		uniform mat4 modelViewMatrix;\n		uniform mat4 projectionMatrix;\n\n		attribute vec3 position;\n		attribute vec2 uv;\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vUv = uv;\n			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n		}",
+	fragmentShader: "\n\n		precision highp float;\n\n		uniform sampler2D tDiffuse;\n\n		#include <tonemapping_pars_fragment>\n		#include <colorspace_pars_fragment>\n\n		varying vec2 vUv;\n\n		void main() {\n\n			gl_FragColor = texture2D( tDiffuse, vUv );\n\n			// tone mapping\n\n			#ifdef LINEAR_TONE_MAPPING\n\n				gl_FragColor.rgb = LinearToneMapping( gl_FragColor.rgb );\n\n			#elif defined( REINHARD_TONE_MAPPING )\n\n				gl_FragColor.rgb = ReinhardToneMapping( gl_FragColor.rgb );\n\n			#elif defined( CINEON_TONE_MAPPING )\n\n				gl_FragColor.rgb = CineonToneMapping( gl_FragColor.rgb );\n\n			#elif defined( ACES_FILMIC_TONE_MAPPING )\n\n				gl_FragColor.rgb = ACESFilmicToneMapping( gl_FragColor.rgb );\n\n			#elif defined( AGX_TONE_MAPPING )\n\n				gl_FragColor.rgb = AgXToneMapping( gl_FragColor.rgb );\n\n			#elif defined( NEUTRAL_TONE_MAPPING )\n\n				gl_FragColor.rgb = NeutralToneMapping( gl_FragColor.rgb );\n\n			#elif defined( CUSTOM_TONE_MAPPING )\n\n				gl_FragColor.rgb = CustomToneMapping( gl_FragColor.rgb );\n\n			#endif\n\n			// color space\n\n			#ifdef SRGB_TRANSFER\n\n				gl_FragColor = sRGBTransferOETF( gl_FragColor );\n\n			#endif\n\n		}"
+}, En = class extends Fe {
+	constructor() {
+		super(), this.isOutputPass = !0, this.uniforms = y.clone(Tn.uniforms), this.material = new oe({
+			name: Tn.name,
+			uniforms: this.uniforms,
+			vertexShader: Tn.vertexShader,
+			fragmentShader: Tn.fragmentShader
+		}), this._fsQuad = new Re(this.material), this._outputColorSpace = null, this._toneMapping = null;
+	}
+	render(e, t, n) {
+		this.uniforms.tDiffuse.value = n.texture, this.uniforms.toneMappingExposure.value = e.toneMappingExposure, (this._outputColorSpace !== e.outputColorSpace || this._toneMapping !== e.toneMapping) && (this._outputColorSpace = e.outputColorSpace, this._toneMapping = e.toneMapping, this.material.defines = {}, j.getTransfer(this._outputColorSpace) === "srgb" && (this.material.defines.SRGB_TRANSFER = ""), this._toneMapping === 1 ? this.material.defines.LINEAR_TONE_MAPPING = "" : this._toneMapping === 2 ? this.material.defines.REINHARD_TONE_MAPPING = "" : this._toneMapping === 3 ? this.material.defines.CINEON_TONE_MAPPING = "" : this._toneMapping === 4 ? this.material.defines.ACES_FILMIC_TONE_MAPPING = "" : this._toneMapping === 6 ? this.material.defines.AGX_TONE_MAPPING = "" : this._toneMapping === 7 ? this.material.defines.NEUTRAL_TONE_MAPPING = "" : this._toneMapping === 5 && (this.material.defines.CUSTOM_TONE_MAPPING = ""), this.material.needsUpdate = !0), this.renderToScreen === !0 ? (e.setRenderTarget(null), this._fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this._fsQuad.render(e));
+	}
+	dispose() {
+		this.material.dispose(), this._fsQuad.dispose();
+	}
+}, Dn = {
+	enabled: !1,
+	intensity: 1,
+	lut: "Bourbon 64"
+}, On = class {
+	get passRenderer() {
+		return this._passRenderer;
+	}
+	get scene() {
+		return this._scene;
+	}
+	get camera() {
+		return this._camera;
+	}
+	get aspect() {
+		return this._sceneRenderer.width / this._sceneRenderer.height;
+	}
+	get cameraChanged() {
+		return this._cameraChanged;
+	}
+	get noOStaticFrames() {
+		return this._noOStaticFrames;
+	}
+	get renderCacheManager() {
+		return this._sceneRenderer.renderCacheManager;
+	}
+	get parameters() {
+		return this._sceneRenderer.parameters;
+	}
+	get sceneRenderPass() {
+		return this._sceneRenderPass;
+	}
+	get bakedGroundContactShadowPass() {
+		return this._bakedGroundContactShadowPass;
+	}
+	get gBufferRenderPass() {
+		return this._gBufferRenderPass;
+	}
+	get groundReflectionPass() {
+		return this._groundReflectionPass;
+	}
+	get screenSpaceShadowMapPass() {
+		return this._screenSpaceShadowMapPass;
+	}
+	get shadowAndAoPass() {
+		return this._shadowAndAoPass;
+	}
+	get lutPassParameters() {
+		return this._lutPassParameters;
+	}
+	get lutMaps() {
+		return Array.from(this._lutMap.keys());
+	}
+	get outlinePass() {
+		return this._outlinePass;
+	}
+	get outlineRenderer() {
+		return this._sceneRenderer.outlineRenderer;
+	}
+	get debugPass() {
+		return this._debugPass ??= new mn(this), this._debugPass;
+	}
+	get debugOutput() {
+		return this._sceneRenderer.debugOutput;
+	}
+	constructor(e, t) {
+		this.materialsNeedUpdate = !0, this._passRenderer = new qe(), this._outlinePass = null, this._debugPass = null, this._cameraUpdate = new We(), this._cameraChanged = !0, this._noUpdateNeededCount = 0, this._noOStaticFrames = 0, this._maxSamples = 1, this._passUpdateStates = {
+			updateGroundReflection: !1,
+			updateGBuffer: !1,
+			updateScreenSpaceShadow: !1,
+			updateShadowAndAoPass: !1,
+			updateOutlinePass: !1,
+			updateDebugPass: !1
+		}, this.aoPassMapTexture = null, this._lutMap = /* @__PURE__ */ new Map(), this._lutPassParameters = Dn, this.lutPassNeedsUpdate = !1, this._renderToRenderTarget = !1, this._creator_ = e, this._sceneRenderer = t, this._maxSamples = Ue(this._sceneRenderer.renderer);
+		let n = this._sceneRenderer.linearAoFilter, r = n ? this._maxSamples : 0, i = n ? this._maxSamples : 0;
+		this._sceneRenderPass = new hn(this), this._bakedGroundContactShadowPass = new kt(this, this._sceneRenderer.renderer, this._sceneRenderer.groundGroup, { sharedShadowGroundPlane: this._sceneRenderer.shadowAndAoGroundPlane }), this._gBufferRenderPass = new Pt(this, {
+			shared: !0,
+			capabilities: this._sceneRenderer.renderer.capabilities,
+			width: this._sceneRenderer.width,
+			height: this._sceneRenderer.height,
+			samples: r,
+			textureMinificationFilter: n ? w : p,
+			textureMagnificationFilter: n ? w : p
+		}), this._groundReflectionPass = new It(this, this._sceneRenderer.width, this._sceneRenderer.height, this._maxSamples, {}), this._screenSpaceShadowMapPass = new Kt(this, new m(this._sceneRenderer.width, this._sceneRenderer.height), {
+			samples: i,
+			alwaysUpdate: !1
+		}), this._shadowAndAoPass = new ut(this, this._sceneRenderer.width, this._sceneRenderer.height, r), this._lutPass = new xn({
+			lut: void 0,
+			intensity: 1
+		}), this._outputPass = new En();
+	}
+	dispose() {
+		this._sceneRenderPass.dispose(), this._bakedGroundContactShadowPass.dispose(), this._gBufferRenderPass.dispose(), this._groundReflectionPass.dispose(), this._screenSpaceShadowMapPass.dispose(), this._shadowAndAoPass.dispose(), this._outlinePass?.dispose(), this._lutPass.dispose(), this._outputPass.dispose(), this._passRenderTarget?.dispose(), this._passPassRenderTarget?.dispose();
+	}
+	setSize(e, t) {
+		this._gBufferRenderPass.setSize(e, t), this._groundReflectionPass.setSize(e, t), this._screenSpaceShadowMapPass.setSize(e, t), this._shadowAndAoPass.setSize(e, t), this._outlinePass?.setSize(e, t);
+		let n = this._sceneRenderer.renderer.getPixelRatio(), r = e * n, i = t * n;
+		this._lutPass.setSize(r, i), this._outputPass.setSize(r, i), this._passRenderTarget?.setSize(r, i), this._passPassRenderTarget?.setSize(r, i);
+	}
+	loadLutImage(e, t) {
+		this._lutMap.set(e, null), new Cn().load(t, (t) => {
+			this._lutMap.set(e, t);
+		});
+	}
+	loadLutCube(e, t) {
+		this._lutMap.set(e, null), new Sn().load(t, (t) => {
+			this._lutMap.set(e, t);
+		});
+	}
+	loadLut3dl(e, t) {
+		this._lutMap.set(e, null), new wn().load(t, (t) => {
+			this._lutMap.set(e, t);
+		});
+	}
+	createOutlinePass() {
+		return this._outlinePass ||= new nn(this, new m(this._sceneRenderer.width, this._sceneRenderer.height), this.scene, this.camera, [], {
+			downSampleRatio: 2,
+			edgeDetectionFxaa: !0
+		}), this._outlinePass;
+	}
+	getRenderPassRenderTarget(e) {
+		return this._lutPassParameters.enabled ? (this._passRenderTarget = this._passRenderTarget ?? new u(this._sceneRenderer.width * e.getPixelRatio(), this._sceneRenderer.height * e.getPixelRatio(), {
+			type: 1016,
+			samples: this._maxSamples
+		}), this._passRenderTarget) : null;
+	}
+	getPostPassRenderTarget(e) {
+		return this._lutPassParameters.enabled ? (this._passPassRenderTarget = this._passPassRenderTarget ?? new u(this._sceneRenderer.width * e.getPixelRatio(), this._sceneRenderer.height * e.getPixelRatio(), { type: 1016 }), this._passPassRenderTarget) : null;
+	}
+	setGroundVisibility(e) {
+		this._sceneRenderer.shadowAndAoGroundPlane.setVisibility(e);
+	}
+	updatePasses(e, t, n) {
+		this._scene = t, this._camera = n, this._cameraChanged = this._cameraUpdate.changed(n);
+		let r = this._evaluateIfShadowAndAoUpdateIsNeeded();
+		this._renderToRenderTarget = this._lutPassParameters.enabled, this._updateSceneRenderPass(), this._updateBakedGroundContactShadowPass(), this._updateGBufferPass(r), this._updateGroundReflectionPass(r), this._updateScreenSpaceShadowPass(r), this._updateShadowAndAoPass(r), this._updateLutPass(), this._updateOutlinePass(), this._updateDebugPass();
+	}
+	_evaluateIfShadowAndAoUpdateIsNeeded() {
+		let e = this._shadowAndAoPass.parameters.alwaysUpdate || this._screenSpaceShadowMapPass.needsUpdate || this._screenSpaceShadowMapPass.shadowTypeNeedsUpdate, t = (this._shadowAndAoPass.parameters.enabled || this._groundReflectionPass.parameters.enabled) && this._cameraChanged, n = 1;
+		t && (this._noUpdateNeededCount = 0, this._noOStaticFrames = 0), e || (this._noUpdateNeededCount++, t = this._noUpdateNeededCount >= this.parameters.effectSuspendFrames, n = Math.max(0, Math.min(1, (this._noUpdateNeededCount - this.parameters.effectSuspendFrames) / this.parameters.effectFadeInFrames))), !e && n === 1 && this._noOStaticFrames++, t = e || t;
+		let r = !t || n < .99 ? this.parameters.shadowOnCameraChange : Z.OFF;
+		return {
+			needsUpdate: t,
+			shadowOnCameraChange: r,
+			intensityScale: n
+		};
+	}
+	_dynamicChanges(e) {
+		return e.needsUpdate || e.shadowOnCameraChange !== Z.OFF;
+	}
+	_updateSceneRenderPass() {
+		this._sceneRenderPass.drawWithDebugMaterial = !1;
+	}
+	_updateBakedGroundContactShadowPass() {
+		let e = this._bakedGroundContactShadowPass.limitPlaneSize;
+		this._bakedGroundContactShadowPass.limitPlaneSize = this._bakedGroundContactShadowPass.parameters.enabled, (e !== this._bakedGroundContactShadowPass.limitPlaneSize || this._bakedGroundContactShadowPass.needsUpdate) && this._bakedGroundContactShadowPass.updateBounds(this._sceneRenderer.boundingVolume, this._sceneRenderer.groundLevel), this._sceneRenderPass.drawGround = this._bakedGroundContactShadowPass.parameters.enabled || this._shadowAndAoPass.parameters.applyToMaterial;
+	}
+	_updateGBufferPass(e) {
+		this._passUpdateStates.updateGBuffer = !1, this._gBufferRenderPass.needsUpdate = e.needsUpdate || e.shadowOnCameraChange === Z.POISSON, this.gBufferRenderPass.drawGround = this._sceneRenderer.boundingVolumeSet && this._shadowAndAoPass.parameters.aoOnGround;
+	}
+	_updateGroundReflectionPass(e) {
+		this._passUpdateStates.updateGroundReflection = !1, this._groundReflectionPass.parameters.enabled && this._dynamicChanges(e) && (!this.parameters.suspendGroundReflection || e.needsUpdate) && (this._groundReflectionPass.reflectionFadeInScale = this.parameters.suspendGroundReflection ? e.intensityScale : 1, this._passUpdateStates.updateGroundReflection = !0);
+	}
+	_updateScreenSpaceShadowPass(e) {
+		if (!this._dynamicChanges(e)) {
+			this._passUpdateStates.updateScreenSpaceShadow = !1;
+			return;
+		}
+		this._screenSpaceShadowMapPass.parameters.alwaysUpdate = this._shadowAndAoPass.parameters.alwaysUpdate, this._screenSpaceShadowMapPass.drawGround = this._shadowAndAoPass.parameters.shadowOnGround, this._passUpdateStates.updateScreenSpaceShadow = this._shadowAndAoPass.parameters.shadowIntensity > 0, this._passUpdateStates.updateScreenSpaceShadow = !0, this._passUpdateStates.updateGBuffer = !0;
+	}
+	_updateShadowAndAoPass(e) {
+		if (!this._dynamicChanges(e)) {
+			this._passUpdateStates.updateShadowAndAoPass = !1;
+			return;
+		}
+		this._shadowAndAoPass.shadowAndAoPassSettings = {
+			shadowMapTexture: this._screenSpaceShadowMapPass.shadowTexture,
+			shadowBlurType: e.needsUpdate ? Z.FULL : e.shadowOnCameraChange,
+			shadowFadeInBlurType: e.shadowOnCameraChange,
+			shadowFadeInMix: 1 - e.intensityScale,
+			noOStaticFrames: this.noOStaticFrames
+		}, this._passUpdateStates.updateShadowAndAoPass = !0, this._passUpdateStates.updateGBuffer = !0;
+	}
+	_updateLutPass() {
+		if (!(!this._lutPassParameters.enabled || !this.lutPassNeedsUpdate) && (this.lutPassNeedsUpdate = !1, this._lutPass.enabled = this._lutPassParameters.enabled, this._lutPass.intensity = this._lutPassParameters.intensity, this._lutMap.has(this._lutPassParameters.lut))) {
+			let e = this._lutMap.get(this._lutPassParameters.lut);
+			e?.texture3D && (this._lutPass.lut = e.texture3D);
+		}
+	}
+	_updateOutlinePass() {
+		if (!this.outlineRenderer.outlinePassActivated || !this.outlineRenderer.outlinePass) {
+			this._passUpdateStates.updateOutlinePass = !1;
+			return;
+		}
+		this.outlineRenderer.outlinePass.renderToScreen = !1, this.outlineRenderer.outlinePass.clearBackground = !1, this._passUpdateStates.updateOutlinePass = !0, this._passUpdateStates.updateGBuffer = !0;
+	}
+	_updateDebugPass() {
+		if (!this.debugOutput || this.debugOutput === "" || this.debugOutput === "off") {
+			this._passUpdateStates.updateDebugPass = !1;
+			return;
+		}
+		if (this.debugOutput === "outline" && this.outlineRenderer.outlinePass) {
+			this.outlineRenderer.outlinePass.clearBackground = !0, this._passUpdateStates.updateDebugPass = !1;
+			return;
+		}
+		if (this.debugOutput === "color" || this.debugOutput === "grayscale") {
+			this._passUpdateStates.updateGroundReflection = !1, this._passUpdateStates.updateGBuffer = !1, this._passUpdateStates.updateScreenSpaceShadow = !1, this._passUpdateStates.updateShadowAndAoPass = !1, this._passUpdateStates.updateOutlinePass = !1, this._passUpdateStates.updateDebugPass = !1, this._sceneRenderPass.drawWithDebugMaterial = this.debugOutput === "grayscale";
+			return;
+		}
+		this.debugPass.debugOutput = this.debugOutput, this._passUpdateStates.updateDebugPass = !0;
+	}
+	_updateMaterials(e, t) {
+		if (!this.materialsNeedUpdate || !this._shadowAndAoPass.parameters.applyToMaterial) return;
+		this.aoPassMapTexture = this._shadowAndAoPass.denoiseRenderTargetTexture;
+		let n = e.getPixelRatio();
+		this.materialsNeedUpdate = !1, t.traverse((e) => {
+			if (e.isMesh) {
+				let t = e.material;
+				t instanceof E && this._updateMaterial(e, t, n);
+			}
+		});
+	}
+	_updateMaterial(e, t, n) {
+		let r = gn.addPlugin(t);
+		r && (this._updatePlugInAo(r, e, t, n), this._updatePlugInReflection(r, e), t.needsUpdate = !1);
+	}
+	_updatePlugInAo(e, t, n, r) {
+		let i = this._shadowAndAoPass.parameters.enabled && this._shadowAndAoPass.parameters.applyToMaterial && this.aoPassMapTexture !== null && (n.name === "ShadowGroundPlaneMaterial" || t.receiveShadow && (!n.transparent || n.alphaTest >= .9)), a = i && this._shadowAndAoPass.parameters.aoIntensity > .01, o = i && this._screenSpaceShadowMapPass.enabled && this._shadowAndAoPass.parameters.shadowIntensity > .01;
+		e.applyAoAndShadowToAlpha = n.name === "ShadowGroundPlaneMaterial", e.aoPassMapIntensity = a ? this._shadowAndAoPass.parameters.aoIntensity * 2 : -1, e.shPassMapIntensity = o ? this._shadowAndAoPass.parameters.shadowIntensity * 2 : -1, e.aoPassMapScale = 1 / r, e.aoPassMap = this.aoPassMapTexture;
+	}
+	_updatePlugInReflection(e, t) {
+		let n = this._groundReflectionPass.intensityRenderTarget.texture, r = t.userData.isPlanFloor && this._groundReflectionPass.parameters.enabled && (n !== null || n !== void 0), i = this._groundReflectionPass.parameters.intensity;
+		e.applyReflectionPassMap = r, e.reflectionPassMapIntensity = r ? i ** .5 : 0, e.reflectionPassMapScale = 1 / (this._groundReflectionPass.parameters.renderTargetDownScale * devicePixelRatio), e.reflectionPassMap = r ? n : null;
+	}
+	renderPasses(e, t) {
+		let n = this.getRenderPassRenderTarget(e), r = this.getPostPassRenderTarget(e);
+		e.setRenderTarget(n);
+		let i = V(e);
+		i && this._bakedGroundContactShadowPass.renderPass(e), this._passUpdateStates.updateGBuffer && i && this._gBufferRenderPass.renderPass(e), this._passUpdateStates.updateScreenSpaceShadow && i && this._screenSpaceShadowMapPass.renderPass(e), this._passUpdateStates.updateShadowAndAoPass && i && this._shadowAndAoPass.renderPass(e), this._updateMaterials(e, t), this._sceneRenderPass.renderPass(e), this._passUpdateStates.updateGroundReflection && i && this._groundReflectionPass.renderPass(e), this._passUpdateStates.updateShadowAndAoPass && !this._shadowAndAoPass.parameters.applyToMaterial && i && this._shadowAndAoPass.renderToTarget(e), this._lutPassParameters.enabled && (e.setRenderTarget(r), this._outputPass.renderToScreen = !1, this._outputPass.render(e, e.getRenderTarget(), n, 0, !1), e.setRenderTarget(null), this._lutPass.renderToScreen = !0, this._lutPass.render(e, e.getRenderTarget(), r, 0, !1)), this._passUpdateStates.updateOutlinePass && i && this._outlinePass?.renderPass(e), this._passUpdateStates.updateDebugPass && i && this._debugPass?.renderPass(e);
+	}
+};
+me([pe, fe("design:type", Object)], On.prototype, "_initData", void 0);
+//#endregion
+//#region packages/common-core/src/webgl/renderer/scene-renderer.ts
+var kn = {
+	HIGHEST: "highest",
+	HIGH: "high",
+	MEDIUM: "medium",
+	LOW: "low"
+}, An = class {
+	get sceneRenderPass() {
+		return this._renderPassManager.sceneRenderPass;
+	}
+	get bakedGroundContactShadowPass() {
+		return this._renderPassManager.bakedGroundContactShadowPass;
+	}
+	get gBufferRenderPass() {
+		return this._renderPassManager.gBufferRenderPass;
+	}
+	get groundReflectionPass() {
+		return this._renderPassManager.groundReflectionPass;
+	}
+	get screenSpaceShadowMapPass() {
+		return this._renderPassManager.screenSpaceShadowMapPass;
+	}
+	get shadowAndAoPass() {
+		return this._renderPassManager.shadowAndAoPass;
+	}
+	get lutPassParameters() {
+		return this._renderPassManager.lutPassParameters;
+	}
+	get lutMaps() {
+		return this._renderPassManager.lutMaps;
+	}
+	get debugPass() {
+		return this._renderPassManager.debugPass;
+	}
+	get shadowAndAoGroundPlane() {
+		return this._shadowAndAoGroundPlane;
+	}
+	constructor(e, t, n, r, i) {
+		this.debugOutput = "off", this.outputColorSpace = "", this.toneMapping = "", this.linearAoFilter = !0, this.environmentLights = !1, this.enableObjectSelection = !0, this.groundLevel = 0, this.uiInteractionMode = !1, this.width = 0, this.height = 0, this.boundingVolume = new He(), this.boundingVolumeSet = !1, this.renderCacheManager = new wt(), this.selectedObjects = [], this.groundGroup = new te(), this._shadingType = ft.DEFAULT, this._qualityLevel = kn.HIGHEST, this._qualityMap = /* @__PURE__ */ new Map(), this._customShadingParameters = null, this._creator_ = e, this.width = n, this.height = r, this.linearAoFilter = i ?? !0, this.renderer = t, this.renderCacheManager.registerCache("inivisibleGround", new Tt((e) => e === this.groundGroup)), this.renderCacheManager.registerCache("groundReflection", new Tt((e) => e === this.groundGroup || e.name === "dimensioning" ? !0 : !!(e instanceof x && St(e.material)))), this.renderCacheManager.registerCache("debug", new Tt()), this.renderCacheManager.registerCache("floorDepthWrite", new Et((e) => e.userData?.isFloor)), this._shadowAndAoGroundPlane = new Ye(null), this.groundGroup.rotateX(-Math.PI / 2), this._renderPassManager = new On(e, this), this.outlineRenderer = new dt(this._renderPassManager, null, {}), this.parameters = {
+			gBufferRenderTargetParameters: this.gBufferRenderPass.parameters,
+			bakedGroundContactShadowParameters: this.bakedGroundContactShadowPass.parameters,
+			screenSpaceShadowMapParameters: this.screenSpaceShadowMapPass.parameters,
+			shAndAoPassParameters: this.shadowAndAoPass.parameters,
+			groundReflectionParameters: this.groundReflectionPass.parameters,
+			outlineParameters: this.outlineRenderer.parameters,
+			effectSuspendFrames: 0,
+			effectFadeInFrames: 0,
+			suspendGroundReflection: !1,
+			shadowOnCameraChange: Z.OFF
+		}, this._addEventListeners(this.renderer);
+	}
+	_addEventListeners(e) {
+		e.domElement && (e.domElement.addEventListener("webglcontextlost", () => {
+			console.log("webglcontextlost");
+		}), e.domElement.addEventListener("webglcontextrestored", () => {
+			console.log("webglcontextrestored"), this._forceEnvironmentMapUpdate(this.renderer);
+		}));
+	}
+	dispose() {
+		this._copyMaterial?.dispose(), this._renderPassManager.dispose(), this.renderer.dispose();
+	}
+	setSize(e, t) {
+		this.width = e, this.height = t, this._renderPassManager.setSize(e, t), this.renderer.setSize(e, t);
+	}
+	loadLutImages(e) {
+		for (let t of e) {
+			let e = t.url;
+			t.type === "image" ? this._renderPassManager.loadLutImage(t.name, e) : t.type === "cube" ? this._renderPassManager.loadLutCube(t.name, e) : t.type === "3dl" && this._renderPassManager.loadLut3dl(t.name, e);
+		}
+	}
+	getQualityLevel() {
+		return this._qualityLevel;
+	}
+	setShadingType(e) {
+		this._shadingType !== e && (this._shadingType = e, this.applyCurrentParameters());
+	}
+	setQualityLevel(e) {
+		this._qualityLevel !== e && (this._qualityMap.has(this._qualityLevel) && (this._qualityLevel = e), this.applyCurrentParameters());
+	}
+	setQualityMap(e) {
+		this._qualityMap = e, this.applyCurrentParameters();
+	}
+	setCustomShadingParameters(e) {
+		this._customShadingParameters = e, this.applyCurrentParameters(), this.requestUpdateOfPasses();
+	}
+	setQualityMapAndShadingParameters(e, t) {
+		this._qualityMap = e, this._customShadingParameters = t, this.applyCurrentParameters(), this.requestUpdateOfPasses();
+	}
+	applyCurrentParameters() {
+		let e = [];
+		this._qualityMap.has(this._qualityLevel) && e.push(this._qualityMap.get(this._qualityLevel));
+		let t = gt(this._shadingType);
+		t && e.push(t);
+		let n = ht(this.uiInteractionMode);
+		if (n && e.push(n), this._customShadingParameters && e.push(_t(this._customShadingParameters)), e.length > 0) {
+			let t = mt(...e);
+			this.updateParameters(t), this.bakedGroundContactShadowPass.applyParameters();
+		}
+	}
+	requestUpdateOfPasses() {
+		this.gBufferRenderPass.needsUpdate = !0, this.screenSpaceShadowMapPass.needsUpdate = !0, this.shadowAndAoPass.needsUpdate = !0, this.shadowAndAoPass.softShadowPass.needsUpdate = !0, this._renderPassManager.materialsNeedUpdate = !0;
+	}
+	clearCache() {
+		this.renderCacheManager.clearCache(), this._renderPassManager.materialsNeedUpdate = !0;
+	}
+	forceShadowUpdates(e) {
+		this.clearCache(), this.gBufferRenderPass.needsUpdate = !0, this.screenSpaceShadowMapPass.forceShadowUpdate(), this.shadowAndAoPass.needsUpdate = !0, e && (this.bakedGroundContactShadowPass.needsUpdate = !0);
+	}
+	forceLutPassUpdate() {
+		this._renderPassManager.lutPassNeedsUpdate = !0, this._renderPassManager.materialsNeedUpdate = !0;
+	}
+	updateParameters(e) {
+		e.shadowType && this.screenSpaceShadowMapPass.switchType(e.shadowType), e.shAndAoPassParameters !== void 0 && this.shadowAndAoPass.updateParameters(e.shAndAoPassParameters), e.bakedGroundContactShadowParameters !== void 0 && this.bakedGroundContactShadowPass.updateParameters(e.bakedGroundContactShadowParameters), e.screenSpaceShadowMapParameters !== void 0 && this.screenSpaceShadowMapPass.updateParameters(e.screenSpaceShadowMapParameters), e.groundReflectionParameters !== void 0 && this.groundReflectionPass.updateParameters(e.groundReflectionParameters), e.outlineParameters !== void 0 && this.outlineRenderer.updateParameters(e.outlineParameters), e.effectSuspendFrames !== void 0 && (this.parameters.effectSuspendFrames = e.effectSuspendFrames), e.effectFadeInFrames !== void 0 && (this.parameters.effectFadeInFrames = e.effectFadeInFrames), e.suspendGroundReflection !== void 0 && (this.parameters.suspendGroundReflection = e.suspendGroundReflection), e.shadowOnCameraChange !== void 0 && (this.parameters.shadowOnCameraChange = e.shadowOnCameraChange);
+	}
+	addRectAreaLight(e, t) {
+		this.environmentLights = !1, this.screenSpaceShadowMapPass.addRectAreaLight(e, t), this.shadowAndAoPass.needsUpdate = !0;
+	}
+	updateRectAreaLights(e, t) {
+		e.length > 0 && (this.environmentLights = !1), this.screenSpaceShadowMapPass.updateRectAreaLights(e, t), this.shadowAndAoPass.needsUpdate = !0;
+	}
+	createShadowFromLightSources(e, t) {
+		this.environmentLights = !0, this.screenSpaceShadowMapPass.createShadowFromLightSources(e, t), this.shadowAndAoPass.needsUpdate = !0;
+	}
+	selectObjects(e) {
+		this.selectedObjects = e;
+	}
+	updateBounds(e, t) {
+		this.clearCache();
+		let n = e.clone();
+		n.min.y > this.groundLevel && (n.min.y = this.groundLevel), this.boundingVolumeSet = !0, this.gBufferRenderPass.groundDepthWrite = this.shadowAndAoPass.parameters.aoOnGround, this.boundingVolume.updateFromBox(n);
+		let r = this.boundingVolume.size, i = (r.x + r.y + r.z) / 3, a = Math.min(r.x, r.y, r.z), o = Math.max(r.x, r.y, r.z), s = a < .5 ? a / .5 : r.z > 5 ? r.z / 5 : 1;
+		this.bakedGroundContactShadowPass.setScale(t ? i : s, i), this.groundReflectionPass.updateBounds(this.groundLevel, Math.min(1, o)), this.screenSpaceShadowMapPass.updateBounds(this.boundingVolume, i), this.shadowAndAoPass.updateBounds(this.boundingVolume, t ? i : Math.min(1, o * 2));
+	}
+	updateNearAndFarPlaneOfPerspectiveCamera(e, t) {
+		let n = this.boundingVolume.getNearAndFarForPerspectiveCamera(e.position, 3);
+		e.near = Math.max(1e-5, n[0] * .9), e.far = Math.max(t ?? e.near, n[1]), e.updateProjectionMatrix();
+	}
+	_forceEnvironmentMapUpdate(e) {
+		let t = e.userData;
+		if (t?.environmentTexture) {
+			let e = t.environmentTexture;
+			t.environmentTexture = void 0, e.dispose();
+		}
+	}
+	_updateEnvironment(e, t) {
+		if (!t.userData?.environmentDefinition) return;
+		e.userData ||= {};
+		let n = e.userData;
+		if (t.userData?.environmentDefinition.needsUpdate || !n.environmentTexture || n.environmentDefinition !== t.userData.environmentDefinition) {
+			let r = t.userData.environmentDefinition;
+			if (n.environmentDefinition = r, n.environmentTexture = r.createNewEnvironment(e), t.userData.shadowFromEnvironment && V(e)) {
+				let e = r.maxNoOfLightSources;
+				e !== void 0 && (this.screenSpaceShadowMapPass.parameters.maximumNumberOfLightSources = e), this.createShadowFromLightSources(t, r.lightSources);
+			}
+		}
+		t.environment = n?.environmentTexture, t.userData.showEnvironmentBackground ? t.background = t.environment : t.background === t.environment && (t.background = null);
+	}
+	render(e, t) {
+		e.add(this.groundGroup), this._updateEnvironment(this.renderer, e), this.outlineRenderer.updateOutline(e, t, this.enableObjectSelection ? this.selectedObjects : []), this._renderPassManager.updatePasses(this.renderer, e, t), this._renderPassManager.renderPasses(this.renderer, e), e.remove(this.groundGroup);
+	}
+};
+me([pe, fe("design:type", Object)], An.prototype, "_initData", void 0);
+//#endregion
+export { Bt as a, Xe as c, Ce as d, un as i, be as l, An as n, ft as o, ln as r, Z as s, kn as t, xe as u };
+
+//# sourceMappingURL=scene-renderer-D8HkTFeZ.mjs.map