babylonjs-tiaratumgames-tools 0.1.0 → 0.1.2

package/dist/EXT_lights_area-w-pVqNzA.js

@@ -0,0 +1,151 @@
+import { t as e } from "./logger-B7TbbsLc.js";
+import { n as t } from "./tools-hJEwvocd.js";
+import { n } from "./typeStore-CSjrT3Od.js";
+import { a as r, n as i } from "./math.vector-Bbyh9hc3.js";
+import { _ as a, i as o } from "./decorators-pjJPuQ9O.js";
+import { t as s } from "./math.color-HuJokdxD.js";
+import { i as c } from "./mesh-DOlqX9sH.js";
+import { t as l } from "./texture-5pV5xPGB.js";
+import { t as u } from "./node-BvfPvXnN.js";
+import { r as d, t as f } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import { t as p } from "./light-qglDZYT1.js";
+import { t as m } from "./rawTexture-BHm1xSpf.js";
+import { ArrayItem as h, GLTFLoader as g } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/core/Lights/LTC/ltcTextureTool.js
+async function _() {
+	let e = new Uint16Array(4096 * 4), n = new Uint16Array(4096 * 4), r = await t.LoadFileAsync(t.GetAssetUrl("https://assets.babylonjs.com/core/areaLights/areaLightsLTC.bin")), i = new Uint16Array(r), a = i.length / 8;
+	for (let t = 0; t < a; t++) e[t * 4] = i[t * 8], e[t * 4 + 1] = i[t * 8 + 1], e[t * 4 + 2] = i[t * 8 + 2], e[t * 4 + 3] = i[t * 8 + 3], n[t * 4] = i[t * 8 + 4], n[t * 4 + 1] = i[t * 8 + 5], n[t * 4 + 2] = i[t * 8 + 6], n[t * 4 + 3] = i[t * 8 + 7];
+	return [e, n];
+}
+//#endregion
+//#region node_modules/@babylonjs/core/Lights/areaLight.js
+function v(t) {
+	let n = t.useDelayedTextureLoading;
+	t.useDelayedTextureLoading = !1;
+	let r = t._blockEntityCollection;
+	t._blockEntityCollection = !1, t._ltcTextures = {
+		LTC1: m.CreateRGBATexture(null, 64, 64, t.getEngine(), !1, !1, 2, 2, 0, !1, !0),
+		LTC2: m.CreateRGBATexture(null, 64, 64, t.getEngine(), !1, !1, 2, 2, 0, !1, !0)
+	}, t._blockEntityCollection = r, t._ltcTextures.LTC1.wrapU = l.CLAMP_ADDRESSMODE, t._ltcTextures.LTC1.wrapV = l.CLAMP_ADDRESSMODE, t._ltcTextures.LTC2.wrapU = l.CLAMP_ADDRESSMODE, t._ltcTextures.LTC2.wrapV = l.CLAMP_ADDRESSMODE, t.useDelayedTextureLoading = n, _().then((e) => {
+		t._ltcTextures && ((t._ltcTextures?.LTC1).update(e[0]), (t._ltcTextures?.LTC2).update(e[1]), t.onDisposeObservable.addOnce(() => {
+			t._ltcTextures?.LTC1.dispose(), t._ltcTextures?.LTC2.dispose();
+		}));
+	}).catch((t) => {
+		e.Error(`Area Light fail to get LTC textures data. Error: ${t}`);
+	});
+}
+var y = class extends p {
+	constructor(e, t, n, r) {
+		super(e, n, r), this.position = t, this._scene._ltcTextures || v(this._scene);
+	}
+	transferTexturesToEffect(e, t) {
+		return this._scene._ltcTextures && (e.setTexture("areaLightsLTC1Sampler", this._scene._ltcTextures.LTC1), e.setTexture("areaLightsLTC2Sampler", this._scene._ltcTextures.LTC2)), this;
+	}
+	prepareLightSpecificDefines(e, t) {
+		e["AREALIGHT" + t] = !0, e.AREALIGHTUSED = !0;
+	}
+	_isReady() {
+		return this._scene._ltcTextures ? this._scene._ltcTextures.LTC1.isReady() && this._scene._ltcTextures.LTC2.isReady() : !1;
+	}
+};
+//#endregion
+//#region node_modules/@babylonjs/core/Lights/rectAreaLight.js
+u.AddNodeConstructor("Light_Type_4", (e, t) => () => new b(e, r.Zero(), 1, 1, t));
+var b = class e extends y {
+	get emissionTexture() {
+		return this._emissionTextureTexture;
+	}
+	set emissionTexture(t) {
+		this._emissionTextureTexture !== t && (this._emissionTextureTexture = t, this._emissionTextureTexture && (this._emissionTextureTexture.wrapU = 0, this._emissionTextureTexture.wrapV = 0), this._emissionTextureTexture && e._IsTexture(this._emissionTextureTexture) && this._emissionTextureTexture.onLoadObservable.addOnce(() => {
+			this._markMeshesAsLightDirty();
+		}));
+	}
+	get width() {
+		return this._width.x;
+	}
+	set width(e) {
+		this._width.x = e;
+	}
+	get height() {
+		return this._height.y;
+	}
+	set height(e) {
+		this._height.y = e;
+	}
+	constructor(e, t, n, i, a, o) {
+		super(e, t, a, o), this._emissionTextureTexture = null, this._width = new r(n, 0, 0), this._height = new r(0, i, 0), this._pointTransformedPosition = r.Zero(), this._pointTransformedWidth = r.Zero(), this._pointTransformedHeight = r.Zero();
+	}
+	getClassName() {
+		return "RectAreaLight";
+	}
+	getTypeID() {
+		return p.LIGHTTYPEID_RECT_AREALIGHT;
+	}
+	_buildUniformLayout() {
+		this._uniformBuffer.addUniform("vLightData", 4), this._uniformBuffer.addUniform("vLightDiffuse", 4), this._uniformBuffer.addUniform("vLightSpecular", 4), this._uniformBuffer.addUniform("vLightWidth", 4), this._uniformBuffer.addUniform("vLightHeight", 4), this._uniformBuffer.addUniform("shadowsInfo", 3), this._uniformBuffer.addUniform("depthValues", 2), this._uniformBuffer.create();
+	}
+	_computeTransformedInformation() {
+		return this.parent && this.parent.getWorldMatrix ? (r.TransformCoordinatesToRef(this.position, this.parent.getWorldMatrix(), this._pointTransformedPosition), r.TransformNormalToRef(this._width, this.parent.getWorldMatrix(), this._pointTransformedWidth), r.TransformNormalToRef(this._height, this.parent.getWorldMatrix(), this._pointTransformedHeight), !0) : !1;
+	}
+	static _IsTexture(e) {
+		return e.onLoadObservable !== void 0;
+	}
+	transferToEffect(e, t) {
+		let n = this._scene.floatingOriginOffset;
+		return this._computeTransformedInformation() ? (this._uniformBuffer.updateFloat4("vLightData", this._pointTransformedPosition.x - n.x, this._pointTransformedPosition.y - n.y, this._pointTransformedPosition.z - n.z, 0, t), this._uniformBuffer.updateFloat4("vLightWidth", this._pointTransformedWidth.x / 2, this._pointTransformedWidth.y / 2, this._pointTransformedWidth.z / 2, 0, t), this._uniformBuffer.updateFloat4("vLightHeight", this._pointTransformedHeight.x / 2, this._pointTransformedHeight.y / 2, this._pointTransformedHeight.z / 2, 0, t)) : (this._uniformBuffer.updateFloat4("vLightData", this.position.x - n.x, this.position.y - n.y, this.position.z - n.z, 0, t), this._uniformBuffer.updateFloat4("vLightWidth", this._width.x / 2, this._width.y / 2, this._width.z / 2, 0, t), this._uniformBuffer.updateFloat4("vLightHeight", this._height.x / 2, this._height.y / 2, this._height.z / 2, 0, t)), this;
+	}
+	transferTexturesToEffect(e, t) {
+		return super.transferTexturesToEffect(e, t), this._emissionTextureTexture && this._emissionTextureTexture.isReady() && e.setTexture("rectAreaLightEmissionTexture" + t, this._emissionTextureTexture), this;
+	}
+	transferToNodeMaterialEffect(e, t) {
+		let n = this._scene.floatingOriginOffset;
+		return this._computeTransformedInformation() ? e.setFloat3(t, this._pointTransformedPosition.x - n.x, this._pointTransformedPosition.y - n.y, this._pointTransformedPosition.z - n.z) : e.setFloat3(t, this.position.x - n.x, this.position.y - n.y, this.position.z - n.z), this;
+	}
+	prepareLightSpecificDefines(e, t) {
+		super.prepareLightSpecificDefines(e, t), e["RECTAREALIGHTEMISSIONTEXTURE" + t] = !!(this._emissionTextureTexture && this._emissionTextureTexture.isReady());
+	}
+};
+a([o()], b.prototype, "width", null), a([o()], b.prototype, "height", null), n("BABYLON.RectAreaLight", b);
+//#endregion
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_area.js
+var x = "EXT_lights_area", S = class {
+	constructor(e) {
+		this.name = x, this._loader = e, this.enabled = this._loader.isExtensionUsed(x);
+	}
+	dispose() {
+		this._loader = null, delete this._lights;
+	}
+	onLoading() {
+		let e = this._loader.gltf.extensions;
+		if (e && e[this.name]) {
+			let t = e[this.name];
+			this._lights = t.lights, h.Assign(this._lights);
+		}
+	}
+	loadNodeAsync(e, t, n) {
+		return g.LoadExtensionAsync(e, t, this.name, async (a, o) => (this._loader._allMaterialsDirtyRequired = !0, await this._loader.loadNodeAsync(e, t, (e) => {
+			let t, l = h.Get(a, this._lights, o.light), u = l.name || e.name;
+			this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;
+			let d = l.size === void 0 ? 1 : l.size;
+			switch (l.type) {
+				case "rect": {
+					let e = l.rect?.aspect === void 0 ? d : l.rect.aspect * d, n = d;
+					t = new b(u, r.Zero(), e, n, this._loader.babylonScene);
+					break;
+				}
+				case "disk": {
+					let e = Math.sqrt(d * d * .25 * Math.PI);
+					t = new b(u, r.Zero(), e, e, this._loader.babylonScene);
+					break;
+				}
+				default: throw this._loader.babylonScene._blockEntityCollection = !1, Error(`${a}: Invalid area light type (${l.type})`);
+			}
+			t._parentContainer = this._loader._assetContainer, this._loader.babylonScene._blockEntityCollection = !1, l._babylonLight = t, t.falloffType = p.FALLOFF_GLTF, t.diffuse = l.color ? s.FromArray(l.color) : s.White(), t.intensity = l.intensity == null ? 1 : l.intensity;
+			let f = new c(`${u}_orientation`, this._loader.babylonScene);
+			f.rotationQuaternion = i.RotationAxis(r.Up(), Math.PI), f.parent = e, t.parent = f, this._loader._babylonLights.push(t), g.AddPointerMetadata(t, a), n(e);
+		})));
+	}
+};
+d(x), f(x, !0, (e) => new S(e));
+//#endregion
+export { S as EXT_lights_area };

