@babylonjs/core 7.40.1 → 7.40.3

package/Meshes/Compression/dracoCodec.d.ts

@@ -0,0 +1,83 @@
+import type { WorkerPool } from "../../Misc/workerPool";
+import type { IDisposable } from "../../scene";
+/**
+ * Configuration for using a Draco codec.
+ */
+export interface IDracoCodecConfiguration {
+    /**
+     * The url to the WebAssembly module.
+     */
+    wasmUrl?: string;
+    /**
+     * The url to the WebAssembly binary.
+     */
+    wasmBinaryUrl?: string;
+    /**
+     * The url to the fallback JavaScript module.
+     */
+    fallbackUrl?: string;
+    /**
+     * The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
+     */
+    numWorkers?: number;
+    /**
+     * Optional worker pool to use for async encoding/decoding.
+     * If provided, the worker pool will be used as is: no Draco scripts will be loaded, and numWorkers will be ignored.
+     */
+    workerPool?: WorkerPool;
+    /**
+     * Optional ArrayBuffer of the WebAssembly binary.
+     * If provided it will be used instead of loading the binary from wasmBinaryUrl.
+     */
+    wasmBinary?: ArrayBuffer;
+    /**
+     * The codec module if already available.
+     */
+    jsModule?: any;
+}
+/**
+ * @internal
+ */
+export declare function _GetDefaultNumWorkers(): number;
+/**
+ * @internal
+ */
+export declare function _IsConfigurationAvailable(config: IDracoCodecConfiguration): boolean;
+/**
+ * Base class for a Draco codec.
+ * @internal
+ */
+export declare abstract class DracoCodec implements IDisposable {
+    protected _workerPoolPromise?: Promise<WorkerPool>;
+    protected _modulePromise?: Promise<{
+        module: any; /** DecoderModule | EncoderModule */
+    }>;
+    /**
+     * Checks if the default codec JS module is in scope.
+     */
+    protected abstract _isModuleAvailable(): boolean;
+    /**
+     * Creates the JS Module for the corresponding wasm.
+     */
+    protected abstract _createModuleAsync(wasmBinary?: ArrayBuffer, jsModule?: any): Promise<{
+        module: any; /** DecoderModule | EncoderModule */
+    }>;
+    /**
+     * Returns the worker content.
+     */
+    protected abstract _getWorkerContent(): string;
+    /**
+     * Constructor
+     * @param configuration The configuration for the DracoCodec instance.
+     */
+    constructor(configuration: IDracoCodecConfiguration);
+    /**
+     * Returns a promise that resolves when ready. Call this manually to ensure the draco codec is ready before use.
+     * @returns a promise that resolves when ready
+     */
+    whenReadyAsync(): Promise<void>;
+    /**
+     * Stop all async operations and release resources.
+     */
+    dispose(): void;
+}

package/Meshes/Compression/dracoCodec.js

