@graphty/graphty-element 1.0.1

package/dist/instancesVertex-BrWNnWxF.js

@@ -0,0 +1,46 @@
+import { S as e } from "./index-ChGTkj2q.js";
+const d = "instancesDeclaration", r = `#ifdef INSTANCES
+attribute vec4 world0;attribute vec4 world1;attribute vec4 world2;attribute vec4 world3;
+#ifdef INSTANCESCOLOR
+attribute vec4 instanceColor;
+#endif
+#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)
+uniform mat4 world;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+attribute vec4 previousWorld0;attribute vec4 previousWorld1;attribute vec4 previousWorld2;attribute vec4 previousWorld3;
+#ifdef THIN_INSTANCES
+uniform mat4 previousWorld;
+#endif
+#endif
+#else
+#if !defined(WORLD_UBO)
+uniform mat4 world;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+uniform mat4 previousWorld;
+#endif
+#endif
+`;
+e.IncludesShadersStore[d] || (e.IncludesShadersStore[d] = r);
+const i = "instancesVertex", f = `#ifdef INSTANCES
+mat4 finalWorld=mat4(world0,world1,world2,world3);
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+mat4 finalPreviousWorld=mat4(previousWorld0,previousWorld1,
+previousWorld2,previousWorld3);
+#endif
+#ifdef THIN_INSTANCES
+finalWorld=world*finalWorld;
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+finalPreviousWorld=previousWorld*finalPreviousWorld;
+#endif
+#endif
+#else
+mat4 finalWorld=world;
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+mat4 finalPreviousWorld=previousWorld;
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] || (e.IncludesShadersStore[i] = f);
+//# sourceMappingURL=instancesVertex-BrWNnWxF.js.map

package/dist/instancesVertex-BrWNnWxF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instancesVertex-BrWNnWxF.js","sources":["../node_modules/@babylonjs/core/Shaders/ShadersInclude/instancesDeclaration.js","../node_modules/@babylonjs/core/Shaders/ShadersInclude/instancesVertex.js"],"sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"instancesDeclaration\";\nconst shader = `#ifdef INSTANCES\nattribute vec4 world0;attribute vec4 world1;attribute vec4 world2;attribute vec4 world3;\n#ifdef INSTANCESCOLOR\nattribute vec4 instanceColor;\n#endif\n#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)\nuniform mat4 world;\n#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nattribute vec4 previousWorld0;attribute vec4 previousWorld1;attribute vec4 previousWorld2;attribute vec4 previousWorld3;\n#ifdef THIN_INSTANCES\nuniform mat4 previousWorld;\n#endif\n#endif\n#else\n#if !defined(WORLD_UBO)\nuniform mat4 world;\n#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nuniform mat4 previousWorld;\n#endif\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStore[name]) {\n    ShaderStore.IncludesShadersStore[name] = shader;\n}\n/** @internal */\nexport const instancesDeclaration = { name, shader };\n//# sourceMappingURL=instancesDeclaration.js.map","// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"instancesVertex\";\nconst shader = `#ifdef INSTANCES\nmat4 finalWorld=mat4(world0,world1,world2,world3);\n#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nmat4 finalPreviousWorld=mat4(previousWorld0,previousWorld1,\npreviousWorld2,previousWorld3);\n#endif\n#ifdef THIN_INSTANCES\nfinalWorld=world*finalWorld;\n#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nfinalPreviousWorld=previousWorld*finalPreviousWorld;\n#endif\n#endif\n#else\nmat4 finalWorld=world;\n#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nmat4 finalPreviousWorld=previousWorld;\n#endif\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStore[name]) {\n    ShaderStore.IncludesShadersStore[name] = shader;\n}\n/** @internal */\nexport const instancesVertex = { name, shader };\n//# sourceMappingURL=instancesVertex.js.map"],"names":["name","shader","ShaderStore"],"mappings":";AAEA,MAAMA,IAAO,wBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBVC,EAAY,qBAAqBF,CAAI,MACtCE,EAAY,qBAAqBF,CAAI,IAAIC;AC1B7C,MAAMD,IAAO,mBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBVC,EAAY,qBAAqBF,CAAI,MACtCE,EAAY,qBAAqBF,CAAI,IAAIC;","x_google_ignoreList":[0,1]}

package/dist/instancesVertex-evcSIvCA.js