package/dist/EXT_lights_ies-D30aOyIZ.js

@@ -0,0 +1,42 @@
+import { a as e } from "./math.vector-Bbyh9hc3.js";
+import { t } from "./math.color-HuJokdxD.js";
+import { t as n } from "./texture-5pV5xPGB.js";
+import { r, t as i } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import { t as a } from "./light-qglDZYT1.js";
+import { a as o } from "./objectModelMapping-BgQ-ovIk.js";
+import { ArrayItem as s, GLTFLoader as c } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_ies.js
+var l = "EXT_lights_ies", u = class {
+	constructor(e) {
+		this.name = l, this._loader = e, this.enabled = this._loader.isExtensionUsed(l);
+	}
+	dispose() {
+		this._loader = null, delete this._lights;
+	}
+	onLoading() {
+		let e = this._loader.gltf.extensions;
+		if (e && e[this.name]) {
+			let t = e[this.name];
+			this._lights = t.lights, s.Assign(this._lights);
+		}
+	}
+	loadNodeAsync(r, i, l) {
+		return c.LoadExtensionAsync(r, i, this.name, async (u, d) => {
+			this._loader._allMaterialsDirtyRequired = !0;
+			let f, p, m = await this._loader.loadNodeAsync(r, i, (n) => {
+				p = s.Get(u, this._lights, d.light);
+				let r = p.name || n.name;
+				this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer, f = new o(r, e.Zero(), e.Backward(), 0, 1, this._loader.babylonScene), f.angle = Math.PI / 2, f.innerAngle = 0, f._parentContainer = this._loader._assetContainer, this._loader.babylonScene._blockEntityCollection = !1, p._babylonLight = f, f.falloffType = a.FALLOFF_GLTF, f.diffuse = d.color ? t.FromArray(d.color) : t.White(), f.intensity = d.multiplier || 1, f.range = Number.MAX_VALUE, f.parent = n, this._loader._babylonLights.push(f), c.AddPointerMetadata(f, u), l(n);
+			}), h;
+			if (p.uri) h = await this._loader.loadUriAsync(r, p, p.uri);
+			else {
+				let e = s.Get(`${r}/bufferView`, this._loader.gltf.bufferViews, p.bufferView);
+				h = await this._loader.loadBufferViewAsync(`/bufferViews/${e.index}`, e);
+			}
+			return f.iesProfileTexture = new n(name + "_iesProfile", this._loader.babylonScene, !0, !1, void 0, null, null, h, !0, void 0, void 0, void 0, void 0, ".ies"), m;
+		});
+	}
+};
+r(l), i(l, !0, (e) => new u(e));
+//#endregion
+export { u as EXT_lights_ies };

