@roomle/web-sdk 5.1.0-alpha.2 → 5.1.0-alpha.3

package/lib/webgpu-BHAP6BLI.mjs

@@ -0,0 +1,3140 @@
+import { Ar as e, Ci as t, Di as n, E as r, Gn as i, Hr as a, Mr as o, On as s, S as c, Si as l, U as u, Ur as d, V as f, Xr as p, Yt as m, Zr as h, ci as g, cn as _, ct as v, h as y, ht as b, jr as x, kr as S, ln as C, m as ee, on as te, qt as w, si as ne, sn as T, vi as re, w as ie, wi as E, yn as ae } from "./three.core-0KaTx8dm.mjs";
+import { t as oe } from "./Pass-DLiMLT5k.mjs";
+import { C as se, Dt as ce, Fn as le, Gn as ue, H as de, Hn as D, Rn as O, Vn as fe, X as k, ln as pe, vt as me } from "./three.webgpu-D3nSEIjD.mjs";
+import { l as he, n as ge, o as _e, r as ve, t as ye } from "./src-HhklrVDg.mjs";
+import { At as A, B as be, Dt as j, E as M, Ft as xe, Ht as Se, M as N, Ot as Ce, Pt as we, Rt as Te, St as P, Tt as F, Ut as I, jt as Ee, kt as De, pt as L, z as Oe } from "./three.tsl-Cf0-sCqB.mjs";
+Object.defineProperty(D.prototype, "layout", { get() {
+	return this;
+} }), D.prototype.isStruct = !0;
+var ke = new D({
+	min: "array<f32, 3>",
+	max: "array<f32, 3>"
+}, "BVHBoundingBox");
+ke.getLength = () => 6;
+var Ae = new D({
+	bounds: "BVHBoundingBox",
+	rightChildOrTriangleOffset: "uint",
+	splitAxisOrTriangleCount: "uint"
+}, "BVHNode");
+Ae.getLength = () => ke.getLength() + 2;
+var je = new D({
+	matrixWorld: "mat4x4f",
+	inverseMatrixWorld: "mat4x4f",
+	nodeOffset: "uint",
+	visible: "uint",
+	_alignment0: "uint",
+	_alignment1: "uint"
+}, "TransformStruct"), R = new D({
+	origin: "vec3f",
+	direction: "vec3f"
+}, "Ray"), z = new D({
+	indices: "vec4u",
+	normal: "vec3f",
+	didHit: "bool",
+	barycoord: "vec3f",
+	objectIndex: "uint",
+	side: "float",
+	dist: "float"
+}, "IntersectionResult"), Me = new D({
+	faceIndices: "vec4u",
+	closestPoint: "vec3f",
+	found: "bool",
+	barycoord: "vec3f",
+	objectIndex: "uint",
+	faceNormal: "vec3f",
+	side: "float",
+	distanceSq: "float"
+}, "PointQueryResult"), Ne = ue.nodeProxyConstructor ?? ((e, t) => new Proxy(e, {
+	get(e, n, r) {
+		let i = Reflect.get(t, n, r);
+		return i === void 0 && n === "functionNode" ? t : i;
+	},
+	set(e, n, r) {
+		return Reflect.set(t, n, r);
+	}
+})), Pe = class extends ce {
+	static get type() {
+		return "ProxyCallNode";
+	}
+	constructor(e, t) {
+		super(), this.proxyNode = e, this.params = t;
+	}
+	setup() {
+		return this.proxyNode.proxyNode.call(...this.params);
+	}
+}, Fe = class {
+	get isNode() {
+		return !0;
+	}
+	get proxyNode() {
+		let { proxyObject: e, proxyProperty: t } = this, n = t.split("."), r = e;
+		for (let e = 0, t = n.length; e < t; e++) r = r[n[e]];
+		return r && "functionNode" in r ? r.functionNode : r;
+	}
+	constructor(e, t = null) {
+		return this.proxyObject = t, this.proxyProperty = e, new Proxy(this, {
+			get(e, t) {
+				if (t in e) return Reflect.get(e, t);
+				{
+					let n = e.proxyNode;
+					if (!n) return;
+					let r = Reflect.get(n, t);
+					return typeof r == "function" ? r.bind(n) : r;
+				}
+			},
+			set(e, t, n) {
+				if (t in e) return Reflect.set(e, t, n);
+				throw Error("NodeProxy: Cannot set members of proxied nodes.");
+			}
+		});
+	}
+}, B = (...e) => new Fe(...e), V = (...e) => {
+	let t = new Fe(...e);
+	return Ne((...e) => new Pe(t, e), t);
+};
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/utils/toObjectBVH.js
+function Ie(e) {
+	return e instanceof ge ? e : (Array.isArray(e) || (e = [e]), new ge(e.map((e) => {
+		if (e.isObject3D) return e;
+		if (e.isBufferGeometry) return new _(e);
+		if (e instanceof _e) {
+			let t = new _();
+			return t.geometry.boundsTree = e, t;
+		}
+	}), {
+		strategy: 2,
+		targetLeafSize: 1
+	}));
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/utils/packBVHBufferUtils.js
+var H = /* @__PURE__ */ new E(), U = /* @__PURE__ */ new E();
+function Le(e, t) {
+	let n = e ? e.array : null, r = new Uint32Array(t.length * 3);
+	for (let e = 0, i = t.length; e < i; e++) {
+		let i = 3 * e, a = 3 * t[e];
+		for (let e = 0; e < 3; e++) r[i + e] = n ? n[a + e] : a + e;
+	}
+	return r;
+}
+function Re(e, t, n, r, i, a = !1) {
+	let o = new Uint16Array(i), s = new Uint32Array(i), c = new Float32Array(i), l = [], u = 0;
+	return e._roots.forEach((e) => {
+		let i = new Uint16Array(e), d = new Uint32Array(e);
+		l.push(r);
+		for (let l = 0, f = e.byteLength / 32; l < f; l++) {
+			let f = l * 8, p = f * 2, m = r * 8, h = m * 2, g = new Float32Array(e, l * 32, 6);
+			if (l === 0) for (let e = 0; e < 3; e++) {
+				let t = g[e + 0], n = g[e + 3];
+				t > n ? (c[m + e + 0] = 1, c[m + e + 3] = -1) : (c[m + e + 0] = t, c[m + e + 3] = n);
+			}
+			else c.set(g, m);
+			if (i[p + 15] === 65535) if (a) {
+				s[m + 6] = u, o[h + 15] = 65280;
+				let e = i[p + 14], t = 0;
+				for (let r = 0; r < e; r++) {
+					let e = n[u].data.bvh._roots.length;
+					u += e, t += e;
+				}
+				o[h + 14] = t;
+			} else s[m + 6] = d[f + 6] + t, o[h + 14] = i[p + 14], o[h + 15] = he;
+			else s[m + 6] = d[f + 6], s[m + 7] = d[f + 7];
+			r++;
+		}
+	}), l;
+}
+function ze(e, t, n, r, i) {
+	let { geometry: a } = e, { start: o, count: s, vertexStart: c } = t;
+	if (e.indirect) {
+		let t = Le(a.index, e._indirectBuffer);
+		for (let e = 0; e < t.length; e++) i[e + r] = t[e] - c + n;
+	} else if (a.index) for (let e = 0; e < s; e++) i[e + r] = a.index.getX(e + o) - c + n;
+	else for (let e = 0; e < s; e++) i[e + r] = e + o + n;
+}
+function Be(e, t, n, r, i, a) {
+	let { geometry: o, mesh: s = null } = e, { vertexStart: c, vertexCount: l } = t, u = new Float32Array(r), d = i.getLength();
+	i.membersLayout.forEach(({ name: e }, t) => {
+		let r = o.attributes[e];
+		a.getDefaultAttributeValue(e, H);
+		for (let i = 0; i < l; i++) {
+			if (r) {
+				switch (U.fromBufferAttribute(r, i + c), r.itemSize) {
+					case 1:
+						U.y = H.y, U.z = H.z, U.w = H.w;
+						break;
+					case 2:
+						U.z = H.z, U.w = H.w;
+						break;
+					case 3:
+						U.w = H.w;
+						break;
+				}
+				s && (e === "position" || e === "normal" || e === "tangent") && s.applyBoneTransform(i + c, U);
+			} else U.copy(H);
+			U.toArray(u, (n + i) * d + t * 4);
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/nodes/WGSLTagFnNode.js
+var Ve = ue.nodeProxyConstructor ?? ((e, t) => new Proxy(e, {
+	get(e, n, r) {
+		let i = Reflect.get(t, n, r);
+		return i === void 0 && n === "functionNode" ? t : i;
+	},
+	set(e, n, r) {
+		return Reflect.set(t, n, r);
+	}
+})), He = class extends ce {
+	constructor(e) {
+		super(), this.literal = e;
+	}
+	build() {
+		return this.literal;
+	}
+}, Ue = class extends ce {
+	constructor(e, t = "property") {
+		super(), this.node = e, this.output = t;
+	}
+	build(e) {
+		return this.node.build(e, this.output);
+	}
+};
+function We(e) {
+	return typeof e == "function" && e.functionNode && !e.isNode ? e.functionNode : e;
+}
+function Ge(e) {
+	return e = We(e), e.isNode ? new Ue(e) : null;
+}
+function Ke(e) {
+	let t = [];
+	for (let n of e) if (Array.isArray(n)) for (let e of n) {
+		let n = Ge(e);
+		n && t.push(n);
+	}
+	return t;
+}
+function qe(e) {
+	return e.map((e) => (e = We(e), e && e.isNode ? e instanceof Xe ? new Ue(e, "inline") : new Ue(e) : e));
+}
+function Je(e, t, n) {
+	let r = "";
+	for (let i = 0, a = e.length; i < a; i++) if (r += e[i], i < t.length) {
+		let e = We(t[i]);
+		Array.isArray(e) || (typeof e == "string" || typeof e == "number" ? r += String(e) : r += e.build(n));
+	}
+	return r;
+}
+var Ye = class extends de {
+	static get type() {
+		return "WGSLTagFnNode";
+	}
+	constructor(e, t, n = "wgsl") {
+		super("", Ke(t), n), this.tokens = e, this.args = t;
+	}
+	getNodeFunction(e) {
+		let { tokens: t } = this, n = qe(this.args), r = e.getDataFromNode(this), i = r.nodeFunction;
+		if (i === void 0) {
+			let a = "";
+			for (let r = 0, i = t.length; r < i; r++) if (a += t[r], r < n.length) {
+				let t = n[r];
+				Array.isArray(t) || (typeof t == "string" || typeof t == "number" ? a += String(t) : t.isStructLayoutNode ? a += t.getNodeType(e) : t.isStruct ? a += t.layout.getNodeType(e) : a += "_arg" + r);
+			}
+			a = a.replace(/\/\/.+[\n\r]/g, ""), i = e.parser.parseFunction(a), r.nodeFunction = i;
+		}
+		return i;
+	}
+	generate(e, t) {
+		let n = super.generate(e, t), r = Je(this.tokens, qe(this.args), e), { type: i } = this.getNodeFunction(e), a = e.getCodeFromNode(this, i);
+		return a.code = r.replace(/\/\/.+[\n\r]/g, "").replace(/->\s*void/, "").trim(), n;
+	}
+}, Xe = class extends se {
+	static get type() {
+		return "WGSLTagCodeNode";
+	}
+	constructor(e, t, n = "wgsl") {
+		super("", Ke(t), n), this.tokens = e, this.args = t;
+	}
+	build(e, t) {
+		return t === "inline" ? Je(this.tokens, qe(this.args), e) : super.build(e, t);
+	}
+	generate(e) {
+		super.generate(e);
+		let t = e.getCodeFromNode(this, this.getNodeType(e));
+		return t.code = Je(this.tokens, qe(this.args), e), t.code;
+	}
+}, Ze = (e) => Ve((...t) => {
+	if (t.length === 1 && t[0] && typeof t[0] == "object" && !t[0].isNode) {
+		let e = t[0];
+		for (let t in e) typeof e[t] == "string" && (e[t] = new He(e[t]));
+	}
+	return e.call(...t);
+}, e), W = (e, ...t) => Ze(new Ye(e, t)), G = (e, ...t) => new Xe(e, t), Qe = De(60);
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/shapecastFns/getShapecastFn.js
+function $e(e, t) {
+	let { name: n = `bvh_shapecast_fn_${Math.random().toString(36).substring(2, 7)}`, shapeStruct: r, resultStruct: i = null, boundsOrderFn: a = null, intersectsBoundsFn: o, intersectRangeFn: s, transformShapeFn: c = null, transformResultFn: l = null, resetShapeFn: u = null } = t, { nodes: d, transforms: f } = e.storage, p = "";
+	l && (p = G`${l}( result, i );`);
+	let m = "";
+	c && (m = G`${c}( &localShape, i );`);
+	let h = "";
+	u && (h = G`${u}( i );`);
+	let g = "";
+	a && (g = G`
+			let leftToRight = ${a}( shape, splitAxis, node );
+			c1 = select( rightIndex, leftIndex, leftToRight );
+			c2 = select( leftIndex, rightIndex, leftToRight );
+		`);
+	let _ = i ? G`result: ptr<function, ${i}>` : "", v = i ? "result" : "", y = (e) => G`
+
+			var pointer: i32 = 0;
+			var stack: array<u32, ${Qe}>;
+			stack[ 0 ] = rootNodeIndex;
+
+			loop {
+
+				if ( pointer < 0 || pointer >= i32( ${Qe} ) ) {
+
+					break;
+
+				}
+
+				let nodeIndex = stack[ pointer ];
+				let node = ${d}[ nodeIndex ];
+				pointer = pointer - 1;
+
+				if ( ${o}( shape, node.bounds, ${v} ) == 0u ) {
+
+					continue;
+
+				}
+
+				let infoX = node.splitAxisOrTriangleCount;
+				let infoY = node.rightChildOrTriangleOffset;
+				let isLeaf = ( infoX & 0xffff0000u ) != 0u;
+
+				if ( isLeaf ) {
+
+					let count = infoX & 0x0000ffffu;
+					let offset = infoY;
+					${e}
+
+				} else {
+
+					let leftIndex = nodeIndex + 1u;
+					let splitAxis = infoX & 0x0000ffffu;
+					let rightIndex = nodeIndex + infoY;
+
+					var c1 = rightIndex;
+					var c2 = leftIndex;
+					${g}
+
+					pointer = pointer + 1;
+					stack[ pointer ] = c2;
+
+					pointer = pointer + 1;
+					stack[ pointer ] = c1;
+
+				}
+
+			}
+
+		`, b = W`
+		// fn
+		fn ${n}_blas( shape: ${r}, rootNodeIndex: u32, ${_} ) -> bool {
+
+			var didHit = false;
+			${y(G`
+
+				didHit = ${s}( shape, offset, count, ${v} ) || didHit;
+
+			`)}
+
+			return didHit;
+
+		}
+	`, x = W`
+		// fn
+		fn ${n}( shape: ${r}, ${_} ) -> bool {
+
+			const rootNodeIndex = 0u;
+			var didHit = false;
+			${y(G`
+
+				for ( var i = offset; i < offset + count; i ++ ) {
+
+					let transform = ${f}[ i ];
+					if ( transform.visible == 0u ) {
+
+						continue;
+
+					}
+
+					// Transform shape into object local space
+					var localShape = shape;
+					${m}
+
+					if ( ${b}( localShape, transform.nodeOffset, ${v} ) ) {
+
+						${p}
+						didHit = true;
+
+					}
+
+					${h}
+
+				}
+
+			`)}
+
+			return didHit;
+
+		}
+	`;
+	return x.outputType = i, x.functionName = n, x;
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/tsl/fns.js
+var et = W`
+	// fn
+	fn closestPointToTriangle(
+		p: vec3f,
+		v0: vec3f,
+		v1: vec3f,
+		v2: vec3f
+	) -> vec3f {
+
+		let v10 = v1 - v0;
+		let v21 = v2 - v1;
+		let v02 = v0 - v2;
+		let p0 = p - v0;
+		let p1 = p - v1;
+		let p2 = p - v2;
+
+		let nor = cross( v10, v02 );
+		let q = cross( nor, p0 );
+		let d = 1.0 / dot( nor, nor );
+		var u = d * dot( q, v02 );
+		var v = d * dot( q, v10 );
+		var w = 1.0 - u - v;
+
+		if ( u < 0.0 ) {
+
+			w = clamp( dot( p2, v02 ) / dot( v02, v02 ), 0.0, 1.0 );
+			u = 0.0;
+			v = 1.0 - w;
+
+		} else if ( v < 0.0 ) {
+
+			u = clamp( dot( p0, v10 ) / dot( v10, v10 ), 0.0, 1.0 );
+			v = 0.0;
+			w = 1.0 - u;
+
+		} else if ( w < 0.0 ) {
+
+			v = clamp( dot( p1, v21 ) / dot( v21, v21 ), 0.0, 1.0 );
+			w = 0.0;
+			u = 1.0 - v;
+
+		}
+
+		return vec3f( w, u, v );
+
+	}
+`, tt = W`
+	// fn
+	fn intersectRayTriangle( ray: ${R}, a: vec3f, b: vec3f, c: vec3f, threshold: f32 ) -> ${z} {
+
+		const DET_EPSILON = 1e-15;
+
+		var result: ${z};
+		result.didHit = false;
+
+		let edge1 = b - a;
+		let edge2 = c - a;
+		let n = cross( edge1, edge2 );
+
+		let det = - dot( ray.direction, n );
+		if ( abs( det ) < DET_EPSILON ) {
+
+			return result;
+
+		}
+
+		let invdet = 1.0 / det;
+
+		let AO = ray.origin - a;
+		let DAO = cross( AO, ray.direction );
+
+		let u = dot( edge2, DAO ) * invdet;
+		if ( u < 0.0 || u > 1.0 ) {
+
+			return result;
+
+		}
+
+		let v = - dot( edge1, DAO ) * invdet;
+		if ( v < 0.0 || u + v > 1.0 ) {
+
+			return result;
+
+		}
+
+		let t = dot( AO, n ) * invdet;
+		let w = 1.0 - u - v;
+		if ( t < threshold ) {
+
+			return result;
+
+		}
+
+		result.didHit = true;
+		result.barycoord = vec3f( w, u, v );
+		result.dist = t;
+		result.side = sign( det );
+		result.normal = result.side * normalize( n );
+
+		return result;
+
+	}
+`, nt = W`
+	// fn
+	fn ndcToCameraRay( ndc: vec2f, inverseModelViewProjection: mat4x4f ) -> ${R} {
+
+		var homogeneous = vec4f();
+		var ray: ${R};
+
+		homogeneous = inverseModelViewProjection * vec4f( ndc, 0.0, 1.0 );
+		ray.origin = homogeneous.xyz / homogeneous.w;
+
+		homogeneous = inverseModelViewProjection * vec4f( ndc, 1.0, 1.0 );
+		ray.direction = ( homogeneous.xyz / homogeneous.w ) - ray.origin;
+
+		return ray;
+
+	}
+`;
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/shapecastFns/getRaycastFirstHitFn.js
+function rt(e) {
+	let { index: t, attributes: n, transforms: r } = e.storage, i = M(1).toVar(`bvh_rayScalar_${Math.random().toString(36).substring(2, 7)}`);
+	return e.getShapecastFn({
+		name: "bvh_RaycastFirstHit",
+		shapeStruct: R,
+		resultStruct: z,
+		boundsOrderFn: W`
+			fn getBoundsOrder( ray: ${R}, splitAxis: u32, node: ${Ae} ) -> bool {
+
+				return ray.direction[ splitAxis ] >= 0.0;
+
+			}
+		`,
+		intersectsBoundsFn: W`
+			fn rayIntersectsBounds( ray: ${R}, bounds: ${ke}, result: ptr<function, ${z}> ) -> u32 {
+
+				let boundsMin = vec3( bounds.min[0], bounds.min[1], bounds.min[2] );
+				let boundsMax = vec3( bounds.max[0], bounds.max[1], bounds.max[2] );
+
+				let invDir = 1.0 / ray.direction;
+				let tMinPlane = ( boundsMin - ray.origin ) * invDir;
+				let tMaxPlane = ( boundsMax - ray.origin ) * invDir;
+
+				let tMinHit = vec3f(
+					min( tMinPlane.x, tMaxPlane.x ),
+					min( tMinPlane.y, tMaxPlane.y ),
+					min( tMinPlane.z, tMaxPlane.z )
+				);
+
+				let tMaxHit = vec3f(
+					max( tMinPlane.x, tMaxPlane.x ),
+					max( tMinPlane.y, tMaxPlane.y ),
+					max( tMinPlane.z, tMaxPlane.z )
+				);
+
+				let t0 = max( max( tMinHit.x, tMinHit.y ), tMinHit.z );
+				let t1 = min( min( tMaxHit.x, tMaxHit.y ), tMaxHit.z );
+
+				let dist = max( t0, 0.0 );
+				if ( t1 < dist ) {
+
+					return 0u;
+
+				} else if ( result.didHit && dist * ${i} >= result.dist ) {
+
+					return 0u;
+
+				} else {
+
+					return 1u;
+
+				}
+
+			}
+
+		`,
+		intersectRangeFn: W`
+			fn intersectRange( ray: ${R}, offset: u32, count: u32, result: ptr<function, ${z}> ) -> bool {
+
+				var didHit = false;
+				for ( var ti = offset; ti < offset + count; ti = ti + 1u ) {
+
+					let i0 = ${t}[ ti * 3u ];
+					let i1 = ${t}[ ti * 3u + 1u ];
+					let i2 = ${t}[ ti * 3u + 2u ];
+
+					let a = ${n}[ i0 ].position.xyz;
+					let b = ${n}[ i1 ].position.xyz;
+					let c = ${n}[ i2 ].position.xyz;
+
+					var triResult = ${tt}( ray, a, b, c, 0.0 );
+					triResult.dist *= ${i};
+					if ( triResult.didHit && ( ! result.didHit || triResult.dist < result.dist ) ) {
+
+						result.didHit = true;
+						result.dist = triResult.dist;
+						result.normal = triResult.normal;
+						result.side = triResult.side;
+						result.barycoord = triResult.barycoord;
+						result.indices = vec4u( i0, i1, i2, ti );
+
+						didHit = true;
+
+					}
+
+				}
+
+				return didHit;
+
+			}
+		`,
+		transformShapeFn: W`
+			fn transformRay( ray: ptr<function, ${R}>, objectIndex: u32 ) -> void {
+
+				let toLocal = ${r}[ objectIndex ].inverseMatrixWorld;
+				ray.origin = ( toLocal * vec4f( ray.origin, 1.0 ) ).xyz;
+				ray.direction = ( toLocal * vec4f( ray.direction, 0.0 ) ).xyz;
+
+				let len = length( ray.direction );
+				ray.direction /= len;
+				${i} = 1.0 / len;
+
+			}
+		`,
+		transformResultFn: W`
+			fn transformResult( hit: ptr<function, ${z}>, objectIndex: u32 ) -> void {
+
+				let toLocal = ${r}[ objectIndex ].inverseMatrixWorld;
+				hit.normal = normalize( ( transpose( toLocal ) * vec4f( hit.normal, 0.0 ) ).xyz );
+				hit.objectIndex = objectIndex;
+
+			}
+		`,
+		resetShapeFn: W`
+			fn resetRayScalar( objectIndex: u32 ) -> void {
+
+				${i} = 1.0;
+
+			}
+		`
+	});
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/shapecastFns/getSampleTrianglePointFn.js
+function it(e) {
+	let { storage: t, structs: n } = e, r = n.attributes.membersLayout.map(({ name: e }) => `result.${e} = a0.${e} * barycoord.x + a1.${e} * barycoord.y + a2.${e} * barycoord.z;`).join("\n");
+	return W`
+		// fn
+		fn bvh_sampleTrianglePoint( barycoord: vec3f, indices: vec3u ) -> ${n.attributes} {
+
+			var result: ${n.attributes};
+			var a0 = ${t.attributes}[ indices.x ];
+			var a1 = ${t.attributes}[ indices.y ];
+			var a2 = ${t.attributes}[ indices.z ];
+			${r}
+			return result;
+
+		}
+	`;
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/shapecastFns/getClosestPointToPointFn.js
+function at(e) {
+	let { index: t, attributes: n, transforms: r } = e.storage, i = be().toVar("bvh_toWorldMat");
+	return e.getShapecastFn({
+		name: "bvh_ClosestPointToPoint",
+		shapeStruct: "vec3f",
+		resultStruct: Me,
+		boundsOrderFn: W`
+			fn cppBoundsOrder( shape: vec3f, splitAxis: u32, node: ${Ae} ) -> bool {
+
+				let toWorld = ${i};
+
+				// get center
+				let bMin = vec3f( node.bounds.min[ 0 ], node.bounds.min[ 1 ], node.bounds.min[ 2 ] );
+				let bMax = vec3f( node.bounds.max[ 0 ], node.bounds.max[ 1 ], node.bounds.max[ 2 ] );
+				let center = bMin * 0.5 + bMax * 0.5;
+
+				// determine the order in world space
+				let worldCenter = ( toWorld * vec4f( center, 1.0 ) ).xyz;
+				let worldAxis = normalize( toWorld[ splitAxis ].xyz );
+				return dot( shape - worldCenter, worldAxis ) <= 0.0;
+
+			}
+		`,
+		intersectsBoundsFn: W`
+			fn cppIntersectsBounds( shape: vec3f, bounds: ${ke}, result: ptr<function, ${Me}> ) -> u32 {
+
+				// return 1u;
+				// we need to check this no matter what if the result has not been found yet
+				if ( ! result.found ) {
+
+					return 1u;
+
+				}
+
+				let toWorld = ${i};
+
+				// transform to world space
+				let bMin = vec3f( bounds.min[ 0 ], bounds.min[ 1 ], bounds.min[ 2 ] );
+				let bMax = vec3f( bounds.max[ 0 ], bounds.max[ 1 ], bounds.max[ 2 ] );
+				let center = ( bMin + bMax ) * 0.5;
+				let halfExtent = ( bMax - bMin ) * 0.5;
+				let worldCenter = ( toWorld * vec4f( center, 1.0 ) ).xyz;
+				let worldHalfExtent =
+					abs( toWorld[ 0 ].xyz ) * halfExtent.x +
+				    abs( toWorld[ 1 ].xyz ) * halfExtent.y +
+				    abs( toWorld[ 2 ].xyz ) * halfExtent.z;
+				let worldMin = worldCenter - worldHalfExtent;
+				let worldMax = worldCenter + worldHalfExtent;
+
+				// intersect if the distance to the bounds is not bigger than the already found
+				let d = shape - clamp( shape, worldMin, worldMax );
+				return select( 0u, 1u, dot( d, d ) < result.distanceSq );
+
+			}
+		`,
+		intersectRangeFn: W`
+			fn cppIntersectsRange( shape: vec3f, offset: u32, count: u32, result: ptr<function, ${Me}> ) -> bool {
+
+				var didHit = false;
+				let toWorld = ${i};
+
+				for ( var i = offset; i < offset + count; i ++ ) {
+
+					// transform the triangle to world space
+					let i0 = ${t}[ i * 3u + 0u ];
+					let i1 = ${t}[ i * 3u + 1u ];
+					let i2 = ${t}[ i * 3u + 2u ];
+					let a = ( toWorld * vec4f( ${n}[ i0 ].position.xyz, 1.0 ) ).xyz;
+					let b = ( toWorld * vec4f( ${n}[ i1 ].position.xyz, 1.0 ) ).xyz;
+					let c = ( toWorld * vec4f( ${n}[ i2 ].position.xyz, 1.0 ) ).xyz;
+
+					let barycoord = ${et}( shape, a, b, c );
+					let closestPoint = barycoord.x * a + barycoord.y * b + barycoord.z * c;
+					let delta = shape - closestPoint;
+					let distSq = dot( delta, delta );
+
+					// copy the content over
+					if ( ! result.found || distSq < result.distanceSq ) {
+
+						let normal = normalize( cross( a - b, b - c ) );
+
+						result.closestPoint = closestPoint;
+						result.barycoord = barycoord;
+						result.distanceSq = distSq;
+						result.faceNormal = normal;
+						result.side = sign( dot( normal, delta ) );
+						result.faceIndices = vec4u( i0, i1, i2, i );
+						result.found = true;
+						didHit = true;
+
+					}
+
+				}
+
+				return didHit;
+
+			}
+		`,
+		transformShapeFn: W`
+			fn cppTransformShape( shape: ptr<function, vec3f>, objectIndex: u32 ) -> void {
+
+				${i} = ${r}[ objectIndex ].matrixWorld;
+
+			}
+		`,
+		transformResultFn: W`
+			fn cppTransformResult( result: ptr<function, ${Me}>, objectIndex: u32 ) -> void {
+
+				result.objectIndex = objectIndex;
+
+			}
+		`
+	});
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/lib/three-mesh-bvh/BVHComputeData.js
+var K = /* @__PURE__ */ new T(), ot = /* @__PURE__ */ new T();
+function st(e) {
+	let t = e;
+	for (; t;) {
+		if (t.visible === !1) return !1;
+		t = t.parent;
+	}
+	return !0;
+}
+function ct(e) {
+	return e._roots.reduce((e, t) => e + t.byteLength, 0);
+}
+var lt = class {
+	constructor(e, t = {}) {
+		e = Ie(e);
+		let { attributes: n = { position: "vec4f" }, autogenerateBvh: r = !0 } = t;
+		this._bvhCache = /* @__PURE__ */ new Map(), this.autogenerateBvh = r, this.attributes = n, this.bvh = e, this.storage = new ut(), this.structs = new ut({ transform: je }), this.fns = new ut({
+			raycastFirstHit: rt(this),
+			closestPointToPoint: at(this),
+			sampleTrianglePoint: null
+		}, V);
+	}
+	getShapecastFn(e) {
+		return $e(this, e);
+	}
+	update() {
+		this.dispose();
+		let { attributes: e, structs: t, bvh: n } = this, r = [], i = [], a = ct(n), o = 0, s = 0;
+		n.primitiveBuffer.forEach((e) => {
+			let t = n.getObjectFromId(e), c = n.getInstanceFromId(e), l = {
+				start: 0,
+				count: 0,
+				vertexStart: 0,
+				vertexCount: 0
+			}, u = this.getBVH(t, c, l);
+			if (!u) throw Error("BVHComputeData: BVH not found.");
+			if (!r.find((e) => e.bvh === u)) {
+				let e = {
+					index: r.length,
+					bvh: u,
+					range: l,
+					bvhNodeOffsets: null,
+					indexBufferOffset: null
+				};
+				a += ct(u), o += e.range.count, s += e.range.vertexCount, r.push(e);
+			}
+			let d = r.find((e) => u === e.bvh);
+			u._roots.forEach((n, r) => {
+				i.push({
+					data: d,
+					root: r,
+					object: t,
+					instanceId: c,
+					compositeId: e
+				});
+			});
+		});
+		let c = Math.max(i.length, 2);
+		o = Math.max(o, 2), s = Math.max(s, 2);
+		let l = new D(e, "bvh_GeometryStruct"), u = 0, d = 0, f = 0, p = new Uint32Array(o), m = /* @__PURE__ */ new ArrayBuffer(s * l.getLength() * 4), h = new ArrayBuffer(a);
+		Re(n, 0, i, 0, h, !0), f += ct(n) / 32, r.forEach((e) => {
+			e.bvhNodeOffsets = Re(e.bvh, d / 3, i, f, h, !1), ze(e.bvh, e.range, u, d, p), Be(e.bvh, e.range, u, m, l, this), e.indexBufferOffset = d, d += e.range.count, u += e.range.vertexCount, f += ct(e.bvh) / 32;
+		});
+		let g = /* @__PURE__ */ new ArrayBuffer(t.transform.getLength() * c * 4);
+		i.forEach((e, t) => {
+			ot.copy(n.matrixWorld).invert(), this.writeTransformData(e, ot, t, g);
+		});
+		let _ = P(new le(new Uint32Array(h), 1), Ae).toReadOnly().setName("bvh_nodes"), v = P(new le(new Uint32Array(g), 1), t.transform).toReadOnly().setName("bvh_transforms"), y = P(new le(p, 1), "uint").toReadOnly().setName("bvh_index"), b = P(new le(new Uint32Array(m), l.getLength()), l).toReadOnly().setName("bvh_attributes");
+		this.storage.transforms = v, this.storage.nodes = _, this.storage.index = y, this.storage.attributes = b, this.structs.attributes = l, this.fns.sampleTrianglePoint = it(this), this._bvhCache.clear();
+	}
+	writeTransformData(e, t, n, r) {
+		let { structs: i } = this, a = new Float32Array(r), o = new Uint32Array(r), { object: s, instanceId: c, root: l, data: u } = e, { bvhNodeOffsets: d } = u;
+		s.isInstancedMesh || s.isBatchedMesh ? (s.getMatrixAt(c, K), K.premultiply(s.matrixWorld)) : K.copy(s.matrixWorld), K.premultiply(t), K.toArray(a, n * i.transform.getLength()), K.invert(), K.toArray(a, n * i.transform.getLength() + 16), o[n * i.transform.getLength() + 32] = d[l];
+		let f = st(s);
+		s.isBatchedMesh && (f &&= s.getVisibleAt(c)), o[n * i.transform.getLength() + 33] = f ? 1 : 0;
+	}
+	getBVH(e, t, n) {
+		let { autogenerateBvh: r, _bvhCache: i } = this, a = null;
+		if (e.boundsTree || e.isSkinnedMesh) {
+			let t = e.geometry;
+			if (n.count = t.index ? t.index.count : t.attributes.position.count, n.vertexCount = t.attributes.position.count, a = e.boundsTree || null, a === null && r) {
+				let t = e.uuid;
+				a = i.get(t) || new ye(e), i.set(t, a);
+			}
+		} else if (e.isBatchedMesh) {
+			let o = e.getGeometryIdAt(t), s = e.getGeometryRangeAt(o);
+			if (Object.assign(n, s), a = e.boundsTrees[o] || null, a === null && r) {
+				let t = `batched_${e.geometry.uuid}_${s.start}_${s.count}`;
+				a = i.get(t) || new ve(e.geometry, { range: { ...n } }), i.set(t, a);
+			}
+		} else {
+			let t = e.geometry;
+			if (n.count = t.index ? t.index.count : t.attributes.position.count, n.vertexCount = t.attributes.position.count, a = e.geometry.boundsTree || null, a === null && r) {
+				let e = t.uuid;
+				a = i.get(e) || new ve(t), i.set(e, a);
+			}
+		}
+		return a;
+	}
+	getDefaultAttributeValue(e, t) {
+		switch (e) {
+			case "position":
+			case "color":
+				t.set(1, 1, 1, 1);
+				break;
+			default: t.set(0, 0, 0, 0);
+		}
+		return t;
+	}
+	dispose() {
+		let { storage: e } = this;
+		for (let t in e) e[t].value?.dispose(), delete e[t];
+	}
+}, ut = class {
+	constructor(e = {}, t = B) {
+		let n = {};
+		return new Proxy({ ...e }, {
+			get(e, r) {
+				return n[r] || (n[r] = t(r, e)), n[r];
+			},
+			set(e, t, n) {
+				return e[t] = n, !0;
+			}
+		});
+	}
+}, dt = I("\n	fn sampleTexel( tex: texture_2d<f32>, coord: vec2f ) -> vec4f {\n\n		// Manual bilinear filtering using textureLoad to support filterable float32 textures\n		// on all devices\n		let size = vec2f( textureDimensions( tex, 0 ) );\n		let pxCoord = coord * size - 0.5;\n		let px = vec2i( floor( pxCoord ) );\n		let fr = fract( pxCoord );\n\n		// get the four sibling samples\n		let s00 = textureLoad( tex, clamp( px,                 vec2i( 0 ), vec2i( size ) - 1 ), 0 );\n		let s10 = textureLoad( tex, clamp( px + vec2i( 1, 0 ), vec2i( 0 ), vec2i( size ) - 1 ), 0 );\n		let s01 = textureLoad( tex, clamp( px + vec2i( 0, 1 ), vec2i( 0 ), vec2i( size ) - 1 ), 0 );\n		let s11 = textureLoad( tex, clamp( px + vec2i( 1, 1 ), vec2i( 0 ), vec2i( size ) - 1 ), 0 );\n\n		// interpolate on the x axis\n		let y0 = mix( s00, s10, fr.x );\n		let y1 = mix( s01, s11, fr.x );\n\n		// then y\n		return mix( y0, y1, fr.y );\n\n	}\n"), ft = class extends me {
+	get texture() {
+		return this._texNode.value;
+	}
+	set texture(e) {
+		this._texNode.value = e;
+	}
+	get fromTexture() {
+		return this._fromTexNode.value;
+	}
+	set fromTexture(e) {
+		this._fromTexNode.value = e;
+	}
+	get toneMapping() {
+		return this._toneMapping.toneMapping;
+	}
+	set toneMapping(e) {
+		this._toneMapping.setToneMapping(e);
+	}
+	get transition() {
+		return this._transitionUniform.value;
+	}
+	set transition(e) {
+		this._transitionUniform.value = e;
+	}
+	get exposure() {
+		return this._toneMapping.exposureNode.value;
+	}
+	set exposure(e) {
+		this._toneMapping.exposureNode.value = e;
+	}
+	constructor(e) {
+		super();
+		let t = F(new O());
+		this._texNode = t;
+		let n = F(new O());
+		this._fromTexNode = n;
+		let r = xe(we()), i = A(1);
+		this._transitionUniform = i;
+		let a = Ce(0, 1, W`
+			fn fade( uv: vec2f ) -> vec4f {
+
+				if ( ${i} <= 0.0 ) {
+
+					return ${dt}( ${n}, uv );
+
+				} else if ( ${i} >= 1.0 ) {
+
+					return ${dt}( ${t}, uv );
+
+				} else {
+
+					let col0 = ${dt}( ${n}, uv );
+					let col1 = ${dt}( ${t}, uv );
+					return mix( col0, col1, ${i} );
+
+				}
+
+			}
+		`(r));
+		this._toneMapping = a, this.transparent = !0, this.colorNode = Te(a.rgb, a.a), this.setValues(e);
+	}
+}, q = class {
+	get computeNode() {
+		return this.kernel.computeNode;
+	}
+	get workgroupSize() {
+		return this.kernel.workgroupSize;
+	}
+	set needsUpdate(e) {
+		this.setWorkgroupSize(...this.workgroupSize);
+	}
+	constructor(e, t = {}) {
+		let { workgroupSize: n = [64] } = t;
+		this._fn = e, this.kernel = null, this.setWorkgroupSize(...n);
+	}
+	defineUniformAccessors(e) {
+		for (let t in e) {
+			if (t in this) throw Error(`ComputeNode: Uniform name ${t} is already defined.`);
+			"value" in e[t] && Object.defineProperty(this, t, {
+				get() {
+					return e[t].value;
+				},
+				set(n) {
+					e[t].value = n;
+				}
+			});
+		}
+	}
+	setWorkgroupSize(e = 64, t = 1, n = 1) {
+		return this.kernel = this._fn.computeKernel([
+			e,
+			t,
+			n
+		]), this;
+	}
+	getDispatchSize(e = 1, t = 1, n = 1, r = []) {
+		let [i, a, o] = this.workgroupSize;
+		return r.length = 3, r[0] = Math.ceil(e / i), r[1] = Math.ceil(t / a), r[2] = Math.ceil(n / o), r;
+	}
+}, pt = Se("\n\n	struct PcgState {\n		s0: vec4u,\n		s1: vec4u,\n	};\n\n	var<private> g_state: PcgState;\n");
+I("\n	fn pcgInitialize( pixelIndex: u32, pathIndex: u32, bounceIndex: u32 ) -> void {\n		let pixel = vec2( ( pixelIndex >> 16 ) & 0xFF, pixelIndex & 0xFF );\n\n		//white noise seed\n		g_state.s0 = vec4u( pixel | vec2( bounceIndex << 16 ), pathIndex, pixel.x + pixel.y);\n\n		//blue noise seed\n		g_state.s1 = vec4u(pathIndex, pathIndex*15843, pathIndex*31 + 4566, pathIndex*2345 + 58585);\n\n	}\n", [pt]);
+var mt = I("\n	fn pcg4d(v: ptr<private, vec4u>) -> void {\n		*v = *v * 1664525u + 1013904223u;\n		*v = *v + v.yzxy * v.wxyz;\n		*v = *v ^ (*v >> vec4u(16u));\n		*v = *v + v.yzxy * v.wxyz;\n	}\n");
+I("\n	fn pcgRand( _id: u32 ) -> f32 {\n		pcg4d(&g_state.s0);\n		return abs( f32( g_state.s0.x ) / f32(0xffffffffu) );\n	}\n", [mt, pt]), I("\n	fn pcgRand2( _id: u32 ) -> vec2f {\n		pcg4d(&g_state.s0);\n		return abs( vec2f( g_state.s0.xy ) / f32(0xffffffffu) );\n	}\n", [mt, pt]), I("\n	fn pcgRand3( _id: u32 ) -> vec3f {\n		pcg4d(&g_state.s0);\n		return abs( vec3f( g_state.s0.xyz ) / f32(0xffffffffu) );\n	}\n", [mt, pt]), I("\n	fn pcgRand4( _id: u32 ) -> vec4f {\n		pcg4d(&g_state.s0);\n		return abs( vec4f( g_state.s0 ) / f32(0xffffffffu) );\n	}\n", [mt, pt]), I("fn noop() -> void {}");
+var ht = De(256 * 256), gt = M(1 / 16777216), _t = Se("\n\n	const SOBOL_DIRECTIONS_1 = array<u32, 32>(\n		0x80000000u, 0xc0000000u, 0xa0000000u, 0xf0000000u,\n		0x88000000u, 0xcc000000u, 0xaa000000u, 0xff000000u,\n		0x80800000u, 0xc0c00000u, 0xa0a00000u, 0xf0f00000u,\n		0x88880000u, 0xcccc0000u, 0xaaaa0000u, 0xffff0000u,\n		0x80008000u, 0xc000c000u, 0xa000a000u, 0xf000f000u,\n		0x88008800u, 0xcc00cc00u, 0xaa00aa00u, 0xff00ff00u,\n		0x80808080u, 0xc0c0c0c0u, 0xa0a0a0a0u, 0xf0f0f0f0u,\n		0x88888888u, 0xccccccccu, 0xaaaaaaaau, 0xffffffffu\n	);\n\n	const SOBOL_DIRECTIONS_2 = array<u32, 32>(\n		0x80000000u, 0xc0000000u, 0x60000000u, 0x90000000u,\n		0xe8000000u, 0x5c000000u, 0x8e000000u, 0xc5000000u,\n		0x68800000u, 0x9cc00000u, 0xee600000u, 0x55900000u,\n		0x80680000u, 0xc09c0000u, 0x60ee0000u, 0x90550000u,\n		0xe8808000u, 0x5cc0c000u, 0x8e606000u, 0xc5909000u,\n		0x6868e800u, 0x9c9c5c00u, 0xeeee8e00u, 0x5555c500u,\n		0x8000e880u, 0xc0005cc0u, 0x60008e60u, 0x9000c590u,\n		0xe8006868u, 0x5c009c9cu, 0x8e00eeeeu, 0xc5005555u\n	);\n\n	const SOBOL_DIRECTIONS_3 = array<u32, 32>(\n		0x80000000u, 0xc0000000u, 0x20000000u, 0x50000000u,\n		0xf8000000u, 0x74000000u, 0xa2000000u, 0x93000000u,\n		0xd8800000u, 0x25400000u, 0x59e00000u, 0xe6d00000u,\n		0x78080000u, 0xb40c0000u, 0x82020000u, 0xc3050000u,\n		0x208f8000u, 0x51474000u, 0xfbea2000u, 0x75d93000u,\n		0xa0858800u, 0x914e5400u, 0xdbe79e00u, 0x25db6d00u,\n		0x58800080u, 0xe54000c0u, 0x79e00020u, 0xb6d00050u,\n		0x800800f8u, 0xc00c0074u, 0x200200a2u, 0x50050093u\n	);\n\n	const SOBOL_DIRECTIONS_4 = array<u32, 32>(\n		0x80000000u, 0x40000000u, 0x20000000u, 0xb0000000u,\n		0xf8000000u, 0xdc000000u, 0x7a000000u, 0x9d000000u,\n		0x5a800000u, 0x2fc00000u, 0xa1600000u, 0xf0b00000u,\n		0xda880000u, 0x6fc40000u, 0x81620000u, 0x40bb0000u,\n		0x22878000u, 0xb3c9c000u, 0xfb65a000u, 0xddb2d000u,\n		0x78022800u, 0x9c0b3c00u, 0x5a0fb600u, 0x2d0ddb00u,\n		0xa2878080u, 0xf3c9c040u, 0xdb65a020u, 0x6db2d0b0u,\n		0x800228f8u, 0x400b3cdcu, 0x200fb67au, 0xb00ddb9du\n	);\n\n"), vt = De(0).toVar("sobolPixelIndex"), yt = De(0).toVar("sobolPathIndex"), bt = De(0).toVar("sobolBounceIndex"), xt = I("\n\n	fn getMaskedSobol( index: u32, directions: array<u32, 32> ) -> u32 {\n\n		var X = 0u;\n		for ( var bit = 0u; bit < 32u; bit ++ ) {\n\n			let mask = ( index >> bit ) & 1u;\n			X ^= mask * directions[ bit ];\n\n		}\n		return X;\n\n	}\n\n"), St = (e = 1) => {
+	if (e <= 0) return;
+	let t = e > 1 ? `vec${e}u` : "u32", n = I(`
+
+			fn sobolReverseBits_${t}( in: ${t} ) -> ${t} {
+
+				var x = in;
+				x = ( ( ( x & ${t}( 0xaaaaaaaau ) ) >> ${t}( 1 ) ) | ( ( x & ${t}( 0x55555555u ) ) << ${t}( 1 ) ) );
+				x = ( ( ( x & ${t}( 0xccccccccu ) ) >> ${t}( 2 ) ) | ( ( x & ${t}( 0x33333333u ) ) << ${t}( 2 ) ) );
+				x = ( ( ( x & ${t}( 0xf0f0f0f0u ) ) >> ${t}( 4 ) ) | ( ( x & ${t}( 0x0f0f0f0fu ) ) << ${t}( 4 ) ) );
+				x = ( ( ( x & ${t}( 0xff00ff00u ) ) >> ${t}( 8 ) ) | ( ( x & ${t}( 0x00ff00ffu ) ) << ${t}( 8 ) ) );
+				return ( ( x >> ${t}( 16 ) ) | ( x << ${t}( 16 ) ) );
+
+			}
+
+	`), r = I(`
+
+		fn sobolHashCombine_${t}( seed: u32, v: ${t} ) -> ${t} {
+
+			return ${t}( seed ) ^ ( v + ${t}( ( seed << 6 ) + ( seed >> 2 ) ) );
+
+		}
+
+	`), i = I(`
+
+		fn sobolLaineKarrasPermutation_${t}( in: ${t}, seed: ${t} ) -> ${t} {
+
+			var x = in;
+			x += seed;
+			x ^= x * 0x6c50b47cu;
+			x ^= x * 0xb82f1e52u;
+			x ^= x * 0xc7afe638u;
+			x ^= x * 0x8d22f6e6u;
+			return x;
+
+		}
+
+	`);
+	return {
+		reverseBits: n,
+		hashCombine: r,
+		lkPermutation: i,
+		scramble: W`
+
+		fn nestedUniformScrambleBase2_${t}( x: ${t}, seed: ${t} ) -> ${t} {
+
+			var res = ${i}( x, seed );
+			res = ${n}( res );
+			return res;
+
+		}
+
+	`
+	};
+}, J = Array.from({ length: 5 }, (e, t) => St(t)), Ct = W`
+  ${[_t]}
+
+	fn generateSobolPoint( id: u32 ) -> vec4f {
+
+		var index = id;
+		if ( index >= ${ht} ) {
+
+			index = index % ${ht};
+			// return vec4( 0.0 );
+
+		}
+
+		// NOTE: this sobol "direction" is also available but we can't write out 5 components
+		// uint x = index & 0x00ffffffu;
+		let x = ${J[1].reverseBits}( ${xt}( index, SOBOL_DIRECTIONS_1 ) ) & 0x00ffffffu;
+		let y = ${J[1].reverseBits}( ${xt}( index, SOBOL_DIRECTIONS_2 ) ) & 0x00ffffffu;
+		let z = ${J[1].reverseBits}( ${xt}( index, SOBOL_DIRECTIONS_3 ) ) & 0x00ffffffu;
+		let w = ${J[1].reverseBits}( ${xt}( index, SOBOL_DIRECTIONS_4 ) ) & 0x00ffffffu;
+
+		return vec4( f32( x ), f32( y ), f32( z ), f32( w ) ) * ${gt};
+
+	}
+
+`, wt = I("\n\n	fn sobolHash( in: u32 ) -> u32 {\n\n		var x = in;\n		// finalizer from murmurhash3\n		x ^= x >> 16;\n		x *= 0x85ebca6bu;\n		x ^= x >> 13;\n		x *= 0xc2b2ae35u;\n		x ^= x >> 16;\n		return x;\n\n	}\n\n"), Tt = W`
+
+	fn sobolGetSeed( effect: u32 ) -> u32 {
+
+		return ${wt}(
+			${J[1].hashCombine}(
+				${J[1].hashCombine}(
+					${wt}( ${bt} ),
+					${vt}
+				),
+				effect
+			)
+		);
+
+	}
+
+`, Et = (e = 1, t = Ct) => {
+	if (e <= 0) return;
+	let n = e > 1 ? `vec${e}u` : "u32", r = e > 1 ? `vec${e}f` : "f32", i = ".r", a = "1u";
+	return e === 2 ? (i = ".rg", a = "vec2( 1u, 2u )") : e === 3 ? (i = ".rgb", a = "vec3( 1u, 2u, 3u )") : e === 4 && (i = "", a = "vec4( 1u, 2u, 3u, 4u )"), W`
+
+		fn sobol${e}( effect: u32 ) -> ${r} {
+
+			let seed = ${Tt}( effect );
+			let index = ${yt};
+
+			let shuffle_seed = ${J[1].hashCombine}( seed, 0u );
+			let shuffled_index = ${J[1].scramble}( ${J[1].reverseBits}( index ), shuffle_seed );
+			let sobol_pt = ${t}( shuffled_index )${i};
+			var result = ${n}( sobol_pt * 16777216.0 );
+
+			let seed2 = ${J[e].hashCombine}( seed, ${a} );
+			result = ${J[e].scramble}( result, seed2 );
+
+			return ${gt} * ${r}( result >> ${n}( 8 ) );
+
+		}
+
+	`;
+}, Dt = Et(1), Y = Et(2);
+Et(3), Et(4);
+var Ot = W`
+
+	fn sobolInit( pixelIndex: u32, pathIndex: u32, bounceIndex: u32 ) -> void {
+
+		${vt} = pixelIndex;
+		${yt} = pathIndex;
+		${bt} = bounceIndex;
+
+	}
+
+`, kt = W`
+
+	fn sobolNextBounce() -> void {
+
+		${bt}++;
+
+	}
+
+`, X = Se("\n\n	const PI: f32 = 3.141592653589793;\n	const EPSILON: f32 = 1e-5;\n	const MIN_ROUGHNESS: f32 = 1e-3;\n\n"), At = new D({
+	color: "vec3f",
+	specularPdf: "float",
+	direction: "vec3f",
+	pdf: "float"
+}, "ScatterRecord"), jt = new D({
+	color: "vec3",
+	map: "int",
+	metalness: "float",
+	metalnessMap: "int",
+	roughness: "float",
+	roughnessMap: "int",
+	ior: "float",
+	transmission: "float",
+	transmissionMap: "int",
+	emissiveIntensity: "float",
+	emissive: "vec3",
+	emissiveMap: "int",
+	normalMap: "int",
+	normalScale: "vec2",
+	clearcoat: "float",
+	clearcoatMap: "int",
+	clearcoatNormalMap: "int",
+	clearcoatNormalScale: "vec2",
+	clearcoatRoughness: "float",
+	clearcoatRoughnessMap: "int",
+	iridescenceMap: "int",
+	iridescenceThicknessMap: "int",
+	iridescence: "float",
+	iridescenceIor: "float",
+	iridescenceThicknessMinimum: "float",
+	iridescenceThicknessMaximum: "float",
+	specularColor: "vec3",
+	specularColorMap: "int",
+	specularIntensity: "float",
+	specularIntensityMap: "int",
+	thinFilm: "int",
+	attenuationColor: "vec3",
+	attenuationDistance: "float",
+	alphaMap: "int",
+	castShadow: "int",
+	opacity: "float",
+	alphaTest: "float",
+	side: "float",
+	matte: "int",
+	sheen: "float",
+	sheenColor: "vec3",
+	sheenColorMap: "int",
+	sheenRoughness: "float",
+	sheenRoughnessMap: "int",
+	vertexColors: "int",
+	flatShading: "int",
+	transparent: "int",
+	fogVolume: "int",
+	mapTransform: "mat3",
+	metalnessMapTransform: "mat3",
+	roughnessMapTransform: "mat3",
+	transmissionMapTransform: "mat3",
+	emissiveMapTransform: "mat3",
+	normalMapTransform: "mat3",
+	clearcoatMapTransform: "mat3",
+	clearcoatNormalMapTransform: "mat3",
+	clearcoatRoughnessMapTransform: "mat3",
+	sheenColorMapTransform: "mat3",
+	sheenRoughnessMapTransform: "mat3",
+	iridescenceMapTransform: "mat3",
+	iridescenceThicknessMapTransform: "mat3",
+	specularColorMapTransform: "mat3",
+	specularIntensityMapTransform: "mat3",
+	alphaMapTransform: "mat3"
+}, "Material"), Mt = new D({
+	volumeParticle: "bool",
+	faceNormal: "vec3f",
+	frontFace: "bool",
+	normal: "vec3f",
+	normalBasis: "mat3x3f",
+	normalInvBasis: "mat3x3f",
+	eta: "f32",
+	f0: "f32",
+	roughness: "f32",
+	metalness: "f32",
+	color: "vec3f",
+	emission: "vec3f",
+	ior: "f32",
+	transmission: "f32",
+	thinFilm: "bool",
+	attenuationColor: "vec3f",
+	attenuationDistance: " f32",
+	clearcoatNormal: "vec3f",
+	clearcoatBasis: "mat3x3f",
+	clearcoatInvBasis: "mat3x3f",
+	clearcoat: "f32",
+	clearcoatRoughness: "f32",
+	sheen: "f32",
+	sheenColor: "vec3f",
+	sheenRoughness: "f32",
+	iridescence: "f32",
+	iridescenceIor: "f32",
+	iridescenceThickness: "f32",
+	specularColor: "vec3f",
+	specularIntensity: "f32"
+}, "SurfaceRecord"), Nt = new D({
+	rotation: "mat3x3f",
+	intensity: "float",
+	blur: "float"
+}, "EnvironmentInfo"), Pt = new D({
+	diffuse: "float",
+	specular: "float",
+	transmission: "float",
+	clearcoat: "float"
+}, "LobeWeights"), Ft = new D({
+	NdotV: "float",
+	NdotL: "float",
+	NdotH: "float",
+	VdotH: "float",
+	VdotNc: "float",
+	LdotNc: "float",
+	HdotNc: "float"
+}, "BxDFContext"), It = I("\n\n	fn inverse(m: mat3x3f) -> mat3x3f {\n		var adj: mat3x3f;\n		adj[0][0] =   (m[1][1] * m[2][2] - m[2][1] * m[1][2]);\n		adj[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);\n		adj[2][0] =   (m[1][0] * m[2][1] - m[2][0] * m[1][1]);\n		adj[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);\n		adj[1][1] =   (m[0][0] * m[2][2] - m[2][0] * m[0][2]);\n		adj[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);\n		adj[0][2] =   (m[0][1] * m[1][2] - m[1][1] * m[0][2]);\n		adj[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);\n		adj[2][2] =   (m[0][0] * m[1][1] - m[1][0] * m[0][1]);\n\n		let det = ( m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])\n			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])\n			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]));\n\n		return adj * ( 1.0 / det );\n	}\n\n"), Lt = I("\n\n	fn getBasisFromNormal( normal: vec3f ) -> mat3x3f {\n\n		var other: vec3f;\n		if ( abs( normal.x ) > 0.5 ) {\n\n			other = vec3f( 0.0, 1.0, 0.0 );\n\n		} else {\n\n			other = vec3f( 1.0, 0.0, 0.0 );\n\n		}\n\n		let ortho = normalize( cross( normal, other ) );\n		let ortho2 = normalize( cross( normal, ortho ) );\n		return mat3x3f( ortho2, ortho, normal );\n\n	}\n\n"), Rt = I("\n\n	fn iorToF0( ior: f32 ) -> f32 {\n		return pow( ( 1 - ior ) / ( 1 + ior ), 2 );\n	}\n\n"), zt = I("\n\n	fn iorToF0General( transmittedIor: f32, incidentIor: f32 ) -> f32 {\n\n		return pow( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ), 2 );\n\n	}\n\n"), Bt = I("\n\n	fn iorToF0GeneralVec( transmittedIor: vec3f, incidentIor: vec3f ) -> vec3f {\n\n		let v = ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor );\n		return v * v;\n\n	}\n\n"), Vt = I("\n\n	fn fresnel0ToIor( f0: vec3f ) -> vec3f {\n\n		let sqrtF0 = sqrt( f0 );\n		return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );\n\n	}\n\n"), Ht = I("\n\n	fn schlickFresnel( cosine: f32, f0: f32 ) -> f32 {\n\n		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );\n\n	}\n\n"), Ut = I("\n\n	fn schlickFresnelVec( cosine: f32, f0: vec3f, f90: vec3f ) -> vec3f {\n\n		return f0 + ( f90 - f0 ) * pow( 1.0 - cosine, 5.0 );\n\n	}\n\n"), Wt = I("\n\n	fn evaluateFresnel( cosine: f32, eta: f32, f0: vec3f, f90: vec3f ) -> vec3f {\n\n		if ( totalInternalReflection( cosine, eta ) ) {\n\n			return f90;\n\n		}\n\n		return f0 + ( f90 - f0 ) * pow( 1.0 - cosine, 5.0 );\n	}\n\n", [I("\n\n	fn totalInternalReflection( cosTheta: f32, eta: f32 ) -> bool {\n\n		let sinTheta = sqrt( 1.0 - cosTheta * cosTheta );\n		return eta * sinTheta > 1.0;\n\n	}\n\n")]), Gt = I("\n\n	fn isTerminatingScatter( scatterRec: ScatterRecord ) -> bool {\n		return scatterRec.pdf <= 0;\n	}\n\n", [At]), Kt = I("\n\n	fn applyWrap( v: f32, wrapMode: i32 ) -> f32 {\n\n		var res = v;\n		if ( wrapMode == 1 ) {\n\n			// ClampToEdge\n			res = clamp( res, 0.0, 1.0 );\n\n		} else if ( wrapMode == 2 ) {\n\n			// MirroredRepeat\n			res = 1.0 - abs( 2.0 * fract( res * 0.5 ) - 1.0 );\n\n		} else {\n\n			// Repeat\n			res = fract( res );\n\n		}\n\n		return res;\n\n	}\n\n"), qt = (e, t, n) => W`
+
+	fn sampleTexel( uv: vec2f, packed: i32, lod: f32 ) -> vec4f {
+
+		let wrapS    = ( packed >> 24 ) & 0x3;
+		let wrapT    = ( packed >> 26 ) & 0x3;
+		let nearest  = ( packed >> 28 ) & 0x1;
+		let texIndex = packed & 0xFFFFFF;
+
+		// look up the texture's rect and page within the atlas. three wraps a
+		// uniformArray in a struct ( textureInfoStruct ) with a "value" array member.
+		let info   = ${e}[ u32( texIndex ) ];
+		let offset = vec2f( vec2u( info.x & 0xFFFFu, info.x >> 16u ) );
+		let size   = vec2f( vec2u( info.y & 0xFFFFu, info.y >> 16u ) );
+		let page   = i32( info.z & 0xFFFFu );
+
+		// wrap is applied on the logical uv first, then remapped into the tile
+		let wrappedUv = vec2f(
+			${Kt}( uv.x, wrapS ),
+			${Kt}( uv.y, wrapT ),
+		);
+
+		let pageDim = vec2f( textureDimensions( ${t}, 0 ).xy );
+
+		if ( nearest == 1 ) {
+
+			let tileTexel = clamp( vec2i( wrappedUv * size ), vec2i( 0 ), vec2i( size ) - vec2i( 1 ) );
+			return textureLoad( ${t}, vec2i( offset ) + tileTexel, page, 0 );
+
+		} else {
+
+			var atlasUv = ( offset + wrappedUv * size ) / pageDim;
+
+			// clamp to half a texel inside the tile so bilinear taps never bleed into
+			// neighboring atlas tiles
+			let minUv = ( offset + vec2f( 0.5 ) ) / pageDim;
+			let maxUv = ( offset + size - vec2f( 0.5 ) ) / pageDim;
+			atlasUv = clamp( atlasUv, minUv, maxUv );
+
+			return textureSampleLevel( ${t}, ${n}, atlasUv, page, lod );
+
+		}
+
+	}
+`, Jt = I("\n\n	fn diffuseDirection( wo: vec3f, uv: vec2f ) -> vec3f {\n\n		var lightDirection = sampleSphere( uv );\n		lightDirection.z += 1.0;\n		lightDirection = normalize( lightDirection );\n\n		return lightDirection;\n\n	}\n\n", [I("\n\n	fn sampleSphere( uv: vec2f ) -> vec3f {\n\n		let u = ( uv.x - 0.5 ) * 2.0;\n		let t = uv.y * PI * 2.0;\n		let f = sqrt( 1.0 - u * u );\n\n		return vec3f( f * cos( t ), f * sin( t ), u );\n\n	}\n\n", [X])]), Yt = I("\n\n	fn getLobeWeights(wo: vec3f, woClearcoat: vec3f, wh: vec3f, clearcoatIor: f32, surf: SurfaceRecord) -> LobeWeights {\n\n		// TODO: experiment with this; I don't see any usage of normal?\n		let metalness = surf.metalness;\n		let transmission = surf.transmission;\n		let HdotL = dot( wh, wo );\n		let fEstimate = evaluateFresnel( HdotL, surf.eta, vec3f( surf.f0 ), vec3f( 1.0 ) ).x;\n\n		let transSpecularProb = mix( max( 0.25, fEstimate ), 1.0, metalness );\n		let diffSpecularProb = 0.5 + 0.5 * metalness;\n\n		var weights: LobeWeights;\n		weights.diffuse = ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );\n		weights.specular = transmission * transSpecularProb + ( 1.0 - transmission ) * diffSpecularProb;\n\n		let clearcoatF0 = iorToF0( clearcoatIor );\n		let clearcoatFresnel = schlickFresnel( saturate( woClearcoat.z ), clearcoatF0 );\n		weights.clearcoat = surf.clearcoat * clearcoatFresnel;\n\n		weights.transmission = transmission * ( 1.0 - transSpecularProb );\n\n		let totalWeight = weights.diffuse + weights.specular;\n		if ( totalWeight > 0 ) {\n			weights.diffuse = ( weights.diffuse / totalWeight ) * ( 1 - weights.clearcoat );\n			weights.specular = ( weights.specular / totalWeight ) * ( 1 - weights.clearcoat );\n		}\n		// weights.transmission /= totalWeight;\n\n		return weights;\n\n	}\n\n", [
+	Ht,
+	Rt,
+	Wt,
+	Pt,
+	X
+]), Xt = I("\n\n	fn sampleEnvironment(\n		envMap: texture_2d<f32>,\n		envMapSampler: sampler,\n		env: EnvironmentInfo,\n		direction: vec3f,\n		uv: vec2f,\n	) -> vec4f {\n\n		let offsetDir = sampleHemisphere( direction, uv ) * 0.5 * env.blur;\n		let sampleDir = normalize( env.rotation * direction + offsetDir );\n		let col = sampleEquirectColor( envMap, envMapSampler, sampleDir );\n\n		return vec4f( env.intensity * col.rgb, col.a );\n\n	}\n\n", [
+	I("\n\n	fn sampleEquirectColor( envMap: texture_2d<f32>, envMapSampler: sampler, direction: vec3f ) -> vec4f {\n\n		return textureSampleLevel( envMap, envMapSampler, equirectDirectionToUv( direction ), 0 );\n\n	}\n\n", [I("\n\n	fn equirectDirectionToUv(direction: vec3f) -> vec2f {\n\n		// from Spherical.setFromCartesianCoords\n		var uv = vec2f( atan2( direction.z, direction.x ), acos( direction.y ) );\n		uv /= vec2f( 2.0 * PI, PI );\n\n		// apply adjustments to get values in range [0, 1] and y right side up\n		uv.x += 0.5;\n		uv.y = 1.0 - uv.y;\n		return uv;\n\n	}\n\n")]),
+	I("\n\n	fn sampleHemisphere( n: vec3f, uv: vec2f ) -> vec3f {\n\n		// https://www.rorydriscoll.com/2009/01/07/better-sampling/\n		// https://graphics.pixar.com/library/OrthonormalB/paper.pdf\n		let sign = select( sign( n.z ), 1.0, n.z == 0.0 );\n		let a = - 1.0 / ( sign + n.z );\n		let b = n.x * n.y * a;\n		let b1 = vec3( 1.0 + sign * n.x * n.x * a, sign * b, - sign * n.x );\n		let b2 = vec3( b, sign + n.y * n.y * a, - n.y );\n\n		let r = sqrt( uv.x );\n		let theta = 2.0 * PI * uv.y;\n		let x = r * cos( theta );\n		let y = r * sin( theta );\n		return x * b1 + y * b2 + sqrt( 1.0 - uv.x ) * n;\n\n	}\n\n", [X]),
+	Nt
+]), Zt = I("\n\n	fn weightedAlphaBlend( prevColor: vec4f, newColor: vec4f, weight: f32 ) -> vec4f {\n\n		let invWeight = 1.0 - weight;\n		let totalAlpha = prevColor.a * invWeight + newColor.a * weight;\n		var blendedColor = vec4f( 0 );\n		if ( totalAlpha != 0.0 ) {\n\n			let prevContrib = prevColor.rgb * invWeight * prevColor.a / totalAlpha;\n			let resContrib = newColor.rgb * weight * newColor.a / totalAlpha;\n			blendedColor = vec4f( prevContrib + resContrib, totalAlpha );\n\n		}\n\n		return blendedColor;\n\n	}\n\n"), Qt = class extends q {
+	constructor() {
+		let e = {
+			bvhData: { value: null },
+			material: { value: null },
+			prevOutputTarget: j(new O(1, 1)).toReadOnly(),
+			outputTarget: j(new O(1, 1)).toWriteOnly(),
+			sampleCountTarget: j(new O(1, 1)).toReadWrite(),
+			offset: A(new l()),
+			tileSize: A(new l()),
+			seed: A(0),
+			bounces: A(5),
+			inverseProjectionMatrix: A(new T()),
+			cameraToModelMatrix: A(new T()),
+			envMap: F(new f()),
+			envMapSampler: L(new f()),
+			envMapRotation: A(new te()),
+			envMapIntensity: A(1),
+			background: F(new f()),
+			backgroundSampler: L(new f()),
+			backgroundRotation: A(new te()),
+			backgroundIntensity: A(1),
+			backgroundBlurriness: A(0),
+			textures: F(new f()),
+			textureSampler: L(new f()),
+			globalId: N
+		}, t = B("bvhData.value.fns.raycastFirstHit.outputType", e), n = V("bvhData.value.fns.raycastFirstHit", e), r = V("bvhData.value.fns.sampleTrianglePoint", e), i = V("bvhData.value.fns.getSurfaceRecord", e), a = V("material.value.bsdfSample", e), o = W`
+
+			fn compute(
+
+				// indices and target
+				globalId: vec3u,
+
+				// tiles
+				offset: vec2u,
+				tileSize: vec2u,
+
+				// settings
+				inverseProjectionMatrix: mat4x4f,
+				cameraToModelMatrix: mat4x4f,
+				seed: u32,
+				bounces: u32,
+
+				// environment
+				envMap: texture_2d<f32>,
+				envMapSampler: sampler,
+				envMapRotation: mat3x3f,
+				envMapIntensity: f32,
+
+				background: texture_2d<f32>,
+				backgroundSampler: sampler,
+				backgroundRotation: mat3x3f,
+				backgroundIntensity: f32,
+				backgroundBlurriness: f32,
+
+			) -> void {
+
+				let transforms = &${B("bvhData.value.storage.transforms", e)};
+				let materials = &${B("bvhData.value.storage.materials", e)};
+
+				let envInfo = EnvironmentInfo(
+					envMapRotation,
+					envMapIntensity,
+					0.0 // blur,
+				);
+
+				let backgroundInfo = EnvironmentInfo(
+					backgroundRotation,
+					backgroundIntensity,
+					backgroundBlurriness,
+				);
+
+				// make sure we don't bleed over the edge of our tile
+				if ( globalId.x >= tileSize.x || globalId.y >= tileSize.y ) {
+
+					return;
+
+				}
+
+				// to screen coordinates
+				let indexUV = offset + globalId.xy;
+				let targetDimensions = textureDimensions( ${e.outputTarget} );
+				if ( indexUV.x >= targetDimensions.x || indexUV.y >= targetDimensions.y ) {
+
+					return;
+
+				}
+
+				let uv = vec2f( indexUV ) / vec2f( targetDimensions );
+				let ndc = uv * 2.0 - vec2f( 1.0 );
+
+				let pixelIndex = ( indexUV.x << 16 ) | indexUV.y;
+				${Ot}( pixelIndex, seed, 0 );
+
+				// scene ray
+				var jitter = 2.0 * ${Y}( ${0} ) / vec2f( targetDimensions.xy );
+				var ray = ${nt}( ndc + jitter, cameraToModelMatrix * inverseProjectionMatrix );
+				ray.direction = normalize( ray.direction );
+
+				var resultColor = vec4f( 0, 0, 0, 1 );
+				var throughputColor = vec3f( 1.0 );
+
+				for ( var bounce = 0u; bounce < bounces; bounce ++ ) {
+
+					var hitResult: ${t};
+					if ( ${n}( ray, &hitResult ) ) {
+
+						let object = transforms[ hitResult.objectIndex ];
+						var material = materials[ object.materialIndex ];
+
+						// apply per-object colors
+						material.color *= object.color.rgb;
+						material.opacity *= object.color.a;
+
+						var vertexData = ${r}( hitResult.barycoord, hitResult.indices.xyz );
+						vertexData.normal = normalize( transpose( object.inverseMatrixWorld ) * vertexData.normal );
+						vertexData.position = object.matrixWorld * vertexData.position;
+
+						let surface = ${i}( material, vertexData, hitResult.side, hitResult.normal );
+
+						resultColor += vec4f( throughputColor * surface.emission, 0.0 );
+
+						let scatterRec = ${a}( - ray.direction, surface );
+
+						if ( ${Gt}( scatterRec ) ) {
+
+							break;
+
+						}
+
+						throughputColor *= scatterRec.color;
+						throughputColor /= scatterRec.pdf;
+
+						// TODO: Investigate offsetting this position to not self-intersect multiple times
+						// Adding + scatterRec.direction * 1e-1 seems to fix almost all the fireflies
+						// However that seems like a very large distance to offset
+						ray.origin = vertexData.position.xyz;
+						ray.direction = scatterRec.direction;
+
+					} else {
+
+						let rng = ${Y}( ${1} );
+						if ( bounce > 0u ) {
+
+							resultColor += ${Xt}( envMap, envMapSampler, envInfo, ray.direction, rng ) * vec4f( throughputColor, 0.0 );
+
+						} else {
+
+							resultColor = ${Xt}( background, backgroundSampler, backgroundInfo, ray.direction, rng );
+
+						}
+
+						break;
+
+					}
+
+					${kt}();
+
+				}
+
+				let sampleCount = textureLoad( ${e.sampleCountTarget}, indexUV ).r + 1;
+				let prevColor = textureLoad( ${e.prevOutputTarget}, indexUV );
+				let blendedColor = ${Zt}( prevColor, resultColor, 1.0 / f32( sampleCount ) );
+				textureStore( ${e.sampleCountTarget}, indexUV, vec4( sampleCount ) );
+				textureStore( ${e.outputTarget}, indexUV, blendedColor );
+
+			}`;
+		super(o(e)), this.defineUniformAccessors(e);
+	}
+};
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/utils/TextureUtils.js
+function $t(e) {
+	let t = new Uint16Array(e.length);
+	for (let n = 0, r = e.length; n < r; ++n) t[n] = u.toHalfFloat(e[n]);
+	return t;
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/uniforms/EquirectHdrInfoUniform.js
+function en(e, t, n = 0, r = e.length) {
+	let i = n, a = n + r - 1;
+	for (; i < a;) {
+		let n = i + a >> 1;
+		e[n] < t ? i = n + 1 : a = n;
+	}
+	return i - n;
+}
+function tn(e, t, n) {
+	return .2126 * e + .7152 * t + .0722 * n;
+}
+function nn(e, t = b) {
+	let n = e.clone();
+	n.source = new h({ ...n.image });
+	let { width: r, height: i, data: a } = n.image, o = a;
+	if (n.type !== t) {
+		o = t === 1016 ? new Uint16Array(a.length) : new Float32Array(a.length);
+		let e;
+		e = a instanceof Int8Array || a instanceof Int16Array || a instanceof Int32Array ? 2 ** (8 * a.BYTES_PER_ELEMENT - 1) - 1 : 2 ** (8 * a.BYTES_PER_ELEMENT) - 1;
+		for (let r = 0, i = a.length; r < i; r++) {
+			let i = a[r];
+			n.type === 1016 && (i = u.fromHalfFloat(a[r])), n.type !== 1015 && n.type !== 1016 && (i /= e), t === 1016 && (o[r] = u.toHalfFloat(i));
+		}
+		n.image.data = o, n.type = t;
+	}
+	if (n.flipY) {
+		let e = o;
+		o = o.slice();
+		for (let t = 0; t < i; t++) for (let n = 0; n < r; n++) {
+			let a = i - t - 1, s = 4 * (t * r + n), c = 4 * (a * r + n);
+			o[c + 0] = e[s + 0], o[c + 1] = e[s + 1], o[c + 2] = e[s + 2], o[c + 3] = e[s + 3];
+		}
+		n.flipY = !1, n.image.data = o;
+	}
+	return n;
+}
+var rn = class {
+	constructor() {
+		let e = new f($t(new Float32Array([
+			0,
+			0,
+			0,
+			0
+		])), 1, 1);
+		e.type = b, e.format = i, e.minFilter = w, e.magFilter = w, e.wrapS = o, e.wrapT = o, e.generateMipmaps = !1, e.needsUpdate = !0;
+		let t = new f($t(new Float32Array([0, 1])), 1, 2);
+		t.type = b, t.format = S, t.minFilter = w, t.magFilter = w, t.generateMipmaps = !1, t.needsUpdate = !0;
+		let n = new f($t(new Float32Array([
+			0,
+			0,
+			1,
+			1
+		])), 2, 2);
+		n.type = b, n.format = S, n.minFilter = w, n.magFilter = w, n.generateMipmaps = !1, n.needsUpdate = !0, this.map = e, this.marginalWeights = t, this.conditionalWeights = n, this.totalSum = 0;
+	}
+	dispose() {
+		this.marginalWeights.dispose(), this.conditionalWeights.dispose(), this.map.dispose();
+	}
+	updateFrom(e) {
+		let t = nn(e);
+		t.wrapS = o, t.wrapT = c;
+		let { width: n, height: r, data: i } = t.image, a = new Float32Array(n * r), s = new Float32Array(n * r), l = new Float32Array(r), d = new Float32Array(r), f = 0, p = 0;
+		for (let e = 0; e < r; e++) {
+			let t = 0;
+			for (let r = 0; r < n; r++) {
+				let o = e * n + r, c = tn(u.fromHalfFloat(i[4 * o + 0]), u.fromHalfFloat(i[4 * o + 1]), u.fromHalfFloat(i[4 * o + 2]));
+				t += c, f += c, a[o] = c, s[o] = t;
+			}
+			if (t !== 0) for (let r = e * n, i = e * n + n; r < i; r++) a[r] /= t, s[r] /= t;
+			p += t, l[e] = t, d[e] = p;
+		}
+		if (p !== 0) for (let e = 0, t = l.length; e < t; e++) l[e] /= p, d[e] /= p;
+		let m = new Uint16Array(r), h = new Uint16Array(n * r);
+		for (let e = 0; e < r; e++) {
+			let t = en(d, (e + 1) / r);
+			m[e] = u.toHalfFloat((t + .5) / r);
+		}
+		for (let e = 0; e < r; e++) for (let t = 0; t < n; t++) {
+			let r = e * n + t, i = en(s, (t + 1) / n, e * n, n);
+			h[r] = u.toHalfFloat((i + .5) / n);
+		}
+		this.dispose();
+		let { marginalWeights: g, conditionalWeights: _ } = this;
+		g.image = {
+			width: r,
+			height: 1,
+			data: m
+		}, g.needsUpdate = !0, _.image = {
+			width: n,
+			height: r,
+			data: h
+		}, _.needsUpdate = !0, this.totalSum = f, this.map = t;
+	}
+}, an = class extends q {
+	constructor() {
+		let e = {
+			globalId: N,
+			outputTarget: j(new O(1, 1)).toWriteOnly()
+		}, t = W`
+			fn compute( globalId: vec3u ) -> void {
+
+				textureStore( ${e.outputTarget}, globalId.xy, vec4( 0, 0, 0, 1 ) );
+
+			}
+		`;
+		super(t(e)), this.defineUniformAccessors({ target: e.outputTarget });
+	}
+}, on = class {
+	constructor(t) {
+		this.renderer = t, this.camera = null, this.samples = 0, this.bounces = 7, this.lowResMode = !1, this._renderTask = null, this.outputTarget = new O(1, 1), this.outputTarget.format = i, this.outputTarget.type = v, this.outputTarget.colorSpace = r.workingColorSpace, this.outputTarget.name = "Output #0", this.outputTarget.generateMipmaps = !1, this.prevOutputTarget = new O(1, 1), this.prevOutputTarget.format = i, this.prevOutputTarget.type = v, this.prevOutputTarget.colorSpace = r.workingColorSpace, this.prevOutputTarget.name = "Output #1", this.prevOutputTarget.generateMipmaps = !1, this.sampleCountTarget = new O(1, 1), this.sampleCountTarget.format = e, this.sampleCountTarget.type = re, this.sampleCountTarget.name = "Sample Count", this.sampleCountTarget.generateMipmaps = !1, this.sampleCountClearKernel = new an().setWorkgroupSize(8, 8, 1), this.outputTargetClearKernel = new an().setWorkgroupSize(8, 8, 1);
+	}
+	setCamera(e) {
+		this.camera = e, this.reset();
+	}
+	setBVHData(e) {}
+	setTextures(e) {}
+	setMaterial(e) {}
+	setEnvironment(e, t, n, r, i, a, o) {}
+	setSize(e, t) {
+		e = Math.ceil(e), t = Math.ceil(t);
+		let { width: n, height: r } = this.outputTarget;
+		return n === e && r === t ? !1 : (this.outputTarget.dispose(), this.prevOutputTarget.dispose(), this.sampleCountTarget.dispose(), this.outputTarget = this.outputTarget.clone(), this.prevOutputTarget = this.outputTarget.clone(), this.sampleCountTarget = this.sampleCountTarget.clone(), this.outputTarget.setSize(e, t), this.prevOutputTarget.setSize(e, t), this.sampleCountTarget.setSize(e, t), this.reset(), !0);
+	}
+	getSize(e) {
+		let { width: t, height: n } = this.outputTarget;
+		return e.x = t, e.y = n, e;
+	}
+	update() {
+		let { camera: e, renderer: t } = this;
+		!e || !t.initialized || (this._renderTask ||= this.createRenderTask(), this._renderTask.next());
+	}
+	*createRenderTask() {}
+	reset() {
+		let { renderer: e, outputTargetClearKernel: t, sampleCountClearKernel: n, outputTarget: r, prevOutputTarget: i, sampleCountTarget: a } = this;
+		if (!e.initialized) return;
+		let { width: o, height: s } = r, c = t.getDispatchSize(o, s);
+		t.target = r, e.compute(t.kernel, c), t.target = i, e.compute(t.kernel, c), n.target = a, e.compute(n.kernel, c), this.samples = 0, this._renderTask = null;
+	}
+	dispose() {
+		this.outputTarget.dispose(), this.prevOutputTarget.dispose(), this.sampleCountTarget.dispose(), this._renderTask = null;
+	}
+}, sn = class extends on {
+	constructor(e) {
+		super(e), this.tiles = new l(2, 2), this.envInfo = new rn(), this.samples = 0, this.kernel = new Qt().setWorkgroupSize(8, 8, 1);
+	}
+	setBVHData(e) {
+		this.kernel.bvhData = e, this.kernel.needsUpdate = !0, this.reset();
+	}
+	setMaterial(e) {
+		this.kernel.material = e.getData(), this.kernel.needsUpdate = !0, this.reset();
+	}
+	setEnvironment(e, t, n, r, i, a, o) {
+		let { kernel: s } = this;
+		s.background.isTexture && s.background.dispose(), e !== null && (this.envInfo.updateFrom(e), s.envMap = this.envInfo.map, s.kernel.computeNode.parameters.envMapSampler.node.value = this.envInfo.map);
+		let c = new T().makeRotationFromEuler(n).invert();
+		s.envMapRotation.setFromMatrix4(c), s.envMapIntensity = t, s.background = r, s.kernel.computeNode.parameters.backgroundSampler.node.value = r, c.makeRotationFromEuler(a).invert(), s.backgroundRotation.setFromMatrix4(c), s.backgroundIntensity = i, s.backgroundBlurriness = o;
+	}
+	setTiles(e) {
+		this.tiles.copy(e);
+	}
+	*createRenderTask() {
+		let { renderer: e, camera: t, kernel: n, bounces: r, tiles: i, outputTarget: a, sampleCountTarget: o, lowResMode: s } = this;
+		for (t.updateMatrixWorld(), n.outputTarget = a, n.sampleCountTarget = o, n.bounces = r, n.inverseProjectionMatrix.copy(t.projectionMatrixInverse), n.cameraToModelMatrix.copy(t.matrixWorld);;) {
+			let t = n.tileSize;
+			s ? this.getSize(t) : this.getSize(t).divide(i).ceil();
+			let r = n.getDispatchSize(t.x, t.y);
+			n.seed += 1, e.copyTextureToTexture(this.outputTarget, this.prevOutputTarget), [this.outputTarget, this.prevOutputTarget] = [this.prevOutputTarget, this.outputTarget], n.prevOutputTarget = this.prevOutputTarget, n.outputTarget = this.outputTarget;
+			for (let a = 0; a < i.x; a++) for (let o = 0; o < i.y; o++) n.offset.set(a, o).multiply(t), e.compute(n.kernel, r), yield;
+			this.samples++;
+		}
+	}
+	dispose() {
+		super.dispose(), this.envInfo.dispose();
+	}
+}, Z = new D({
+	origin: "vec3f",
+	seed: "uint",
+	direction: "vec3f",
+	_alignment0: "uint",
+	throughputColor: "vec3f",
+	currentBounce: "uint",
+	pixel: "vec2u",
+	resultColor: "vec4f"
+}, "QueuedRay"), Q = new D({
+	indices: "vec3u",
+	seed: "uint",
+	barycoord: "vec2f",
+	pixel_x: "uint",
+	pixel_y: "uint",
+	view: "vec3f",
+	currentBounce: "uint",
+	throughputColor: "vec3f",
+	objectIndex: "uint",
+	normal: "vec3f",
+	side: "float",
+	resultColor: "vec4f"
+}, "QueuedHit"), cn = class extends q {
+	constructor() {
+		let e = {
+			rayWorkGroupSize: A(new t()),
+			tileSize: A(new l()),
+			tileCount: A(new l()),
+			tileOffset: A(1),
+			rayQueue: P(new k(1, Z.getLength()), Z).toReadOnly(),
+			queueSizes: P(new k(4, 1), "u32"),
+			outputTileIndex: P(new k(2, 1), "u32").setName("outputTileIndex"),
+			outputDispatch: P(new k(3, 1), "u32").setName("outputDispatch")
+		}, n = W`
+			fn compute(
+				rayWorkGroupSize: vec3u,
+
+				tileSize: vec2u,
+				tileCount: vec2u,
+				tileOffset: u32,
+			) -> void {
+
+				let rayQueue = &${e.rayQueue};
+				let queueSizes = &${e.queueSizes};
+
+				let outputTileIndex = &${e.outputTileIndex};
+				let outputDispatch = &${e.outputDispatch};
+
+				// reset hit queue size from previous iteration
+				queueSizes[ 2 ] = 0u;
+				queueSizes[ 3 ] = 0u;
+
+				// keep the queue index small
+			    let queueCapacity = arrayLength( rayQueue );
+				if ( queueSizes[ 0 ] >= queueCapacity ) {
+
+					// uint division results in a floored value
+					let offset = queueSizes[ 0 ] / queueCapacity;
+					queueSizes[ 0 ] = queueSizes[ 0 ] - queueCapacity * offset;
+					queueSizes[ 1 ] = queueSizes[ 1 ] - queueCapacity * offset;
+
+				}
+
+				// calculate the amount of elements in the queue
+			    var queueSize = queueSizes[ 1 ] - queueSizes[ 0 ];
+
+				// calculate the overhead of space in the queue and how much space we need to run a new tile
+				let overhead = queueCapacity - queueSize;
+				let requiredSpace = tileSize.x * tileSize.y;
+
+				if ( overhead >= requiredSpace ) {
+
+					// calculate the necessary dispatch size to cover the tile
+					outputDispatch[ 0 ] = u32( ceil( f32( tileSize.x ) / f32( rayWorkGroupSize.x ) ) );
+					outputDispatch[ 1 ] = u32( ceil( f32( tileSize.y ) / f32( rayWorkGroupSize.y ) ) );
+					outputDispatch[ 2 ] = 1;
+
+					// calculate the tile index to generate rays for
+					let totalTiles = tileCount.x * tileCount.y;
+					let currentIndex = outputTileIndex[ 1 ] * tileCount.x + outputTileIndex[ 0 ];
+					let nextIndex = ( currentIndex + tileOffset ) % totalTiles;
+
+					outputTileIndex[ 0 ] = nextIndex % tileCount.x;
+					outputTileIndex[ 1 ] = nextIndex / tileCount.x;
+
+				} else {
+
+					outputDispatch[ 0 ] = 0;
+					outputDispatch[ 1 ] = 0;
+					outputDispatch[ 2 ] = 0;
+
+				}
+
+			}
+		`;
+		super(n(e)), this.defineUniformAccessors(e);
+	}
+}, ln = class extends q {
+	constructor() {
+		let e = {
+			cameraToModelMatrix: A(new T()),
+			inverseProjectionMatrix: A(new T()),
+			seed: A(0),
+			tileIndexBuffer: P(new k(2, 1), "u32"),
+			tileSize: A(new l()),
+			rayQueue: P(new k(1, Z.getLength()), Z),
+			queueSizes: P(new k(4, 1), "u32").toAtomic(),
+			sampleCountTarget: j(new O()).toReadWrite(),
+			globalId: N
+		}, t = W`
+			fn compute(
+				cameraToModelMatrix: mat4x4f,
+				inverseProjectionMatrix: mat4x4f,
+
+				seed: u32,
+				tileSize: vec2u,
+
+				globalId: vec3u
+			) -> void {
+
+				let rayQueue = &${e.rayQueue};
+				let queueSizes = &${e.queueSizes};
+				let tileIndexBuffer = &${e.tileIndexBuffer};
+
+				// don't overstep the edge of the tile
+				if ( globalId.x >= tileSize.x || globalId.y >= tileSize.y ) {
+
+					return;
+
+				}
+
+				// calculate the pixel index and ensure we are not generating rays outside the texture bounds
+				let offset = vec2( tileIndexBuffer[ 0 ] * tileSize.x, tileIndexBuffer[ 1 ] * tileSize.y );
+				let indexUV = offset + globalId.xy;
+				let targetDimensions = textureDimensions( ${e.sampleCountTarget} );
+				if ( indexUV.x >= targetDimensions.x || indexUV.y >= targetDimensions.y ) {
+
+					return;
+
+				}
+
+				// calculate the screen uv
+				let uv = vec2f( indexUV ) / vec2f( targetDimensions );
+				let ndc = uv * 2.0 - vec2f( 1.0 );
+
+				// check whether ray is already active (added on the queue) and skip it if it is
+				let ACTIVE_FLAG = 0xF0000000u;
+				let combinedField = textureLoad( ${e.sampleCountTarget}, indexUV ).r;
+				let isActive = ( ACTIVE_FLAG & combinedField ) != 0;
+				let samples = ( ( ~ ACTIVE_FLAG ) & combinedField );
+
+				if ( isActive ) {
+
+					return;
+
+				}
+
+				// get the ray index
+				let queueCapacity = arrayLength( rayQueue );
+				let index = atomicAdd( &queueSizes[ 1 ], 1 ) % queueCapacity;
+
+				let pixelIndex = ( indexUV.x << 16 ) | indexUV.y;
+				${Ot}( pixelIndex, seed, 0 );
+
+				// write the ray data
+				var jitter = 2.0 * ${Y}( ${0} ) / vec2f( targetDimensions.xy );
+				var ray = ${nt}( ndc + jitter, cameraToModelMatrix * inverseProjectionMatrix );
+				ray.direction = normalize( ray.direction );
+
+				rayQueue[ index ].origin = ray.origin;
+				rayQueue[ index ].direction = ray.direction;
+				rayQueue[ index ].pixel = indexUV;
+				rayQueue[ index ].throughputColor = vec3f( 1.0 );
+				rayQueue[ index ].currentBounce = 0;
+				rayQueue[ index ].resultColor = vec4f( 0.0, 0.0, 0.0, 1.0 );
+				rayQueue[ index ].seed = seed;
+
+				// write the active params
+				textureStore( ${e.sampleCountTarget}, indexUV, vec4( ACTIVE_FLAG | samples ) );
+
+			}
+		`;
+		super(t(e)), this.defineUniformAccessors(e);
+	}
+}, un = class extends q {
+	constructor() {
+		let e = {
+			bvhData: { value: null },
+			prevOutputTarget: j(new O(1, 1)).toReadOnly(),
+			outputTarget: j(new O(1, 1)).toWriteOnly(),
+			sampleCountTarget: j(new O(1, 1)).toReadWrite(),
+			rayQueue: P(new k(1, Z.getLength()), Z).toReadOnly(),
+			hitQueue: P(new k(1, Q.getLength()), Q),
+			queueSizes: P(new k(4, 1), "u32").toAtomic(),
+			envMap: F(new f()),
+			envMapSampler: L(new f()),
+			envMapRotation: A(new te()),
+			envMapIntensity: A(1),
+			background: F(new f()),
+			backgroundSampler: L(new f()),
+			backgroundRotation: A(new te()),
+			backgroundIntensity: A(1),
+			backgroundBlurriness: A(0),
+			globalId: N
+		}, t = B("bvhData.value.fns.raycastFirstHit.outputType", e), n = B("bvhData.value.fns.raycastFirstHit", e), r = W`
+
+			fn compute(
+				// environment
+				envMap: texture_2d<f32>,
+				envMapSampler: sampler,
+				envMapRotation: mat3x3f,
+				envMapIntensity: f32,
+
+				background: texture_2d<f32>,
+				backgroundSampler: sampler,
+				backgroundRotation: mat3x3f,
+				backgroundIntensity: f32,
+				backgroundBlurriness: f32,
+
+				globalId: vec3u
+			) -> void {
+
+				let rayQueue = &${e.rayQueue};
+				let hitQueue = &${e.hitQueue};
+				let queueSizes = &${e.queueSizes};
+
+				let envInfo = EnvironmentInfo(
+					envMapRotation,
+					envMapIntensity,
+					0.0 // blur,
+				);
+
+				let backgroundInfo = EnvironmentInfo(
+					backgroundRotation,
+					backgroundIntensity,
+					backgroundBlurriness,
+				);
+
+				// skip any rays invocations beyond the ray count
+				let queueCapacity = arrayLength( rayQueue );
+				let rayIndex = ( globalId.x + atomicLoad( &queueSizes[ 0 ] ) );
+				if ( rayIndex >= atomicLoad( &queueSizes[ 1 ] ) ) {
+
+					return;
+
+				}
+
+				// get the ray info
+				let ACTIVE_FLAG = 0xF0000000u;
+				let input = rayQueue[ rayIndex % queueCapacity ];
+				let indexUV = input.pixel;
+
+				let pixelIndex = ( indexUV.x << 16 ) | indexUV.y;
+				${Ot}( pixelIndex, input.seed, input.currentBounce );
+
+				// run intersection
+				let ray = Ray( input.origin, input.direction );
+				var hitResult: ${t};
+				if ( ${n}( ray, &hitResult ) ) {
+
+					// TODO: we process all of these materials immediately to push to the ray queue
+					let index = atomicAdd( &queueSizes[ 3 ], 1 );
+					hitQueue[ index ].view = - input.direction;
+					hitQueue[ index ].indices = hitResult.indices.xyz;
+					hitQueue[ index ].barycoord = hitResult.barycoord.xy;
+					hitQueue[ index ].normal = hitResult.normal.xyz;
+					hitQueue[ index ].side = hitResult.side;
+					hitQueue[ index ].pixel_x = indexUV.x;
+					hitQueue[ index ].pixel_y = indexUV.y;
+					hitQueue[ index ].objectIndex = hitResult.objectIndex;
+					hitQueue[ index ].throughputColor = input.throughputColor;
+					hitQueue[ index ].currentBounce = input.currentBounce;
+					hitQueue[ index ].resultColor = input.resultColor;
+					hitQueue[ index ].seed = input.seed;
+
+				} else {
+
+					let rng = ${Y}( ${1} );
+					var resultColor = input.resultColor;
+					if ( input.currentBounce > 0u ) {
+
+						resultColor += ${Xt}( envMap, envMapSampler, envInfo, input.direction, rng ) * vec4f( input.throughputColor, 0.0 );
+
+					} else {
+
+						resultColor = ${Xt}( background, backgroundSampler, backgroundInfo, input.direction, rng );
+
+					}
+
+					let sampleCount = ( textureLoad( ${e.sampleCountTarget}, indexUV ).r & ( ~ ACTIVE_FLAG ) ) + 1;
+					let prevColor = textureLoad( ${e.prevOutputTarget}, indexUV );
+					let blendedColor = ${Zt}( prevColor, resultColor, 1.0 / f32( sampleCount ) );
+					textureStore( ${e.sampleCountTarget}, indexUV, vec4( sampleCount ) );
+					textureStore( ${e.outputTarget}, indexUV, blendedColor );
+
+				}
+
+			}
+		`;
+		super(r(e)), this.defineUniformAccessors(e);
+	}
+}, dn = class extends q {
+	constructor() {
+		let e = {
+			processed: A(0),
+			queueSizes: P(new k(4, 1), "u32")
+		}, t = W`
+			fn compute( processed: u32 ) -> void {
+
+				let queueSizes = &${e.queueSizes};
+			    var queueSize = queueSizes[ 1 ] - queueSizes[ 0 ];
+				if ( processed > queueSize ) {
+
+					queueSizes[ 0 ] = queueSizes[ 1 ];
+
+				} else {
+
+					queueSizes[ 0 ] = queueSizes[ 0 ] + processed;
+
+				}
+
+			}
+		`;
+		super(t(e)), this.defineUniformAccessors(e);
+	}
+}, fn = class extends q {
+	constructor(e = {}) {
+		let { type: t = "u32" } = e, n = {
+			globalId: N,
+			outputTarget: P(new k(1, 1), t)
+		}, r = W`
+			fn compute( globalId: vec3u ) -> void {
+
+				${n.outputTarget}[ globalId.x ] = 0;
+
+			}
+		`;
+		super(r(n)), this.defineUniformAccessors({ target: n.outputTarget });
+	}
+}, pn = class extends q {
+	constructor() {
+		let e = {
+			bvhData: { value: null },
+			material: { value: null },
+			prevOutputTarget: j(new O(1, 1)).toReadOnly(),
+			outputTarget: j(new O(1, 1)).toWriteOnly(),
+			sampleCountTarget: j(new O(1, 1)).toReadWrite(),
+			smoothNormals: A(1),
+			bounces: A(1),
+			rayQueue: P(new k(1, Z.getLength()), Z),
+			hitQueue: P(new k(1, Q.getLength()), Q),
+			queueSizes: P(new k(4, 1), "u32").toAtomic(),
+			textures: F(new f()),
+			textureSampler: L(new f()),
+			globalId: N
+		}, t = V("bvhData.value.fns.sampleTrianglePoint", e), n = V("bvhData.value.fns.getSurfaceRecord", e), r = V("material.value.bsdfSample", e), i = W`
+
+			fn compute(
+				// settings
+				smoothNormals: u32,
+				bounces: u32,
+
+				globalId: vec3u
+			) -> void {
+
+				let rayQueue = &${e.rayQueue};
+				let hitQueue = &${e.hitQueue};
+				let queueSizes = &${e.queueSizes};
+
+				let materials = &${B("bvhData.value.storage.materials", e)};
+				let transforms = &${B("bvhData.value.storage.transforms", e)};
+
+				// skip any rays invocations beyond the ray count
+				let hitQueueCapacity = arrayLength( hitQueue );
+				let hitIndex = ( globalId.x + atomicLoad( &queueSizes[ 2 ] ) );
+				if ( hitIndex >= atomicLoad( &queueSizes[ 3 ] ) ) {
+
+					return;
+
+				}
+
+				// get the ray info
+				let ACTIVE_FLAG = 0xF0000000u;
+				let input = hitQueue[ hitIndex ];
+				let indexUV = vec2u( input.pixel_x, input.pixel_y );
+
+				let pixelIndex = ( indexUV.x << 16 ) | indexUV.y;
+				${Ot}( pixelIndex, input.seed, input.currentBounce );
+
+				let object = transforms[ input.objectIndex ];
+				var material = materials[ object.materialIndex ];
+
+				// apply per-object colors
+				material.color *= object.color.rgb;
+				material.opacity *= object.color.a;
+
+				let barycoord = vec3( input.barycoord, 1.0 - input.barycoord.x - input.barycoord.y );
+				var vertexData = ${t}( barycoord, input.indices.xyz );
+				vertexData.normal = normalize( transpose( object.inverseMatrixWorld ) * vertexData.normal );
+				vertexData.position = object.matrixWorld * vertexData.position;
+
+				let surface = ${n}( material, vertexData, input.side, input.normal );
+
+				let scatterRec = ${r}( input.view, surface );
+
+				let resultColor = input.resultColor + vec4f( input.throughputColor * surface.emission, 0.0 );
+
+				let isTerminated = input.currentBounce >= bounces || ${Gt}( scatterRec );
+
+				if ( isTerminated ) {
+
+					// terminate ray, write color
+					let sampleCount = ( textureLoad( ${e.sampleCountTarget}, indexUV ).r & ( ~ ACTIVE_FLAG ) ) + 1;
+					let prevColor = textureLoad( ${e.prevOutputTarget}, indexUV );
+					let blendedColor = ${Zt}( prevColor, resultColor, 1.0 / f32( sampleCount ) );
+					textureStore( ${e.sampleCountTarget}, indexUV, vec4( sampleCount ) );
+					textureStore( ${e.outputTarget}, indexUV, blendedColor );
+
+				} else {
+
+					let rayQueueCapacity = arrayLength( rayQueue );
+					let index = atomicAdd( &queueSizes[ 1 ], 1 ) % rayQueueCapacity;
+					rayQueue[ index ].origin = vertexData.position.xyz;
+					rayQueue[ index ].direction = scatterRec.direction;
+					rayQueue[ index ].pixel = indexUV;
+					rayQueue[ index ].throughputColor = input.throughputColor * scatterRec.color / scatterRec.pdf;
+					rayQueue[ index ].currentBounce = input.currentBounce + 1;
+					rayQueue[ index ].resultColor = resultColor;
+					rayQueue[ index ].seed = input.seed;
+
+				}
+
+			}`;
+		super(i(e)), this.defineUniformAccessors(e);
+	}
+}, mn = 25e4, hn = 134217728, gn = Math.floor(hn / (Z.getLength() * 4)), _n = Math.floor(hn / (Q.getLength() * 4)), vn = class extends on {
+	constructor(e) {
+		super(e), this.tiles = new l(3, 3), this.envInfo = new rn(), this.rayQueue = new k(gn, Z.getLength()), this.rayQueue.name = "Ray Queue", this.hitQueue = new k(_n, Q.getLength()), this.hitQueue.name = "Hit Queue", this.queueSizes = new k(4, 1), this.queueSizes.name = "Queue Sizes", this.tileIndexBuffer = new k(2, 1), this.rayGenerationDispatch = new k(3, 1), this.hitProcessDispatch = new k(3, 1), this.primeRayGenerationDispatchKernel = new cn().setWorkgroupSize(1, 1, 1), this.enqueueRaysKernel = new ln().setWorkgroupSize(8, 8, 1), this.rayIntersectionKernel = new un().setWorkgroupSize(64, 1, 1), this.updateRayQueueParamsKernel = new dn().setWorkgroupSize(1, 1, 1), this.hitProcessKernel = new pn().setWorkgroupSize(64, 1, 1), this.zeroDispatchKernel = new fn().setWorkgroupSize(1, 1, 1), this.volumeKernel = null, this.lightConnectionKernel = null;
+	}
+	setBVHData(e) {
+		this.rayIntersectionKernel.bvhData = e, this.rayIntersectionKernel.needsUpdate = !0, this.hitProcessKernel.bvhData = e, this.hitProcessKernel.needsUpdate = !0, this.reset();
+	}
+	setMaterial(e) {
+		this.hitProcessKernel.material = e.getData(), this.hitProcessKernel.needsUpdate = !0, this.reset();
+	}
+	setEnvironment(e, t, n, r, i, a, o) {
+		let s = this.rayIntersectionKernel;
+		s.background.isTexture && s.background.dispose(), e !== null && (this.envInfo.updateFrom(e), s.envMap = this.envInfo.map, s.kernel.computeNode.parameters.envMapSampler.node.value = this.envInfo.map);
+		let c = new T().makeRotationFromEuler(n).invert();
+		s.envMapRotation.setFromMatrix4(c), s.envMapIntensity = t, s.background = r, s.kernel.computeNode.parameters.backgroundSampler.node.value = r, c.makeRotationFromEuler(a).invert(), s.backgroundRotation.setFromMatrix4(c), s.backgroundIntensity = i, s.backgroundBlurriness = o;
+	}
+	setTiles(e) {
+		this.tiles.copy(e);
+	}
+	getTileSize(e) {
+		return this.getSize(e).divide(this.tiles).ceil(), e;
+	}
+	dispose() {
+		super.dispose(), this.envInfo.dispose();
+	}
+	reset() {
+		let { renderer: e, sampleCountClearKernel: t, zeroDispatchKernel: n, sampleCountTarget: r, hitProcessDispatch: i, rayGenerationDispatch: a, queueSizes: o, tileIndexBuffer: s } = this;
+		if (!e.initialized) return;
+		super.reset(), this.enqueueRaysKernel.seed = 0;
+		let { width: c, height: l } = r, u = t.getDispatchSize(c, l);
+		t.target = r, e.compute(t.kernel, u), n.target = o, e.compute(n.kernel, [o.count]), n.target = i, e.compute(n.kernel, [i.count]), n.target = a, e.compute(n.kernel, [a.count]), n.target = s, e.compute(n.kernel, [s.count]);
+	}
+	*createRenderTask() {
+		let { renderer: e, camera: t, bounces: n, tiles: r, sampleCountTarget: i, rayQueue: a, hitQueue: o, queueSizes: s, rayGenerationDispatch: c, tileIndexBuffer: u, primeRayGenerationDispatchKernel: d, enqueueRaysKernel: f, rayIntersectionKernel: p, updateRayQueueParamsKernel: m, hitProcessKernel: h, lowResMode: g } = this;
+		t.updateMatrixWorld(), d.tileOffset = 0;
+		let _ = new l(), v = mn / (i.width * i.height * n), y = g ? 5 : 1, b = 0;
+		for (;;) {
+			for (let l = 0; l < y; l++) {
+				this.getTileSize(_), e.copyTextureToTexture(this.outputTarget, this.prevOutputTarget), [this.outputTarget, this.prevOutputTarget] = [this.prevOutputTarget, this.outputTarget], p.prevOutputTarget = this.prevOutputTarget, p.outputTarget = this.outputTarget, h.prevOutputTarget = this.prevOutputTarget, h.outputTarget = this.outputTarget, d.rayWorkGroupSize.set(8, 8, 1), d.tileCount.copy(r), d.tileSize.copy(_), d.rayQueue = a, d.queueSizes = s, d.outputTileIndex = u, d.outputDispatch = c, f.seed++, f.cameraToModelMatrix.copy(t.matrixWorld), f.inverseProjectionMatrix.copy(t.projectionMatrixInverse), f.tileIndexBuffer = u, f.tileSize.copy(_), f.rayQueue = a, f.queueSizes = s, f.sampleCountTarget = i;
+				for (let t = 0; t < r.x * r.y; t++) e.compute(d.kernel, [
+					1,
+					1,
+					1
+				]), e.compute(f.kernel, c), d.tileOffset = 1;
+				let l = p.getDispatchSize(mn, 1, 1);
+				p.sampleCountTarget = i, p.rayQueue = a, p.queueSizes = s, p.hitQueue = o, e.compute(p.kernel, l);
+				let g = l[0] * p.workgroupSize[0];
+				m.processed = g, m.queueSizes = s, e.compute(m.kernel, [
+					1,
+					1,
+					1
+				]), h.sampleCountTarget = i, h.bounces = n, h.rayQueue = a, h.queueSizes = s, h.hitQueue = o, e.compute(h.kernel, h.getDispatchSize(g, 1, 1)), b += v, this.samples = Math.floor(b);
+			}
+			yield;
+		}
+	}
+}, yn = "\n\n	// TODO: possibly this should be renamed something related to material or path tracing logic\n\n	#ifndef RAY_OFFSET\n	#define RAY_OFFSET 1e-4\n	#endif\n\n	// adjust the hit point by the surface normal by a factor of some offset and the\n	// maximum component-wise value of the current point to accommodate floating point\n	// error as values increase.\n	vec3 stepRayOrigin( vec3 rayOrigin, vec3 rayDirection, vec3 offset, float dist ) {\n\n		vec3 point = rayOrigin + rayDirection * dist;\n		vec3 absPoint = abs( point );\n		float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );\n		return point + offset * ( maxPoint + 1.0 ) * RAY_OFFSET;\n\n	}\n\n	// https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md#attenuation\n	vec3 transmissionAttenuation( float dist, vec3 attColor, float attDist ) {\n\n		vec3 ot = - log( attColor ) / attDist;\n		return exp( - ot * dist );\n\n	}\n\n	vec3 getHalfVector( vec3 wi, vec3 wo, float eta ) {\n\n		// get the half vector - assuming if the light incident vector is on the other side\n		// of the that it's transmissive.\n		vec3 h;\n		if ( wi.z > 0.0 ) {\n\n			h = normalize( wi + wo );\n\n		} else {\n\n			// Scale by the ior ratio to retrieve the appropriate half vector\n			// From Section 2.2 on computing the transmission half vector:\n			// https://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf\n			h = normalize( wi + wo * eta );\n\n		}\n\n		h *= sign( h.z );\n		return h;\n\n	}\n\n	vec3 getHalfVector( vec3 a, vec3 b ) {\n\n		return normalize( a + b );\n\n	}\n\n	// The discrepancy between interpolated surface normal and geometry normal can cause issues when a ray\n	// is cast that is on the top side of the geometry normal plane but below the surface normal plane. If\n	// we find a ray like that we ignore it to avoid artifacts.\n	// This function returns if the direction is on the same side of both planes.\n	bool isDirectionValid( vec3 direction, vec3 surfaceNormal, vec3 geometryNormal ) {\n\n		bool aboveSurfaceNormal = dot( direction, surfaceNormal ) > 0.0;\n		bool aboveGeometryNormal = dot( direction, geometryNormal ) > 0.0;\n		return aboveSurfaceNormal == aboveGeometryNormal;\n\n	}\n\n	// ray sampling x and z are swapped to align with expected background view\n	vec2 equirectDirectionToUv( vec3 direction ) {\n\n		// from Spherical.setFromCartesianCoords\n		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );\n		uv /= vec2( 2.0 * PI, PI );\n\n		// apply adjustments to get values in range [0, 1] and y right side up\n		uv.x += 0.5;\n		uv.y = 1.0 - uv.y;\n		return uv;\n\n	}\n\n	vec3 equirectUvToDirection( vec2 uv ) {\n\n		// undo above adjustments\n		uv.x -= 0.5;\n		uv.y = 1.0 - uv.y;\n\n		// from Vector3.setFromSphericalCoords\n		float theta = uv.x * 2.0 * PI;\n		float phi = uv.y * PI;\n\n		float sinPhi = sin( phi );\n\n		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );\n\n	}\n\n	// power heuristic for multiple importance sampling\n	float misHeuristic( float a, float b ) {\n\n		float aa = a * a;\n		float bb = b * b;\n		return aa / ( aa + bb );\n\n	}\n\n	// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60\n	// erichlof/THREE.js-PathTracing-Renderer/\n	float tentFilter( float x ) {\n\n		return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );\n\n	}\n", bn = class extends d {
+	constructor() {
+		super({
+			uniforms: {
+				envMap: { value: null },
+				flipEnvMap: { value: -1 }
+			},
+			vertexShader: "\n				varying vec2 vUv;\n				void main() {\n\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n				}",
+			fragmentShader: `
+				#define ENVMAP_TYPE_CUBE_UV
+
+				uniform samplerCube envMap;
+				uniform float flipEnvMap;
+				varying vec2 vUv;
+
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				${yn}
+
+				void main() {
+
+					vec3 rayDirection = equirectUvToDirection( vUv );
+					rayDirection.x *= flipEnvMap;
+					gl_FragColor = textureCube( envMap, rayDirection );
+
+				}`
+		}), this.depthWrite = !1, this.depthTest = !1;
+	}
+}, xn = class {
+	constructor(e) {
+		this._renderer = e, this._quad = new oe(new bn());
+	}
+	generate(e, t = null, r = null) {
+		if (!e.isCubeTexture) throw Error("CubeToEquirectMaterial: Source can only be cube textures.");
+		let a = e.images[0], s = this._renderer, c = this._quad;
+		t === null && (t = 4 * a.height), r === null && (r = 2 * a.height);
+		let l = new n(t, r, {
+			type: v,
+			colorSpace: a.colorSpace
+		}), d = a.height, p = Math.log2(d) - 2, h = 1 / d, g = 1 / (3 * Math.max(2 ** p, 112));
+		c.material.defines.CUBEUV_MAX_MIP = `${p}.0`, c.material.defines.CUBEUV_TEXEL_WIDTH = g, c.material.defines.CUBEUV_TEXEL_HEIGHT = h, c.material.uniforms.envMap.value = e, c.material.uniforms.flipEnvMap.value = e.isRenderTargetTexture ? 1 : -1, c.material.needsUpdate = !0;
+		let _ = s.getRenderTarget(), y = s.autoClear;
+		s.autoClear = !0, s.setRenderTarget(l), c.render(s), s.setRenderTarget(_), s.autoClear = y;
+		let x = new Uint16Array(t * r * 4), S = new Float32Array(t * r * 4);
+		s.readRenderTargetPixels(l, 0, 0, t, r, S), l.dispose();
+		for (let e = 0, t = S.length; e < t; e++) x[e] = u.toHalfFloat(S[e]);
+		let C = new f(x, t, r, i, b);
+		return C.minFilter = m, C.magFilter = w, C.wrapS = o, C.wrapT = o, C.mapping = 303, C.needsUpdate = !0, C;
+	}
+	dispose() {
+		this._quad.dispose();
+	}
+};
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/core/utils/sceneUpdateUtils.js
+function Sn(e) {
+	return `${e.source.uuid}:${e.colorSpace}`;
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/nodes/ggx.wgsl.js
+var Cn = I("\n\n	fn ggxDirection( incidentDir: vec3f, alpha: vec2f, uv: vec2f ) -> vec3f {\n\n		// Implementation from reference [1]\n		// stretch view\n		let V = normalize( vec3f( alpha * incidentDir.xy, incidentDir.z ) );\n\n		// orthonormal basis\n		var T1: vec3f;\n		if ( V.z < 0.9999 ) {\n			T1 = normalize( cross( V, vec3( 0.0, 0.0, 1.0 ) ) );\n		} else {\n			T1 = vec3( 1.0, 0.0, 0.0 );\n		}\n\n		let T2 = cross( T1, V );\n\n		// sample point with polar coordinates (r, phi)\n		let a = 1.0 / ( 1.0 + V.z );\n		let r = sqrt( uv.x );\n		var phi: f32;\n		if ( uv.y < a ) {\n			phi = uv.y / a * PI;\n		} else {\n			phi = PI + ( uv.y - a ) / ( 1.0 - a ) * PI;\n		}\n		let P1 = r * cos( phi );\n		var P2 = r * sin( phi );\n		if ( uv.y >= a ) {\n			P2 *= V.z;\n		}\n\n		// compute normal\n		var N = P1 * T1 + P2 * T2 + V * sqrt( max( 0.0, 1.0 - P1 * P1 - P2 * P2 ) );\n\n		// unstretch\n		N = normalize( vec3( alpha * N.xy, max( 0.0, N.z ) ) );\n\n		return N;\n\n	}\n\n", [X]), wn = I("\n\n	fn ggxLamda( theta: f32, alpha: f32 ) -> f32 {\n\n		let tanTheta = tan( theta );\n		let tanTheta2 = tanTheta * tanTheta;\n		let alpha2 = alpha * alpha;\n\n		let numerator = - 1.0 + sqrt( 1.0 + alpha2 * tanTheta2 );\n		return numerator / 2.0;\n\n	}\n\n"), Tn = I("\n\n	fn ggxShadowMaskG1( cosTheta: f32, alpha: f32 ) -> f32 {\n\n		let a2 = alpha * alpha;\n		let cosTheta2 = cosTheta * cosTheta;\n		let denom = cosTheta + sqrt( cosTheta2 * ( 1 - a2 ) + a2 );\n		return 2.0 * cosTheta / denom;\n\n	}\n\n", [wn]), En = I("\n\n	fn ggxSmithVisibility( NdotV: f32, NdotL: f32, alpha: f32 ) -> f32 {\n\n		// Original formulation of G_SmithGGX Correlated\n		// lambda_v = ( -1 + sqrt ( alphaG2 * (1 - NdotL2 ) / NdotL2 + 1)) * 0.5 f;\n		// lambda_l = ( -1 + sqrt ( alphaG2 * (1 - NdotV2 ) / NdotV2 + 1)) * 0.5 f;\n		// G_SmithGGXCorrelated = 1 / (1 + lambda_v + lambda_l );\n		// V_SmithGGXCorrelated = G_SmithGGXCorrelated / (4.0 f * NdotL * NdotV );\n\n		// This is an optimized version\n		let alpha2 = alpha * alpha;\n		// Caution: the \"NdotL *\" and \"NdotV *\" are explicitely inversed , this is not a mistake.\n		let Lambda_GGXV = NdotL * sqrt (( - NdotV * alpha2 + NdotV ) * NdotV + alpha2 );\n		let Lambda_GGXL = NdotV * sqrt (( - NdotL * alpha2 + NdotL ) * NdotL + alpha2 );\n\n		return 0.5 / ( Lambda_GGXV + Lambda_GGXL );\n\n	}\n\n", [wn]), Dn = I("\n	fn ggxDistribution( NdotH: f32, alpha: f32 ) -> f32 {\n\n		let a2 = max( alpha * alpha, EPSILON );\n		let denom = NdotH * NdotH * ( a2 - 1 ) + 1;\n\n		return ( a2 / ( PI * denom * denom ) );\n\n	}\n"), On = I("\n	fn ggxReflectionAdjustedPDF( NdotV: f32, NdotH: f32, alpha: f32 ) -> f32 {\n\n		let D = ggxDistribution( NdotH, alpha );\n		let G1 = ggxShadowMaskG1( NdotV, alpha );\n\n		return D * G1 / ( 4 * NdotV );\n\n	}\n", [Dn, Tn]), kn = (e) => I("\n\n	fn getSurfaceRecord(\n		material: Material,\n		vertexData: bvh_GeometryStruct,\n		side: f32,\n		faceNormal: vec3f,\n	) -> SurfaceRecord {\n		let uv = vertexData.uv.xy;\n\n		var normal = faceNormal * side;\n		if ( material.flatShading == 0 ) {\n\n			normal = vertexData.normal.xyz;\n\n		}\n		normal = normalize( normal );\n		let baseNormal = normal;\n\n		if ( material.normalMap != -1 ) {\n\n			// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate\n			// resulting in NaNs and slow path tracing.\n			if ( length( vertexData.tangent.xyz ) > 0.0 && vertexData.tangent.w != 0.0 ) {\n\n				let tangent = normalize( vertexData.tangent.xyz );\n				let bitangent = normalize( cross( baseNormal, tangent ) * vertexData.tangent.w );\n				let vTBN = mat3x3f( tangent, bitangent, baseNormal );\n\n				let uvPrime = material.normalMapTransform * vec3( uv, 1.0 );\n				var texNormal = sampleTexel( uvPrime.xy, material.normalMap, 0 ).xyz;\n				texNormal = texNormal * 2.0 - 1.0;\n				texNormal = texNormal * vec3f( material.normalScale, 1.0 );\n				normal = normalize( vTBN * texNormal );\n\n			}\n\n		}\n\n		normal *= side;\n\n		var albedo = vec4( material.color, material.opacity );\n\n		if ( material.vertexColors == 1 ) {\n\n			let vertexColor = vertexData.color.xyz;\n			albedo *= vec4f( vertexColor, 1.0 );\n\n		}\n\n		if ( material.map != -1 ) {\n\n			let uvPrime = material.mapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.map, 0 );\n			albedo *= vec4f( texColor.rgb, 1.0 );\n\n		}\n\n		var roughness = material.roughness;\n		if ( material.roughnessMap != -1 ) {\n\n			let uvPrime = material.roughnessMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.roughnessMap, 0 );\n			roughness *= texColor.g;\n\n		}\n\n		var metalness = material.metalness;\n		if ( material.metalnessMap != -1 ) {\n\n			let uvPrime = material.metalnessMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.metalnessMap, 0 );\n			metalness *= texColor.b;\n\n		}\n\n		var emission = material.emissiveIntensity * material.emissive;\n		if ( material.emissiveMap != -1 ) {\n\n			let uvPrime = material.emissiveMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.emissiveMap, 0 );\n			emission *= texColor.rgb;\n\n		}\n\n		var transmission = material.transmission;\n		if ( material.transmissionMap != -1 ) {\n\n			let uvPrime = material.transmissionMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.transmissionMap, 0 );\n			transmission *= texColor.r;\n\n		}\n\n		var clearcoat = material.clearcoat;\n		if ( material.clearcoatMap != -1 ) {\n\n			let uvPrime = material.clearcoatMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.clearcoatMap, 0 );\n			clearcoat *= texColor.r;\n\n		}\n\n		var clearcoatRoughness = material.clearcoatRoughness;\n		if ( material.clearcoatRoughnessMap != -1 ) {\n\n			let uvPrime = material.clearcoatRoughnessMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.clearcoatRoughnessMap, 0 );\n			clearcoatRoughness *= texColor.g;\n\n		}\n\n		var clearcoatNormal = baseNormal;\n		if ( material.clearcoatNormalMap != -1 ) {\n\n			// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate\n			// resulting in NaNs and slow path tracing.\n			if ( length( vertexData.tangent.xyz ) > 0.0 && vertexData.tangent.w != 0.0 ) {\n\n				let tangent = normalize( vertexData.tangent.xyz );\n				let bitangent = normalize( cross( baseNormal, tangent ) * vertexData.tangent.w );\n				let vTBN = mat3x3f( tangent, bitangent, baseNormal );\n\n				let uvPrime = material.clearcoatNormalMapTransform * vec3( uv, 1.0 );\n				var texNormal = sampleTexel( uvPrime.xy, material.clearcoatNormalMap, 0 ).xyz;\n				texNormal = texNormal * 2.0 - 1.0;\n				texNormal = texNormal * vec3f( material.clearcoatNormalScale, 1.0 );\n				clearcoatNormal = normalize( vTBN * texNormal );\n\n			}\n\n		}\n		clearcoatNormal *= side;\n\n		var sheenColor = material.sheenColor;\n		if ( material.sheenColorMap != -1 ) {\n\n			let uvPrime = material.sheenColorMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.sheenColorMap, 0 );\n			sheenColor *= texColor.rgb;\n\n		}\n\n		var sheenRoughness = material.sheenRoughness;\n		if ( material.sheenRoughnessMap != -1 ) {\n\n			let uvPrime = material.sheenRoughnessMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.sheenRoughnessMap, 0 );\n			sheenRoughness *= texColor.r;\n\n		}\n\n		var iridescence = material.iridescence;\n		if ( material.iridescenceMap != -1 ) {\n\n			let uvPrime = material.iridescenceMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.iridescenceMap, 0 );\n			iridescence *= texColor.r;\n\n		}\n\n		var iridescenceThickness = material.iridescenceThicknessMaximum;\n		if ( material.iridescenceThicknessMap != -1 ) {\n\n			let uvPrime = material.iridescenceThicknessMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.iridescenceThicknessMap, 0 );\n\n			iridescenceThickness = mix(\n				material.iridescenceThicknessMinimum,\n				material.iridescenceThicknessMaximum,\n				texColor.g,\n			);\n\n		}\n\n		var specularColor = material.specularColor;\n		if ( material.specularColorMap != -1 ) {\n\n			let uvPrime = material.specularColorMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.specularColorMap, 0 );\n			specularColor *= texColor.rgb;\n\n		}\n\n		var specularIntensity = material.specularIntensity;\n		if ( material.specularIntensityMap != -1 ) {\n\n			let uvPrime = material.specularIntensityMapTransform * vec3f( uv, 1 );\n			let texColor = sampleTexel( uvPrime.xy, material.specularIntensityMap, 0 );\n			specularIntensity *= texColor.r;\n\n		}\n\n		var surf: SurfaceRecord;\n\n		surf.volumeParticle = false;\n		surf.faceNormal = faceNormal;\n		surf.normal = normal;\n\n		surf.metalness = metalness;\n		surf.color = albedo.rgb;\n		surf.emission = emission;\n\n		surf.ior = material.ior;\n		surf.transmission = transmission;\n		surf.thinFilm = material.thinFilm == 1;\n		surf.attenuationColor = material.attenuationColor;\n		surf.attenuationDistance = material.attenuationDistance;\n\n		surf.clearcoatNormal = clearcoatNormal;\n		surf.clearcoat = clearcoat;\n\n		surf.iridescence = iridescence;\n		surf.iridescenceIor = material.iridescenceIor;\n		surf.iridescenceThickness = iridescenceThickness;\n\n		surf.specularColor = specularColor;\n		surf.specularIntensity = specularIntensity;\n\n		surf.roughness = clamp( roughness, MIN_ROUGHNESS, 1.0 );\n		surf.clearcoatRoughness = clamp( clearcoatRoughness, MIN_ROUGHNESS, 1.0 );\n		surf.sheenRoughness = clamp( sheenRoughness, MIN_ROUGHNESS, 1.0 );\n\n		// frontFace is used to determine transmissive properties and PDF. If no transmission is used\n		// then we can just always assume this is a front face.\n		surf.frontFace = side == 1.0 || transmission == 0.0;\n		if ( material.thinFilm == 1 || surf.frontFace ) {\n			surf.eta = 1.0 / material.ior;\n		} else {\n			surf.eta = material.ior;\n		}\n		surf.f0 = iorToF0( surf.eta );\n\n		// get the normal frames\n		surf.normalBasis = getBasisFromNormal( surf.normal );\n		surf.normalInvBasis = inverse( surf.normalBasis );\n\n		surf.clearcoatBasis = getBasisFromNormal( surf.clearcoatNormal );\n		surf.clearcoatInvBasis = inverse( surf.clearcoatBasis );\n\n		return surf;\n	}\n\n", [
+	It,
+	Rt,
+	Lt,
+	e,
+	Mt,
+	X
+]), An = I("\n\n	fn diffuseBrdf( NdotV: f32, NdotL: f32, VdotH: f32, surf: SurfaceRecord ) -> vec3f {\n\n		// https://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf\n		// See equation (4)\n\n		let fl = schlickFresnel( NdotL, 0.0 );\n		let fv = schlickFresnel( NdotV, 0.0 );\n\n		let alpha = surf.roughness * surf.roughness;\n		let bias = mix( 0.0, 0.5, alpha ) - 1;\n		let energyFactor = mix( 1.0, 1.0 / 1.51, alpha );\n\n		let rr = 2.0 * alpha * VdotH * VdotH;\n		let retro = rr * ( fl + fv + fl * fv * ( rr + 2.0 * bias ) );\n		let fresnel = ( 1.0 + bias * fl ) * ( 1.0f + bias * fv );\n\n		// TODO: subsurface approx?\n\n		return energyFactor * ( surf.color / PI ) * ( retro + fresnel );\n\n	}\n\n", [
+	X,
+	Ht,
+	Mt
+]), jn = I("\n\n	fn specularBrdf( NdotL: f32, NdotV: f32, NdotH: f32, alpha: f32 ) -> vec3f {\n\n		let Vis = ggxSmithVisibility( NdotV, NdotL, alpha );\n		let D = ggxDistribution( NdotH, alpha );\n\n		return vec3f( D * Vis );\n\n	}\n\n", [En, Dn]), Mn = I("\n\n	fn fresnelMix( VdotH: f32, ior: f32, base: vec3f, layer: vec3f ) -> vec3f {\n\n		let f0 = iorToF0( ior );\n  	let F = schlickFresnel( abs( VdotH ), f0 );\n\n  	return base + F * layer;\n\n	}\n\n", [Ht, Rt]), Nn = Oe(3.2404542, -.969266, .0556434, -1.5371385, 1.8760108, -.2040259, -.4985314, .041556, 1.0572252), Pn = I("\n\n	fn iridescentFresnel(\n		cosTheta1: f32, baseF0: vec3f, iridescenceIor: f32,\n		outsideIor: f32, iridescenceThickness: f32,\n	) -> vec3f {\n\n		let sinTheta2Sq = pow( outsideIor / iridescenceIor, 2.0 ) * ( 1.0 - pow( cosTheta1, 2.0 ) );\n		let cosTheta2Sq = 1.0 - sinTheta2Sq;\n\n		// Handle total internal reflection\n		if ( cosTheta2Sq < 0.0 ) {\n\n			return vec3( 1.0 );\n\n		}\n\n		let cosTheta2 = sqrt( cosTheta2Sq );\n\n		// First interface: air -> iridescent thin film\n		let R0 = iorToF0General( iridescenceIor, outsideIor );\n		let R12 = schlickFresnel( cosTheta1, R0 );\n		let R21 = R12;\n		let T121 = 1.0 - R12;\n		let phi12 = select( 0.0, PI, iridescenceIor < outsideIor );\n		let phi21 = PI - phi12;\n\n		// Second interface: iridescent thin film -> base material\n		let baseIor = fresnel0ToIor( baseF0 + 0.0001 ); // guard against 1.0\n		let R1 = iorToF0GeneralVec( baseIor, vec3( iridescenceIor ) );\n		let R23 = schlickFresnelVec( cosTheta2, R1, vec3( 1.0 ) );\n		let phi23 = select( vec3( 0.0 ), vec3( PI ), baseIor < vec3( iridescenceIor ) );\n\n		// Phase shift\n		let OPD = 2.0 * iridescenceIor * iridescenceThickness * cosTheta2;\n		let phi = vec3( phi21 ) + phi23;\n\n		// Analytical integration\n		// Compound terms\n		let R123 = clamp( R12 * R23, vec3( 1e-5 ), vec3( 0.9999 ) );\n		let r123 = sqrt( R123 );\n		let Rs = T121 * T121 * R23 / ( vec3( 1.0 ) - R123 );\n\n		// Reflectance term for m = 0 (DC term amplitude)\n		let C0 = R12 + Rs;\n		var I = C0;\n\n		// Reflectance term for m > 0 (pairs of diracs)\n		var Cm = Rs - T121;\n		for (var m = 1; m <= 2; m += 1) {\n\n			Cm *= r123;\n			let Sm = 2.0 * evalSensitivity( f32( m ) * OPD, f32( m ) * phi );\n			I += Cm * Sm;\n\n		}\n\n		return max( I, vec3(0.0) );\n\n	}\n\n", [
+	zt,
+	Bt,
+	Ht,
+	Vt,
+	W`
+
+	fn evalSensitivity( OPD: f32, shift: vec3f ) -> vec3f {
+
+		let phase = 2.0 * ${Math.PI} * OPD * 1.0e-9;
+		const val = vec3(5.4856e-13, 4.4201e-13, 5.2481e-13);
+		const pos = vec3(1.6810e+06, 1.7953e+06, 2.2084e+06);
+		const _var = vec3(4.3278e+09, 9.3046e+09, 6.6121e+09);
+
+		var xyz = val * sqrt(2.0 * ${Math.PI} * _var) * cos(pos * phase + shift) * exp(-phase * phase * _var);
+		xyz.x += 9.7470e-14 * sqrt(2.0 * ${Math.PI} * 4.5282e+09) * cos(2.2399e+06 * phase + shift.x) * exp(-4.5282e+09 * phase * phase);
+		xyz /= 1.0685e-7;
+
+		let rgb = ${Nn} * xyz;
+		return rgb;
+
+	}
+
+`
+]), Fn = I("\n\n	fn iridescentDielectricLayer(\n		dielectricBase: vec3f, base: vec3f, specular: vec3f, HdotL: f32,\n		outsideIor: f32, baseIor: f32, iridescenceIor: f32, thickness: f32, strength: f32,\n	) -> vec3f {\n\n		let baseF0 = vec3( iorToF0( baseIor ) );\n\n		let iridescentF = iridescentFresnel( HdotL, baseF0, iridescenceIor, outsideIor, thickness );\n\n		return mix( dielectricBase, rgbMix( base, specular, iridescentF ), strength );\n\n	}\n\n", [
+	Rt,
+	Pn,
+	I("\n\n	fn rgbMix( base: vec3f, specular: vec3f, rgbAlpha: vec3f ) -> vec3f {\n\n		let alphaMax = max( max( rgbAlpha.x, rgbAlpha.y ), rgbAlpha.z );\n		return ( 1 - alphaMax ) * base + rgbAlpha * specular;\n\n	}\n\n")
+]), In = I("\n\n	fn iridescentConductorLayer(\n		metalBase: vec3f, specular: vec3f, baseF0: vec3f, HdotL: f32,\n		outsideIor: f32, iridescenceIor: f32, thickness: f32, strength: f32,\n	) -> vec3f {\n\n		let iridescenceF = iridescentFresnel( HdotL, baseF0, iridescenceIor, outsideIor, thickness );\n\n		return mix( metalBase, specular * iridescenceF, strength );\n\n	}\n\n", [Pn]), Ln = (e) => I("\n\n	fn conductorFresnel( NdotV: f32, VdotH: f32, f0: vec3f, bsdf: vec3f, alpha: f32 ) -> vec3f {\n\n	  let ss = bsdf * schlickFresnelVec( abs( VdotH ), f0, vec3f( 1 ) );\n\n		let uv = vec2( NdotV, sqrt( alpha ) );\n		let energySs = max( textureSampleLevel( turquinTexture, turquinTexture_sampler, uv, 0 ).r, 1e-5 );\n\n		return ss * ( 1.0 + f0 * ( 1.0 - energySs ) / energySs );\n\n	}\n\n", [Ut, e]), Rn = I("\n\n	fn fresnelCoat( VdotNc: f32, ior: f32, base: vec3f, layer: vec3f, weight: f32 ) -> vec3f {\n\n		let f0 = iorToF0( ior );\n		let F = schlickFresnel( abs( VdotNc ), f0 );\n\n		return mix( base, layer, weight * F );\n\n	}\n\n", [Rt, Ht]), zn = W`
+
+	fn albedo(
+		texture: texture_storage_2d<r16float, write>,
+
+		globalId: vec3u,
+	) -> void {
+
+		const INTEGRATION_SAMPLES = ( 1 << 20 );
+		let pixelIndex = ( globalId.x << 16 ) | globalId.y;
+		${Ot}( pixelIndex, 0, 0 );
+
+		let dimensions = textureDimensions( texture ).xy;
+		let uv = ( vec2f( globalId.xy ) + vec2f( 0.5 ) ) / vec2f( dimensions );
+
+		let cosThetaO = uv.x;
+		let roughness = uv.y;
+
+		let alpha = roughness * roughness;
+
+		let wo = vec3( sqrt( 1 - cosThetaO * cosThetaO ), 0 , cosThetaO );
+
+		var result = 0.0;
+		for ( var i = 0; i < INTEGRATION_SAMPLES; i++ ) {
+
+			let wh = ${Cn}( wo, vec2( alpha ), ${Y}(${3}) );
+			var wi = - reflect( wo, wh );
+
+			let NdotV = max( wo.z, EPSILON );
+			let NdotL = saturate( wi.z );
+			let NdotH = saturate( wh.z );
+
+			let specular = ${jn}( NdotL, NdotV, NdotH, alpha );
+			let pdf = ${On}( NdotV, NdotH, alpha );
+
+			var weight = 0.0;
+			if ( pdf != 0.0 ) {
+				weight = 1 / pdf;
+			}
+
+			result += specular.x * NdotL * weight;
+
+		}
+
+		result /= f32( INTEGRATION_SAMPLES );
+
+		textureStore( texture, globalId.xy, vec4( result ) );
+
+	}
+
+`, Bn = 4096, Vn = new ie();
+function Hn(e) {
+	return `${e.source.uuid}:${e.source.version}`;
+}
+function Un(e, t, n, r) {
+	if (e[t].x + n > r) return -1;
+	let i = n, a = 0, o = t;
+	for (; i > 0;) {
+		if (o >= e.length) return -1;
+		a = Math.max(a, e[o].y), i -= e[o].width, o++;
+	}
+	return a;
+}
+function Wn(e, t, n, r) {
+	let i = t + r, a = [], o = !1;
+	for (let s = 0; s < e.length; s++) {
+		let c = e[s], l = c.x + c.width;
+		l <= t ? a.push(c) : c.x >= i ? (o ||= (a.push({
+			x: t,
+			y: n,
+			width: r
+		}), !0), a.push(c)) : (o ||= (a.push({
+			x: t,
+			y: n,
+			width: r
+		}), !0), l > i && a.push({
+			x: i,
+			y: c.y,
+			width: l - i
+		}));
+	}
+	o || a.push({
+		x: t,
+		y: n,
+		width: r
+	}), e.length = 0;
+	for (let t = 0; t < a.length; t++) {
+		let n = a[t], r = e[e.length - 1];
+		r && r.y === n.y && r.x + r.width === n.x ? r.width += n.width : e.push(n);
+	}
+}
+function Gn(e, t, n, r, i) {
+	let a = Infinity, o = 0, s = -1;
+	for (let c = 0; c < e.length; c++) {
+		let l = Un(e, c, t, r);
+		l >= 0 && l + n <= i && l < a && (a = l, o = e[c].x, s = c);
+	}
+	return s === -1 ? null : (Wn(e, o, a + n, t), {
+		x: o,
+		y: a
+	});
+}
+var Kn = class {
+	get width() {
+		return this.renderTarget.width;
+	}
+	get height() {
+		return this.renderTarget.height;
+	}
+	get pageCount() {
+		return this.renderTarget.depth;
+	}
+	get texture() {
+		return this.renderTarget.texture;
+	}
+	constructor(e = {}) {
+		this.renderTarget = new x(1, 1, {
+			depthBuffer: !1,
+			depth: 1,
+			...e
+		}), this.texture.isArrayTexture = !0, this.textureInfo = [new E()], this.hashes = [], this.quadMesh = new pe(new C()), this.quadMesh.material.blending = 0;
+	}
+	setTextures(e, t) {
+		if (this._hashesMatch(t)) return;
+		let n = t.reduce((e, t) => Math.max(e, t.width, t.height), 1);
+		n = Math.min(Bn, n);
+		let r = n, i = n, { renderTarget: a } = this, { placements: o, pageCount: s } = this._packTextures(t, r, i);
+		a.setSize(r, i, s), this.texture.isArrayTexture = !0, this._buildTextureInfo(o), this._renderTextures(e, t, o);
+		let c = Array(t.length);
+		for (let e = 0, n = t.length; e < n; e++) c[e] = Hn(t[e]);
+		this.hashes = c;
+	}
+	dispose() {
+		this.renderTarget.dispose(), this.quadMesh.material.dispose();
+	}
+	_hashesMatch(e) {
+		let t = this.hashes;
+		if (t.length !== e.length) return !1;
+		for (let n = 0, r = e.length; n < r; n++) if (t[n] !== Hn(e[n])) return !1;
+		return !0;
+	}
+	_packTextures(e, t, n) {
+		let r = [];
+		for (let i = 0, a = e.length; i < a; i++) {
+			let a = e[i];
+			r.push({
+				index: i,
+				w: Math.min(a.width, t),
+				h: Math.min(a.height, n)
+			});
+		}
+		let i = r.sort((e, t) => t.h - e.h), a = Array(e.length), o = [];
+		for (let e = 0, r = i.length; e < r; e++) {
+			let r = i[e], s = null, c = -1;
+			for (let e = 0; e < o.length; e++) if (s = Gn(o[e], r.w, r.h, t, n), s) {
+				c = e;
+				break;
+			}
+			if (!s) {
+				let e = [{
+					x: 0,
+					y: 0,
+					width: t
+				}];
+				s = Gn(e, r.w, r.h, t, n), o.push(e), c = o.length - 1;
+			}
+			a[r.index] = {
+				x: s.x,
+				y: s.y,
+				w: r.w,
+				h: r.h,
+				page: c
+			};
+		}
+		return {
+			placements: a,
+			pageCount: Math.max(o.length, 1)
+		};
+	}
+	_buildTextureInfo(e) {
+		let t = this.textureInfo;
+		t.length = 0;
+		for (let n = 0, r = e.length; n < r; n++) {
+			let { x: r, y: i, w: a, h: o, page: s } = e[n], c = new E();
+			c.x = r & 65535 | (i & 65535) << 16, c.y = a & 65535 | (o & 65535) << 16, c.z = s & 65535, c.w = 0, t.push(c);
+		}
+		t.length === 0 && t.push(new E(0, 0, 0, 0));
+	}
+	_renderTextures(e, t, n) {
+		let { quadMesh: r, renderTarget: i, width: a, height: o } = this, s = e.getRenderTarget(), c = e.toneMapping, l = e.autoClear, u = e.getScissorTest(), d = e.getClearAlpha();
+		e.getClearColor(Vn), e.toneMapping = 0, e.autoClear = !1, e.setScissorTest(!0), e.setClearColor(0, 0);
+		for (let t = 0, n = i.depth; t < n; t++) i.viewport.set(0, 0, a, o), i.scissor.set(0, 0, a, o), e.setRenderTarget(i, t), e.clear();
+		for (let a = 0, o = t.length; a < o; a++) {
+			let { x: o, y: s, w: c, h: l, page: u } = n[a], d = t[a].clone();
+			d.matrixAutoUpdate = !1, d.matrix.identity(), d.needsUpdate = !0, r.material.map = d, i.viewport.set(o, s, c, l), i.scissor.set(o, s, c, l), e.setRenderTarget(i, u), r.render(e), d.dispose();
+		}
+		i.viewport.set(0, 0, a, o), i.scissor.set(0, 0, a, o), r.material.map = null, e.setClearColor(Vn, d), e.setScissorTest(u), e.autoClear = l, e.setRenderTarget(s), e.toneMapping = c;
+	}
+}, qn = new E(), Jn = new D({
+	matrixWorld: "mat4x4f",
+	inverseMatrixWorld: "mat4x4f",
+	nodeOffset: "uint",
+	visible: "uint",
+	materialIndex: "uint",
+	_alignment0: "uint",
+	color: "vec4f"
+}, "TransformStruct"), Yn = class extends lt {
+	constructor(e, t = {}) {
+		super(e, {
+			attributes: {
+				position: "vec4f",
+				normal: "vec4f",
+				tangent: "vec4f",
+				color: "vec4f",
+				uv: "vec4f"
+			},
+			...t
+		}), this.structs.transform = Jn, this.structs.material = jt, this.storage.materials = null, this.materials = [], this.bvhMap = /* @__PURE__ */ new Map(), this.textureAtlas = new Kn();
+	}
+	useTransparencyRaycastFn() {
+		let { textureAtlas: e, storage: t, structs: n, fns: r } = this, i = e.texture, a = qt(Ee(e.textureInfo, "uvec4"), F(i), L(i));
+		r.getSurfaceRecord = kn(a);
+		let o = new fe(n.material).toVar("bvh_material"), s = M(1).toVar("bvh_rayScalar"), c = M(1).toVar("bvh_baseOpacity");
+		r.raycastFirstHit = this.getShapecastFn({
+			name: "raycastFirstHit",
+			shapeStruct: R,
+			resultStruct: z,
+			boundsOrderFn: W`
+				fn getBoundsOrder( ray: ${R}, splitAxis: u32, node: ${Ae} ) -> bool {
+
+					return ray.direction[ splitAxis ] >= 0.0;
+
+				}
+			`,
+			intersectsBoundsFn: W`
+				fn rayIntersectsBounds( ray: ${R}, bounds: ${ke}, result: ptr<function, ${z}> ) -> u32 {
+
+					// early-out if our object is completely transparent
+					if ( ${c} == 0.0 ) {
+
+						return 0u;
+
+					}
+
+					let boundsMin = vec3( bounds.min[0], bounds.min[1], bounds.min[2] );
+					let boundsMax = vec3( bounds.max[0], bounds.max[1], bounds.max[2] );
+
+					let invDir = 1.0 / ray.direction;
+					let tMinPlane = ( boundsMin - ray.origin ) * invDir;
+					let tMaxPlane = ( boundsMax - ray.origin ) * invDir;
+
+					let tMinHit = min( tMinPlane, tMaxPlane );
+					let tMaxHit = max( tMinPlane, tMaxPlane );
+
+					let t0 = max( max( tMinHit.x, tMinHit.y ), tMinHit.z );
+					let t1 = min( min( tMaxHit.x, tMaxHit.y ), tMaxHit.z );
+
+					let dist = max( t0, 0.0 );
+					if ( t1 < dist ) {
+
+						return 0u;
+
+					} else if ( result.didHit && dist * ${s} >= result.dist ) {
+
+						return 0u;
+
+					} else {
+
+						return 1u;
+
+					}
+
+				}
+
+			`,
+			intersectRangeFn: W`
+				fn intersectRange( ray: ${R}, offset: u32, count: u32, result: ptr<function, ${z}> ) -> bool {
+
+					var didHit = false;
+					for ( var ti = offset; ti < offset + count; ti = ti + 1u ) {
+
+						let i0 = ${t.index}[ ti * 3u ];
+						let i1 = ${t.index}[ ti * 3u + 1u ];
+						let i2 = ${t.index}[ ti * 3u + 2u ];
+
+						let a = ${t.attributes}[ i0 ].position.xyz;
+						let b = ${t.attributes}[ i1 ].position.xyz;
+						let c = ${t.attributes}[ i2 ].position.xyz;
+
+						var triResult = ${tt}( ray, a, b, c, 1e-5 );
+						triResult.dist *= ${s};
+						if ( triResult.didHit && ( ! result.didHit || triResult.dist < result.dist ) ) {
+
+							let material = ${o};
+
+							// TODO: if material is a transmissive volume we may need to assume double-sidedness
+							if ( material.side != 0 && triResult.side != material.side ) {
+
+								continue;
+
+							}
+
+							if ( material.transparent != 0 || material.alphaTest > 0.0 ) {
+
+								var opacity = ${c};
+
+								// account for alpha component of albedo map
+								if ( material.map != - 1 ) {
+
+									let barycoord = triResult.barycoord;
+									let a = ${t.attributes}[ i0 ].uv.xy;
+									let b = ${t.attributes}[ i1 ].uv.xy;
+									let c = ${t.attributes}[ i2 ].uv.xy;
+									let uv = barycoord.x * a + barycoord.y * b + barycoord.z * c;
+									let uvPrime = material.mapTransform * vec3f( uv, 1 );
+
+									opacity *= ${a}( uvPrime.xy, material.map, 0 ).a;
+
+								}
+
+								// account for green component of alpha map
+								if ( material.alphaMap != - 1 ) {
+
+									let barycoord = triResult.barycoord;
+									let a = ${t.attributes}[ i0 ].uv.xy;
+									let b = ${t.attributes}[ i1 ].uv.xy;
+									let c = ${t.attributes}[ i2 ].uv.xy;
+									let uv = barycoord.x * a + barycoord.y * b + barycoord.z * c;
+									let uvPrime = material.alphaMapTransform * vec3f( uv, 1 );
+
+									opacity *= ${a}( uvPrime.xy, material.alphaMap, 0 ).g;
+
+								}
+
+								if ( material.transparent != 0 && opacity < ${Dt}( ${4} + ti ) ) {
+
+									continue;
+
+								}
+
+								if ( opacity < material.alphaTest ) {
+
+									continue;
+
+								}
+
+							}
+
+							result.didHit = true;
+							result.dist = triResult.dist;
+							result.normal = triResult.normal;
+							result.side = triResult.side;
+							result.barycoord = triResult.barycoord;
+							result.indices = vec4u( i0, i1, i2, ti );
+
+							didHit = true;
+
+						}
+
+					}
+
+					return didHit;
+
+				}
+			`,
+			transformShapeFn: W`
+				fn transformRay( ray: ptr<function, ${R}>, objectIndex: u32 ) -> void {
+
+					let toLocal = ${t.transforms}[ objectIndex ].inverseMatrixWorld;
+					ray.origin = ( toLocal * vec4f( ray.origin, 1.0 ) ).xyz;
+					ray.direction = ( toLocal * vec4f( ray.direction, 0.0 ) ).xyz;
+
+					let len = length( ray.direction );
+					ray.direction /= len;
+					${s} = 1.0 / len;
+
+					let object = ${t.transforms}[ objectIndex ];
+					${o} = ${t.materials}[ object.materialIndex ];
+					if ( ${o}.transparent == 1 ) {
+
+						${c} = ${o}.opacity * object.color.a;
+
+					} else {
+
+						${c} = 1.0;
+
+					}
+
+				}
+			`,
+			transformResultFn: W`
+				fn transformResult( hit: ptr<function, ${z}>, objectIndex: u32 ) -> void {
+
+					let toLocal = ${t.transforms}[ objectIndex ].inverseMatrixWorld;
+					hit.normal = normalize( ( transpose( toLocal ) * vec4f( hit.normal, 0.0 ) ).xyz );
+					hit.objectIndex = objectIndex;
+
+				}
+			`
+		});
+	}
+	update() {
+		super.update();
+		let { materials: e, structs: t } = this, { materialData: n, textures: r } = this.writeMaterialsBuffer(e);
+		this.textures = r;
+		let i = P(new le(n, t.material.getLength()), t.material).toReadOnly().setName("bvh_materials");
+		this.storage.materials = i, this.bvhMap.clear(), this.materials.length = 0, this.useTransparencyRaycastFn();
+	}
+	writeMaterialsBuffer(e) {
+		function t(e) {
+			switch (e) {
+				case o: return 0;
+				case c: return 1;
+				case ae: return 2;
+				default: return 0;
+			}
+		}
+		function n(e, n) {
+			if (n in e && e[n]) {
+				let r = e[n], i = Sn(r);
+				s.has(i) || (s.set(i, s.size), l.push(r));
+				let a = s.get(i), o = t(r.wrapS), c = t(r.wrapT);
+				return (r.magFilter === 1003 ? 1 : 0) << 28 | c << 26 | o << 24 | a;
+			} else return -1;
+		}
+		function r(e, t, n) {
+			return t in e ? e[t] : n;
+		}
+		function i(e, t, n, r) {
+			let i = e[t] && e[t].isTexture ? e[t] : null;
+			if (i) {
+				i.matrixAutoUpdate && i.updateMatrix();
+				let e = i.matrix.elements;
+				for (let t = 0; t < 3; t++) n[r + 4 * t + 0] = e[3 * t + 0], n[r + 4 * t + 1] = e[3 * t + 1], n[r + 4 * t + 2] = e[3 * t + 2], n[r + 4 * t + 3] = 0;
+			}
+			return 12;
+		}
+		let a = 0, s = /* @__PURE__ */ new Map(), l = [], u = Math.max(e.length, 2), d = new Float32Array(u * this.structs.material.getLength()), f = new Int32Array(d.buffer);
+		for (let t = 0, o = e.length; t < o; t++) {
+			let o = e[t];
+			d[a++] = o.color.r, d[a++] = o.color.g, d[a++] = o.color.b, f[a++] = n(o, "map"), d[a++] = r(o, "metalness", 0), f[a++] = n(o, "metalnessMap"), d[a++] = r(o, "roughness", 0), f[a++] = n(o, "roughnessMap"), d[a++] = r(o, "ior", 1.5), d[a++] = r(o, "transmission", 0), f[a++] = n(o, "transmissionMap"), d[a++] = r(o, "emissiveIntensity", 0), "emissive" in o ? (d[a++] = o.emissive.r, d[a++] = o.emissive.g, d[a++] = o.emissive.b) : (d[a++] = 0, d[a++] = 0, d[a++] = 0), f[a++] = n(o, "emissiveMap"), f[a++] = n(o, "normalMap"), a++, "normalScale" in o ? (d[a++] = o.normalScale.x, d[a++] = o.normalScale.y) : (d[a++] = 1, d[a++] = 1), d[a++] = r(o, "clearcoat", 0), f[a++] = n(o, "clearcoatMap"), f[a++] = n(o, "clearcoatNormalMap"), a++, "clearcoatNormalScale" in o ? (d[a++] = o.clearcoatNormalScale.x, d[a++] = o.clearcoatNormalScale.y) : (d[a++] = 1, d[a++] = 1), d[a++] = r(o, "clearcoatRoughness", 0), f[a++] = n(o, "clearcoatRoughnessMap"), f[a++] = n(o, "iridescenceMap"), f[a++] = n(o, "iridescenceThicknessMap"), d[a++] = r(o, "iridescence", 0), d[a++] = r(o, "iridescenceIOR", 1.3);
+			let s = r(o, "iridescenceThicknessRange", [100, 400]);
+			d[a++] = s[0], d[a++] = s[1], a++, a++, "specularColor" in o ? (d[a++] = o.specularColor.r, d[a++] = o.specularColor.g, d[a++] = o.specularColor.b) : (d[a++] = 1, d[a++] = 1, d[a++] = 1), f[a++] = n(o, "specularColorMap"), d[a++] = r(o, "specularIntensity", 1), f[a++] = n(o, "specularIntensityMap");
+			let c = r(o, "thickness", 0) === 0 && r(o, "attenuationDistance", Infinity) === Infinity;
+			if (f[a++] = Number(c), a++, "attenuationColor" in o ? (d[a++] = o.attenuationColor.r, d[a++] = o.attenuationColor.g, d[a++] = o.attenuationColor.b) : (d[a++] = 1, d[a++] = 1, d[a++] = 1), d[a++] = r(o, "attenuationDistance", Infinity), f[a++] = n(o, "alphaMap"), f[a++] = Number(r(o, "castShadow", !0)), d[a++] = o.opacity, d[a++] = o.alphaTest, !c && o.transmission > 0) d[a++] = 0;
+			else switch (o.side) {
+				case 0:
+					d[a++] = 1;
+					break;
+				case 1:
+					d[a++] = -1;
+					break;
+				case 2:
+					d[a++] = 0;
+					break;
+			}
+			f[a++] = Number(r(o, "matte", !1)), d[a++] = r(o, "sheen", 0), a++, "sheenColor" in o ? (d[a++] = o.sheenColor.r, d[a++] = o.sheenColor.g, d[a++] = o.sheenColor.b) : (d[a++] = 0, d[a++] = 0, d[a++] = 0), f[a++] = n(o, "sheenColorMap"), d[a++] = r(o, "sheenRoughness", 0), f[a++] = n(o, "sheenRoughnessMap"), f[a++] = Number(o.vertexColors), f[a++] = Number(o.flatShading), f[a++] = Number(o.transparent), f[a++] = 0, a++, a++, a += i(o, "map", d, a), a += i(o, "metalnessMap", d, a), a += i(o, "roughnessMap", d, a), a += i(o, "transmissionMap", d, a), a += i(o, "emissiveMap", d, a), a += i(o, "normalMap", d, a), a += i(o, "clearcoatMap", d, a), a += i(o, "clearcoatNormalMap", d, a), a += i(o, "clearcoatRoughnessMap", d, a), a += i(o, "sheenColorMap", d, a), a += i(o, "sheenRoughnessMap", d, a), a += i(o, "iridescenceMap", d, a), a += i(o, "iridescenceThicknessMap", d, a), a += i(o, "specularColorMap", d, a), a += i(o, "specularIntensityMap", d, a), a += i(o, "alphaMap", d, a);
+		}
+		return {
+			materialData: d,
+			textures: l
+		};
+	}
+	writeTransformData(e, t, n, r) {
+		super.writeTransformData(e, t, n, r);
+		let { materials: i } = this, { object: a, instanceId: o, root: s } = e, c = a.material;
+		if (Array.isArray(c)) {
+			let { materialIndex: e } = a.geometry.groups[s];
+			c = c[e];
+		}
+		let l = i.indexOf(c);
+		l === -1 && (l = i.length, i.push(c));
+		let u = new Uint32Array(r);
+		u[n * Jn.getLength() + 34] = l, a.isInstancedMesh && a.instanceColor ? (a.getColorAt(o, qn), qn.w = 1) : a.isBatchedMesh && a._colorsTexture ? a.getColorAt(o, qn) : qn.setScalar(1);
+		let d = new Float32Array(r);
+		qn.toArray(d, n * Jn.getLength() + 36);
+	}
+	getBVH(e, t, n) {
+		let { bvhMap: r } = this, i = super.getBVH(e, t, n);
+		if (r.has(i)) {
+			let e = r.get(i);
+			if (Object.assign(n, e.range), i !== e.bvh && i instanceof ye) {
+				let t = i.mesh, n = e.bvh.mesh;
+				n.matrixWorld.copy(t.matrixWorld).decompose(n.position, n.quaternion, n.scale), i.refit();
+			}
+			return e.bvh;
+		} else if (i.indirect) {
+			let e = new y();
+			e.attributes = i.geometry.attributes;
+			let t;
+			if (i.geometry.index) t = i.geometry.index.array.slice(n.start, n.count + n.start);
+			else {
+				let { start: e, count: r } = n;
+				t = new Uint32Array(r);
+				for (let r = 0, i = n.count; r < i; r++) t[r] = e + r;
+			}
+			e.index = new ee(t, 1), n.start = 0;
+			let a;
+			if (i instanceof ye) {
+				let t = i.mesh, n = new p(e);
+				n.copy(t), n.matrixWorld.copy(t.matrixWorld).decompose(n.position, n.quaternion, n.scale), a = new ye(n, {
+					strategy: 2,
+					maxLeafSize: 5
+				});
+			} else a = new ve(e, {
+				strategy: 2,
+				maxLeafSize: 5
+			});
+			return r.set(i, {
+				bvh: a,
+				range: { ...n }
+			}), a;
+		} else return i;
+	}
+}, Xn = class extends me {
+	set texture(e) {
+		this._texNode.value = e;
+	}
+	set layer(e) {
+		this._layerUniform.value = e;
+	}
+	constructor() {
+		super(), this.blending = 0, this._texNode = F(new f()), this._layerUniform = A(0), this.colorNode = I("\n			fn atlasDebug( tex: texture_2d_array<f32>, coord: vec2f, layer: f32 ) -> vec4f {\n\n				// flip y so texel origin shows at the top-left\n				let dims = vec2f( textureDimensions( tex, 0 ).xy );\n				let texel = vec2i( vec2f( coord.x, 1.0 - coord.y ) * dims );\n				return textureLoad( tex, texel, i32( layer ), 0 );\n\n			}\n		")(this._texNode, xe(we()), this._layerUniform);
+	}
+};
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/core/utils/GeometryPreparationUtils.js
+function Zn(e, t) {
+	if (!e.index) {
+		let t = e.attributes.position.count, n = Array(t);
+		for (let e = 0; e < t; e++) n[e] = e;
+		e.setIndex(n);
+	}
+	if (!e.attributes.normal && t && t.includes("normal") && e.computeVertexNormals(), !e.attributes.uv && t && t.includes("uv")) {
+		let t = e.attributes.position.count;
+		e.setAttribute("uv", new ee(new Float32Array(t * 2), 2, !1));
+	}
+	if (!e.attributes.uv2 && t && t.includes("uv2")) {
+		let t = e.attributes.position.count;
+		e.setAttribute("uv2", new ee(new Float32Array(t * 2), 2, !1));
+	}
+	if (!e.attributes.tangent && t && t.includes("tangent")) if (e.attributes.uv && e.attributes.normal) e.computeTangents();
+	else {
+		let t = e.attributes.position.count;
+		e.setAttribute("tangent", new ee(new Float32Array(t * 4), 4, !1));
+	}
+	if (!e.attributes.color && t && t.includes("color")) {
+		let t = e.attributes.position.count, n = new Float32Array(t * 4);
+		n.fill(1), e.setAttribute("color", new ee(n, 4));
+	}
+}
+//#endregion
+//#region ../../node_modules/three-gpu-pathtracer/src/webgpu/materials/PathtracingMaterial.js
+var Qn = class {
+	init() {}
+	getBsdfNode() {
+		return W`
+
+			fn bsdfSample( worldWo: vec3f, surf: SurfaceRecord ) -> ScatterRecord {
+
+				var record: ScatterRecord;
+
+				let wo = normalize( surf.normalInvBasis * worldWo );
+				let wi = ${Jt}( wo, ${Y}( ${3} ) );
+				record.color = surf.color * max( wi.z, 0.0 );
+				record.pdf = max( wi.z, 0.0 ) / PI;
+				record.direction = normalize( surf.normalBasis * wi );
+
+				return record;
+
+			}
+
+		`;
+	}
+	getData() {
+		return { bsdfSample: this.getBsdfNode() };
+	}
+}, $n = new URL("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAACsUlEQVR4AcTWjXISMRiF4WTb3v+1dqblH5QnzsGPdUF0tDDzepLdJe9JEGX69uTXdDqd2jNf0/v7e1PifBBP6TGtVqu22+0uJb66yNR7b0rs9/t2PB6bAnP+59FMb29vbbvdts1m01KiFiGfFzJ3/V8wvb6+jp0rAR/H4XAY1/zdAGGINPO/yawhR4HeeyMlh5OAkwgpkqxiC/0J9b3T+dXgIqkCMIZiKSEVCN4Dc/kI86Jn9zQKuGEhQmIlYAzXFQieDcR1bP4o41vw8vLSeu/jG0BABmIYVzwzJwVcz1jOi7gW3BsFeu+jgFNw0SIRKlBPwjx4xrMVi5vLW3DA/VHg/DmMAr3/OAU3LUIAQiVgjFw3hnnw3iUI4Z7EZNe9/zwBczfgwSwqiaAIjCueCa5nbJ1bjAKkvXcxcAIp4I0WyoIyKAFzGczn1DWMw6XAMJ//IIcCUADeUBetsoxr1meN3ZNzfilw7jC+DSkRuQKoC1h0Cf+izll6zlqXAoQVu4cCqPIsZoG56JG59+c5v4jGjrNz0kBcUQLEFqlkwZr+g7uF59xbPIEUkAqQBvKQAhYLFr3Her1uwXOjgKMnSxoTVxSIWN6SK2JhkqQx/O6QMMblI6hyBZAC5IE83CpBDKIkmbmsjAJklYjlI2JFsvMIyVBln5+f49eXDFcfgRKkiLhmdi5JQ+RJJaBASJGIk+MEcvzElcgJQ6TJSJOES3LXU0Iq8PHx0UYBO0fkESeX5IQVUrhGFsgqxJXxEZCHeYnIa2b3kjAoEFIgeavEOIH6EWTX8p50LleCnFDCONQCGTuJUcDus3NJHmoJY2IQBjLM566lQDJyeVUgJX4nJg8RJgmXiDxJDvOrEyCvJ2DHIdIkqbEEcdI4kNRx5hJXBe7JFalCsntE6pmMk8TG8jsAAAD//yGAaM0AAAAGSURBVAMAifCfleVLEBEAAAAASUVORK5CYII=", "" + import.meta.url).toString(), er = await new ne().loadAsync($n), tr = M(1.5), nr = M(.001), rr = class extends Qn {
+	constructor(e = {}) {
+		super();
+		let { specularBrdf: t = jn, diffuseBrdf: n = An, fresnelMix: r = Mn, conductorFresnel: i = Ln, fresnelCoat: a = Rn, iridescentDielectricLayer: o = Fn, iridescentConductorLayer: s = In, calculateTurquinTexture: c = !1 } = e;
+		c ? (this.turquinTexture = new O(32, 32), this.turquinTexture.type = b) : (this.turquinTexture = er, this.turquinTexture.flipY = !1), this.turquinTexture.format = S, this.turquinTexture.minFilter = w, this.turquinTexture.magFilter = w;
+		let l = F(this.turquinTexture).setName("turquinTexture");
+		this.specularBrdf = t, this.diffuseBrdf = n, this.fresnelMix = r, this.conductorFresnel = i(l), this.fresnelCoat = a, this.iridescentDielectricLayer = o, this.iridescentConductorLayer = s, this.calculateTurquinTexture = c;
+	}
+	init(e) {
+		if (!this.calculateTurquinTexture) return;
+		let t = new q(zn({
+			texture: j(this.turquinTexture).toWriteOnly(),
+			globalId: N
+		}), { workgroupSize: [
+			16,
+			16,
+			1
+		] });
+		e.compute(t.kernel, [
+			2,
+			2,
+			1
+		]);
+	}
+	getBsdfNode() {
+		return W`
+
+			fn bsdfSample( worldWo: vec3f, surf: ${Mt} ) -> ${At} {
+
+				var result: ${At};
+				result.pdf = 0.0;
+
+				let alpha = surf.roughness * surf.roughness;
+				let clearcoatAlpha = surf.clearcoatRoughness * surf.clearcoatRoughness;
+
+				let normalBasis = surf.normalBasis;
+				let invBasis = surf.normalInvBasis;
+				let clearcoatBasis = surf.clearcoatBasis;
+				let invClearcoatBasis = surf.clearcoatInvBasis;
+
+				let wo = normalize( invBasis * worldWo );
+				let woClearcoat = normalize( invClearcoatBasis * worldWo );
+
+				// TODO: handle such intersections better;
+				// Sometimes .z < 0.0 on a pretty round surface e.g. sphere
+				// Disabling this condition leads to more fireflies on ClearCoatCarPaint example
+				// This could also be fixed by offsetting rays by 1e-1
+				// Also, this will be an invalid condition when transmission is implemented
+				if ( wo.z < 0.0 || woClearcoat.z < 0.0 ) {
+
+					return result;
+
+				}
+
+				let weights = ${Yt}( wo, woClearcoat, vec3( 0, 0, 1 ), ${tr}, surf );
+
+				var cdf: vec4f;
+				cdf.x = weights.diffuse;
+				cdf.y = weights.specular + cdf.x;
+				cdf.z = weights.clearcoat + cdf.y;
+				cdf.w = 0; // weights.transmission + cdf.z;
+
+				let r = ${Dt}( ${2} ) * cdf.z;
+
+				let directionUV = ${Y}( ${3} );
+				var wi: vec3f;
+				var wiClearcoat: vec3f;
+				var wh: vec3f;
+				var whClearcoat: vec3f;
+
+				if ( r <= cdf.x ) { // diffuse
+
+					wi = ${Jt}( wo, directionUV );
+					wh = normalize( wi + wo );
+
+					wiClearcoat = normalize( invClearcoatBasis * normalBasis * wi );
+					whClearcoat = normalize( invClearcoatBasis * normalBasis * wh );
+
+				} else if ( r <= cdf.y ) { // specular
+
+					wh = ${Cn}( wo, vec2( alpha ), directionUV );
+					wi = - normalize( reflect( wo, wh ) );
+
+					wiClearcoat = normalize( invClearcoatBasis * normalBasis * wi );
+					whClearcoat = normalize( invClearcoatBasis * normalBasis * wh );
+
+				} else if ( r <= cdf.z ) { // clearcoat
+
+					whClearcoat = ${Cn}( woClearcoat, vec2( clearcoatAlpha ), directionUV );
+					wiClearcoat = - normalize( reflect( woClearcoat, whClearcoat ) );
+
+					wi = normalize( invBasis * clearcoatBasis * wiClearcoat );
+					wh = normalize( invBasis * clearcoatBasis * whClearcoat );
+
+				} else if ( r <= cdf.w ) { // transmission / refraction
+
+					// NOT IMPLEMENTED
+
+				}
+
+				var ctx: ${Ft};
+				ctx.NdotV = max( wo.z, ${nr} );
+				ctx.NdotL = max( wi.z, ${nr} );
+				ctx.NdotH = saturate( wh.z );
+				ctx.VdotH = saturate( dot( wo, wh ) );
+
+				ctx.VdotNc = max( woClearcoat.z, ${nr} );
+				ctx.LdotNc = max( wiClearcoat.z, ${nr} );
+				ctx.HdotNc = saturate( whClearcoat.z );
+
+				if ( weights.diffuse > 0.0 ) {
+
+					result.pdf += weights.diffuse * max( wi.z, 0.0 ) / PI;
+
+				}
+
+				if ( weights.specular > 0.0 && wi.z > 0.0 ) {
+
+					result.pdf += weights.specular * ${On}( ctx.NdotV, ctx.NdotH, alpha );
+
+				}
+
+				if ( weights.clearcoat > 0.0 && wiClearcoat.z > 0.0 ) {
+
+					result.pdf += weights.clearcoat * ${On}( ctx.VdotNc, ctx.HdotNc, clearcoatAlpha );
+
+				}
+
+				result.color = ${W`
+
+			fn bsdfEval( ctx: ${Ft}, surf: ${Mt} ) -> vec3f {
+
+				let alpha = surf.roughness * surf.roughness;
+
+				let specular = ${this.specularBrdf}( ctx.NdotL, ctx.NdotV, ctx.NdotH, alpha );
+				let diffuse = ${this.diffuseBrdf}( ctx.NdotV, ctx.NdotL, ctx.VdotH, surf );
+				let dielectricBase = ${this.fresnelMix}( ctx.VdotH, surf.ior, diffuse, specular );
+
+				let dielectric = ${this.iridescentDielectricLayer}(
+					dielectricBase, diffuse, specular, ctx.VdotH, /* outsideIor */ 1.0,
+					surf.ior, surf.iridescenceIor, surf.iridescenceThickness, surf.iridescence
+				);
+
+				let metallicBase = ${this.conductorFresnel}( ctx.NdotV, ctx.VdotH, surf.color, specular, alpha );
+
+				let metallic = ${this.iridescentConductorLayer}(
+					metallicBase, specular, surf.color, ctx.VdotH, /* outsideIor */ 1.0,
+					surf.iridescenceIor, surf.iridescenceThickness, surf.iridescence
+				);
+
+				let material = mix( dielectric, metallic, surf.metalness );
+
+				let clearcoatAlpha = surf.clearcoatRoughness * surf.clearcoatRoughness;
+				let clearcoat = ${this.specularBrdf}( ctx.LdotNc, ctx.VdotNc, ctx.HdotNc, clearcoatAlpha );
+
+				let coatedMaterial = ${this.fresnelCoat}( ctx.VdotNc, ${tr}, material, clearcoat, surf.clearcoat );
+
+				return coatedMaterial;
+
+			}
+
+		`}( ctx, surf );
+				result.color *= max( 0.0, wi.z );
+				result.direction = normalize( normalBasis * wi );
+
+				return result;
+
+			}
+
+		`;
+	}
+}, $ = new l(), ir = new ie(), ar = class {
+	get bounces() {
+		return this._pathTracer.bounces;
+	}
+	set bounces(e) {
+		this._pathTracer.bounces = e, this._pathTracer.reset();
+	}
+	get samples() {
+		return this._pathTracer.samples;
+	}
+	get fadeState() {
+		return this._fadeState;
+	}
+	get textureAtlas() {
+		return this._bvhData.textureAtlas;
+	}
+	useMegakernel(e) {
+		this._pathTracer.dispose(), this._pathTracer = e ? new sn(this._renderer) : new vn(this._renderer), this._pathTracer.setBVHData(this._bvhData), this._pathTracer.setMaterial(this.material), this.setCamera(this.camera), this.updateEnvironment();
+	}
+	constructor(e) {
+		this._renderer = e, this._timer = new g(), this._envColorTexture = new f(), this._envColorTexture.image.data = new Uint8Array([
+			255,
+			255,
+			255,
+			255
+		]), this._envColorTexture.needsUpdate = !0, this._envColorTexture.minFilter = w, this._envColorTexture.magFilter = w, this._backgroundColorTexture = new f(), this._backgroundColorTexture.image.data = new Uint8Array([
+			255,
+			255,
+			255,
+			255
+		]), this._backgroundColorTexture.needsUpdate = !0, this._backgroundColorTexture.minFilter = w, this._backgroundColorTexture.magFilter = w, this._resetTime = -1, this._fadeState = 0, this._size = new l(), this._blitQuad = new oe(new ft()), this._lowResTarget = new O(1, 1), this._lowResTarget.type = v, this._lowResTarget.generateMipmaps = !1, this.minSamples = 1, this.renderDelay = 500, this.fadeDuration = 500, this.dynamicLowRes = !0, this.lowResScale = .2, this.renderScale = 1, this.synchronizeRenderSize = !0, this.generateMissingAttributes = !0, this.commonAttributes = [
+			"normal",
+			"uv",
+			"tangent",
+			"color"
+		], this.material = new rr(), this._pathTracer = new sn(e), this.setScene(new a(), new s());
+	}
+	setScene(e, t) {
+		e.updateMatrixWorld(!0), t.updateMatrixWorld(), e.traverse((e) => {
+			this.generateMissingAttributes && e.geometry?.isBufferGeometry && Zn(e.geometry, this.commonAttributes), e.isSkinnedMesh ? e.boundsTree ? e.boundsTree.refit() : e.boundsTree = new ye(e, {
+				strategy: 2,
+				maxLeafSize: 5,
+				indirect: !0
+			}) : e.isMesh && (e.geometry.boundsTree || (e.geometry.boundsTree = new ve(e.geometry, {
+				strategy: 2,
+				maxLeafSize: 5
+			})));
+		});
+		let n = new Yn(e);
+		n.update(), n.textureAtlas.setTextures(this._renderer, n.textures), this.scene = e, this._bvhData = n, this._pathTracer.setBVHData(n), this.setCamera(t), this.updateEnvironment();
+	}
+	getMaterial() {
+		return this.material;
+	}
+	setMaterial(e) {
+		this.material = e, this._pathTracer.setMaterial(e);
+	}
+	setSceneAsync(...e) {
+		this.setScene(...e);
+	}
+	setCamera(e) {
+		this.camera = e, this.updateCamera();
+	}
+	updateCamera() {
+		let e = this.camera;
+		e.updateMatrixWorld(), this._pathTracer.setCamera(e), this.reset();
+	}
+	updateEnvironment() {
+		let { _renderer: e, _pathTracer: t, scene: n, _envColorTexture: r, _backgroundColorTexture: i } = this, a = or(e, n.environment || ir.set(0), r), o = or(e, n.background, i);
+		t.setEnvironment(a, n.environmentIntensity, n.environmentRotation, o, n.backgroundIntensity, n.backgroundRotation, n.backgroundBlurriness);
+	}
+	setSize(e, t) {
+		(this._size.x !== e || this._size.y !== t) && (this._size.set(e, t), this.reset());
+	}
+	reset() {
+		this._pathTracer.reset(), this._resetTime = 0, this._fadeState = 0;
+	}
+	renderSample() {
+		let e = this._renderer, t = this._size, n = this._blitQuad, r = this._pathTracer, i = this._lowResTarget, a = this._timer, { renderDelay: o, dynamicLowRes: s, synchronizeRenderSize: c, renderScale: l, lowResScale: u, minSamples: d } = this;
+		if (a.update(), !this._renderer._initialized) return;
+		this.material.initialized || (this.material.init(e), this.material.initialized = !0);
+		let f = 1e3 * a.getDelta();
+		this._resetTime += f;
+		let p = e.toneMapping, m = e.toneMappingExposure, h = e.getRenderTarget(), g = e.autoClear;
+		if (e.toneMapping = 0, e.toneMappingExposure = 1, c) {
+			e.getDrawingBufferSize($);
+			let t = Math.floor(l * $.x), n = Math.floor(l * $.y);
+			this.setSize(t, n);
+		}
+		let { width: _, height: v } = t, y = this._resetTime < o;
+		y && (_ = Math.ceil(u * _), v = Math.ceil(u * v)), r.getSize($), ($.x !== _ || $.y !== v) && (!y && s && (i.setSize(Math.ceil(u * _), Math.ceil(u * v)), e.copyTextureToTexture(r.outputTarget, i)), r.setSize(_, v)), !y && r.samples >= d && (this._fadeState += f / this.fadeDuration, this._fadeState = Math.min(1, this._fadeState)), (!y || y && s) && (r.lowResMode = y, r.update());
+		let b = y && s ? 1 : this._fadeState;
+		e.autoClear = s ? !0 : b === 1, n.material.transition = s ? b : 1, n.material.opacity = s ? 1 : b, n.material.fromTexture = i, n.material.texture = r.outputTarget, n.material.toneMapping = p, n.material.toneMappingExposure = m, n.render(e), e.autoClear = g, e.toneMapping = p, e.toneMappingExposure = m, e.setRenderTarget(h);
+	}
+	renderTextureAtlas(e = 0) {
+		let t = this._renderer;
+		if (!t._initialized) return;
+		this._atlasDebugQuad ||= new oe(new Xn());
+		let n = this._atlasDebugQuad;
+		n.material.texture = this.textureAtlas.texture, n.material.layer = e, t.setRenderTarget(null), n.render(t);
+	}
+	dispose() {
+		this._pathTracer.dispose(), this._blitQuad.dispose(), this._lowResTarget.dispose(), this._envColorTexture.dispose(), this._backgroundColorTexture.dispose(), this._atlasDebugQuad?.dispose();
+	}
+	async getDetailedSampleCount() {
+		let e = this._pathTracer.sampleCountTarget, { width: t, height: n } = e, r = this._renderer, i = { textures: [e] }, a = await r.readRenderTargetPixelsAsync(i, 0, 0, t, n), o = new Uint32Array(a.buffer), s = Math.ceil(t / 64) * 64, c = 0, l = Number.MAX_VALUE, u = -Number.MAX_VALUE;
+		for (let e = 0, n = o.length; e < n; e++) {
+			if (e % s >= t) continue;
+			let n = o[e] & 268435455;
+			c += n, l = Math.min(l, n), u = Math.max(u, n);
+		}
+		return {
+			min: l,
+			max: u,
+			avg: Math.floor(c / (t * n))
+		};
+	}
+	getRenderTime() {
+		return this._resetTime;
+	}
+};
+function or(e, t, n) {
+	if (t) t.isColor ? (n.image.data[0] = t.r * 255, n.image.data[1] = t.g * 255, n.image.data[2] = t.b * 255, n.image.data[3] = 255, n.needsUpdate = !0, t = n) : t?.isCubeTexture && (t = new xn(e).generate(t));
+	else {
+		let r = e.getClearAlpha();
+		e.getClearColor(ir), n.image.data[0] = ir.r * 255, n.image.data[1] = ir.g * 255, n.image.data[2] = ir.b * 255, n.image.data[3] = r * 255, n.needsUpdate = !0, t = n;
+	}
+	return t;
+}
+//#endregion
+export { ar as WebGPUPathTracer };
+
+//# sourceMappingURL=webgpu-BHAP6BLI.mjs.map