@@ -0,0 +1,107 @@
+import { Tools } from "../../Misc/tools.js";
+import { AutoReleaseWorkerPool } from "../../Misc/workerPool.js";
+import { initializeWebWorker } from "./dracoCompressionWorker.js";
+/**
+ * @internal
+ */
+export function _GetDefaultNumWorkers() {
+    if (typeof navigator !== "object" || !navigator.hardwareConcurrency) {
+        return 1;
+    }
+    // Use 50% of the available logical processors but capped at 4.
+    return Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);
+}
+/**
+ * @internal
+ */
+export function _IsConfigurationAvailable(config) {
+    return !!((config.wasmUrl && (config.wasmBinary || config.wasmBinaryUrl) && typeof WebAssembly === "object") || config.fallbackUrl);
+    // TODO: Account for jsModule
+}
+/**
+ * Base class for a Draco codec.
+ * @internal
+ */
+export class DracoCodec {
+    /**
+     * Constructor
+     * @param configuration The configuration for the DracoCodec instance.
+     */
+    constructor(configuration) {
+        // check if the codec binary and worker pool was injected
+        // Note - it is expected that the developer checked if WebWorker, WebAssembly and the URL object are available
+        if (configuration.workerPool) {
+            // Set the promise accordingly
+            this._workerPoolPromise = Promise.resolve(configuration.workerPool);
+            return;
+        }
+        // to avoid making big changes to the code here, if wasmBinary is provided use it in the wasmBinaryPromise
+        const wasmBinaryProvided = configuration.wasmBinary;
+        const numberOfWorkers = configuration.numWorkers ?? _GetDefaultNumWorkers();
+        const useWorkers = numberOfWorkers && typeof Worker === "function" && typeof URL === "function";
+        const urlNeeded = useWorkers || !configuration.jsModule;
+        // code maintained here for back-compat with no changes
+        const codecInfo = configuration.wasmUrl && configuration.wasmBinaryUrl && typeof WebAssembly === "object"
+            ? {
+                url: urlNeeded ? Tools.GetBabylonScriptURL(configuration.wasmUrl, true) : "",
+                wasmBinaryPromise: wasmBinaryProvided
+                    ? Promise.resolve(wasmBinaryProvided)
+                    : Tools.LoadFileAsync(Tools.GetBabylonScriptURL(configuration.wasmBinaryUrl, true)),
+            }
+            : {
+                url: urlNeeded ? Tools.GetBabylonScriptURL(configuration.fallbackUrl) : "",
+                wasmBinaryPromise: Promise.resolve(undefined),
+            };
+        // If using workers, initialize a worker pool with either the wasm or url?
+        if (useWorkers) {
+            this._workerPoolPromise = codecInfo.wasmBinaryPromise.then((wasmBinary) => {
+                const workerContent = this._getWorkerContent();
+                const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: "application/javascript" }));
+                return new AutoReleaseWorkerPool(numberOfWorkers, () => {
+                    const worker = new Worker(workerBlobUrl);
+                    return initializeWebWorker(worker, wasmBinary, codecInfo.url);
+                });
+            });
+        }
+        else {
+            this._modulePromise = codecInfo.wasmBinaryPromise.then(async (wasmBinary) => {
+                if (!this._isModuleAvailable()) {
+                    if (!configuration.jsModule) {
+                        if (!codecInfo.url) {
+                            throw new Error("Draco codec module is not available");
+                        }
+                        await Tools.LoadBabylonScriptAsync(codecInfo.url);
+                    }
+                }
+                return this._createModuleAsync(wasmBinary, configuration.jsModule);
+            });
+        }
+    }
+    /**
+     * Returns a promise that resolves when ready. Call this manually to ensure the draco codec is ready before use.
+     * @returns a promise that resolves when ready
+     */
+    async whenReadyAsync() {
+        if (this._workerPoolPromise) {
+            await this._workerPoolPromise;
+            return;
+        }
+        if (this._modulePromise) {
+            await this._modulePromise;
+            return;
+        }
+    }
+    /**
+     * Stop all async operations and release resources.
+     */
+    dispose() {
+        if (this._workerPoolPromise) {
+            this._workerPoolPromise.then((workerPool) => {
+                workerPool.dispose();
+            });
+        }
+        delete this._workerPoolPromise;
+        delete this._modulePromise;
+    }
+}
+//# sourceMappingURL=dracoCodec.js.map