package/dist/EXT_lights_image_based-Bal4Y1IU.js

@@ -0,0 +1,197 @@
+import { t as e } from "./observable-CfpCDzrN.js";
+import { n as t } from "./tools-hJEwvocd.js";
+import { n, t as r } from "./typeStore-CSjrT3Od.js";
+import { n as i } from "./math.size-C4V1YqcV.js";
+import { a, n as o, r as s, t as c } from "./math.vector-Bbyh9hc3.js";
+import { _ as l, h as u, i as d, u as f } from "./decorators-pjJPuQ9O.js";
+import { r as p, t as m } from "./texture-5pV5xPGB.js";
+import { n as h, t as g } from "./sphericalPolynomial-DcDQFxce.js";
+import { r as _, t as v } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import "./abstractEngine.cubeTexture-D6ftbd2l.js";
+import { i as y } from "./environmentTextureTools-DiBrdx38.js";
+import { ArrayItem as b, GLTFLoader as x } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/core/Materials/Textures/cubeTexture.js
+var S = .8, C = class n extends p {
+	set boundingBoxSize(e) {
+		if (this._boundingBoxSize && this._boundingBoxSize.equals(e)) return;
+		this._boundingBoxSize = e;
+		let t = this.getScene();
+		t && t.markAllMaterialsAsDirty(1);
+	}
+	get boundingBoxSize() {
+		return this._boundingBoxSize;
+	}
+	set rotationY(e) {
+		this._rotationY = e, this.setReflectionTextureMatrix(c.RotationY(this._rotationY));
+	}
+	get rotationY() {
+		return this._rotationY;
+	}
+	get noMipmap() {
+		return this._noMipmap;
+	}
+	get forcedExtension() {
+		return this._forcedExtension;
+	}
+	static CreateFromImages(e, t, r) {
+		let i = "";
+		for (let t of e) i += t;
+		return new n(i, t, null, r, e);
+	}
+	static CreateFromPrefilteredData(e, t, r = null, i = !0) {
+		let a = t.useDelayedTextureLoading;
+		t.useDelayedTextureLoading = !1;
+		let o = new n(e, t, null, !1, null, null, null, void 0, !0, r, i);
+		return t.useDelayedTextureLoading = a, o;
+	}
+	constructor(t, n, r = null, i = !1, o = null, s = null, l = null, u = 5, d = !1, f = null, p = !1, h = S, g = 0, _, v) {
+		super(n), this.onLoadObservable = new e(), this.boundingBoxPosition = a.Zero(), this._rotationY = 0, this._files = null, this._forcedExtension = null, this._extensions = null, this._textureMatrixRefraction = new c(), this._buffer = null, this.name = t, this.url = t, this._noMipmap = i, this.hasAlpha = !1, this.isCube = !0, this._textureMatrix = c.Identity(), this.coordinatesMode = m.CUBIC_MODE;
+		let y, b = null;
+		r !== null && !Array.isArray(r) ? (y = r.extensions ?? null, this._noMipmap = r.noMipmap ?? !1, o = r.files ?? null, b = r.buffer ?? null, this._format = r.format ?? 5, d = r.prefiltered ?? !1, f = r.forcedExtension ?? null, this._createPolynomials = r.createPolynomials ?? !1, this._lodScale = r.lodScale ?? S, this._lodOffset = r.lodOffset ?? 0, this._loaderOptions = r.loaderOptions, this._useSRGBBuffer = r.useSRGBBuffer, this._sphericalPolynomialTargetSize = r.sphericalPolynomialTargetSize ?? 0, s = r.onLoad ?? null, l = r.onError ?? null) : (this._noMipmap = i, this._format = u, this._createPolynomials = p, y = r, this._loaderOptions = _, this._useSRGBBuffer = v, this._lodScale = h, this._lodOffset = g), !(!t && !o) && this.updateURL(t, f, s, d, l, y, this.getScene()?.useDelayedTextureLoading, o, b);
+	}
+	getClassName() {
+		return "CubeTexture";
+	}
+	updateURL(e, t = null, n = null, r = !1, i = null, a = null, o = !1, s = null, c = null) {
+		(!this.name || this.name.startsWith("data:")) && (this.name = e), this.url = e, t && (this._forcedExtension = t);
+		let l = e.lastIndexOf("."), u = t || (l > -1 ? e.substring(l).toLowerCase() : ""), d = u.indexOf(".dds") === 0, f = u.indexOf(".env") === 0, p = u.indexOf(".basis") === 0;
+		if (f ? (this.gammaSpace = !1, this._prefiltered = !1, this.anisotropicFilteringLevel = 1) : (this._prefiltered = r, r && (this.gammaSpace = !1, this.anisotropicFilteringLevel = 1)), s) this._files = s;
+		else if (!p && !f && !d && !a && (a = [
+			"_px.jpg",
+			"_py.jpg",
+			"_pz.jpg",
+			"_nx.jpg",
+			"_ny.jpg",
+			"_nz.jpg"
+		]), this._files = this._files || [], this._files.length = 0, a) {
+			for (let t = 0; t < a.length; t++) this._files.push(e + a[t]);
+			this._extensions = a;
+		}
+		this._buffer = c, o ? (this.delayLoadState = 4, this._delayedOnLoad = n, this._delayedOnError = i) : this._loadTexture(n, i);
+	}
+	delayLoad(e) {
+		this.delayLoadState === 4 && (e && (this._forcedExtension = e), this.delayLoadState = 1, this._loadTexture(this._delayedOnLoad, this._delayedOnError));
+	}
+	getReflectionTextureMatrix() {
+		return this._textureMatrix;
+	}
+	setReflectionTextureMatrix(e) {
+		if (e.updateFlag === this._textureMatrix.updateFlag || (e.isIdentity() !== this._textureMatrix.isIdentity() && this.getScene()?.markAllMaterialsAsDirty(1, (e) => e.getActiveTextures().indexOf(this) !== -1), this._textureMatrix = e, !this.getScene()?.useRightHandedSystem)) return;
+		let t = s.Vector3[0], n = s.Quaternion[0], r = s.Vector3[1];
+		this._textureMatrix.decompose(t, n, r), n.z *= -1, n.w *= -1, c.ComposeToRef(t, n, r, this._textureMatrixRefraction);
+	}
+	getRefractionTextureMatrix() {
+		return this.getScene()?.useRightHandedSystem ? this._textureMatrixRefraction : this._textureMatrix;
+	}
+	_loadTexture(e = null, n = null) {
+		let r = this.getScene(), i = this._texture;
+		this._texture = this._getFromCache(this.url, this._noMipmap, void 0, void 0, this._useSRGBBuffer, this.isCube);
+		let a = () => {
+			this.onLoadObservable.notifyObservers(this), i && (i.dispose(), this.getScene()?.markAllMaterialsAsDirty(1)), e && e();
+		}, o = (e, t) => {
+			this._loadingError = !0, this._errorObject = {
+				message: e,
+				exception: t
+			}, n && n(e, t), m.OnTextureLoadErrorObservable.notifyObservers(this);
+		};
+		this._texture ? this._texture.isReady ? t.SetImmediate(() => a()) : this._texture.onLoadedObservable.add(() => a()) : (this._prefiltered ? this._texture = this._getEngine().createPrefilteredCubeTexture(this.url, r, this._lodScale, this._lodOffset, e, o, this._format, this._forcedExtension, this._createPolynomials) : this._texture = this._getEngine().createCubeTexture(this.url, r, this._files, this._noMipmap, e, o, this._format, this._forcedExtension, !1, this._lodScale, this._lodOffset, null, this._loaderOptions, !!this._useSRGBBuffer, this._buffer), this._texture?.onLoadedObservable.add(() => this.onLoadObservable.notifyObservers(this)));
+	}
+	static Parse(e, t, o) {
+		let s = i.Parse(() => {
+			let r = !1;
+			return e.prefiltered && (r = e.prefiltered), new n(o + (e.url ?? e.name), t, e.extensions, !1, e.files || null, null, null, void 0, r, e.forcedExtension);
+		}, e, t);
+		if (e.boundingBoxPosition && (s.boundingBoxPosition = a.FromArray(e.boundingBoxPosition)), e.boundingBoxSize && (s.boundingBoxSize = a.FromArray(e.boundingBoxSize)), e.animations) for (let t = 0; t < e.animations.length; t++) {
+			let n = e.animations[t], i = r("BABYLON.Animation");
+			i && s.animations.push(i.Parse(n));
+		}
+		return s;
+	}
+	clone() {
+		let e = 0, t = this.irradianceTexture, r = i.Clone(() => {
+			let t = new n(this.url, this.getScene() || this._getEngine(), this._extensions, this._noMipmap, this._files);
+			return e = t.uniqueId, t;
+		}, this);
+		return r.uniqueId = e, t && !this.irradianceTexture && (this.irradianceTexture = t), r;
+	}
+};
+l([d()], C.prototype, "url", void 0), l([u()], C.prototype, "boundingBoxPosition", void 0), l([u()], C.prototype, "boundingBoxSize", null), l([d("rotationY")], C.prototype, "rotationY", null), l([d("files")], C.prototype, "_files", void 0), l([d("forcedExtension")], C.prototype, "_forcedExtension", void 0), l([d("extensions")], C.prototype, "_extensions", void 0), l([f("textureMatrix")], C.prototype, "_textureMatrix", void 0), l([f("textureMatrixRefraction")], C.prototype, "_textureMatrixRefraction", void 0), m._CubeTextureParser = C.Parse, n("BABYLON.CubeTexture", C);
+//#endregion
+//#region node_modules/@babylonjs/core/Materials/Textures/rawCubeTexture.js
+var w = class e extends C {
+	constructor(e, t, n, r = 5, i = 0, a = !1, o = !1, s = 3, c = null) {
+		super("", e), this._texture = e.getEngine().createRawCubeTexture(t, n, r, i, a, o, s, c);
+	}
+	update(e, t, n, r, i = null) {
+		this._texture.getEngine().updateRawCubeTexture(this._texture, e, t, n, r, i);
+	}
+	updateRGBDAsync(e, t = null, n = .8, r = 0) {
+		return y(this._texture, e, t, n, r).then(() => {});
+	}
+	clone() {
+		return i.Clone(() => {
+			let t = this.getScene(), n = this._texture, r = new e(t, n._bufferViewArray, n.width, n.format, n.type, n.generateMipMaps, n.invertY, n.samplingMode, n._compression);
+			return n.source === 13 && r.updateRGBDAsync(n._bufferViewArrayArray, n._sphericalPolynomial, n._lodGenerationScale, n._lodGenerationOffset), r;
+		}, this);
+	}
+}, T = "EXT_lights_image_based", E = class {
+	constructor(e) {
+		this.name = T, this._loader = e, this.enabled = this._loader.isExtensionUsed(T);
+	}
+	dispose() {
+		this._loader = null, delete this._lights;
+	}
+	onLoading() {
+		let e = this._loader.gltf.extensions;
+		if (e && e[this.name]) {
+			let t = e[this.name];
+			this._lights = t.lights;
+		}
+	}
+	loadSceneAsync(e, t) {
+		return x.LoadExtensionAsync(e, t, this.name, async (n, r) => {
+			this._loader._allMaterialsDirtyRequired = !0;
+			let i = [];
+			i.push(this._loader.loadSceneAsync(e, t)), this._loader.logOpen(`${n}`);
+			let a = b.Get(`${n}/light`, this._lights, r.light);
+			return i.push(this._loadLightAsync(`/extensions/${this.name}/lights/${r.light}`, a).then((e) => {
+				this._loader.babylonScene.environmentTexture = e;
+			})), this._loader.logClose(), await Promise.all(i).then(() => {});
+		});
+	}
+	_loadLightAsync(e, t) {
+		if (!t._loaded) {
+			let n = [];
+			this._loader.logOpen(`${e}`);
+			let r = Array(t.specularImages.length);
+			for (let i = 0; i < t.specularImages.length; i++) {
+				let a = t.specularImages[i];
+				r[i] = Array(a.length);
+				for (let t = 0; t < a.length; t++) {
+					let o = `${e}/specularImages/${i}/${t}`;
+					this._loader.logOpen(`${o}`);
+					let s = a[t], c = b.Get(o, this._loader.gltf.images, s);
+					n.push(this._loader.loadImageAsync(`/images/${s}`, c).then((e) => {
+						r[i][t] = e;
+					})), this._loader.logClose();
+				}
+			}
+			this._loader.logClose(), t._loaded = Promise.all(n).then(async () => {
+				let n = new w(this._loader.babylonScene, null, t.specularImageSize);
+				if (n.name = t.name || "environment", t._babylonTexture = n, t.intensity != null && (n.level = t.intensity), t.rotation) {
+					let e = o.FromArray(t.rotation);
+					this._loader.babylonScene.useRightHandedSystem || (e = o.Inverse(e)), c.FromQuaternionToRef(e, n.getReflectionTextureMatrix());
+				}
+				if (!t.irradianceCoefficients) throw Error(`${e}: Irradiance coefficients are missing`);
+				let i = g.FromArray(t.irradianceCoefficients);
+				i.scaleInPlace(t.intensity), i.convertIrradianceToLambertianRadiance();
+				let a = h.FromHarmonics(i), s = (r.length - 1) / Math.log2(t.specularImageSize);
+				return await n.updateRGBDAsync(r, a, s);
+			});
+		}
+		return t._loaded.then(() => t._babylonTexture);
+	}
+};
+_(T), v(T, !0, (e) => new E(e));
+//#endregion
+export { E as EXT_lights_image_based };

