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

package/lib/shading-settings-BWeccIZv.mjs

@@ -0,0 +1,1108 @@
+import { Ci as e, Ei as t, En as n, Gn as r, Hr as i, Mr as a, On as o, Si as s, Ur as c, V as l, bn as u, cn as d, f, fi as p, h as m, in as h, on as g, pi as _, qt as v, sn as y, st as b, w as x, xi as S } from "./three.core-tV_4n8Wg.mjs";
+import { h as C } from "./common-utils-DMk5jc_R.mjs";
+//#region packages/common-core/src/webgl/renderer/shader-utility.ts
+var w = {
+	uniforms: {
+		tDiffuse: { value: null },
+		colorTransform: { value: new y() },
+		colorBase: { value: new e(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        }"
+}, T = new y(), E = new y().set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0), D = new y().set(0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0), O = new y().set(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1);
+new y().set(0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1), new y().set(0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+var k = new y().set(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1), A = new e(0, 0, 0, 0), j = new e(0, 0, 0, 1), M = new g(), N = new g().set(1, 0, 0, 0, -1, 1, 0, 0, 1), P = {
+	DEFAULT: "default",
+	ADDITIVE: "additive"
+}, F = class extends c {
+	constructor(e, t = P.ADDITIVE, n = !1, r = !1) {
+		let i = t === P.ADDITIVE ? {
+			blendSrc: 208,
+			blendDst: 200,
+			blendEquation: 100,
+			blendSrcAlpha: 206,
+			blendDstAlpha: 200,
+			blendEquationAlpha: 100
+		} : {};
+		super({
+			uniforms: p.clone(w.uniforms),
+			vertexShader: w.vertexShader,
+			fragmentShader: w.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;
+	}
+}, I = {
+	uniforms: {
+		tDiffuse: { value: null },
+		rangeMin: { value: new S(1 / 512, 1 / 512) },
+		rangeMax: { value: new S(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 S(.1, .9), new S(.1, .9);
+var ee = "varying vec2 vUv;\n  void main() {\n      vUv = uv;\n      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n  }", te = "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  }", ne = class t extends c {
+	static {
+		this._linearDepthShader = {
+			uniforms: {
+				tDepth: { value: null },
+				depthFilter: { value: new e(1, 0, 0, 0) },
+				cameraNear: { value: .1 },
+				cameraFar: { value: 1 }
+			},
+			defines: {
+				PERSPECTIVE_CAMERA: 1,
+				ALPHA_DEPTH: 0
+			},
+			vertexShader: ee,
+			fragmentShader: te
+		};
+	}
+	constructor(e) {
+		super({
+			defines: Object.assign({}, t._linearDepthShader.defines),
+			uniforms: p.clone(t._linearDepthShader.uniforms),
+			vertexShader: t._linearDepthShader.vertexShader,
+			fragmentShader: t._linearDepthShader.fragmentShader,
+			blending: 0
+		}), this.update(e);
+	}
+	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;
+	}
+}, re = 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() {}
+}, L = new n(-1, 1, 1, -1, 0, 1), R = new class extends m {
+	constructor() {
+		super(), this.setAttribute("position", new b([
+			-1,
+			3,
+			0,
+			-1,
+			-1,
+			0,
+			3,
+			-1,
+			0
+		], 3)), this.setAttribute("uv", new b([
+			0,
+			2,
+			0,
+			0,
+			2,
+			0
+		], 2));
+	}
+}(), z = class {
+	constructor(e) {
+		this._mesh = new d(R, e);
+	}
+	dispose() {
+		this._mesh.geometry.dispose();
+	}
+	render(e) {
+		e.render(this._mesh, L);
+	}
+	get material() {
+		return this._mesh.material;
+	}
+	set material(e) {
+		this._mesh.material = e;
+	}
+}, B = 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, k = _ - C + 2 * d, A = v - w + 2 * d, j = g - 1 + 3 * d, M = _ - 1 + 3 * d, N = v - 1 + 3 * d, P = c & 255, F = l & 255, I = u & 255, ee = this.perm[P + this.perm[F + this.perm[I]]] % 12, te = this.perm[P + y + this.perm[F + b + this.perm[I + x]]] % 12, ne = this.perm[P + S + this.perm[F + C + this.perm[I + w]]] % 12, re = this.perm[P + 1 + this.perm[F + 1 + this.perm[I + 1]]] % 12, L = .6 - g * g - _ * _ - v * v;
+		L < 0 ? r = 0 : (L *= L, r = L * L * this._dot3(this.grad3[ee], g, _, v));
+		let R = .6 - T * T - E * E - D * D;
+		R < 0 ? i = 0 : (R *= R, i = R * R * this._dot3(this.grad3[te], T, E, D));
+		let z = .6 - O * O - k * k - A * A;
+		z < 0 ? a = 0 : (z *= z, a = z * z * this._dot3(this.grad3[ne], O, k, A));
+		let B = .6 - j * j - M * M - N * N;
+		return B < 0 ? o = 0 : (B *= B, o = B * B * this._dot3(this.grad3[re], j, M, N)), 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, k = w > E ? 16 : 0, A = T > E ? 8 : 0, j = w > D ? 4 : 0, M = T > D ? 2 : 0, N = E > D ? 1 : 0, P = O + k + A + j + M + N, F = a[P][0] >= 3 ? 1 : 0, I = a[P][1] >= 3 ? 1 : 0, ee = a[P][2] >= 3 ? 1 : 0, te = a[P][3] >= 3 ? 1 : 0, ne = a[P][0] >= 2 ? 1 : 0, re = a[P][1] >= 2 ? 1 : 0, L = a[P][2] >= 2 ? 1 : 0, R = a[P][3] >= 2 ? 1 : 0, z = a[P][0] >= 1 ? 1 : 0, B = a[P][1] >= 1 ? 1 : 0, ie = a[P][2] >= 1 ? 1 : 0, ae = a[P][3] >= 1 ? 1 : 0, oe = w - F + c, se = T - I + c, ce = E - ee + c, le = D - te + c, V = w - ne + 2 * c, ue = T - re + 2 * c, H = E - L + 2 * c, U = D - R + 2 * c, W = w - z + 3 * c, G = T - B + 3 * c, de = E - ie + 3 * c, K = D - ae + 3 * c, q = w - 1 + 4 * c, fe = T - 1 + 4 * c, J = E - 1 + 4 * c, pe = D - 1 + 4 * c, Y = h & 255, X = g & 255, Z = _ & 255, Q = v & 255, me = o[Y + o[X + o[Z + o[Q]]]] % 32, he = o[Y + F + o[X + I + o[Z + ee + o[Q + te]]]] % 32, ge = o[Y + ne + o[X + re + o[Z + L + o[Q + R]]]] % 32, _e = o[Y + z + o[X + B + o[Z + ie + o[Q + ae]]]] % 32, ve = o[Y + 1 + o[X + 1 + o[Z + 1 + o[Q + 1]]]] % 32, $ = .6 - w * w - T * T - E * E - D * D;
+		$ < 0 ? l = 0 : ($ *= $, l = $ * $ * this._dot4(i[me], w, T, E, D));
+		let ye = .6 - oe * oe - se * se - ce * ce - le * le;
+		ye < 0 ? u = 0 : (ye *= ye, u = ye * ye * this._dot4(i[he], oe, se, ce, le));
+		let be = .6 - V * V - ue * ue - H * H - U * U;
+		be < 0 ? d = 0 : (be *= be, d = be * be * this._dot4(i[ge], V, ue, H, U));
+		let xe = .6 - W * W - G * G - de * de - K * K;
+		xe < 0 ? f = 0 : (xe *= xe, f = xe * xe * this._dot4(i[_e], W, G, de, K));
+		let Se = .6 - q * q - fe * fe - J * J - pe * pe;
+		return Se < 0 ? p = 0 : (Se *= Se, p = Se * Se * this._dot4(i[ve], q, fe, J, pe)), 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;
+	}
+}, ie = (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();
+}, ae = (e, t) => {
+	let n = Math.min(-t.min.z, -t.max.z), r = Math.max(-t.min.z, -t.max.z);
+	if (n < .001) return;
+	let i = Math.max(Math.abs(t.min.x), Math.abs(t.max.x)), a = Math.max(Math.abs(t.min.y), Math.abs(t.max.y));
+	e.aspect = i / a, e.fov = h.radToDeg(Math.atan2(a, n) * 2), e.near = n, e.far = r, e.updateProjectionMatrix();
+}, oe = class {
+	constructor() {
+		this.bounds = new f(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 t = this.bounds.clone().applyMatrix4(e.matrixWorldInverse);
+		e instanceof n ? ie(e, t) : e instanceof o && ae(e, t);
+	}
+	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];
+	}
+}, se = 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;
+	}
+}, ce = (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;
+}, le = (e) => {
+	let t = new B(), n = Math.floor(e) % 2 == 0 ? Math.floor(e) + 1 : Math.floor(e), r = ce(n), i = r.length, o = new Uint8Array(i * 4);
+	for (let n = 0; n < i; ++n) {
+		let a = r[n], c = 2 * Math.PI * a / i, l = new s(Math.cos(c), Math.sin(c), 0).normalize();
+		o[n * 4] = (l.x * .5 + .5) * 255, o[n * 4 + 1] = (l.y * .5 + .5) * 255, o[n * 4 + 2] = 127, o[n * 4 + 3] = (t.noise(n / e, n % e) * .5 + .5) * 255;
+	}
+	let c = new l(o, n, n);
+	return c.wrapS = a, c.wrapT = a, c.needsUpdate = !0, c;
+}, V = class {
+	constructor() {
+		this._originalClearColor = new x(), this._originalClearAlpha = 0, this._originalAutoClear = !1, this._originalRenderTarget = null, this._screenSpaceQuad = new z(void 0), this._emptyScene = new i(), this._defaultCamera = new o();
+	}
+	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;
+	}
+}, ue = class {
+	constructor(e, t) {
+		this._passRenderer = t?.passRenderer ?? new V(), this._blurMaterial = new c(e ?? I), 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]);
+	}
+}, H = {
+	INPUT_RGB_NORMAL: "inputRgbNormal",
+	FLOAT_BUFFER_NORMAL: "floatBufferNormal",
+	CONSTANT_Z: "constantZ"
+}, U = {
+	SEPARATE_BUFFER: "separateBuffer",
+	NORMAL_VECTOR_ALPHA: "normalVectorAlpha"
+}, W = {
+	SSAO: 0,
+	SAO: 1,
+	N8AO: 2,
+	HBAO: 3,
+	GTAO: 4
+}, G = (e, t) => {
+	let n = de(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;
+}, de = (t, n) => {
+	let r = [];
+	for (let i = 0; i < t; i++) {
+		let a = i * Math.PI * (3 - Math.sqrt(5)), o = .01 + i / (t - 1) * .99, s = n ? Math.sqrt(1 - o * o) : 1 - o, c = Math.cos(a) * s, l = Math.sin(a) * s, u = Math.floor(t / 4), d = 1 - (Math.floor(i / 4) + i % 4 * u) / t;
+		d = .1 + .9 * d, r.push(new e(c, l, o, d));
+	}
+	return r;
+}, K = {
+	name: "AOShader",
+	defines: {
+		PERSPECTIVE_CAMERA: 1,
+		SAMPLES: 16,
+		SAMPLE_VECTORS: G(16, !1),
+		NORMAL_VECTOR_TYPE: 1,
+		DEPTH_SWIZZLING: "x",
+		AO_ALGORITHM: W.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 S() },
+		cameraNear: { value: null },
+		cameraFar: { value: null },
+		cameraProjectionMatrix: { value: new y() },
+		cameraProjectionMatrixInverse: { value: new y() },
+		cameraWorldMatrix: { value: new y() },
+		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		}"
+}, q = {
+	resolutionScale: 1,
+	algorithm: W.SSAO,
+	samples: 32,
+	radius: .25,
+	distanceExponent: 2,
+	thickness: .5,
+	distanceFallOff: .5,
+	scale: 1,
+	bias: .01,
+	screenSpaceRadius: !1
+}, fe = class {
+	get texture() {
+		return this._renderTarget ? this._renderTarget?.texture : null;
+	}
+	constructor(e, t, n, r, i) {
+		this.needsUpdate = !0, this.parameters = { ...q }, this._width = 0, this._height = 0, this._samples = 0, this._gBufferAntiAliasing = !1, this._normalVectorSourceType = H.FLOAT_BUFFER_NORMAL, this._depthValueSourceType = U.NORMAL_VECTOR_ALPHA, this._modulateRedChannel = !1, this.depthTexture = null, this.normalTexture = null, this._noiseTexture = null, this._renderTarget = null, this._passRenderer = new V(), this._sceneClipBox = new f(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 || H.FLOAT_BUFFER_NORMAL, this._depthValueSourceType = i?.depthValueSourceType || U.NORMAL_VECTOR_ALPHA, this._modulateRedChannel = i?.modulateRedChannel || !1, i?.aoParameters && (this.parameters = i.aoParameters), i && this.updateTextures(i);
+	}
+	_getNoiseTexture(e = 64) {
+		if (!this._noiseTexture) {
+			let t = new B(), n = new Uint8Array(e * e * 4);
+			for (let r = 0; r < e; r++) for (let i = 0; i < e; i++) {
+				let a = r, o = i;
+				n[(r * e + i) * 4] = (t.noise(a, o) + 1) * 127.5, n[(r * e + i) * 4 + 1] = (t.noise(a + e, o) + 1) * 127.5, n[(r * e + i) * 4 + 2] = (t.noise(a, o + e) + 1) * 127.5, n[(r * e + i) * 4 + 3] = (t.noise(a + e, o + e) + 1) * 127.5;
+			}
+			this._noiseTexture = new l(n, e, e, r, _), this._noiseTexture.wrapS = a, this._noiseTexture.wrapT = a, 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 c({
+			defines: Object.assign({}, K.defines),
+			uniforms: p.clone(K.uniforms),
+			vertexShader: K.vertexShader,
+			fragmentShader: K.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 = le(5), e;
+	}
+	_updateShader(e, t) {
+		e.defines.PERSPECTIVE_CAMERA = t.isPerspectiveCamera ? 1 : 0, e.defines.SAMPLES = this.parameters.samples, e.defines.SAMPLE_VECTORS = G(this.parameters.samples, this.parameters.algorithm === W.SSAO), e.defines.NORMAL_VECTOR_TYPE = this._normalVectorSourceType === H.FLOAT_BUFFER_NORMAL ? 2 : 1, e.defines.DEPTH_SWIZZLING = this._depthValueSourceType === U.NORMAL_VECTOR_ALPHA ? "a" : "x", e.defines.AO_ALGORITHM = this.parameters.algorithm, e.defines.NV_ALIGNED_SAMPLES = this.parameters.algorithm === W.HBAO || this.parameters.algorithm === W.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 === U.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 t(this._width, this._height, {
+			samples: this._samples,
+			magFilter: this._samples > 1 ? v : u,
+			minFilter: this._samples > 1 ? v : u
+		}), 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 f().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());
+	}
+}, J = {
+	DEFAULT: "default",
+	BRIGHT: "bright"
+}, pe = {
+	shadowType: "PCFShadowMap",
+	shAndAoPassParameters: {
+		aoIntensity: .3,
+		shadow: { shadowRadius: .1 },
+		ao: {
+			algorithm: W.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 }
+}, Y = (...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 = C(t, e[n]);
+	return t;
+}, X = (e) => e ? { groundReflectionParameters: { enabled: !1 } } : null, Z = (e) => !e || e === J.DEFAULT ? null : e === J.BRIGHT ? pe : null, Q = (e) => Math.max(0, Math.min(1, e)), me = (e) => {
+	let t = {
+		shAndAoPassParameters: {
+			ao: {},
+			shadow: {}
+		},
+		groundReflectionParameters: {},
+		bakedGroundContactShadowParameters: {}
+	};
+	return he(t, e), ge(t, e), _e(t, e), t;
+}, he = (e, t) => {
+	t.aoIntensity !== void 0 && (e.shAndAoPassParameters.aoIntensity = Q(t.aoIntensity)), t.aoExtent !== void 0 && (e.shAndAoPassParameters.ao.radius = Q(t.aoExtent) * .3, e.shAndAoPassParameters.ao.thickness = .1 + Q(t.aoExtent) * .2);
+}, ge = (e, t) => {
+	t.shBakedOnGround ? (e.bakedGroundContactShadowParameters.enabled = !0, e.shAndAoPassParameters.shadowIntensity = 0, t.shadowIntensity !== void 0 && (e.bakedGroundContactShadowParameters.opacity = Q(t.shadowIntensity)), t.shadowIntensity !== void 0 && (e.bakedGroundContactShadowParameters.blurMax = Q(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 = Q(t.shadowIntensity)), t.shadowSoftening !== void 0 && (e.shAndAoPassParameters.shadow.shadowRadius = .001 + Q(t.shadowSoftening) * .2));
+}, _e = (e, t) => {
+	t.grReflectIntensity !== void 0 && (e.groundReflectionParameters.enabled = t.grReflectIntensity > 0, e.groundReflectionParameters.intensity = Q(t.grReflectIntensity)), t.grReflectFadeOut !== void 0 && (e.groundReflectionParameters.fadeOutDistance = (1 - Q(t.grReflectFadeOut)) * 4);
+};
+//#endregion
+export { A, T as C, ne as D, k as E, O, F as S, N as T, re as _, Y as a, I as b, W as c, ue as d, se as f, z as g, B as h, me as i, E as k, U as l, oe as m, X as n, fe as o, V as p, Z as r, q as s, J as t, H as u, j as v, M as w, P as x, D as y };
+
+//# sourceMappingURL=shading-settings-BWeccIZv.mjs.map