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

package/lib/GLTFExporter-D8qsdwDK.mjs

@@ -0,0 +1,1092 @@
+import { $ as e, $n as t, At as n, Ct as r, Gt as i, Jt as a, Kt as o, Nt as s, Rr as c, St as l, _r as u, an as d, c as f, h as p, lr as m, on as h, p as g, qt as _, ut as v, v as y, wt as b } from "./three.core-CLIofecG.mjs";
+//#region ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+var x = {
+	POSITION: [
+		"byte",
+		"byte normalized",
+		"unsigned byte",
+		"unsigned byte normalized",
+		"short",
+		"short normalized",
+		"unsigned short",
+		"unsigned short normalized"
+	],
+	NORMAL: ["byte normalized", "short normalized"],
+	TANGENT: ["byte normalized", "short normalized"],
+	TEXCOORD: [
+		"byte",
+		"byte normalized",
+		"unsigned byte",
+		"short",
+		"short normalized",
+		"unsigned short"
+	]
+}, S = class {
+	constructor() {
+		this.textureUtils = null, this.pluginCallbacks = [], this.register(function(e) {
+			return new U(e);
+		}), this.register(function(e) {
+			return new W(e);
+		}), this.register(function(e) {
+			return new J(e);
+		}), this.register(function(e) {
+			return new Y(e);
+		}), this.register(function(e) {
+			return new X(e);
+		}), this.register(function(e) {
+			return new Z(e);
+		}), this.register(function(e) {
+			return new G(e);
+		}), this.register(function(e) {
+			return new K(e);
+		}), this.register(function(e) {
+			return new q(e);
+		}), this.register(function(e) {
+			return new Q(e);
+		}), this.register(function(e) {
+			return new $(e);
+		}), this.register(function(e) {
+			return new ee(e);
+		}), this.register(function(e) {
+			return new te(e);
+		}), this.register(function(e) {
+			return new ne(e);
+		});
+	}
+	register(e) {
+		return this.pluginCallbacks.indexOf(e) === -1 && this.pluginCallbacks.push(e), this;
+	}
+	unregister(e) {
+		return this.pluginCallbacks.indexOf(e) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(e), 1), this;
+	}
+	setTextureUtils(e) {
+		return this.textureUtils = e, this;
+	}
+	parse(e, t, n, r) {
+		let i = new H(), a = [];
+		for (let e = 0, t = this.pluginCallbacks.length; e < t; e++) a.push(this.pluginCallbacks[e](i));
+		i.setPlugins(a), i.setTextureUtils(this.textureUtils), i.writeAsync(e, t, r).catch(n);
+	}
+	parseAsync(e, t) {
+		let n = this;
+		return new Promise(function(r, i) {
+			n.parse(e, r, i, t);
+		});
+	}
+}, C = {
+	POINTS: 0,
+	LINES: 1,
+	LINE_LOOP: 2,
+	LINE_STRIP: 3,
+	TRIANGLES: 4,
+	TRIANGLE_STRIP: 5,
+	TRIANGLE_FAN: 6,
+	BYTE: 5120,
+	UNSIGNED_BYTE: 5121,
+	SHORT: 5122,
+	UNSIGNED_SHORT: 5123,
+	INT: 5124,
+	UNSIGNED_INT: 5125,
+	FLOAT: 5126,
+	ARRAY_BUFFER: 34962,
+	ELEMENT_ARRAY_BUFFER: 34963,
+	NEAREST: 9728,
+	LINEAR: 9729,
+	NEAREST_MIPMAP_NEAREST: 9984,
+	LINEAR_MIPMAP_NEAREST: 9985,
+	NEAREST_MIPMAP_LINEAR: 9986,
+	LINEAR_MIPMAP_LINEAR: 9987,
+	CLAMP_TO_EDGE: 33071,
+	MIRRORED_REPEAT: 33648,
+	REPEAT: 10497
+}, w = "KHR_mesh_quantization", T = {};
+T[o] = C.NEAREST, T[a] = C.NEAREST_MIPMAP_NEAREST, T[_] = C.NEAREST_MIPMAP_LINEAR, T[l] = C.LINEAR, T[b] = C.LINEAR_MIPMAP_NEAREST, T[r] = C.LINEAR_MIPMAP_LINEAR, T[g] = C.CLAMP_TO_EDGE, T[t] = C.REPEAT, T[i] = C.MIRRORED_REPEAT;
+var E = {
+	scale: "scale",
+	position: "translation",
+	quaternion: "rotation",
+	morphTargetInfluences: "weights"
+}, D = new p(), O = 12, k = 1179937895, A = 2, j = 8, M = 1313821514, N = 5130562;
+function P(e, t) {
+	return e.length === t.length && e.every(function(e, n) {
+		return e === t[n];
+	});
+}
+function F(e) {
+	return new TextEncoder().encode(e).buffer;
+}
+function I(e) {
+	return P(e.elements, [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1
+	]);
+}
+function L(e, t, r) {
+	let i = {
+		min: Array(e.itemSize).fill(Infinity),
+		max: Array(e.itemSize).fill(-Infinity)
+	};
+	for (let a = t; a < t + r; a++) for (let t = 0; t < e.itemSize; t++) {
+		let r;
+		e.itemSize > 4 ? r = e.array[a * e.itemSize + t] : (t === 0 ? r = e.getX(a) : t === 1 ? r = e.getY(a) : t === 2 ? r = e.getZ(a) : t === 3 && (r = e.getW(a)), e.normalized === !0 && (r = n.normalize(r, e.array))), i.min[t] = Math.min(i.min[t], r), i.max[t] = Math.max(i.max[t], r);
+	}
+	return i;
+}
+function R(e) {
+	return Math.ceil(e / 4) * 4;
+}
+function z(e, t = 0) {
+	let n = R(e.byteLength);
+	if (n !== e.byteLength) {
+		let r = new Uint8Array(n);
+		if (r.set(new Uint8Array(e)), t !== 0) for (let i = e.byteLength; i < n; i++) r[i] = t;
+		return r.buffer;
+	}
+	return e;
+}
+function B() {
+	return typeof document > "u" && typeof OffscreenCanvas < "u" ? new OffscreenCanvas(1, 1) : document.createElement("canvas");
+}
+function V(e, t) {
+	if (typeof OffscreenCanvas < "u" && e instanceof OffscreenCanvas) {
+		let n;
+		return t === "image/jpeg" ? n = .92 : t === "image/webp" && (n = .8), e.convertToBlob({
+			type: t,
+			quality: n
+		});
+	} else return new Promise((n) => e.toBlob(n, t));
+}
+var H = class {
+	constructor() {
+		this.plugins = [], this.options = {}, this.pending = [], this.buffers = [], this.byteOffset = 0, this.buffers = [], this.nodeMap = /* @__PURE__ */ new Map(), this.skins = [], this.extensionsUsed = {}, this.extensionsRequired = {}, this.uids = /* @__PURE__ */ new Map(), this.uid = 0, this.json = { asset: {
+			version: "2.0",
+			generator: "THREE.GLTFExporter r183"
+		} }, this.cache = {
+			meshes: /* @__PURE__ */ new Map(),
+			attributes: /* @__PURE__ */ new Map(),
+			attributesNormalized: /* @__PURE__ */ new Map(),
+			materials: /* @__PURE__ */ new Map(),
+			textures: /* @__PURE__ */ new Map(),
+			images: /* @__PURE__ */ new Map()
+		}, this.textureUtils = null;
+	}
+	setPlugins(e) {
+		this.plugins = e;
+	}
+	setTextureUtils(e) {
+		this.textureUtils = e;
+	}
+	async writeAsync(e, t, n = {}) {
+		this.options = Object.assign({
+			binary: !1,
+			trs: !1,
+			onlyVisible: !0,
+			maxTextureSize: Infinity,
+			animations: [],
+			includeCustomExtensions: !1
+		}, n), this.options.animations.length > 0 && (this.options.trs = !0), await this.processInputAsync(e), await Promise.all(this.pending);
+		let r = this, i = r.buffers, a = r.json;
+		n = r.options;
+		let o = r.extensionsUsed, s = r.extensionsRequired, c = new Blob(i, { type: "application/octet-stream" }), l = Object.keys(o), u = Object.keys(s);
+		if (l.length > 0 && (a.extensionsUsed = l), u.length > 0 && (a.extensionsRequired = u), a.buffers && a.buffers.length > 0 && (a.buffers[0].byteLength = c.size), n.binary === !0) {
+			let e = new FileReader();
+			e.readAsArrayBuffer(c), e.onloadend = function() {
+				let n = z(e.result), r = new DataView(new ArrayBuffer(j));
+				r.setUint32(0, n.byteLength, !0), r.setUint32(4, N, !0);
+				let i = z(F(JSON.stringify(a)), 32), o = new DataView(new ArrayBuffer(j));
+				o.setUint32(0, i.byteLength, !0), o.setUint32(4, M, !0);
+				let s = new ArrayBuffer(O), c = new DataView(s);
+				c.setUint32(0, k, !0), c.setUint32(4, A, !0);
+				let l = O + o.byteLength + i.byteLength + r.byteLength + n.byteLength;
+				c.setUint32(8, l, !0);
+				let u = new Blob([
+					s,
+					o,
+					i,
+					r,
+					n
+				], { type: "application/octet-stream" }), d = new FileReader();
+				d.readAsArrayBuffer(u), d.onloadend = function() {
+					t(d.result);
+				};
+			};
+		} else if (a.buffers && a.buffers.length > 0) {
+			let e = new FileReader();
+			e.readAsDataURL(c), e.onloadend = function() {
+				let n = e.result;
+				a.buffers[0].uri = n, t(a);
+			};
+		} else t(a);
+	}
+	serializeUserData(e, t) {
+		if (Object.keys(e.userData).length === 0) return;
+		let n = this.options, r = this.extensionsUsed;
+		try {
+			let i = JSON.parse(JSON.stringify(e.userData));
+			if (n.includeCustomExtensions && i.gltfExtensions) {
+				t.extensions === void 0 && (t.extensions = {});
+				for (let e in i.gltfExtensions) t.extensions[e] = i.gltfExtensions[e], r[e] = !0;
+				delete i.gltfExtensions;
+			}
+			Object.keys(i).length > 0 && (t.extras = i);
+		} catch (t) {
+			console.warn("THREE.GLTFExporter: userData of '" + e.name + "' won't be serialized because of JSON.stringify error - " + t.message);
+		}
+	}
+	getUID(e, t = !1) {
+		if (this.uids.has(e) === !1) {
+			let t = /* @__PURE__ */ new Map();
+			t.set(!0, this.uid++), t.set(!1, this.uid++), this.uids.set(e, t);
+		}
+		return this.uids.get(e).get(t);
+	}
+	isNormalizedNormalAttribute(e) {
+		if (this.cache.attributesNormalized.has(e)) return !1;
+		let t = new c();
+		for (let n = 0, r = e.count; n < r; n++) if (Math.abs(t.fromBufferAttribute(e, n).length() - 1) > 5e-4) return !1;
+		return !0;
+	}
+	createNormalizedNormalAttribute(e) {
+		let t = this.cache;
+		if (t.attributesNormalized.has(e)) return t.attributesNormalized.get(e);
+		let n = e.clone(), r = new c();
+		for (let e = 0, t = n.count; e < t; e++) r.fromBufferAttribute(n, e), r.x === 0 && r.y === 0 && r.z === 0 ? r.setX(1) : r.normalize(), n.setXYZ(e, r.x, r.y, r.z);
+		return t.attributesNormalized.set(e, n), n;
+	}
+	applyTextureTransform(e, t) {
+		let n = !1, r = {};
+		(t.offset.x !== 0 || t.offset.y !== 0) && (r.offset = t.offset.toArray(), n = !0), t.rotation !== 0 && (r.rotation = t.rotation, n = !0), (t.repeat.x !== 1 || t.repeat.y !== 1) && (r.scale = t.repeat.toArray(), n = !0), n && (e.extensions = e.extensions || {}, e.extensions.KHR_texture_transform = r, this.extensionsUsed.KHR_texture_transform = !0);
+	}
+	async buildMetalRoughTextureAsync(e, t) {
+		if (e === t) return e;
+		function n(e) {
+			return e.colorSpace === "srgb" ? function(e) {
+				return e < .04045 ? e * .0773993808 : (e * .9478672986 + .0521327014) ** 2.4;
+			} : function(e) {
+				return e;
+			};
+		}
+		e instanceof y && (e = await this.decompressTextureAsync(e)), t instanceof y && (t = await this.decompressTextureAsync(t));
+		let r = e ? e.image : null, i = t ? t.image : null, a = Math.max(r ? r.width : 0, i ? i.width : 0), o = Math.max(r ? r.height : 0, i ? i.height : 0), s = B();
+		s.width = a, s.height = o;
+		let c = s.getContext("2d", { willReadFrequently: !0 });
+		c.fillStyle = "#00ffff", c.fillRect(0, 0, a, o);
+		let l = c.getImageData(0, 0, a, o);
+		if (r) {
+			c.drawImage(r, 0, 0, a, o);
+			let t = n(e), i = c.getImageData(0, 0, a, o).data;
+			for (let e = 2; e < i.length; e += 4) l.data[e] = t(i[e] / 256) * 256;
+		}
+		if (i) {
+			c.drawImage(i, 0, 0, a, o);
+			let e = n(t), r = c.getImageData(0, 0, a, o).data;
+			for (let t = 1; t < r.length; t += 4) l.data[t] = e(r[t] / 256) * 256;
+		}
+		c.putImageData(l, 0, 0);
+		let d = (e || t).clone();
+		return d.source = new u(s), d.colorSpace = "", d.channel = (e || t).channel, e && t && e.channel !== t.channel && console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match."), console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures."), d;
+	}
+	async decompressTextureAsync(e, t = Infinity) {
+		if (this.textureUtils === null) throw Error("THREE.GLTFExporter: setTextureUtils() must be called to process compressed textures.");
+		return await this.textureUtils.decompress(e, t);
+	}
+	processBuffer(e) {
+		let t = this.json, n = this.buffers;
+		return t.buffers ||= [{ byteLength: 0 }], n.push(e), 0;
+	}
+	processBufferView(e, t, r, i, a) {
+		let o = this.json;
+		o.bufferViews ||= [];
+		let s;
+		switch (t) {
+			case C.BYTE:
+			case C.UNSIGNED_BYTE:
+				s = 1;
+				break;
+			case C.SHORT:
+			case C.UNSIGNED_SHORT:
+				s = 2;
+				break;
+			default: s = 4;
+		}
+		let c = e.itemSize * s;
+		a === C.ARRAY_BUFFER && (c = Math.ceil(c / 4) * 4);
+		let l = R(i * c), u = new DataView(new ArrayBuffer(l)), d = 0;
+		for (let a = r; a < r + i; a++) {
+			for (let r = 0; r < e.itemSize; r++) {
+				let i;
+				e.itemSize > 4 ? i = e.array[a * e.itemSize + r] : (r === 0 ? i = e.getX(a) : r === 1 ? i = e.getY(a) : r === 2 ? i = e.getZ(a) : r === 3 && (i = e.getW(a)), e.normalized === !0 && (i = n.normalize(i, e.array))), t === C.FLOAT ? u.setFloat32(d, i, !0) : t === C.INT ? u.setInt32(d, i, !0) : t === C.UNSIGNED_INT ? u.setUint32(d, i, !0) : t === C.SHORT ? u.setInt16(d, i, !0) : t === C.UNSIGNED_SHORT ? u.setUint16(d, i, !0) : t === C.BYTE ? u.setInt8(d, i) : t === C.UNSIGNED_BYTE && u.setUint8(d, i), d += s;
+			}
+			d % c !== 0 && (d += c - d % c);
+		}
+		let f = {
+			buffer: this.processBuffer(u.buffer),
+			byteOffset: this.byteOffset,
+			byteLength: l
+		};
+		return a !== void 0 && (f.target = a), a === C.ARRAY_BUFFER && (f.byteStride = c), this.byteOffset += l, o.bufferViews.push(f), {
+			id: o.bufferViews.length - 1,
+			byteLength: 0
+		};
+	}
+	processBufferViewImage(e) {
+		let t = this, n = t.json;
+		return n.bufferViews ||= [], new Promise(function(r) {
+			let i = new FileReader();
+			i.readAsArrayBuffer(e), i.onloadend = function() {
+				let e = z(i.result), a = {
+					buffer: t.processBuffer(e),
+					byteOffset: t.byteOffset,
+					byteLength: e.byteLength
+				};
+				t.byteOffset += e.byteLength, r(n.bufferViews.push(a) - 1);
+			};
+		});
+	}
+	processAccessor(e, t, n, r) {
+		let i = this.json, a = {
+			1: "SCALAR",
+			2: "VEC2",
+			3: "VEC3",
+			4: "VEC4",
+			9: "MAT3",
+			16: "MAT4"
+		}, o;
+		if (e.array.constructor === Float32Array) o = C.FLOAT;
+		else if (e.array.constructor === Int32Array) o = C.INT;
+		else if (e.array.constructor === Uint32Array) o = C.UNSIGNED_INT;
+		else if (e.array.constructor === Int16Array) o = C.SHORT;
+		else if (e.array.constructor === Uint16Array) o = C.UNSIGNED_SHORT;
+		else if (e.array.constructor === Int8Array) o = C.BYTE;
+		else if (e.array.constructor === Uint8Array) o = C.UNSIGNED_BYTE;
+		else throw Error("THREE.GLTFExporter: Unsupported bufferAttribute component type: " + e.array.constructor.name);
+		if (n === void 0 && (n = 0), (r === void 0 || r === Infinity) && (r = e.count), r === 0) return null;
+		let s = L(e, n, r), c;
+		t !== void 0 && (c = e === t.index ? C.ELEMENT_ARRAY_BUFFER : C.ARRAY_BUFFER);
+		let l = this.processBufferView(e, o, n, r, c), u = {
+			bufferView: l.id,
+			byteOffset: l.byteOffset,
+			componentType: o,
+			count: r,
+			max: s.max,
+			min: s.min,
+			type: a[e.itemSize]
+		};
+		return e.normalized === !0 && (u.normalized = !0), i.accessors ||= [], i.accessors.push(u) - 1;
+	}
+	processImage(t, n, r, i = "image/png") {
+		if (t !== null) {
+			let a = this, o = a.cache, s = a.json, c = a.options, l = a.pending;
+			o.images.has(t) || o.images.set(t, {});
+			let u = o.images.get(t), d = i + ":flipY/" + r.toString();
+			if (u[d] !== void 0) return u[d];
+			s.images ||= [];
+			let f = { mimeType: i }, p = B();
+			p.width = Math.min(t.width, c.maxTextureSize), p.height = Math.min(t.height, c.maxTextureSize);
+			let m = p.getContext("2d", { willReadFrequently: !0 });
+			if (r === !0 && (m.translate(0, p.height), m.scale(1, -1)), t.data !== void 0) {
+				n !== 1023 && console.error("GLTFExporter: Only RGBAFormat is supported.", n), (t.width > c.maxTextureSize || t.height > c.maxTextureSize) && console.warn("GLTFExporter: Image size is bigger than maxTextureSize", t);
+				let e = new Uint8ClampedArray(t.height * t.width * 4);
+				for (let n = 0; n < e.length; n += 4) e[n + 0] = t.data[n + 0], e[n + 1] = t.data[n + 1], e[n + 2] = t.data[n + 2], e[n + 3] = t.data[n + 3];
+				m.putImageData(new ImageData(e, t.width, t.height), 0, 0);
+			} else if (typeof HTMLImageElement < "u" && t instanceof HTMLImageElement || typeof HTMLCanvasElement < "u" && t instanceof HTMLCanvasElement || typeof ImageBitmap < "u" && t instanceof ImageBitmap || typeof OffscreenCanvas < "u" && t instanceof OffscreenCanvas) m.drawImage(t, 0, 0, p.width, p.height);
+			else throw Error("THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.");
+			c.binary === !0 ? l.push(V(p, i).then((e) => a.processBufferViewImage(e)).then((e) => {
+				f.bufferView = e;
+			})) : f.uri = e.getDataURL(p, i);
+			let h = s.images.push(f) - 1;
+			return u[d] = h, h;
+		} else throw Error("THREE.GLTFExporter: No valid image data found. Unable to process texture.");
+	}
+	processSampler(e) {
+		let t = this.json;
+		t.samplers ||= [];
+		let n = {
+			magFilter: T[e.magFilter],
+			minFilter: T[e.minFilter],
+			wrapS: T[e.wrapS],
+			wrapT: T[e.wrapT]
+		};
+		return t.samplers.push(n) - 1;
+	}
+	async processTextureAsync(e) {
+		let t = this.options, n = this.cache, r = this.json;
+		if (n.textures.has(e)) return n.textures.get(e);
+		r.textures ||= [], e instanceof y && (e = await this.decompressTextureAsync(e, t.maxTextureSize));
+		let i = e.userData.mimeType;
+		i === "image/webp" && (i = "image/png");
+		let a = {
+			sampler: this.processSampler(e),
+			source: this.processImage(e.image, e.format, e.flipY, i)
+		};
+		e.name && (a.name = e.name), await this._invokeAllAsync(async function(t) {
+			t.writeTexture && await t.writeTexture(e, a);
+		});
+		let o = r.textures.push(a) - 1;
+		return n.textures.set(e, o), o;
+	}
+	async processMaterialAsync(e) {
+		let t = this.cache, n = this.json;
+		if (t.materials.has(e)) return t.materials.get(e);
+		if (e.isShaderMaterial) return console.warn("GLTFExporter: THREE.ShaderMaterial not supported."), null;
+		n.materials ||= [];
+		let r = { pbrMetallicRoughness: {} };
+		e.isMeshStandardMaterial !== !0 && e.isMeshBasicMaterial !== !0 && console.warn("GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.");
+		let i = e.color.toArray().concat([e.opacity]);
+		if (P(i, [
+			1,
+			1,
+			1,
+			1
+		]) || (r.pbrMetallicRoughness.baseColorFactor = i), e.isMeshStandardMaterial ? (r.pbrMetallicRoughness.metallicFactor = e.metalness, r.pbrMetallicRoughness.roughnessFactor = e.roughness) : (r.pbrMetallicRoughness.metallicFactor = 0, r.pbrMetallicRoughness.roughnessFactor = 1), e.metalnessMap || e.roughnessMap) {
+			let t = await this.buildMetalRoughTextureAsync(e.metalnessMap, e.roughnessMap), n = {
+				index: await this.processTextureAsync(t),
+				texCoord: t.channel
+			};
+			this.applyTextureTransform(n, t), r.pbrMetallicRoughness.metallicRoughnessTexture = n;
+		}
+		if (e.map) {
+			let t = {
+				index: await this.processTextureAsync(e.map),
+				texCoord: e.map.channel
+			};
+			this.applyTextureTransform(t, e.map), r.pbrMetallicRoughness.baseColorTexture = t;
+		}
+		if (e.emissive) {
+			let t = e.emissive;
+			if (Math.max(t.r, t.g, t.b) > 0 && (r.emissiveFactor = e.emissive.toArray()), e.emissiveMap) {
+				let t = {
+					index: await this.processTextureAsync(e.emissiveMap),
+					texCoord: e.emissiveMap.channel
+				};
+				this.applyTextureTransform(t, e.emissiveMap), r.emissiveTexture = t;
+			}
+		}
+		if (e.normalMap) {
+			let t = {
+				index: await this.processTextureAsync(e.normalMap),
+				texCoord: e.normalMap.channel
+			};
+			e.normalScale && e.normalScale.x !== 1 && (t.scale = e.normalScale.x), this.applyTextureTransform(t, e.normalMap), r.normalTexture = t;
+		}
+		if (e.aoMap) {
+			let t = {
+				index: await this.processTextureAsync(e.aoMap),
+				texCoord: e.aoMap.channel
+			};
+			e.aoMapIntensity !== 1 && (t.strength = e.aoMapIntensity), this.applyTextureTransform(t, e.aoMap), r.occlusionTexture = t;
+		}
+		e.transparent ? r.alphaMode = "BLEND" : e.alphaTest > 0 && (r.alphaMode = "MASK", r.alphaCutoff = e.alphaTest), e.side === 2 && (r.doubleSided = !0), e.name !== "" && (r.name = e.name), this.serializeUserData(e, r), await this._invokeAllAsync(async function(t) {
+			t.writeMaterialAsync && await t.writeMaterialAsync(e, r);
+		});
+		let a = n.materials.push(r) - 1;
+		return t.materials.set(e, a), a;
+	}
+	async processMeshAsync(e) {
+		let t = this.cache, n = this.json, r = [e.geometry.uuid];
+		if (Array.isArray(e.material)) for (let t = 0, n = e.material.length; t < n; t++) r.push(e.material[t].uuid);
+		else r.push(e.material.uuid);
+		let i = r.join(":");
+		if (t.meshes.has(i)) return t.meshes.get(i);
+		let a = e.geometry, o;
+		o = e.isLineSegments ? C.LINES : e.isLineLoop ? C.LINE_LOOP : e.isLine ? C.LINE_STRIP : e.isPoints ? C.POINTS : e.material.wireframe ? C.LINES : C.TRIANGLES;
+		let s = {}, c = {}, l = [], u = [], d = {
+			uv: "TEXCOORD_0",
+			uv1: "TEXCOORD_1",
+			uv2: "TEXCOORD_2",
+			uv3: "TEXCOORD_3",
+			color: "COLOR_0",
+			skinWeight: "WEIGHTS_0",
+			skinIndex: "JOINTS_0"
+		}, f = a.getAttribute("normal");
+		f !== void 0 && !this.isNormalizedNormalAttribute(f) && (console.warn("THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one."), a.setAttribute("normal", this.createNormalizedNormalAttribute(f)));
+		let p = null;
+		for (let e in a.attributes) {
+			if (e.slice(0, 5) === "morph") continue;
+			let n = a.attributes[e];
+			if (e = d[e] || e.toUpperCase(), /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/.test(e) || (e = "_" + e), t.attributes.has(this.getUID(n))) {
+				c[e] = t.attributes.get(this.getUID(n));
+				continue;
+			}
+			p = null;
+			let r = n.array;
+			e === "JOINTS_0" && !(r instanceof Uint16Array) && !(r instanceof Uint8Array) ? (console.warn("GLTFExporter: Attribute \"skinIndex\" converted to type UNSIGNED_SHORT."), p = S.Utils.toTypedBufferAttribute(n, Uint16Array)) : (r instanceof Uint32Array || r instanceof Int32Array) && !e.startsWith("_") && (console.warn(`GLTFExporter: Attribute "${e}" converted to type FLOAT.`), p = S.Utils.toTypedBufferAttribute(n, Float32Array));
+			let i = this.processAccessor(p || n, a);
+			i !== null && (e.startsWith("_") || this.detectMeshQuantization(e, n), c[e] = i, t.attributes.set(this.getUID(n), i));
+		}
+		if (f !== void 0 && a.setAttribute("normal", f), Object.keys(c).length === 0) return null;
+		if (e.morphTargetInfluences !== void 0 && e.morphTargetInfluences.length > 0) {
+			let n = [], r = [], i = {};
+			if (e.morphTargetDictionary !== void 0) for (let t in e.morphTargetDictionary) i[e.morphTargetDictionary[t]] = t;
+			for (let o = 0; o < e.morphTargetInfluences.length; ++o) {
+				let s = {}, c = !1;
+				for (let e in a.morphAttributes) {
+					if (e !== "position" && e !== "normal") {
+						c ||= (console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported."), !0);
+						continue;
+					}
+					let n = a.morphAttributes[e][o], r = e.toUpperCase(), i = a.attributes[e];
+					if (t.attributes.has(this.getUID(n, !0))) {
+						s[r] = t.attributes.get(this.getUID(n, !0));
+						continue;
+					}
+					let l = n.clone();
+					if (!a.morphTargetsRelative) for (let e = 0, t = n.count; e < t; e++) for (let t = 0; t < n.itemSize; t++) t === 0 && l.setX(e, n.getX(e) - i.getX(e)), t === 1 && l.setY(e, n.getY(e) - i.getY(e)), t === 2 && l.setZ(e, n.getZ(e) - i.getZ(e)), t === 3 && l.setW(e, n.getW(e) - i.getW(e));
+					s[r] = this.processAccessor(l, a), t.attributes.set(this.getUID(i, !0), s[r]);
+				}
+				u.push(s), n.push(e.morphTargetInfluences[o]), e.morphTargetDictionary !== void 0 && r.push(i[o]);
+			}
+			s.weights = n, r.length > 0 && (s.extras = {}, s.extras.targetNames = r);
+		}
+		let m = Array.isArray(e.material);
+		if (m && a.groups.length === 0) return null;
+		let h = !1;
+		if (m && a.index === null) {
+			let e = [];
+			for (let t = 0, n = a.attributes.position.count; t < n; t++) e[t] = t;
+			a.setIndex(e), h = !0;
+		}
+		let g = m ? e.material : [e.material], _ = m ? a.groups : [{
+			materialIndex: 0,
+			start: void 0,
+			count: void 0
+		}];
+		for (let e = 0, n = _.length; e < n; e++) {
+			let n = {
+				mode: o,
+				attributes: c
+			};
+			if (this.serializeUserData(a, n), u.length > 0 && (n.targets = u), a.index !== null) {
+				let r = this.getUID(a.index);
+				(_[e].start !== void 0 || _[e].count !== void 0) && (r += ":" + _[e].start + ":" + _[e].count), t.attributes.has(r) ? n.indices = t.attributes.get(r) : (n.indices = this.processAccessor(a.index, a, _[e].start, _[e].count), t.attributes.set(r, n.indices)), n.indices === null && delete n.indices;
+			}
+			let r = await this.processMaterialAsync(g[_[e].materialIndex]);
+			r !== null && (n.material = r), l.push(n);
+		}
+		h === !0 && a.setIndex(null), s.primitives = l, n.meshes ||= [], await this._invokeAllAsync(function(t) {
+			t.writeMesh && t.writeMesh(e, s);
+		});
+		let v = n.meshes.push(s) - 1;
+		return t.meshes.set(i, v), v;
+	}
+	detectMeshQuantization(e, t) {
+		if (this.extensionsUsed[w]) return;
+		let n;
+		switch (t.array.constructor) {
+			case Int8Array:
+				n = "byte";
+				break;
+			case Uint8Array:
+				n = "unsigned byte";
+				break;
+			case Int16Array:
+				n = "short";
+				break;
+			case Uint16Array:
+				n = "unsigned short";
+				break;
+			default: return;
+		}
+		t.normalized && (n += " normalized");
+		let r = e.split("_", 1)[0];
+		x[r] && x[r].includes(n) && (this.extensionsUsed[w] = !0, this.extensionsRequired[w] = !0);
+	}
+	processCamera(e) {
+		let t = this.json;
+		t.cameras ||= [];
+		let r = e.isOrthographicCamera, i = { type: r ? "orthographic" : "perspective" };
+		return r ? i.orthographic = {
+			xmag: e.right * 2,
+			ymag: e.top * 2,
+			zfar: e.far <= 0 ? .001 : e.far,
+			znear: e.near < 0 ? 0 : e.near
+		} : i.perspective = {
+			aspectRatio: e.aspect,
+			yfov: n.degToRad(e.fov),
+			zfar: e.far <= 0 ? .001 : e.far,
+			znear: e.near < 0 ? 0 : e.near
+		}, e.name !== "" && (i.name = e.type), t.cameras.push(i) - 1;
+	}
+	processAnimation(e, t) {
+		let n = this.json, r = this.nodeMap;
+		n.animations ||= [], e = S.Utils.mergeMorphTargetTracks(e.clone(), t);
+		let i = e.tracks, a = [], o = [];
+		for (let e = 0; e < i.length; ++e) {
+			let n = i[e], s = d.parseTrackName(n.name), c = d.findNode(t, s.nodeName), l = E[s.propertyName];
+			if (s.objectName === "bones" && (c = c.isSkinnedMesh === !0 ? c.skeleton.getBoneByName(s.objectIndex) : void 0), !c || !l) {
+				console.warn("THREE.GLTFExporter: Could not export animation track \"%s\".", n.name);
+				continue;
+			}
+			let u = n.values.length / n.times.length;
+			l === E.morphTargetInfluences && (u /= c.morphTargetInfluences.length);
+			let p;
+			n.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === !0 ? (p = "CUBICSPLINE", u /= 3) : p = n.getInterpolation() === 2300 ? "STEP" : "LINEAR", o.push({
+				input: this.processAccessor(new f(n.times, 1)),
+				output: this.processAccessor(new f(n.values, u)),
+				interpolation: p
+			}), a.push({
+				sampler: o.length - 1,
+				target: {
+					node: r.get(c),
+					path: l
+				}
+			});
+		}
+		let s = {
+			name: e.name || "clip_" + n.animations.length,
+			samplers: o,
+			channels: a
+		};
+		return this.serializeUserData(e, s), n.animations.push(s), n.animations.length - 1;
+	}
+	processSkin(e) {
+		let t = this.json, n = this.nodeMap, r = t.nodes[n.get(e)], i = e.skeleton;
+		if (i === void 0) return null;
+		let a = e.skeleton.bones[0];
+		if (a === void 0) return null;
+		let o = [], c = new Float32Array(i.bones.length * 16), l = new s();
+		for (let t = 0; t < i.bones.length; ++t) o.push(n.get(i.bones[t])), l.copy(i.boneInverses[t]), l.multiply(e.bindMatrix).toArray(c, t * 16);
+		return t.skins === void 0 && (t.skins = []), t.skins.push({
+			inverseBindMatrices: this.processAccessor(new f(c, 16)),
+			joints: o,
+			skeleton: n.get(a)
+		}), r.skin = t.skins.length - 1;
+	}
+	async processNodeAsync(e) {
+		let t = this.json, n = this.options, r = this.nodeMap;
+		if (t.nodes ||= [], e.pivot !== null) return await this._processNodeWithPivotAsync(e);
+		let i = {};
+		if (n.trs) {
+			let t = e.quaternion.toArray(), n = e.position.toArray(), r = e.scale.toArray();
+			P(t, [
+				0,
+				0,
+				0,
+				1
+			]) || (i.rotation = t), P(n, [
+				0,
+				0,
+				0
+			]) || (i.translation = n), P(r, [
+				1,
+				1,
+				1
+			]) || (i.scale = r);
+		} else e.matrixAutoUpdate && e.updateMatrix(), I(e.matrix) === !1 && (i.matrix = e.matrix.elements);
+		if (e.name !== "" && (i.name = String(e.name)), this.serializeUserData(e, i), e.isMesh || e.isLine || e.isPoints) {
+			let t = await this.processMeshAsync(e);
+			t !== null && (i.mesh = t);
+		} else e.isCamera && (i.camera = this.processCamera(e));
+		e.isSkinnedMesh && this.skins.push(e);
+		let a = t.nodes.push(i) - 1;
+		if (r.set(e, a), e.children.length > 0) {
+			let t = [];
+			for (let r = 0, i = e.children.length; r < i; r++) {
+				let i = e.children[r];
+				if (i.visible || n.onlyVisible === !1) {
+					let e = await this.processNodeAsync(i);
+					e !== null && t.push(e);
+				}
+			}
+			t.length > 0 && (i.children = t);
+		}
+		return await this._invokeAllAsync(function(t) {
+			t.writeNode && t.writeNode(e, i);
+		}), a;
+	}
+	async _processNodeWithPivotAsync(e) {
+		let t = this.json, n = this.options, r = this.nodeMap, i = e.pivot, a = {}, o = e.quaternion.toArray(), s = [
+			e.position.x + i.x,
+			e.position.y + i.y,
+			e.position.z + i.z
+		], c = e.scale.toArray();
+		P(o, [
+			0,
+			0,
+			0,
+			1
+		]) || (a.rotation = o), P(s, [
+			0,
+			0,
+			0
+		]) || (a.translation = s), P(c, [
+			1,
+			1,
+			1
+		]) || (a.scale = c), a.extras = { pivot: i.toArray() }, e.name !== "" && (a.name = String(e.name)), this.serializeUserData(e, a);
+		let l = t.nodes.push(a) - 1;
+		r.set(e, l);
+		let u = {}, d = [
+			-i.x,
+			-i.y,
+			-i.z
+		];
+		if (P(d, [
+			0,
+			0,
+			0
+		]) || (u.translation = d), e.isMesh || e.isLine || e.isPoints) {
+			let t = await this.processMeshAsync(e);
+			t !== null && (u.mesh = t);
+		} else e.isCamera && (u.camera = this.processCamera(e));
+		e.isSkinnedMesh && this.skins.push(e);
+		let f = [t.nodes.push(u) - 1];
+		if (e.children.length > 0) {
+			let t = [];
+			for (let r = 0, i = e.children.length; r < i; r++) {
+				let i = e.children[r];
+				if (i.visible || n.onlyVisible === !1) {
+					let e = await this.processNodeAsync(i);
+					e !== null && t.push(e);
+				}
+			}
+			t.length > 0 && (u.children = t);
+		}
+		return a.children = f, await this._invokeAllAsync(function(t) {
+			t.writeNode && t.writeNode(e, a);
+		}), l;
+	}
+	async processSceneAsync(e) {
+		let t = this.json, n = this.options;
+		t.scenes || (t.scenes = [], t.scene = 0);
+		let r = {};
+		e.name !== "" && (r.name = e.name), t.scenes.push(r);
+		let i = [];
+		for (let t = 0, r = e.children.length; t < r; t++) {
+			let r = e.children[t];
+			if (r.visible || n.onlyVisible === !1) {
+				let e = await this.processNodeAsync(r);
+				e !== null && i.push(e);
+			}
+		}
+		i.length > 0 && (r.nodes = i), this.serializeUserData(e, r);
+	}
+	async processObjectsAsync(e) {
+		let t = new m();
+		t.name = "AuxScene";
+		for (let n = 0; n < e.length; n++) t.children.push(e[n]);
+		await this.processSceneAsync(t);
+	}
+	async processInputAsync(e) {
+		let t = this.options;
+		e = e instanceof Array ? e : [e], await this._invokeAllAsync(function(t) {
+			t.beforeParse && t.beforeParse(e);
+		});
+		let n = [];
+		for (let t = 0; t < e.length; t++) e[t] instanceof m ? await this.processSceneAsync(e[t]) : n.push(e[t]);
+		n.length > 0 && await this.processObjectsAsync(n);
+		for (let e = 0; e < this.skins.length; ++e) this.processSkin(this.skins[e]);
+		for (let n = 0; n < t.animations.length; ++n) this.processAnimation(t.animations[n], e[0]);
+		await this._invokeAllAsync(function(t) {
+			t.afterParse && t.afterParse(e);
+		});
+	}
+	async _invokeAllAsync(e) {
+		for (let t = 0, n = this.plugins.length; t < n; t++) await e(this.plugins[t]);
+	}
+}, U = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_lights_punctual";
+	}
+	writeNode(e, t) {
+		if (!e.isLight) return;
+		if (!e.isDirectionalLight && !e.isPointLight && !e.isSpotLight) {
+			console.warn("THREE.GLTFExporter: Only directional, point, and spot lights are supported.", e);
+			return;
+		}
+		let n = this.writer, r = n.json, i = n.extensionsUsed, a = {};
+		e.name && (a.name = e.name), a.color = e.color.toArray(), a.intensity = e.intensity, e.isDirectionalLight ? a.type = "directional" : e.isPointLight ? (a.type = "point", e.distance > 0 && (a.range = e.distance)) : e.isSpotLight && (a.type = "spot", e.distance > 0 && (a.range = e.distance), a.spot = {}, a.spot.innerConeAngle = (1 - e.penumbra) * e.angle, a.spot.outerConeAngle = e.angle), e.decay !== void 0 && e.decay !== 2 && console.warn("THREE.GLTFExporter: Light decay may be lost. glTF is physically-based, and expects light.decay=2."), e.target && (e.target.parent !== e || e.target.position.x !== 0 || e.target.position.y !== 0 || e.target.position.z !== -1) && console.warn("THREE.GLTFExporter: Light direction may be lost. For best results, make light.target a child of the light with position 0,0,-1."), i[this.name] || (r.extensions = r.extensions || {}, r.extensions[this.name] = { lights: [] }, i[this.name] = !0);
+		let o = r.extensions[this.name].lights;
+		o.push(a), t.extensions = t.extensions || {}, t.extensions[this.name] = { light: o.length - 1 };
+	}
+}, W = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_unlit";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshBasicMaterial) return;
+		let n = this.writer.extensionsUsed;
+		t.extensions = t.extensions || {}, t.extensions[this.name] = {}, n[this.name] = !0, t.pbrMetallicRoughness.metallicFactor = 0, t.pbrMetallicRoughness.roughnessFactor = .9;
+	}
+}, G = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_clearcoat";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.clearcoat === 0) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (i.clearcoatFactor = e.clearcoat, e.clearcoatMap) {
+			let t = {
+				index: await n.processTextureAsync(e.clearcoatMap),
+				texCoord: e.clearcoatMap.channel
+			};
+			n.applyTextureTransform(t, e.clearcoatMap), i.clearcoatTexture = t;
+		}
+		if (i.clearcoatRoughnessFactor = e.clearcoatRoughness, e.clearcoatRoughnessMap) {
+			let t = {
+				index: await n.processTextureAsync(e.clearcoatRoughnessMap),
+				texCoord: e.clearcoatRoughnessMap.channel
+			};
+			n.applyTextureTransform(t, e.clearcoatRoughnessMap), i.clearcoatRoughnessTexture = t;
+		}
+		if (e.clearcoatNormalMap) {
+			let t = {
+				index: await n.processTextureAsync(e.clearcoatNormalMap),
+				texCoord: e.clearcoatNormalMap.channel
+			};
+			e.clearcoatNormalScale.x !== 1 && (t.scale = e.clearcoatNormalScale.x), n.applyTextureTransform(t, e.clearcoatNormalMap), i.clearcoatNormalTexture = t;
+		}
+		t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, K = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_dispersion";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.dispersion === 0) return;
+		let n = this.writer.extensionsUsed, r = {};
+		r.dispersion = e.dispersion, t.extensions = t.extensions || {}, t.extensions[this.name] = r, n[this.name] = !0;
+	}
+}, q = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_iridescence";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.iridescence === 0) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (i.iridescenceFactor = e.iridescence, e.iridescenceMap) {
+			let t = {
+				index: await n.processTextureAsync(e.iridescenceMap),
+				texCoord: e.iridescenceMap.channel
+			};
+			n.applyTextureTransform(t, e.iridescenceMap), i.iridescenceTexture = t;
+		}
+		if (i.iridescenceIor = e.iridescenceIOR, i.iridescenceThicknessMinimum = e.iridescenceThicknessRange[0], i.iridescenceThicknessMaximum = e.iridescenceThicknessRange[1], e.iridescenceThicknessMap) {
+			let t = {
+				index: await n.processTextureAsync(e.iridescenceThicknessMap),
+				texCoord: e.iridescenceThicknessMap.channel
+			};
+			n.applyTextureTransform(t, e.iridescenceThicknessMap), i.iridescenceThicknessTexture = t;
+		}
+		t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, J = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_transmission";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.transmission === 0) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (i.transmissionFactor = e.transmission, e.transmissionMap) {
+			let t = {
+				index: await n.processTextureAsync(e.transmissionMap),
+				texCoord: e.transmissionMap.channel
+			};
+			n.applyTextureTransform(t, e.transmissionMap), i.transmissionTexture = t;
+		}
+		t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, Y = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_volume";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.transmission === 0) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (i.thicknessFactor = e.thickness, e.thicknessMap) {
+			let t = {
+				index: await n.processTextureAsync(e.thicknessMap),
+				texCoord: e.thicknessMap.channel
+			};
+			n.applyTextureTransform(t, e.thicknessMap), i.thicknessTexture = t;
+		}
+		e.attenuationDistance !== Infinity && (i.attenuationDistance = e.attenuationDistance), i.attenuationColor = e.attenuationColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, X = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_ior";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.ior === 1.5) return;
+		let n = this.writer.extensionsUsed, r = {};
+		r.ior = e.ior, t.extensions = t.extensions || {}, t.extensions[this.name] = r, n[this.name] = !0;
+	}
+}, Z = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_specular";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.specularIntensity === 1 && e.specularColor.equals(D) && !e.specularIntensityMap && !e.specularColorMap) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (e.specularIntensityMap) {
+			let t = {
+				index: await n.processTextureAsync(e.specularIntensityMap),
+				texCoord: e.specularIntensityMap.channel
+			};
+			n.applyTextureTransform(t, e.specularIntensityMap), i.specularTexture = t;
+		}
+		if (e.specularColorMap) {
+			let t = {
+				index: await n.processTextureAsync(e.specularColorMap),
+				texCoord: e.specularColorMap.channel
+			};
+			n.applyTextureTransform(t, e.specularColorMap), i.specularColorTexture = t;
+		}
+		i.specularFactor = e.specularIntensity, i.specularColorFactor = e.specularColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, Q = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_sheen";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.sheen == 0) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (e.sheenRoughnessMap) {
+			let t = {
+				index: await n.processTextureAsync(e.sheenRoughnessMap),
+				texCoord: e.sheenRoughnessMap.channel
+			};
+			n.applyTextureTransform(t, e.sheenRoughnessMap), i.sheenRoughnessTexture = t;
+		}
+		if (e.sheenColorMap) {
+			let t = {
+				index: await n.processTextureAsync(e.sheenColorMap),
+				texCoord: e.sheenColorMap.channel
+			};
+			n.applyTextureTransform(t, e.sheenColorMap), i.sheenColorTexture = t;
+		}
+		i.sheenRoughnessFactor = e.sheenRoughness, i.sheenColorFactor = e.sheenColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, $ = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_anisotropy";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshPhysicalMaterial || e.anisotropy == 0) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (e.anisotropyMap) {
+			let t = { index: await n.processTextureAsync(e.anisotropyMap) };
+			n.applyTextureTransform(t, e.anisotropyMap), i.anisotropyTexture = t;
+		}
+		i.anisotropyStrength = e.anisotropy, i.anisotropyRotation = e.anisotropyRotation, t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, ee = class {
+	constructor(e) {
+		this.writer = e, this.name = "KHR_materials_emissive_strength";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshStandardMaterial || e.emissiveIntensity === 1) return;
+		let n = this.writer.extensionsUsed, r = {};
+		r.emissiveStrength = e.emissiveIntensity, t.extensions = t.extensions || {}, t.extensions[this.name] = r, n[this.name] = !0;
+	}
+}, te = class {
+	constructor(e) {
+		this.writer = e, this.name = "EXT_materials_bump";
+	}
+	async writeMaterialAsync(e, t) {
+		if (!e.isMeshStandardMaterial || e.bumpScale === 1 && !e.bumpMap) return;
+		let n = this.writer, r = n.extensionsUsed, i = {};
+		if (e.bumpMap) {
+			let t = {
+				index: await n.processTextureAsync(e.bumpMap),
+				texCoord: e.bumpMap.channel
+			};
+			n.applyTextureTransform(t, e.bumpMap), i.bumpTexture = t;
+		}
+		i.bumpFactor = e.bumpScale, t.extensions = t.extensions || {}, t.extensions[this.name] = i, r[this.name] = !0;
+	}
+}, ne = class {
+	constructor(e) {
+		this.writer = e, this.name = "EXT_mesh_gpu_instancing";
+	}
+	writeNode(e, t) {
+		if (!e.isInstancedMesh) return;
+		let n = this.writer, r = e, i = new Float32Array(r.count * 3), a = new Float32Array(r.count * 4), o = new Float32Array(r.count * 3), l = new s(), u = new c(), d = new h(), p = new c();
+		for (let e = 0; e < r.count; e++) r.getMatrixAt(e, l), l.decompose(u, d, p), u.toArray(i, e * 3), d.toArray(a, e * 4), p.toArray(o, e * 3);
+		let m = {
+			TRANSLATION: n.processAccessor(new f(i, 3)),
+			ROTATION: n.processAccessor(new f(a, 4)),
+			SCALE: n.processAccessor(new f(o, 3))
+		};
+		r.instanceColor && (m._COLOR_0 = n.processAccessor(r.instanceColor)), t.extensions = t.extensions || {}, t.extensions[this.name] = { attributes: m }, n.extensionsUsed[this.name] = !0, n.extensionsRequired[this.name] = !0;
+	}
+};
+S.Utils = {
+	insertKeyframe: function(e, t) {
+		let n = .001, r = e.getValueSize(), i = new e.TimeBufferType(e.times.length + 1), a = new e.ValueBufferType(e.values.length + r), o = e.createInterpolant(new e.ValueBufferType(r)), s;
+		if (e.times.length === 0) {
+			i[0] = t;
+			for (let e = 0; e < r; e++) a[e] = 0;
+			s = 0;
+		} else if (t < e.times[0]) {
+			if (Math.abs(e.times[0] - t) < n) return 0;
+			i[0] = t, i.set(e.times, 1), a.set(o.evaluate(t), 0), a.set(e.values, r), s = 0;
+		} else if (t > e.times[e.times.length - 1]) {
+			if (Math.abs(e.times[e.times.length - 1] - t) < n) return e.times.length - 1;
+			i[i.length - 1] = t, i.set(e.times, 0), a.set(e.values, 0), a.set(o.evaluate(t), e.values.length), s = i.length - 1;
+		} else for (let c = 0; c < e.times.length; c++) {
+			if (Math.abs(e.times[c] - t) < n) return c;
+			if (e.times[c] < t && e.times[c + 1] > t) {
+				i.set(e.times.slice(0, c + 1), 0), i[c + 1] = t, i.set(e.times.slice(c + 1), c + 2), a.set(e.values.slice(0, (c + 1) * r), 0), a.set(o.evaluate(t), (c + 1) * r), a.set(e.values.slice((c + 1) * r), (c + 2) * r), s = c + 1;
+				break;
+			}
+		}
+		return e.times = i, e.values = a, s;
+	},
+	mergeMorphTargetTracks: function(e, t) {
+		let n = [], r = {}, i = e.tracks;
+		for (let e = 0; e < i.length; ++e) {
+			let a = i[e], o = d.parseTrackName(a.name), s = d.findNode(t, o.nodeName);
+			if (o.propertyName !== "morphTargetInfluences" || o.propertyIndex === void 0) {
+				n.push(a);
+				continue;
+			}
+			if (a.createInterpolant !== a.InterpolantFactoryMethodDiscrete && a.createInterpolant !== a.InterpolantFactoryMethodLinear) {
+				if (a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) throw Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
+				console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead."), a = a.clone(), a.setInterpolation(v);
+			}
+			let c = s.morphTargetInfluences.length, l = s.morphTargetDictionary[o.propertyIndex];
+			if (l === void 0) throw Error("THREE.GLTFExporter: Morph target name not found: " + o.propertyIndex);
+			let u;
+			if (r[s.uuid] === void 0) {
+				u = a.clone();
+				let e = new u.ValueBufferType(c * u.times.length);
+				for (let t = 0; t < u.times.length; t++) e[t * c + l] = u.values[t];
+				u.name = (o.nodeName || "") + ".morphTargetInfluences", u.values = e, r[s.uuid] = u, n.push(u);
+				continue;
+			}
+			let f = a.createInterpolant(new a.ValueBufferType(1));
+			u = r[s.uuid];
+			for (let e = 0; e < u.times.length; e++) u.values[e * c + l] = f.evaluate(u.times[e]);
+			for (let e = 0; e < a.times.length; e++) {
+				let t = this.insertKeyframe(u, a.times[e]);
+				u.values[t * c + l] = a.values[e];
+			}
+		}
+		return e.tracks = n, e;
+	},
+	toTypedBufferAttribute: function(e, t) {
+		let n = new f(new t(e.count * e.itemSize), e.itemSize, !1);
+		if (!e.normalized && !e.isInterleavedBufferAttribute) return n.array.set(e.array), n;
+		for (let t = 0, r = e.count; t < r; t++) for (let r = 0; r < e.itemSize; r++) n.setComponent(t, r, e.getComponent(t, r));
+		return n;
+	}
+};
+//#endregion
+export { S as GLTFExporter };
+
+//# sourceMappingURL=GLTFExporter-D8qsdwDK.mjs.map