package/dist/EXT_mesh_gpu_instancing-DPkp8Oj5.js

@@ -0,0 +1,40 @@
+import { t as e } from "./logger-B7TbbsLc.js";
+import { a as t, n, r, t as i } from "./math.vector-Bbyh9hc3.js";
+import { r as a, t as o } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import "./thinInstanceMesh-VaMp8Yyd.js";
+import { ArrayItem as s, GLTFLoader as c } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.js
+var l = "EXT_mesh_gpu_instancing", u = class {
+	constructor(e) {
+		this.name = l, this._loader = e, this.enabled = this._loader.isExtensionUsed(l);
+	}
+	dispose() {
+		this._loader = null;
+	}
+	loadNodeAsync(a, o, l) {
+		return c.LoadExtensionAsync(a, o, this.name, async (a, c) => {
+			this._loader._disableInstancedMesh++;
+			let u = this._loader.loadNodeAsync(`/nodes/${o.index}`, o, l);
+			if (this._loader._disableInstancedMesh--, !o._primitiveBabylonMeshes) return await u;
+			let d = [], f = 0, p = (e) => {
+				if (c.attributes[e] == null) {
+					d.push(Promise.resolve(null));
+					return;
+				}
+				let t = s.Get(`${a}/attributes/${e}`, this._loader.gltf.accessors, c.attributes[e]);
+				if (d.push(this._loader._loadFloatAccessorAsync(`/accessors/${t.bufferView}`, t)), f === 0) f = t.count;
+				else if (f !== t.count) throw Error(`${a}/attributes: Instance buffer accessors do not have the same count.`);
+			};
+			return p("TRANSLATION"), p("ROTATION"), p("SCALE"), p("_COLOR_0"), await u.then(async (a) => {
+				let [s, c, l, u] = await Promise.all(d), p = new Float32Array(f * 16);
+				r.Vector3[0].copyFromFloats(0, 0, 0), r.Quaternion[0].copyFromFloats(0, 0, 0, 1), r.Vector3[1].copyFromFloats(1, 1, 1);
+				for (let e = 0; e < f; ++e) s && t.FromArrayToRef(s, e * 3, r.Vector3[0]), c && n.FromArrayToRef(c, e * 4, r.Quaternion[0]), l && t.FromArrayToRef(l, e * 3, r.Vector3[1]), i.ComposeToRef(r.Vector3[1], r.Quaternion[0], r.Vector3[0], r.Matrix[0]), r.Matrix[0].copyToArray(p, e * 16);
+				for (let t of o._primitiveBabylonMeshes) t.thinInstanceSetBuffer("matrix", p, 16, !0), u && (u.length === f * 3 ? t.thinInstanceSetBuffer("color", u, 3, !0) : u.length === f * 4 ? t.thinInstanceSetBuffer("color", u, 4, !0) : e.Warn("Unexpected size of _COLOR_0 attribute for mesh " + t.name));
+				return a;
+			});
+		});
+	}
+};
+a(l), o(l, !0, (e) => new u(e));
+//#endregion
+export { u as EXT_mesh_gpu_instancing };