package/Meshes/Compression/dracoCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dracoCodec.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/Compression/dracoCodec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AA4C/D;;GAEG;AACH,MAAM,UAAU,qBAAqB;IACjC,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAAC;QAClE,OAAO,CAAC,CAAC;IACb,CAAC;IAED,+DAA+D;IAC/D,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,mBAAmB,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;AACxE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAAgC;IACtE,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,aAAa,CAAC,IAAI,OAAO,WAAW,KAAK,QAAQ,CAAC,IAAI,MAAM,CAAC,WAAW,CAAC,CAAC;IACpI,6BAA6B;AACjC,CAAC;AAED;;;GAGG;AACH,MAAM,OAAgB,UAAU;IAmB5B;;;OAGG;IACH,YAAY,aAAuC;QAC/C,yDAAyD;QACzD,8GAA8G;QAC9G,IAAI,aAAa,CAAC,UAAU,EAAE,CAAC;YAC3B,8BAA8B;YAC9B,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YACpE,OAAO;QACX,CAAC;QAED,0GAA0G;QAC1G,MAAM,kBAAkB,GAAG,aAAa,CAAC,UAAU,CAAC;QACpD,MAAM,eAAe,GAAG,aAAa,CAAC,UAAU,IAAI,qBAAqB,EAAE,CAAC;QAC5E,MAAM,UAAU,GAAG,eAAe,IAAI,OAAO,MAAM,KAAK,UAAU,IAAI,OAAO,GAAG,KAAK,UAAU,CAAC;QAChG,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;QACxD,uDAAuD;QAEvD,MAAM,SAAS,GACX,aAAa,CAAC,OAAO,IAAI,aAAa,CAAC,aAAa,IAAI,OAAO,WAAW,KAAK,QAAQ;YACnF,CAAC,CAAC;gBACI,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC5E,iBAAiB,EAAE,kBAAkB;oBACjC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC;oBACrC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;aAC1F;YACH,CAAC,CAAC;gBACI,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,WAAY,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC3E,iBAAiB,EAAE,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;aAChD,CAAC;QACZ,0EAA0E;QAC1E,IAAI,UAAU,EAAE,CAAC;YACb,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;gBACtE,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC/C,MAAM,aAAa,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC,aAAa,CAAC,EAAE,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC,CAAC,CAAC;gBAEzG,OAAO,IAAI,qBAAqB,CAAC,eAAyB,EAAE,GAAG,EAAE;oBAC7D,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC,CAAC;oBACzC,OAAO,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;gBAClE,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;gBACxE,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;oBAC7B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;wBAC1B,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;4BACjB,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;wBAC3D,CAAC;wBACD,MAAM,KAAK,CAAC,sBAAsB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;oBACtD,CAAC;gBACL,CAAC;gBACD,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAyB,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;YACtF,CAAC,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,cAAc;QACvB,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,MAAM,IAAI,CAAC,kBAAkB,CAAC;YAC9B,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,MAAM,IAAI,CAAC,cAAc,CAAC;YAC1B,OAAO;QACX,CAAC;IACL,CAAC;IAED;;OAEG;IACI,OAAO;QACV,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;gBACxC,UAAU,CAAC,OAAO,EAAE,CAAC;YACzB,CAAC,CAAC,CAAC;QACP,CAAC;QAED,OAAO,IAAI,CAAC,kBAAkB,CAAC;QAC/B,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;CACJ","sourcesContent":["import { Tools } from \"../../Misc/tools\";\r\nimport { AutoReleaseWorkerPool } from \"../../Misc/workerPool\";\r\nimport type { WorkerPool } from \"../../Misc/workerPool\";\r\nimport type { IDisposable } from \"../../scene\";\r\nimport { initializeWebWorker } from \"./dracoCompressionWorker\";\r\n\r\n/**\r\n * Configuration for using a Draco codec.\r\n */\r\nexport interface IDracoCodecConfiguration {\r\n    /**\r\n     * The url to the WebAssembly module.\r\n     */\r\n    wasmUrl?: string;\r\n\r\n    /**\r\n     * The url to the WebAssembly binary.\r\n     */\r\n    wasmBinaryUrl?: string;\r\n\r\n    /**\r\n     * The url to the fallback JavaScript module.\r\n     */\r\n    fallbackUrl?: string;\r\n\r\n    /**\r\n     * The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.\r\n     */\r\n    numWorkers?: number;\r\n\r\n    /**\r\n     * Optional worker pool to use for async encoding/decoding.\r\n     * If provided, the worker pool will be used as is: no Draco scripts will be loaded, and numWorkers will be ignored.\r\n     */\r\n    workerPool?: WorkerPool;\r\n\r\n    /**\r\n     * Optional ArrayBuffer of the WebAssembly binary.\r\n     * If provided it will be used instead of loading the binary from wasmBinaryUrl.\r\n     */\r\n    wasmBinary?: ArrayBuffer;\r\n\r\n    /**\r\n     * The codec module if already available.\r\n     */\r\n    jsModule?: any /* DracoDecoderModule | DracoEncoderModule */;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function _GetDefaultNumWorkers(): number {\r\n    if (typeof navigator !== \"object\" || !navigator.hardwareConcurrency) {\r\n        return 1;\r\n    }\r\n\r\n    // Use 50% of the available logical processors but capped at 4.\r\n    return Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function _IsConfigurationAvailable(config: IDracoCodecConfiguration): boolean {\r\n    return !!((config.wasmUrl && (config.wasmBinary || config.wasmBinaryUrl) && typeof WebAssembly === \"object\") || config.fallbackUrl);\r\n    // TODO: Account for jsModule\r\n}\r\n\r\n/**\r\n * Base class for a Draco codec.\r\n * @internal\r\n */\r\nexport abstract class DracoCodec implements IDisposable {\r\n    protected _workerPoolPromise?: Promise<WorkerPool>;\r\n    protected _modulePromise?: Promise<{ module: any /** DecoderModule | EncoderModule */ }>;\r\n\r\n    /**\r\n     * Checks if the default codec JS module is in scope.\r\n     */\r\n    protected abstract _isModuleAvailable(): boolean;\r\n\r\n    /**\r\n     * Creates the JS Module for the corresponding wasm.\r\n     */\r\n    protected abstract _createModuleAsync(wasmBinary?: ArrayBuffer, jsModule?: any): Promise<{ module: any /** DecoderModule | EncoderModule */ }>;\r\n\r\n    /**\r\n     * Returns the worker content.\r\n     */\r\n    protected abstract _getWorkerContent(): string;\r\n\r\n    /**\r\n     * Constructor\r\n     * @param configuration The configuration for the DracoCodec instance.\r\n     */\r\n    constructor(configuration: IDracoCodecConfiguration) {\r\n        // check if the codec binary and worker pool was injected\r\n        // Note - it is expected that the developer checked if WebWorker, WebAssembly and the URL object are available\r\n        if (configuration.workerPool) {\r\n            // Set the promise accordingly\r\n            this._workerPoolPromise = Promise.resolve(configuration.workerPool);\r\n            return;\r\n        }\r\n\r\n        // to avoid making big changes to the code here, if wasmBinary is provided use it in the wasmBinaryPromise\r\n        const wasmBinaryProvided = configuration.wasmBinary;\r\n        const numberOfWorkers = configuration.numWorkers ?? _GetDefaultNumWorkers();\r\n        const useWorkers = numberOfWorkers && typeof Worker === \"function\" && typeof URL === \"function\";\r\n        const urlNeeded = useWorkers || !configuration.jsModule;\r\n        // code maintained here for back-compat with no changes\r\n\r\n        const codecInfo: { url: string | undefined; wasmBinaryPromise: Promise<ArrayBuffer | undefined> } =\r\n            configuration.wasmUrl && configuration.wasmBinaryUrl && typeof WebAssembly === \"object\"\r\n                ? {\r\n                      url: urlNeeded ? Tools.GetBabylonScriptURL(configuration.wasmUrl, true) : \"\",\r\n                      wasmBinaryPromise: wasmBinaryProvided\r\n                          ? Promise.resolve(wasmBinaryProvided)\r\n                          : Tools.LoadFileAsync(Tools.GetBabylonScriptURL(configuration.wasmBinaryUrl, true)),\r\n                  }\r\n                : {\r\n                      url: urlNeeded ? Tools.GetBabylonScriptURL(configuration.fallbackUrl!) : \"\",\r\n                      wasmBinaryPromise: Promise.resolve(undefined),\r\n                  };\r\n        // If using workers, initialize a worker pool with either the wasm or url?\r\n        if (useWorkers) {\r\n            this._workerPoolPromise = codecInfo.wasmBinaryPromise.then((wasmBinary) => {\r\n                const workerContent = this._getWorkerContent();\r\n                const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: \"application/javascript\" }));\r\n\r\n                return new AutoReleaseWorkerPool(numberOfWorkers as number, () => {\r\n                    const worker = new Worker(workerBlobUrl);\r\n                    return initializeWebWorker(worker, wasmBinary, codecInfo.url);\r\n                });\r\n            });\r\n        } else {\r\n            this._modulePromise = codecInfo.wasmBinaryPromise.then(async (wasmBinary) => {\r\n                if (!this._isModuleAvailable()) {\r\n                    if (!configuration.jsModule) {\r\n                        if (!codecInfo.url) {\r\n                            throw new Error(\"Draco codec module is not available\");\r\n                        }\r\n                        await Tools.LoadBabylonScriptAsync(codecInfo.url);\r\n                    }\r\n                }\r\n                return this._createModuleAsync(wasmBinary as ArrayBuffer, configuration.jsModule);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a promise that resolves when ready. Call this manually to ensure the draco codec is ready before use.\r\n     * @returns a promise that resolves when ready\r\n     */\r\n    public async whenReadyAsync(): Promise<void> {\r\n        if (this._workerPoolPromise) {\r\n            await this._workerPoolPromise;\r\n            return;\r\n        }\r\n\r\n        if (this._modulePromise) {\r\n            await this._modulePromise;\r\n            return;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Stop all async operations and release resources.\r\n     */\r\n    public dispose(): void {\r\n        if (this._workerPoolPromise) {\r\n            this._workerPoolPromise.then((workerPool) => {\r\n                workerPool.dispose();\r\n            });\r\n        }\r\n\r\n        delete this._workerPoolPromise;\r\n        delete this._modulePromise;\r\n    }\r\n}\r\n"]}