@@ -0,0 +1,55 @@
+import { S as e } from "./index-ChGTkj2q.js";
+const d = "instancesDeclaration", r = `#ifdef INSTANCES
+attribute world0 : vec4<f32>;attribute world1 : vec4<f32>;attribute world2 : vec4<f32>;attribute world3 : vec4<f32>;
+#ifdef INSTANCESCOLOR
+attribute instanceColor : vec4<f32>;
+#endif
+#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)
+uniform world : mat4x4<f32>;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+attribute previousWorld0 : vec4<f32>;attribute previousWorld1 : vec4<f32>;attribute previousWorld2 : vec4<f32>;attribute previousWorld3 : vec4<f32>;
+#ifdef THIN_INSTANCES
+uniform previousWorld : mat4x4<f32>;
+#endif
+#endif
+#else
+#if !defined(WORLD_UBO)
+uniform world : mat4x4<f32>;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+uniform previousWorld : mat4x4<f32>;
+#endif
+#endif
+`;
+e.IncludesShadersStoreWGSL[d] || (e.IncludesShadersStoreWGSL[d] = r);
+const i = "instancesVertex", f = `#ifdef INSTANCES
+var finalWorld=mat4x4<f32>(vertexInputs.world0,vertexInputs.world1,vertexInputs.world2,vertexInputs.world3);
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+var finalPreviousWorld=mat4x4<f32>(
+vertexInputs.previousWorld0,vertexInputs.previousWorld1,
+vertexInputs.previousWorld2,vertexInputs.previousWorld3);
+#endif
+#ifdef THIN_INSTANCES
+#if !defined(WORLD_UBO)
+finalWorld=uniforms.world*finalWorld;
+#else
+finalWorld=mesh.world*finalWorld;
+#endif
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+finalPreviousWorld=uniforms.previousWorld*finalPreviousWorld;
+#endif
+#endif
+#else
+#if !defined(WORLD_UBO)
+var finalWorld=uniforms.world;
+#else
+var finalWorld=mesh.world;
+#endif
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+var finalPreviousWorld=uniforms.previousWorld;
+#endif
+#endif
+`;
+e.IncludesShadersStoreWGSL[i] || (e.IncludesShadersStoreWGSL[i] = f);
+//# sourceMappingURL=instancesVertex-evcSIvCA.js.map

package/dist/instancesVertex-evcSIvCA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instancesVertex-evcSIvCA.js","sources":["../node_modules/@babylonjs/core/ShadersWGSL/ShadersInclude/instancesDeclaration.js","../node_modules/@babylonjs/core/ShadersWGSL/ShadersInclude/instancesVertex.js"],"sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"instancesDeclaration\";\nconst shader = `#ifdef INSTANCES\nattribute world0 : vec4<f32>;attribute world1 : vec4<f32>;attribute world2 : vec4<f32>;attribute world3 : vec4<f32>;\n#ifdef INSTANCESCOLOR\nattribute instanceColor : vec4<f32>;\n#endif\n#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)\nuniform world : mat4x4<f32>;\n#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nattribute previousWorld0 : vec4<f32>;attribute previousWorld1 : vec4<f32>;attribute previousWorld2 : vec4<f32>;attribute previousWorld3 : vec4<f32>;\n#ifdef THIN_INSTANCES\nuniform previousWorld : mat4x4<f32>;\n#endif\n#endif\n#else\n#if !defined(WORLD_UBO)\nuniform world : mat4x4<f32>;\n#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nuniform previousWorld : mat4x4<f32>;\n#endif\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const instancesDeclarationWGSL = { name, shader };\n//# sourceMappingURL=instancesDeclaration.js.map","// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"instancesVertex\";\nconst shader = `#ifdef INSTANCES\nvar finalWorld=mat4x4<f32>(vertexInputs.world0,vertexInputs.world1,vertexInputs.world2,vertexInputs.world3);\n#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nvar finalPreviousWorld=mat4x4<f32>(\nvertexInputs.previousWorld0,vertexInputs.previousWorld1,\nvertexInputs.previousWorld2,vertexInputs.previousWorld3);\n#endif\n#ifdef THIN_INSTANCES\n#if !defined(WORLD_UBO)\nfinalWorld=uniforms.world*finalWorld;\n#else\nfinalWorld=mesh.world*finalWorld;\n#endif\n#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nfinalPreviousWorld=uniforms.previousWorld*finalPreviousWorld;\n#endif\n#endif\n#else\n#if !defined(WORLD_UBO)\nvar finalWorld=uniforms.world;\n#else\nvar finalWorld=mesh.world;\n#endif\n#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)\nvar finalPreviousWorld=uniforms.previousWorld;\n#endif\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const instancesVertexWGSL = { name, shader };\n//# sourceMappingURL=instancesVertex.js.map"],"names":["name","shader","ShaderStore"],"mappings":";AAEA,MAAMA,IAAO,wBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBVC,EAAY,yBAAyBF,CAAI,MAC1CE,EAAY,yBAAyBF,CAAI,IAAIC;AC1BjD,MAAMD,IAAO,mBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BVC,EAAY,yBAAyBF,CAAI,MAC1CE,EAAY,yBAAyBF,CAAI,IAAIC;","x_google_ignoreList":[0,1]}

package/dist/ktxTextureLoader-Dg1h0a-4.js