package/dist/EXT_meshopt_compression-Bj-t4gTc.js

@@ -0,0 +1,45 @@
+import { n as e } from "./tools-hJEwvocd.js";
+import { r as t, t as n } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import { ArrayItem as r, GLTFLoader as i } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/core/Meshes/Compression/meshoptCompression.js
+var a = 0, o = null, s = class t {
+	static get Default() {
+		return t._Default ||= new t(), t._Default;
+	}
+	constructor() {
+		let n = t.Configuration.decoder;
+		this._decoderModulePromise = e.LoadBabylonScriptAsync(n.url).then(() => MeshoptDecoder.ready);
+	}
+	dispose() {
+		delete this._decoderModulePromise;
+	}
+	async decodeGltfBufferAsync(e, t, n, r, i) {
+		await this._decoderModulePromise, a === 0 && (MeshoptDecoder.useWorkers(1), a = 1);
+		let s = await MeshoptDecoder.decodeGltfBufferAsync(t, n, e, r, i);
+		return o !== null && clearTimeout(o), o = setTimeout(() => {
+			MeshoptDecoder.useWorkers(0), a = 0, o = null;
+		}, 1e3), s;
+	}
+};
+s.Configuration = { decoder: { url: `${e._DefaultCdnUrl}/meshopt_decoder.js` } }, s._Default = null;
+//#endregion
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_meshopt_compression.js
+var c = "EXT_meshopt_compression", l = class {
+	constructor(e) {
+		this.name = c, this.enabled = e.isExtensionUsed(c), this._loader = e;
+	}
+	dispose() {
+		this._loader = null;
+	}
+	loadBufferViewAsync(e, t) {
+		return i.LoadExtensionAsync(e, t, this.name, async (n, i) => {
+			let a = t;
+			if (a._meshOptData) return await a._meshOptData;
+			let o = r.Get(`${e}/buffer`, this._loader.gltf.buffers, i.buffer);
+			return a._meshOptData = this._loader.loadBufferAsync(`/buffers/${o.index}`, o, i.byteOffset || 0, i.byteLength).then(async (e) => await s.Default.decodeGltfBufferAsync(e, i.count, i.byteStride, i.mode, i.filter)), await a._meshOptData;
+		});
+	}
+};
+t(c), n(c, !0, (e) => new l(e));
+//#endregion
+export { l as EXT_meshopt_compression };