package/Meshes/Compression/dracoCompression.d.ts

@@ -1,15 +1,10 @@
-import type { BoundingInfo } from "../../Culling/boundingInfo";
-import { AutoReleaseWorkerPool } from "../../Misc/workerPool";
-import type { Nullable } from "../../types";
-import type { IDisposable, Scene } from "../../scene";
-import { Geometry } from "../geometry";
+import type { IDracoCodecConfiguration } from "./dracoCodec";
+import type { MeshData } from "./dracoDecoder";
 import { VertexData } from "../mesh.vertexData";
-import { type AttributeData } from "./dracoCompressionWorker";
-interface MeshData {
-    indices?: Uint16Array | Uint32Array;
-    attributes: Array<AttributeData>;
-    totalVertices: number;
-}
+import type { Nullable } from "../../types.js";
+import type { Geometry } from "../geometry";
+import type { BoundingInfo } from "../../Culling/boundingInfo";
+import type { Scene } from "../../scene";
 /**
  * Configuration for Draco compression
  */
@@ -17,52 +12,12 @@ export interface IDracoCompressionConfiguration {
     /**
      * Configuration for the decoder.
      */
-    decoder: {
-        /**
-         * The url to the WebAssembly module.
-         */
-        wasmUrl?: string;
-        /**
-         * The url to the WebAssembly binary.
-         */
-        wasmBinaryUrl?: string;
-        /**
-         * The url to the fallback JavaScript module.
-         */
-        fallbackUrl?: string;
-        /**
-         * Optional worker pool to use for async decoding instead of creating a new worker pool.
-         */
-        workerPool?: AutoReleaseWorkerPool;
-        /**
-         * Optional ArrayBuffer of the WebAssembly binary
-         */
-        wasmBinary?: ArrayBuffer;
-        /**
-         * The decoder module if already available.
-         */
-        jsModule?: any;
-    };
+    decoder: IDracoCodecConfiguration;
 }
 /**
  * Options for Draco compression
  */