@@ -0,0 +1,520 @@
+import { c as n, e as _ } from "./index-ChGTkj2q.js";
+class l {
+  /**
+   * Creates a new KhronosTextureContainer
+   * @param data contents of the KTX container file
+   * @param facesExpected should be either 1 or 6, based whether a cube texture or or
+   */
+  constructor(s, e) {
+    if (this.data = s, this.isInvalid = !1, !l.IsValid(s)) {
+      this.isInvalid = !0, n.Error("texture missing KTX identifier");
+      return;
+    }
+    const i = Uint32Array.BYTES_PER_ELEMENT, r = new DataView(this.data.buffer, this.data.byteOffset + 12, 13 * i), a = r.getUint32(0, !0) === 67305985;
+    if (this.glType = r.getUint32(1 * i, a), this.glTypeSize = r.getUint32(2 * i, a), this.glFormat = r.getUint32(3 * i, a), this.glInternalFormat = r.getUint32(4 * i, a), this.glBaseInternalFormat = r.getUint32(5 * i, a), this.pixelWidth = r.getUint32(6 * i, a), this.pixelHeight = r.getUint32(7 * i, a), this.pixelDepth = r.getUint32(8 * i, a), this.numberOfArrayElements = r.getUint32(9 * i, a), this.numberOfFaces = r.getUint32(10 * i, a), this.numberOfMipmapLevels = r.getUint32(11 * i, a), this.bytesOfKeyValueData = r.getUint32(12 * i, a), this.glType !== 0) {
+      n.Error("only compressed formats currently supported"), this.isInvalid = !0;
+      return;
+    } else
+      this.numberOfMipmapLevels = Math.max(1, this.numberOfMipmapLevels);
+    if (this.pixelHeight === 0 || this.pixelDepth !== 0) {
+      n.Error("only 2D textures currently supported"), this.isInvalid = !0;
+      return;
+    }
+    if (this.numberOfArrayElements !== 0) {
+      n.Error("texture arrays not currently supported"), this.isInvalid = !0;
+      return;
+    }
+    if (this.numberOfFaces !== e) {
+      n.Error("number of faces expected" + e + ", but found " + this.numberOfFaces), this.isInvalid = !0;
+      return;
+    }
+    this.loadType = l.COMPRESSED_2D;
+  }
+  /**
+   * Uploads KTX content to a Babylon Texture.
+   * It is assumed that the texture has already been created & is currently bound
+   * @internal
+   */
+  uploadLevels(s, e) {
+    switch (this.loadType) {
+      case l.COMPRESSED_2D:
+        this._upload2DCompressedLevels(s, e);
+        break;
+    }
+  }
+  _upload2DCompressedLevels(s, e) {
+    let i = l.HEADER_LEN + this.bytesOfKeyValueData, r = this.pixelWidth, c = this.pixelHeight;
+    const a = e ? this.numberOfMipmapLevels : 1;
+    for (let f = 0; f < a; f++) {
+      const R = new Int32Array(this.data.buffer, this.data.byteOffset + i, 1)[0];
+      i += 4;
+      for (let d = 0; d < this.numberOfFaces; d++) {
+        const h = new Uint8Array(this.data.buffer, this.data.byteOffset + i, R);
+        s.getEngine()._uploadCompressedDataToTextureDirectly(s, s.format, r, c, h, d, f), i += R, i += 3 - (R + 3) % 4;
+      }
+      r = Math.max(1, r * 0.5), c = Math.max(1, c * 0.5);
+    }
+  }
+  /**
+   * Checks if the given data starts with a KTX file identifier.
+   * @param data the data to check
+   * @returns true if the data is a KTX file or false otherwise
+   */
+  static IsValid(s) {
+    if (s.byteLength >= 12) {
+      const e = new Uint8Array(s.buffer, s.byteOffset, 12);
+      if (e[0] === 171 && e[1] === 75 && e[2] === 84 && e[3] === 88 && e[4] === 32 && e[5] === 49 && e[6] === 49 && e[7] === 187 && e[8] === 13 && e[9] === 10 && e[10] === 26 && e[11] === 10)
+        return !0;
+    }
+    return !1;
+  }
+}
+l.HEADER_LEN = 12 + 13 * 4;
+l.COMPRESSED_2D = 0;
+l.COMPRESSED_3D = 1;
+l.TEX_2D = 2;
+l.TEX_3D = 3;
+class G {
+  /**
+   * Constructor
+   * @param workers Array of workers to use for actions
+   */
+  constructor(s) {
+    this._pendingActions = new Array(), this._workerInfos = s.map((e) => ({
+      workerPromise: Promise.resolve(e),
+      idle: !0
+    }));
+  }
+  /**
+   * Terminates all workers and clears any pending actions.
+   */
+  dispose() {
+    for (const s of this._workerInfos)
+      s.workerPromise.then((e) => {
+        e.terminate();
+      });
+    this._workerInfos.length = 0, this._pendingActions.length = 0;
+  }
+  /**
+   * Pushes an action to the worker pool. If all the workers are active, the action will be
+   * pended until a worker has completed its action.
+   * @param action The action to perform. Call onComplete when the action is complete.
+   */
+  push(s) {
+    this._executeOnIdleWorker(s) || this._pendingActions.push(s);
+  }
+  _executeOnIdleWorker(s) {
+    for (const e of this._workerInfos)
+      if (e.idle)
+        return this._execute(e, s), !0;
+    return !1;
+  }
+  _execute(s, e) {
+    s.idle = !1, s.workerPromise.then((i) => {
+      e(i, () => {
+        const r = this._pendingActions.shift();
+        r ? this._execute(s, r) : s.idle = !0;
+      });
+    });
+  }
+}
+class A extends G {
+  constructor(s, e, i = A.DefaultOptions) {
+    super([]), this._maxWorkers = s, this._createWorkerAsync = e, this._options = i;
+  }
+  push(s) {
+    if (!this._executeOnIdleWorker(s))
+      if (this._workerInfos.length < this._maxWorkers) {
+        const e = {
+          workerPromise: this._createWorkerAsync(),
+          idle: !1
+        };
+        this._workerInfos.push(e), this._execute(e, s);
+      } else
+        this._pendingActions.push(s);
+  }
+  _execute(s, e) {
+    s.timeoutId && (clearTimeout(s.timeoutId), delete s.timeoutId), super._execute(s, (i, r) => {
+      e(i, () => {
+        r(), s.idle && (s.timeoutId = setTimeout(() => {
+          s.workerPromise.then((a) => {
+            a.terminate();
+          });
+          const c = this._workerInfos.indexOf(s);
+          c !== -1 && this._workerInfos.splice(c, 1);
+        }, this._options.idleTimeElapsedBeforeRelease));
+      });
+    });
+  }
+}
+A.DefaultOptions = {
+  idleTimeElapsedBeforeRelease: 1e3
+};
+var D;
+(function(t) {
+  t[t.ETC1S = 0] = "ETC1S", t[t.UASTC4x4 = 1] = "UASTC4x4";
+})(D || (D = {}));
+var S;
+(function(t) {
+  t[t.ASTC_4X4_RGBA = 0] = "ASTC_4X4_RGBA", t[t.BC7_RGBA = 1] = "BC7_RGBA", t[t.BC3_RGBA = 2] = "BC3_RGBA", t[t.BC1_RGB = 3] = "BC1_RGB", t[t.PVRTC1_4_RGBA = 4] = "PVRTC1_4_RGBA", t[t.PVRTC1_4_RGB = 5] = "PVRTC1_4_RGB", t[t.ETC2_RGBA = 6] = "ETC2_RGBA", t[t.ETC1_RGB = 7] = "ETC1_RGB", t[t.RGBA32 = 8] = "RGBA32", t[t.R8 = 9] = "R8", t[t.RG8 = 10] = "RG8";
+})(S || (S = {}));
+var u;
+(function(t) {
+  t[t.COMPRESSED_RGBA_BPTC_UNORM_EXT = 36492] = "COMPRESSED_RGBA_BPTC_UNORM_EXT", t[t.COMPRESSED_RGBA_ASTC_4X4_KHR = 37808] = "COMPRESSED_RGBA_ASTC_4X4_KHR", t[t.COMPRESSED_RGB_S3TC_DXT1_EXT = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT", t[t.COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT", t[t.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG", t[t.COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG", t[t.COMPRESSED_RGBA8_ETC2_EAC = 37496] = "COMPRESSED_RGBA8_ETC2_EAC", t[t.COMPRESSED_RGB8_ETC2 = 37492] = "COMPRESSED_RGB8_ETC2", t[t.COMPRESSED_RGB_ETC1_WEBGL = 36196] = "COMPRESSED_RGB_ETC1_WEBGL", t[t.RGBA8Format = 32856] = "RGBA8Format", t[t.R8Format = 33321] = "R8Format", t[t.RG8Format = 33323] = "RG8Format";
+})(u || (u = {}));
+function p(t, s) {
+  const e = (s == null ? void 0 : s.jsDecoderModule) || KTX2DECODER;
+  t && (t.wasmUASTCToASTC && (e.LiteTranscoder_UASTC_ASTC.WasmModuleURL = t.wasmUASTCToASTC), t.wasmUASTCToBC7 && (e.LiteTranscoder_UASTC_BC7.WasmModuleURL = t.wasmUASTCToBC7), t.wasmUASTCToRGBA_UNORM && (e.LiteTranscoder_UASTC_RGBA_UNORM.WasmModuleURL = t.wasmUASTCToRGBA_UNORM), t.wasmUASTCToRGBA_SRGB && (e.LiteTranscoder_UASTC_RGBA_SRGB.WasmModuleURL = t.wasmUASTCToRGBA_SRGB), t.wasmUASTCToR8_UNORM && (e.LiteTranscoder_UASTC_R8_UNORM.WasmModuleURL = t.wasmUASTCToR8_UNORM), t.wasmUASTCToRG8_UNORM && (e.LiteTranscoder_UASTC_RG8_UNORM.WasmModuleURL = t.wasmUASTCToRG8_UNORM), t.jsMSCTranscoder && (e.MSCTranscoder.JSModuleURL = t.jsMSCTranscoder), t.wasmMSCTranscoder && (e.MSCTranscoder.WasmModuleURL = t.wasmMSCTranscoder), t.wasmZSTDDecoder && (e.ZSTDDecoder.WasmModuleURL = t.wasmZSTDDecoder)), s && (s.wasmUASTCToASTC && (e.LiteTranscoder_UASTC_ASTC.WasmBinary = s.wasmUASTCToASTC), s.wasmUASTCToBC7 && (e.LiteTranscoder_UASTC_BC7.WasmBinary = s.wasmUASTCToBC7), s.wasmUASTCToRGBA_UNORM && (e.LiteTranscoder_UASTC_RGBA_UNORM.WasmBinary = s.wasmUASTCToRGBA_UNORM), s.wasmUASTCToRGBA_SRGB && (e.LiteTranscoder_UASTC_RGBA_SRGB.WasmBinary = s.wasmUASTCToRGBA_SRGB), s.wasmUASTCToR8_UNORM && (e.LiteTranscoder_UASTC_R8_UNORM.WasmBinary = s.wasmUASTCToR8_UNORM), s.wasmUASTCToRG8_UNORM && (e.LiteTranscoder_UASTC_RG8_UNORM.WasmBinary = s.wasmUASTCToRG8_UNORM), s.jsMSCTranscoder && (e.MSCTranscoder.JSModule = s.jsMSCTranscoder), s.wasmMSCTranscoder && (e.MSCTranscoder.WasmBinary = s.wasmMSCTranscoder), s.wasmZSTDDecoder && (e.ZSTDDecoder.WasmBinary = s.wasmZSTDDecoder));
+}
+function M(t) {
+  typeof t > "u" && typeof KTX2DECODER < "u" && (t = KTX2DECODER);
+  let s;
+  onmessage = (e) => {
+    if (e.data)
+      switch (e.data.action) {
+        case "init": {
+          const i = e.data.urls;
+          i && (i.jsDecoderModule && typeof t > "u" && (importScripts(i.jsDecoderModule), t = KTX2DECODER), p(i)), e.data.wasmBinaries && p(void 0, { ...e.data.wasmBinaries, jsDecoderModule: t }), s = new t.KTX2Decoder(), postMessage({ action: "init" });
+          break;
+        }
+        case "setDefaultDecoderOptions": {
+          t.KTX2Decoder.DefaultDecoderOptions = e.data.options;
+          break;
+        }
+        case "decode":
+          s.decode(e.data.data, e.data.caps, e.data.options).then((i) => {
+            const r = [];
+            for (let c = 0; c < i.mipmaps.length; ++c) {
+              const a = i.mipmaps[c];
+              a && a.data && r.push(a.data.buffer);
+            }
+            postMessage({ action: "decoded", success: !0, decodedData: i }, r);
+          }).catch((i) => {
+            postMessage({ action: "decoded", success: !1, msg: i });
+          });
+          break;
+      }
+  };
+}
+async function y(t, s, e) {
+  return await new Promise((i, r) => {
+    const c = (f) => {
+      t.removeEventListener("error", c), t.removeEventListener("message", a), r(f);
+    }, a = (f) => {
+      f.data.action === "init" && (t.removeEventListener("error", c), t.removeEventListener("message", a), i(t));
+    };
+    t.addEventListener("error", c), t.addEventListener("message", a), t.postMessage({
+      action: "init",
+      urls: e,
+      wasmBinaries: s
+    });
+  });
+}
+class w {
+  constructor() {
+    this._isDirty = !0, this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC = !0, this._ktx2DecoderOptions = {};
+  }
+  /**
+   * Gets the dirty flag
+   */
+  get isDirty() {
+    return this._isDirty;
+  }
+  /**
+   * force a (uncompressed) RGBA transcoded format if transcoding a UASTC source format and ASTC + BC7 are not available as a compressed transcoded format
+   */
+  get useRGBAIfASTCBC7NotAvailableWhenUASTC() {
+    return this._useRGBAIfASTCBC7NotAvailableWhenUASTC;
+  }
+  set useRGBAIfASTCBC7NotAvailableWhenUASTC(s) {
+    this._useRGBAIfASTCBC7NotAvailableWhenUASTC !== s && (this._useRGBAIfASTCBC7NotAvailableWhenUASTC = s, this._isDirty = !0);
+  }
+  /**
+   * force a (uncompressed) RGBA transcoded format if transcoding a UASTC source format and only BC1 or BC3 are available as a compressed transcoded format.
+   * This property is true by default to favor speed over memory, because currently transcoding from UASTC to BC1/3 is slow because the transcoder transcodes
+   * to uncompressed and then recompresses the texture
+   */
+  get useRGBAIfOnlyBC1BC3AvailableWhenUASTC() {
+    return this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC;
+  }
+  set useRGBAIfOnlyBC1BC3AvailableWhenUASTC(s) {
+    this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC !== s && (this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC = s, this._isDirty = !0);
+  }
+  /**
+   * force to always use (uncompressed) RGBA for transcoded format
+   */
+  get forceRGBA() {
+    return this._forceRGBA;
+  }
+  set forceRGBA(s) {
+    this._forceRGBA !== s && (this._forceRGBA = s, this._isDirty = !0);
+  }
+  /**
+   * force to always use (uncompressed) R8 for transcoded format
+   */
+  get forceR8() {
+    return this._forceR8;
+  }
+  set forceR8(s) {
+    this._forceR8 !== s && (this._forceR8 = s, this._isDirty = !0);
+  }
+  /**
+   * force to always use (uncompressed) RG8 for transcoded format
+   */
+  get forceRG8() {
+    return this._forceRG8;
+  }
+  set forceRG8(s) {
+    this._forceRG8 !== s && (this._forceRG8 = s, this._isDirty = !0);
+  }
+  /**
+   * list of transcoders to bypass when looking for a suitable transcoder. The available transcoders are:
+   *      UniversalTranscoder_UASTC_ASTC
+   *      UniversalTranscoder_UASTC_BC7
+   *      UniversalTranscoder_UASTC_RGBA_UNORM
+   *      UniversalTranscoder_UASTC_RGBA_SRGB
+   *      UniversalTranscoder_UASTC_R8_UNORM
+   *      UniversalTranscoder_UASTC_RG8_UNORM
+   *      MSCTranscoder
+   */
+  get bypassTranscoders() {
+    return this._bypassTranscoders;
+  }
+  set bypassTranscoders(s) {
+    this._bypassTranscoders !== s && (this._bypassTranscoders = s, this._isDirty = !0);
+  }
+  /** @internal */
+  _getKTX2DecoderOptions() {
+    if (!this._isDirty)
+      return this._ktx2DecoderOptions;
+    this._isDirty = !1;
+    const s = {
+      useRGBAIfASTCBC7NotAvailableWhenUASTC: this._useRGBAIfASTCBC7NotAvailableWhenUASTC,
+      forceRGBA: this._forceRGBA,
+      forceR8: this._forceR8,
+      forceRG8: this._forceRG8,
+      bypassTranscoders: this._bypassTranscoders
+    };
+    return this.useRGBAIfOnlyBC1BC3AvailableWhenUASTC && (s.transcodeFormatDecisionTree = {
+      UASTC: {
+        transcodeFormat: [S.BC1_RGB, S.BC3_RGBA],
+        yes: {
+          transcodeFormat: S.RGBA32,
+          engineFormat: 32856,
+          roundToMultiple4: !1
+        }
+      }
+    }), this._ktx2DecoderOptions = s, s;
+  }
+}
+class o {
+  static GetDefaultNumWorkers() {
+    return typeof navigator != "object" || !navigator.hardwareConcurrency ? 1 : Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);
+  }
+  static _Initialize(s) {
+    if (o._WorkerPoolPromise || o._DecoderModulePromise)
+      return;
+    const e = {
+      jsDecoderModule: _.GetBabylonScriptURL(this.URLConfig.jsDecoderModule, !0),
+      wasmUASTCToASTC: _.GetBabylonScriptURL(this.URLConfig.wasmUASTCToASTC, !0),
+      wasmUASTCToBC7: _.GetBabylonScriptURL(this.URLConfig.wasmUASTCToBC7, !0),
+      wasmUASTCToRGBA_UNORM: _.GetBabylonScriptURL(this.URLConfig.wasmUASTCToRGBA_UNORM, !0),
+      wasmUASTCToRGBA_SRGB: _.GetBabylonScriptURL(this.URLConfig.wasmUASTCToRGBA_SRGB, !0),
+      wasmUASTCToR8_UNORM: _.GetBabylonScriptURL(this.URLConfig.wasmUASTCToR8_UNORM, !0),
+      wasmUASTCToRG8_UNORM: _.GetBabylonScriptURL(this.URLConfig.wasmUASTCToRG8_UNORM, !0),
+      jsMSCTranscoder: _.GetBabylonScriptURL(this.URLConfig.jsMSCTranscoder, !0),
+      wasmMSCTranscoder: _.GetBabylonScriptURL(this.URLConfig.wasmMSCTranscoder, !0),
+      wasmZSTDDecoder: _.GetBabylonScriptURL(this.URLConfig.wasmZSTDDecoder, !0)
+    };
+    s && typeof Worker == "function" && typeof URL < "u" ? o._WorkerPoolPromise = new Promise((i) => {
+      const r = `${p}(${M})()`, c = URL.createObjectURL(new Blob([r], { type: "application/javascript" }));
+      i(new A(s, async () => await y(new Worker(c), void 0, e)));
+    }) : typeof o._KTX2DecoderModule > "u" ? o._DecoderModulePromise = _.LoadBabylonScriptAsync(e.jsDecoderModule).then(() => (o._KTX2DecoderModule = KTX2DECODER, o._KTX2DecoderModule.MSCTranscoder.UseFromWorkerThread = !1, o._KTX2DecoderModule.WASMMemoryManager.LoadBinariesFromCurrentThread = !0, p(e, o._KTX2DecoderModule), new o._KTX2DecoderModule.KTX2Decoder())) : (o._KTX2DecoderModule.MSCTranscoder.UseFromWorkerThread = !1, o._KTX2DecoderModule.WASMMemoryManager.LoadBinariesFromCurrentThread = !0, o._DecoderModulePromise = Promise.resolve(new o._KTX2DecoderModule.KTX2Decoder()));
+  }
+  /**
+   * Constructor
+   * @param engine The engine to use
+   * @param numWorkersOrOptions The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
+   */
+  constructor(s, e = o.DefaultNumWorkers) {
+    var r;
+    this._engine = s;
+    const i = typeof e == "object" && e.workerPool || o.WorkerPool;
+    if (i)
+      o._WorkerPoolPromise = Promise.resolve(i);
+    else {
+      typeof e == "object" ? o._KTX2DecoderModule = (r = e == null ? void 0 : e.binariesAndModulesContainer) == null ? void 0 : r.jsDecoderModule : typeof KTX2DECODER < "u" && (o._KTX2DecoderModule = KTX2DECODER);
+      const c = typeof e == "number" ? e : e.numWorkers ?? o.DefaultNumWorkers;
+      o._Initialize(c);
+    }
+  }
+  /**
+   * @internal
+   */
+  async _uploadAsync(s, e, i) {
+    const r = this._engine.getCaps(), c = {
+      astc: !!r.astc,
+      bptc: !!r.bptc,
+      s3tc: !!r.s3tc,
+      pvrtc: !!r.pvrtc,
+      etc2: !!r.etc2,
+      etc1: !!r.etc1
+    };
+    if (o._WorkerPoolPromise) {
+      const a = await o._WorkerPoolPromise;
+      return await new Promise((f, R) => {
+        a.push((d, h) => {
+          const T = (m) => {
+            d.removeEventListener("error", T), d.removeEventListener("message", C), R(m), h();
+          }, C = (m) => {
+            if (m.data.action === "decoded") {
+              if (d.removeEventListener("error", T), d.removeEventListener("message", C), !m.data.success)
+                R({ message: m.data.msg });
+              else
+                try {
+                  this._createTexture(m.data.decodedData, e, i), f();
+                } catch (U) {
+                  R({ message: U });
+                }
+              h();
+            }
+          };
+          d.addEventListener("error", T), d.addEventListener("message", C), d.postMessage({ action: "setDefaultDecoderOptions", options: o.DefaultDecoderOptions._getKTX2DecoderOptions() });
+          const B = new Uint8Array(s.byteLength);
+          B.set(new Uint8Array(s.buffer, s.byteOffset, s.byteLength)), d.postMessage({ action: "decode", data: B, caps: c, options: i }, [B.buffer]);
+        });
+      });
+    } else if (o._DecoderModulePromise) {
+      const a = await o._DecoderModulePromise;
+      return o.DefaultDecoderOptions.isDirty && (o._KTX2DecoderModule.KTX2Decoder.DefaultDecoderOptions = o.DefaultDecoderOptions._getKTX2DecoderOptions()), await new Promise((f, R) => {
+        a.decode(s, r).then((d) => {
+          this._createTexture(d, e), f();
+        }).catch((d) => {
+          R({ message: d });
+        });
+      });
+    }
+    throw new Error("KTX2 decoder module is not available");
+  }
+  _createTexture(s, e, i) {
+    this._engine._bindTextureDirectly(3553, e), i && (i.transcodedFormat = s.transcodedFormat, i.isInGammaSpace = s.isInGammaSpace, i.hasAlpha = s.hasAlpha, i.transcoderName = s.transcoderName);
+    let c = !0;
+    switch (s.transcodedFormat) {
+      case 32856:
+        e.type = 0, e.format = 5;
+        break;
+      case 33321:
+        e.type = 0, e.format = 6;
+        break;
+      case 33323:
+        e.type = 0, e.format = 7;
+        break;
+      default:
+        e.format = s.transcodedFormat, c = !1;
+        break;
+    }
+    if (e._gammaSpace = s.isInGammaSpace, e.generateMipMaps = s.mipmaps.length > 1, s.errors)
+      throw new Error("KTX2 container - could not transcode the data. " + s.errors);
+    for (let a = 0; a < s.mipmaps.length; ++a) {
+      const f = s.mipmaps[a];
+      if (!f || !f.data)
+        throw new Error("KTX2 container - could not transcode one of the image");
+      c ? (e.width = f.width, e.height = f.height, this._engine._uploadDataToTextureDirectly(e, f.data, 0, a, void 0, !0)) : this._engine._uploadCompressedDataToTextureDirectly(e, s.transcodedFormat, f.width, f.height, f.data, 0, a);
+    }
+    e._extension = ".ktx2", e.width = s.mipmaps[0].width, e.height = s.mipmaps[0].height, e.isReady = !0, this._engine._bindTextureDirectly(3553, null);
+  }
+  /**
+   * Checks if the given data starts with a KTX2 file identifier.
+   * @param data the data to check
+   * @returns true if the data is a KTX2 file or false otherwise
+   */
+  static IsValid(s) {
+    if (s.byteLength >= 12) {
+      const e = new Uint8Array(s.buffer, s.byteOffset, 12);
+      if (e[0] === 171 && e[1] === 75 && e[2] === 84 && e[3] === 88 && e[4] === 32 && e[5] === 50 && e[6] === 48 && e[7] === 187 && e[8] === 13 && e[9] === 10 && e[10] === 26 && e[11] === 10)
+        return !0;
+    }
+    return !1;
+  }
+}
+o.URLConfig = {
+  jsDecoderModule: "https://cdn.babylonjs.com/babylon.ktx2Decoder.js",
+  wasmUASTCToASTC: null,
+  wasmUASTCToBC7: null,
+  wasmUASTCToRGBA_UNORM: null,
+  wasmUASTCToRGBA_SRGB: null,
+  wasmUASTCToR8_UNORM: null,
+  wasmUASTCToRG8_UNORM: null,
+  jsMSCTranscoder: null,
+  wasmMSCTranscoder: null,
+  wasmZSTDDecoder: null
+};
+o.DefaultNumWorkers = o.GetDefaultNumWorkers();
+o.DefaultDecoderOptions = new w();
+function E(t) {
+  switch (t) {
+    case 35916:
+      return 33776;
+    case 35918:
+      return 33778;
+    case 35919:
+      return 33779;
+    case 37493:
+      return 37492;
+    case 37497:
+      return 37496;
+    case 37495:
+      return 37494;
+    case 37840:
+      return 37808;
+    case 36493:
+      return 36492;
+  }
+  return null;
+}
+class g {
+  constructor() {
+    this.supportCascades = !1;
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param createPolynomials will be true if polynomials have been requested
+   * @param onLoad defines the callback to trigger once the texture is ready
+   */
+  loadCubeData(s, e, i, r) {
+    if (Array.isArray(s))
+      return;
+    e._invertVScale = !e.invertY;
+    const c = e.getEngine(), a = new l(s, 6), f = a.numberOfMipmapLevels > 1 && e.generateMipMaps;
+    c._unpackFlipY(!0), a.uploadLevels(e, e.generateMipMaps), e.width = a.pixelWidth, e.height = a.pixelHeight, c._setCubeMapTextureParams(e, f, a.numberOfMipmapLevels - 1), e.isReady = !0, e.onLoadedObservable.notifyObservers(e), e.onLoadedObservable.clear(), r && r();
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param callback defines the method to call once ready to upload
+   * @param options
+   */
+  loadData(s, e, i, r) {
+    if (l.IsValid(s)) {
+      e._invertVScale = !e.invertY;
+      const c = new l(s, 1), a = E(c.glInternalFormat);
+      a ? (e.format = a, e._useSRGBBuffer = e.getEngine()._getUseSRGBBuffer(!0, e.generateMipMaps), e._gammaSpace = !0) : e.format = c.glInternalFormat, i(c.pixelWidth, c.pixelHeight, e.generateMipMaps, !0, () => {
+        c.uploadLevels(e, e.generateMipMaps);
+      }, c.isInvalid);
+    } else o.IsValid(s) ? new o(e.getEngine())._uploadAsync(s, e, r).then(() => {
+      i(e.width, e.height, e.generateMipMaps, !0, () => {
+      }, !1);
+    }, (a) => {
+      n.Warn(`Failed to load KTX2 texture data: ${a.message}`), i(0, 0, !1, !1, () => {
+      }, !0);
+    }) : (n.Error("texture missing KTX identifier"), i(0, 0, !1, !1, () => {
+    }, !0));
+  }
+}
+export {
+  g as _KTXTextureLoader
+};
+//# sourceMappingURL=ktxTextureLoader-Dg1h0a-4.js.map