package/dist/EXT_texture_avif-CUC_Ekel.js

@@ -0,0 +1,22 @@
+import { r as e, t } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import { ArrayItem as n, GLTFLoader as r } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_texture_avif.js
+var i = "EXT_texture_avif", a = class {
+	constructor(e) {
+		this.name = i, this._loader = e, this.enabled = e.isExtensionUsed(i);
+	}
+	dispose() {
+		this._loader = null;
+	}
+	_loadTextureAsync(e, t, i) {
+		return r.LoadExtensionAsync(e, t, this.name, async (a, o) => {
+			let s = t.sampler == null ? r.DefaultSampler : n.Get(`${e}/sampler`, this._loader.gltf.samplers, t.sampler), c = n.Get(`${a}/source`, this._loader.gltf.images, o.source);
+			return await this._loader._createTextureAsync(e, s, c, (e) => {
+				i(e);
+			}, void 0, !t._textureInfo.nonColorData);
+		});
+	}
+};
+e(i), t(i, !0, (e) => new a(e));
+//#endregion
+export { a as EXT_texture_avif };

package/dist/EXT_texture_webp-CF94Nge8.js

@@ -0,0 +1,22 @@
+import { r as e, t } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+import { ArrayItem as n, GLTFLoader as r } from "./glTFLoader-DBsVDPMF.js";
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_texture_webp.js
+var i = "EXT_texture_webp", a = class {
+	constructor(e) {
+		this.name = i, this._loader = e, this.enabled = e.isExtensionUsed(i);
+	}
+	dispose() {
+		this._loader = null;
+	}
+	_loadTextureAsync(e, t, i) {
+		return r.LoadExtensionAsync(e, t, this.name, async (a, o) => {
+			let s = t.sampler == null ? r.DefaultSampler : n.Get(`${e}/sampler`, this._loader.gltf.samplers, t.sampler), c = n.Get(`${a}/source`, this._loader.gltf.images, o.source);
+			return await this._loader._createTextureAsync(e, s, c, (e) => {
+				i(e);
+			}, void 0, !t._textureInfo.nonColorData);
+		});
+	}
+};
+e(i), t(i, !0, (e) => new a(e));
+//#endregion
+export { a as EXT_texture_webp };