-export interface IDracoCompressionOptions {
-    /**
-     * The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
-     */
-    numWorkers?: number;
-    /**
-     * Optional ArrayBuffer of the WebAssembly binary.
-     * If provided it will be used instead of loading the binary from wasmBinaryUrl.
-     */
-    wasmBinary?: ArrayBuffer;
-    /**
-     * Optional worker pool to use for async decoding.
-     * If provided, numWorkers will be ignored and the worker pool will be used instead.
-     * If provided the draco script will not be loaded from the DracoConfiguration.
-     */
-    workerPool?: AutoReleaseWorkerPool;
+export interface IDracoCompressionOptions extends Pick<IDracoCodecConfiguration, "numWorkers" | "wasmBinary" | "workerPool"> {
 }
 /**
  * Draco compression (https://google.github.io/draco/)
@@ -99,9 +54,8 @@ export interface IDracoCompressionOptions {
  *
  * @see https://playground.babylonjs.com/#DMZIBD#0
  */
-export declare class DracoCompression implements IDisposable {
-    private _workerPoolPromise?;
-    private _decoderModulePromise?;
+export declare class DracoCompression {
+    private _decoder;
     /**
      * The configuration. Defaults to the following urls:
      * - wasmUrl: "https://cdn.babylonjs.com/draco_wasm_wrapper_gltf.js"
@@ -117,10 +71,9 @@ export declare class DracoCompression implements IDisposable {
      * Default number of workers to create when creating the draco compression object.
      */
     static DefaultNumWorkers: number;
-    private static GetDefaultNumWorkers;
-    private static _Default;
+    protected static _Default: Nullable<DracoCompression>;
     /**
-     * Default instance for the draco compression object.
+     * Default instance for the DracoCompression.
      */
     static get Default(): DracoCompression;
     /**
@@ -131,10 +84,12 @@ export declare class DracoCompression implements IDisposable {
      */
     static ResetDefault(skipDispose?: boolean): void;
     /**
-     * Constructor
-     * @param numWorkers The number of workers for async operations Or an options object. Specify `0` to disable web workers and run synchronously in the current context.
+     * Creates a new DracoCompression object.
+     * @param numWorkersOrOptions Overrides for the Configuration. Either:
+     * - The number of workers for async operations or a config object. Specify `0` to disable web workers and run synchronously in the current context.
+     * - An options object
      */
-    constructor(numWorkers?: number | IDracoCompressionOptions);
+    constructor(numWorkersOrOptions?: number | IDracoCompressionOptions);
     /**
      * Stop all async operations and release resources.
      */
@@ -184,4 +139,3 @@ export declare class DracoCompression implements IDisposable {
         [kind: string]: number;
     }): Promise<VertexData>;
 }
-export {};

package/Meshes/Compression/dracoCompression.js

@@ -1,17 +1,7 @@
-import { Tools } from "../../Misc/tools.js";
-import { AutoReleaseWorkerPool } from "../../Misc/workerPool.js";
-import { Geometry } from "../geometry.js";
+import { _GetDefaultNumWorkers, _IsConfigurationAvailable } from "./dracoCodec.js";
+import { DracoDecoder } from "./dracoDecoder.js";
 import { VertexBuffer } from "../buffer.js";
 import { VertexData } from "../mesh.vertexData.js";
-import { Logger } from "../../Misc/logger.js";
-import { decodeMesh, workerFunction, initializeWebWorker } from "./dracoCompressionWorker.js";
-function createDecoderAsync(wasmBinary, jsModule) {
-    return new Promise((resolve) => {
-        (jsModule || DracoDecoderModule)({ wasmBinary }).then((module) => {
-            resolve({ module });
-        });
-    });
-}
 /**
  * Draco compression (https://google.github.io/draco/)
  *
@@ -52,23 +42,13 @@ export class DracoCompression {
      * Returns true if the decoder configuration is available.
      */
     static get DecoderAvailable() {
-        const decoder = DracoCompression.Configuration.decoder;
-        return !!((decoder.wasmUrl && decoder.wasmBinaryUrl && typeof WebAssembly === "object") || decoder.fallbackUrl);
-    }
-    static GetDefaultNumWorkers() {
-        if (typeof navigator !== "object" || !navigator.hardwareConcurrency) {
-            return 1;
-        }
-        // Use 50% of the available logical processors but capped at 4.
-        return Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);
+        return _IsConfigurationAvailable(DracoCompression.Configuration.decoder);
     }
     /**
-     * Default instance for the draco compression object.
+     * Default instance for the DracoCompression.
      */
     static get Default() {
-        if (!DracoCompression._Default) {
-            DracoCompression._Default = new DracoCompression();
-        }
+        DracoCompression._Default ?? (DracoCompression._Default = new DracoCompression());
         return DracoCompression._Default;
     }
     /**
@@ -86,83 +66,29 @@ export class DracoCompression {
         }
     }
     /**
-     * Constructor
-     * @param numWorkers The number of workers for async operations Or an options object. Specify `0` to disable web workers and run synchronously in the current context.
+     * Creates a new DracoCompression object.
+     * @param numWorkersOrOptions Overrides for the Configuration. Either:
+     * - The number of workers for async operations or a config object. Specify `0` to disable web workers and run synchronously in the current context.
+     * - An options object
      */
-    constructor(numWorkers = DracoCompression.DefaultNumWorkers) {
-        const decoder = DracoCompression.Configuration.decoder;
-        // check if the decoder binary and worker pool was injected
-        // Note - it is expected that the developer checked if WebWorker, WebAssembly and the URL object are available
-        if (decoder.workerPool || (typeof numWorkers === "object" && numWorkers.workerPool)) {
-            // set the promise accordingly
-            this._workerPoolPromise = Promise.resolve(decoder.workerPool || numWorkers.workerPool);
-        }
-        else {
-            // to avoid making big changes to the decider, if wasmBinary is provided use it in the wasmBinaryPromise
-            const wasmBinaryProvided = decoder.wasmBinary || (typeof numWorkers === "object" && numWorkers.wasmBinary);
-            const numberOfWorkers = typeof numWorkers === "number" ? numWorkers : numWorkers.numWorkers;
-            const useWorkers = numberOfWorkers && typeof Worker === "function" && typeof URL === "function";
-            const urlNeeded = useWorkers || (!useWorkers && !decoder.jsModule);
-            // code maintained here for back-compat with no changes
-            const decoderInfo = decoder.wasmUrl && decoder.wasmBinaryUrl && typeof WebAssembly === "object"
-                ? {
-                    url: urlNeeded ? Tools.GetBabylonScriptURL(decoder.wasmUrl, true) : "",
-                    wasmBinaryPromise: wasmBinaryProvided ? Promise.resolve(wasmBinaryProvided) : Tools.LoadFileAsync(Tools.GetBabylonScriptURL(decoder.wasmBinaryUrl, true)),
-                }
-                : {
-                    url: urlNeeded ? Tools.GetBabylonScriptURL(decoder.fallbackUrl) : "",
-                    wasmBinaryPromise: Promise.resolve(undefined),
-                };
-            if (useWorkers) {
-                this._workerPoolPromise = decoderInfo.wasmBinaryPromise.then((decoderWasmBinary) => {
-                    const workerContent = `${decodeMesh}(${workerFunction})()`;
-                    const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: "application/javascript" }));
-                    return new AutoReleaseWorkerPool(numberOfWorkers, () => {
-                        const worker = new Worker(workerBlobUrl);
-                        return initializeWebWorker(worker, decoderWasmBinary, decoderInfo.url);
-                    });
-                });
-            }
-            else {
-                this._decoderModulePromise = decoderInfo.wasmBinaryPromise.then(async (decoderWasmBinary) => {
-                    if (typeof DracoDecoderModule === "undefined") {
-                        if (!decoder.jsModule) {
-                            if (!decoderInfo.url) {
-                                throw new Error("Draco decoder module is not available");
-                            }
-                            await Tools.LoadBabylonScriptAsync(decoderInfo.url);
-                        }
-                    }
-                    return await createDecoderAsync(decoderWasmBinary, decoder.jsModule);
-                });
-            }
-        }
+    constructor(numWorkersOrOptions = DracoCompression.DefaultNumWorkers) {
+        const configuration = typeof numWorkersOrOptions === "number"
+            ? { ...DracoCompression.Configuration.decoder, numWorkers: numWorkersOrOptions }
+            : { ...DracoCompression.Configuration.decoder, ...numWorkersOrOptions };
+        this._decoder = new DracoDecoder(configuration);
     }
     /**
      * Stop all async operations and release resources.
      */
     dispose() {
-        if (this._workerPoolPromise) {
-            this._workerPoolPromise.then((workerPool) => {
-                workerPool.dispose();
-            });
-        }
-        delete this._workerPoolPromise;
-        delete this._decoderModulePromise;
+        this._decoder.dispose();
     }
     /**
      * Returns a promise that resolves when ready. Call this manually to ensure draco compression is ready before use.
      * @returns a promise that resolves when ready
      */
     async whenReadyAsync() {
-        if (this._workerPoolPromise) {
-            await this._workerPoolPromise;
-            return;
-        }
-        if (this._decoderModulePromise) {
-            await this._decoderModulePromise;
-            return;
-        }
+        return this._decoder.whenReadyAsync();
     }
     /**
      * Decode Draco compressed mesh data to mesh data.
@@ -172,85 +98,7 @@ export class DracoCompression {
      * @returns A promise that resolves with the decoded mesh data
      */
     decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride) {
-        const dataView = data instanceof ArrayBuffer ? new Int8Array(data) : new Int8Array(data.buffer, data.byteOffset, data.byteLength);
-        const applyGltfNormalizedOverride = (kind, normalized) => {
-            if (gltfNormalizedOverride && gltfNormalizedOverride[kind] !== undefined) {
-                if (normalized !== gltfNormalizedOverride[kind]) {
-                    Logger.Warn(`Normalized flag from Draco data (${normalized}) does not match normalized flag from glTF accessor (${gltfNormalizedOverride[kind]}). Using flag from glTF accessor.`);
-                }
-                return gltfNormalizedOverride[kind];
-            }
-            else {
-                return normalized;
-            }
-        };
-        if (this._workerPoolPromise) {
-            return this._workerPoolPromise.then((workerPool) => {
-                return new Promise((resolve, reject) => {
-                    workerPool.push((worker, onComplete) => {
-                        let resultIndices = null;
-                        const resultAttributes = [];
-                        const onError = (error) => {
-                            worker.removeEventListener("error", onError);
-                            worker.removeEventListener("message", onMessage);
-                            reject(error);
-                            onComplete();
-                        };
-                        const onMessage = (event) => {
-                            const message = event.data;
-                            switch (message.id) {
-                                case "decodeMeshDone": {
-                                    worker.removeEventListener("error", onError);
-                                    worker.removeEventListener("message", onMessage);
-                                    resolve({ indices: resultIndices, attributes: resultAttributes, totalVertices: message.totalVertices });
-                                    onComplete();
-                                    break;
-                                }
-                                case "indices": {
-                                    resultIndices = message.data;
-                                    break;
-                                }
-                                case "attribute": {
-                                    resultAttributes.push({
-                                        kind: message.kind,
-                                        data: message.data,
-                                        size: message.size,
-                                        byteOffset: message.byteOffset,
-                                        byteStride: message.byteStride,
-                                        normalized: applyGltfNormalizedOverride(message.kind, message.normalized),
-                                    });
-                                    break;
-                                }
-                            }
-                        };
-                        worker.addEventListener("error", onError);
-                        worker.addEventListener("message", onMessage);
-                        const dataViewCopy = dataView.slice();
-                        worker.postMessage({ id: "decodeMesh", dataView: dataViewCopy, attributes: attributes }, [dataViewCopy.buffer]);
-                    });
-                });
-            });
-        }
-        if (this._decoderModulePromise) {
-            return this._decoderModulePromise.then((decoder) => {
-                let resultIndices = null;
-                const resultAttributes = [];
-                const numPoints = decodeMesh(decoder.module, dataView, attributes, (indices) => {
-                    resultIndices = indices;
-                }, (kind, data, size, byteOffset, byteStride, normalized) => {
-                    resultAttributes.push({
-                        kind,
-                        data,
-                        size,
-                        byteOffset,
-                        byteStride,
-                        normalized,
-                    });
-                });
-                return { indices: resultIndices, attributes: resultAttributes, totalVertices: numPoints };
-            });
-        }
-        throw new Error("Draco decoder module is not available");
+        return this._decoder.decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride);
     }
     /**
      * Decode Draco compressed mesh data to Babylon geometry.
@@ -261,31 +109,11 @@ export class DracoCompression {
      * @returns A promise that resolves with the decoded geometry
      */
     async decodeMeshToGeometryAsync(name, scene, data, attributes) {
-        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes);
-        const geometry = new Geometry(name, scene);
-        if (meshData.indices) {
-            geometry.setIndices(meshData.indices);
-        }
-        for (const attribute of meshData.attributes) {
-            geometry.setVerticesBuffer(new VertexBuffer(scene.getEngine(), attribute.data, attribute.kind, false, undefined, attribute.byteStride, undefined, attribute.byteOffset, attribute.size, undefined, attribute.normalized, true), meshData.totalVertices);
-        }
-        return geometry;
+        return this._decoder.decodeMeshToGeometryAsync(name, scene, data, attributes);
     }
     /** @internal */
     async _decodeMeshToGeometryForGltfAsync(name, scene, data, attributes, gltfNormalizedOverride, boundingInfo) {
-        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride);
-        const geometry = new Geometry(name, scene);
-        if (boundingInfo) {
-            geometry._boundingInfo = boundingInfo;
-            geometry.useBoundingInfoFromGeometry = true;
-        }
-        if (meshData.indices) {
-            geometry.setIndices(meshData.indices);
-        }
-        for (const attribute of meshData.attributes) {
-            geometry.setVerticesBuffer(new VertexBuffer(scene.getEngine(), attribute.data, attribute.kind, false, undefined, attribute.byteStride, undefined, attribute.byteOffset, attribute.size, undefined, attribute.normalized, true), meshData.totalVertices);
-        }
-        return geometry;
+        return this._decoder._decodeMeshToGeometryForGltfAsync(name, scene, data, attributes, gltfNormalizedOverride, boundingInfo);
     }
     /**
      * Decode Draco compressed mesh data to Babylon vertex data.
@@ -295,7 +123,7 @@ export class DracoCompression {
      * @deprecated Use {@link decodeMeshToGeometryAsync} for better performance in some cases
      */
     async decodeMeshAsync(data, attributes) {
-        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes);
+        const meshData = await this._decoder.decodeMeshToMeshDataAsync(data, attributes);
         const vertexData = new VertexData();
         if (meshData.indices) {
             vertexData.indices = meshData.indices;
@@ -313,16 +141,10 @@ export class DracoCompression {
  * - wasmBinaryUrl: "https://cdn.babylonjs.com/draco_decoder_gltf.wasm"
  * - fallbackUrl: "https://cdn.babylonjs.com/draco_decoder_gltf.js"
  */
-DracoCompression.Configuration = {
-    decoder: {
-        wasmUrl: `${Tools._DefaultCdnUrl}/draco_wasm_wrapper_gltf.js`,
-        wasmBinaryUrl: `${Tools._DefaultCdnUrl}/draco_decoder_gltf.wasm`,
-        fallbackUrl: `${Tools._DefaultCdnUrl}/draco_decoder_gltf.js`,
-    },
-};
+DracoCompression.Configuration = { decoder: { ...DracoDecoder.DefaultConfiguration } }; // Use copy
 /**
  * Default number of workers to create when creating the draco compression object.
  */
-DracoCompression.DefaultNumWorkers = DracoCompression.GetDefaultNumWorkers();
+DracoCompression.DefaultNumWorkers = _GetDefaultNumWorkers();
 DracoCompression._Default = null;
 //# sourceMappingURL=dracoCompression.js.map