package/dist/ExtrasAsMetadata-Dap4z-J4.js

@@ -0,0 +1,36 @@
+import { r as e, t } from "./glTFLoaderExtensionRegistry-BrcdADCj.js";
+//#region node_modules/@babylonjs/loaders/glTF/2.0/Extensions/ExtrasAsMetadata.js
+var n = "ExtrasAsMetadata", r = class {
+	_assignExtras(e, t) {
+		if (t.extras && Object.keys(t.extras).length > 0) {
+			let n = e.metadata = e.metadata || {}, r = n.gltf = n.gltf || {};
+			r.extras = t.extras;
+		}
+	}
+	constructor(e) {
+		this.name = n, this.enabled = !0, this._loader = e;
+	}
+	dispose() {
+		this._loader = null;
+	}
+	loadNodeAsync(e, t, n) {
+		return this._loader.loadNodeAsync(e, t, (e) => {
+			this._assignExtras(e, t), n(e);
+		});
+	}
+	loadCameraAsync(e, t, n) {
+		return this._loader.loadCameraAsync(e, t, (e) => {
+			this._assignExtras(e, t), n(e);
+		});
+	}
+	createMaterial(e, t, n) {
+		let r = this._loader.createMaterial(e, t, n);
+		return this._assignExtras(r, t), r;
+	}
+	loadAnimationAsync(e, t) {
+		return this._loader.loadAnimationAsync(e, t).then((e) => (this._assignExtras(e, t), e));
+	}
+};
+e(n), t(n, !1, (e) => new r(e));
+//#endregion
+export { r as ExtrasAsMetadata };