@needle-tools/engine 4.7.1 → 4.7.2-alpha

package/lib/engine/engine_loaders.callbacks.d.ts

@@ -1,97 +1,97 @@
-import { BufferGeometry, Object3D } from "three";
-import { Context } from "./engine_setup.js";
-import { CustomModel } from "./engine_types.js";
-import { type NeedleMimetype } from "./engine_utils_format.js";
-export type ValidLoaderReturnType = CustomModel | Object3D | BufferGeometry;
-/** @internal */
-export type CustomLoader = {
-    /** The name of the loader. This is used for debugging purposes. */
-    name?: string;
-    /** Load the model from the given URL. This method should return a promise that resolves to the loaded model. */
-    loadAsync: (url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined) => Promise<ValidLoaderReturnType>;
-    /** Load the model given a buffer. This method should return the loaded model. */
-    parse: (buffer: ArrayBuffer | string, path: string) => ValidLoaderReturnType;
-};
-type CustomLoaderCallback = (args: {
-    context: Context;
-    url: string;
-    mimetype: NeedleMimetype;
-}) => CustomLoader | Promise<CustomLoader> | null | undefined | void;
-/** @internal */
-export declare const registeredModelLoaderCallbacks: Array<{
-    name?: string;
-    priority: number;
-    callback: CustomLoaderCallback;
-}>;
-type MimetypeCallback = (args: {
-    /** The URL of the file to load */
-    url: string;
-    /** The response of the range request with the first few bytes of the file (bytes are available in the 'args.bytes' property of this callback) */
-    response: Response;
-    /** The mimetype of the file as provided by the request header */
-    contentType: string | null;
-    /** The first few bytes of the file as a Uint8Array */
-    bytes: Uint8Array;
-}) => NeedleMimetype | null;
-/** @internal */
-export declare const registeredMimetypeCallbacks: Array<MimetypeCallback>;
-/**
- * NeedleEngineModelLoader is a namespace that provides functions to register custom model loaders and mimetype callbacks.
- * It allows you to create custom loaders for specific file types and determine the mimetype of files based on their content.
- * @example
- * ```ts
- * import { NeedleEngineModelLoader } from "@needle-tools/engine";
- * import { STLLoader } from "three/examples/jsm/loaders/STLLoader";
- *
- * NeedleEngineModelLoader.onCreateCustomModelLoader(args => {
- *    if (args.mimetype === "model/stl") {
- *       return new STLLoader();
- *  }
- * });
- *
- * NeedleEngineModelLoader.onDetermineModelMimetype((args) => {
- *   // detect stl mimetype
- *   const bytes = args.bytes;
- *   if (bytes[0] === 0x73 && bytes[1] === 0x74 && bytes[2] === 0x6c) {
- *      return "model/stl";
- *   }
- *   return null;
- * });
- * ```
- */
-export declare namespace NeedleEngineModelLoader {
-    type CustomLoaderOptions = {
-        /** The name of the loader. This is used for debugging purposes. */
-        name?: string;
-        /**
-         * The priority of the loader. Higher priority loaders will be called first.
-         * @default 0
-         */
-        priority?: number;
-    };
-    /**
-     * Register a custom loader callback. For every file that is requested this callback is called with the url and mimetype. It should return a custom loader or null if it does not want to handle the file.
-     * @param callback The callback to register
-     * @param opts Optional options for the loader (e.g. name, priority)
-     * @returns A function to unregister the callback
-     * @example
-     * ```ts
-     * import { onCreateModelLoader } from "@needle-tools/engine";
-     * const unregister = onCreateModelLoader((url, mimetype) => {
-     *     if (mimetype === "application/vnd.usdz+zip") {
-     *         return new CustomLoader();
-     *     }
-     *     return null;
-     * });
-     */
-    export function onCreateCustomModelLoader(callback: CustomLoaderCallback, opts?: CustomLoaderOptions): () => void;
-    /**
-     * Register a callback to determine the mimetype of a file. This is to support custom loaders. The callback will provide the URL of the file to load + a range request response with the first few bytes of the file. The callback should return a mimetype or null if it does not want to handle the file.
-     * @param callback The callback to register
-     * @returns A function to unregister the callback
-     *
-     */
-    export function onDetermineModelMimetype(callback: MimetypeCallback): (() => void);
-    export {};
-}
-export {};
+import { BufferGeometry, Object3D } from "three";
+import { Context } from "./engine_setup.js";
+import { CustomModel } from "./engine_types.js";
+import { type NeedleMimetype } from "./engine_utils_format.js";
+export type ValidLoaderReturnType = CustomModel | Object3D | BufferGeometry;
+/** @internal */
+export type CustomLoader = {
+    /** The name of the loader. This is used for debugging purposes. */
+    name?: string;
+    /** Load the model from the given URL. This method should return a promise that resolves to the loaded model. */
+    loadAsync: (url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined) => Promise<ValidLoaderReturnType>;
+    /** Load the model given a buffer. This method should return the loaded model. */
+    parse: (buffer: ArrayBuffer | string, path: string) => ValidLoaderReturnType;
+};
+type CustomLoaderCallback = (args: {
+    context: Context;
+    url: string;
+    mimetype: NeedleMimetype;
+}) => CustomLoader | Promise<CustomLoader> | null | undefined | void;
+/** @internal */
+export declare const registeredModelLoaderCallbacks: Array<{
+    name?: string;
+    priority: number;
+    callback: CustomLoaderCallback;
+}>;
+type MimetypeCallback = (args: {
+    /** The URL of the file to load */
+    url: string;
+    /** The response of the range request with the first few bytes of the file (bytes are available in the 'args.bytes' property of this callback) */
+    response: Response;
+    /** The mimetype of the file as provided by the request header */
+    contentType: string | null;
+    /** The first few bytes of the file as a Uint8Array */
+    bytes: Uint8Array;
+}) => NeedleMimetype | null;
+/** @internal */
+export declare const registeredMimetypeCallbacks: Array<MimetypeCallback>;
+/**
+ * NeedleEngineModelLoader is a namespace that provides functions to register custom model loaders and mimetype callbacks.
+ * It allows you to create custom loaders for specific file types and determine the mimetype of files based on their content.
+ * @example
+ * ```ts
+ * import { NeedleEngineModelLoader } from "@needle-tools/engine";
+ * import { STLLoader } from "three/examples/jsm/loaders/STLLoader";
+ *
+ * NeedleEngineModelLoader.onCreateCustomModelLoader(args => {
+ *    if (args.mimetype === "model/stl") {
+ *       return new STLLoader();
+ *  }
+ * });
+ *
+ * NeedleEngineModelLoader.onDetermineModelMimetype((args) => {
+ *   // detect stl mimetype
+ *   const bytes = args.bytes;
+ *   if (bytes[0] === 0x73 && bytes[1] === 0x74 && bytes[2] === 0x6c) {
+ *      return "model/stl";
+ *   }
+ *   return null;
+ * });
+ * ```
+ */
+export declare namespace NeedleEngineModelLoader {
+    type CustomLoaderOptions = {
+        /** The name of the loader. This is used for debugging purposes. */
+        name?: string;
+        /**
+         * The priority of the loader. Higher priority loaders will be called first.
+         * @default 0
+         */
+        priority?: number;
+    };
+    /**
+     * Register a custom loader callback. For every file that is requested this callback is called with the url and mimetype. It should return a custom loader or null if it does not want to handle the file.
+     * @param callback The callback to register
+     * @param opts Optional options for the loader (e.g. name, priority)
+     * @returns A function to unregister the callback
+     * @example
+     * ```ts
+     * import { onCreateModelLoader } from "@needle-tools/engine";
+     * const unregister = onCreateModelLoader((url, mimetype) => {
+     *     if (mimetype === "application/vnd.usdz+zip") {
+     *         return new CustomLoader();
+     *     }
+     *     return null;
+     * });
+     */
+    export function onCreateCustomModelLoader(callback: CustomLoaderCallback, opts?: CustomLoaderOptions): () => void;
+    /**
+     * Register a callback to determine the mimetype of a file. This is to support custom loaders. The callback will provide the URL of the file to load + a range request response with the first few bytes of the file. The callback should return a mimetype or null if it does not want to handle the file.
+     * @param callback The callback to register
+     * @returns A function to unregister the callback
+     *
+     */
+    export function onDetermineModelMimetype(callback: MimetypeCallback): (() => void);
+    export {};
+}
+export {};

package/lib/engine/engine_loaders.callbacks.js

@@ -1,87 +1,87 @@
-/** @internal */
-export const registeredModelLoaderCallbacks = [];
-/** @internal */
-export const registeredMimetypeCallbacks = [];
-/**
- * NeedleEngineModelLoader is a namespace that provides functions to register custom model loaders and mimetype callbacks.
- * It allows you to create custom loaders for specific file types and determine the mimetype of files based on their content.
- * @example
- * ```ts
- * import { NeedleEngineModelLoader } from "@needle-tools/engine";
- * import { STLLoader } from "three/examples/jsm/loaders/STLLoader";
- *
- * NeedleEngineModelLoader.onCreateCustomModelLoader(args => {
- *    if (args.mimetype === "model/stl") {
- *       return new STLLoader();
- *  }
- * });
- *
- * NeedleEngineModelLoader.onDetermineModelMimetype((args) => {
- *   // detect stl mimetype
- *   const bytes = args.bytes;
- *   if (bytes[0] === 0x73 && bytes[1] === 0x74 && bytes[2] === 0x6c) {
- *      return "model/stl";
- *   }
- *   return null;
- * });
- * ```
- */
-export var NeedleEngineModelLoader;
-(function (NeedleEngineModelLoader) {
-    // export type Plugin = {
-    //     readonly name: string;
-    //     canLoad: (mimetype: string, url: string) => boolean,
-    //     createLoader: (url: string, mimetype: string) => Promise<CustomLoader>,
-    // }
-    /**
-     * Register a custom loader callback. For every file that is requested this callback is called with the url and mimetype. It should return a custom loader or null if it does not want to handle the file.
-     * @param callback The callback to register
-     * @param opts Optional options for the loader (e.g. name, priority)
-     * @returns A function to unregister the callback
-     * @example
-     * ```ts
-     * import { onCreateModelLoader } from "@needle-tools/engine";
-     * const unregister = onCreateModelLoader((url, mimetype) => {
-     *     if (mimetype === "application/vnd.usdz+zip") {
-     *         return new CustomLoader();
-     *     }
-     *     return null;
-     * });
-     */
-    function onCreateCustomModelLoader(callback, opts) {
-        const entry = { name: opts?.name, priority: opts?.priority ?? 0, callback };
-        registeredModelLoaderCallbacks.push(entry);
-        // sort plugins by priority. Higher priority first
-        registeredModelLoaderCallbacks.sort((a, b) => {
-            if (a.priority === b.priority)
-                return 0;
-            if (a.priority > b.priority)
-                return -1;
-            return 1;
-        });
-        return () => {
-            const index = registeredModelLoaderCallbacks.indexOf(entry);
-            if (index >= 0) {
-                registeredModelLoaderCallbacks.splice(index, 1);
-            }
-        };
-    }
-    NeedleEngineModelLoader.onCreateCustomModelLoader = onCreateCustomModelLoader;
-    /**
-     * Register a callback to determine the mimetype of a file. This is to support custom loaders. The callback will provide the URL of the file to load + a range request response with the first few bytes of the file. The callback should return a mimetype or null if it does not want to handle the file.
-     * @param callback The callback to register
-     * @returns A function to unregister the callback
-     *
-     */
-    function onDetermineModelMimetype(callback) {
-        registeredMimetypeCallbacks.push(callback);
-        return () => {
-            const index = registeredMimetypeCallbacks.indexOf(callback);
-            if (index >= 0) {
-                registeredMimetypeCallbacks.splice(index, 1);
-            }
-        };
-    }
-    NeedleEngineModelLoader.onDetermineModelMimetype = onDetermineModelMimetype;
-})(NeedleEngineModelLoader || (NeedleEngineModelLoader = {}));
+/** @internal */
+export const registeredModelLoaderCallbacks = [];
+/** @internal */
+export const registeredMimetypeCallbacks = [];
+/**
+ * NeedleEngineModelLoader is a namespace that provides functions to register custom model loaders and mimetype callbacks.
+ * It allows you to create custom loaders for specific file types and determine the mimetype of files based on their content.
+ * @example
+ * ```ts
+ * import { NeedleEngineModelLoader } from "@needle-tools/engine";
+ * import { STLLoader } from "three/examples/jsm/loaders/STLLoader";
+ *
+ * NeedleEngineModelLoader.onCreateCustomModelLoader(args => {
+ *    if (args.mimetype === "model/stl") {
+ *       return new STLLoader();
+ *  }
+ * });
+ *
+ * NeedleEngineModelLoader.onDetermineModelMimetype((args) => {
+ *   // detect stl mimetype
+ *   const bytes = args.bytes;
+ *   if (bytes[0] === 0x73 && bytes[1] === 0x74 && bytes[2] === 0x6c) {
+ *      return "model/stl";
+ *   }
+ *   return null;
+ * });
+ * ```
+ */
+export var NeedleEngineModelLoader;
+(function (NeedleEngineModelLoader) {
+    // export type Plugin = {
+    //     readonly name: string;
+    //     canLoad: (mimetype: string, url: string) => boolean,
+    //     createLoader: (url: string, mimetype: string) => Promise<CustomLoader>,
+    // }
+    /**
+     * Register a custom loader callback. For every file that is requested this callback is called with the url and mimetype. It should return a custom loader or null if it does not want to handle the file.
+     * @param callback The callback to register
+     * @param opts Optional options for the loader (e.g. name, priority)
+     * @returns A function to unregister the callback
+     * @example
+     * ```ts
+     * import { onCreateModelLoader } from "@needle-tools/engine";
+     * const unregister = onCreateModelLoader((url, mimetype) => {
+     *     if (mimetype === "application/vnd.usdz+zip") {
+     *         return new CustomLoader();
+     *     }
+     *     return null;
+     * });
+     */
+    function onCreateCustomModelLoader(callback, opts) {
+        const entry = { name: opts?.name, priority: opts?.priority ?? 0, callback };
+        registeredModelLoaderCallbacks.push(entry);
+        // sort plugins by priority. Higher priority first
+        registeredModelLoaderCallbacks.sort((a, b) => {
+            if (a.priority === b.priority)
+                return 0;
+            if (a.priority > b.priority)
+                return -1;
+            return 1;
+        });
+        return () => {
+            const index = registeredModelLoaderCallbacks.indexOf(entry);
+            if (index >= 0) {
+                registeredModelLoaderCallbacks.splice(index, 1);
+            }
+        };
+    }
+    NeedleEngineModelLoader.onCreateCustomModelLoader = onCreateCustomModelLoader;
+    /**
+     * Register a callback to determine the mimetype of a file. This is to support custom loaders. The callback will provide the URL of the file to load + a range request response with the first few bytes of the file. The callback should return a mimetype or null if it does not want to handle the file.
+     * @param callback The callback to register
+     * @returns A function to unregister the callback
+     *
+     */
+    function onDetermineModelMimetype(callback) {
+        registeredMimetypeCallbacks.push(callback);
+        return () => {
+            const index = registeredMimetypeCallbacks.indexOf(callback);
+            if (index >= 0) {
+                registeredMimetypeCallbacks.splice(index, 1);
+            }
+        };
+    }
+    NeedleEngineModelLoader.onDetermineModelMimetype = onDetermineModelMimetype;
+})(NeedleEngineModelLoader || (NeedleEngineModelLoader = {}));
 //# sourceMappingURL=engine_loaders.callbacks.js.map

package/lib/engine/engine_loaders.d.ts

@@ -1,48 +1,48 @@
-import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
-import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
-import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
-import { USDZLoader } from 'three/examples/jsm/loaders/USDZLoader.js';
-import { type INeedleGltfLoader } from "./engine_gltf.js";
-import { CustomLoader } from "./engine_loaders.callbacks.js";
-import { SerializationContext } from "./engine_serialization_core.js";
-import { Context } from "./engine_setup.js";
-import { Model, type UIDProvider } from "./engine_types.js";
-import { NEEDLE_components } from "./extensions/NEEDLE_components.js";
-/** @internal */
-export declare class NeedleLoader implements INeedleGltfLoader {
-    createBuiltinComponents(context: Context, gltfId: string, gltf: any, seed: number | UIDProvider | null, extension?: NEEDLE_components | undefined): Promise<void>;
-    writeBuiltinComponentData(comp: any, context: SerializationContext): object | null;
-    parseSync(context: Context, data: string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<Model | undefined>;
-    loadSync(context: Context, url: string, sourceId: string, seed: number | UIDProvider | null, prog?: ((ProgressEvent: any) => void) | undefined): Promise<Model | undefined>;
-}
-export declare function onCreateLoader(url: string, context: Context): Promise<CustomLoader | GLTFLoader | FBXLoader | USDZLoader | OBJLoader | null>;
-/**
- * Load a 3D model file from a remote URL
- * @param url URL to glTF, FBX or OBJ file
- * @param options
- * @returns A promise that resolves to the loaded model or undefined if the loading failed
- */
-export declare function loadAsset(url: string, options?: {
-    context?: Context;
-    path?: string;
-    seed?: number;
-    onprogress?: (evt: ProgressEvent) => void;
-}): Promise<Model | undefined>;
-/** Load a gltf file from a url. This is the core method used by Needle Engine to load gltf files. All known extensions are registered here.
- * @param context The current context
- * @param data The gltf data as string or ArrayBuffer
- * @param path The path to the gltf file
- * @param seed The seed for generating unique ids
- * @returns The loaded gltf object
- */
-export declare function parseSync(context: Context, data: string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<Model | undefined>;
-/**
- * Load a gltf file from a url. This is the core method used by Needle Engine to load gltf files. All known extensions are registered here.
- * @param context The current context
- * @param url The url to the gltf file
- * @param sourceId The source id of the gltf file - this is usually the url
- * @param seed The seed for generating unique ids
- * @param prog A progress callback
- * @returns The loaded gltf object
- */
-export declare function loadSync(context: Context, url: string, sourceId: string, seed: number | UIDProvider | null, prog?: (ProgressEvent: any) => void): Promise<Model | undefined>;
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
+import { USDZLoader } from 'three/examples/jsm/loaders/USDZLoader.js';
+import { type INeedleGltfLoader } from "./engine_gltf.js";
+import { CustomLoader } from "./engine_loaders.callbacks.js";
+import { SerializationContext } from "./engine_serialization_core.js";
+import { Context } from "./engine_setup.js";
+import { Model, type UIDProvider } from "./engine_types.js";
+import { NEEDLE_components } from "./extensions/NEEDLE_components.js";
+/** @internal */
+export declare class NeedleLoader implements INeedleGltfLoader {
+    createBuiltinComponents(context: Context, gltfId: string, gltf: any, seed: number | UIDProvider | null, extension?: NEEDLE_components | undefined): Promise<void>;
+    writeBuiltinComponentData(comp: any, context: SerializationContext): object | null;
+    parseSync(context: Context, data: string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<Model | undefined>;
+    loadSync(context: Context, url: string, sourceId: string, seed: number | UIDProvider | null, prog?: ((ProgressEvent: any) => void) | undefined): Promise<Model | undefined>;
+}
+export declare function onCreateLoader(url: string, context: Context): Promise<CustomLoader | GLTFLoader | FBXLoader | USDZLoader | OBJLoader | null>;
+/**
+ * Load a 3D model file from a remote URL
+ * @param url URL to glTF, FBX or OBJ file
+ * @param options
+ * @returns A promise that resolves to the loaded model or undefined if the loading failed
+ */
+export declare function loadAsset(url: string, options?: {
+    context?: Context;
+    path?: string;
+    seed?: number;
+    onprogress?: (evt: ProgressEvent) => void;
+}): Promise<Model | undefined>;
+/** Load a gltf file from a url. This is the core method used by Needle Engine to load gltf files. All known extensions are registered here.
+ * @param context The current context
+ * @param data The gltf data as string or ArrayBuffer
+ * @param path The path to the gltf file
+ * @param seed The seed for generating unique ids
+ * @returns The loaded gltf object
+ */
+export declare function parseSync(context: Context, data: string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<Model | undefined>;
+/**
+ * Load a gltf file from a url. This is the core method used by Needle Engine to load gltf files. All known extensions are registered here.
+ * @param context The current context
+ * @param url The url to the gltf file
+ * @param sourceId The source id of the gltf file - this is usually the url
+ * @param seed The seed for generating unique ids
+ * @param prog A progress callback
+ * @returns The loaded gltf object
+ */
+export declare function loadSync(context: Context, url: string, sourceId: string, seed: number | UIDProvider | null, prog?: (ProgressEvent: any) => void): Promise<Model | undefined>;

package/lib/engine/engine_loaders.gltf.d.ts

@@ -1,13 +1,13 @@
-import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
-import { Context } from "./engine_setup.js";
-export declare function setDracoDecoderPath(path: string | undefined): void;
-export declare function setDracoDecoderType(type: string | undefined): void;
-export declare function setKtx2TranscoderPath(path: string): void;
-export declare function setMeshoptDecoder(_meshoptDecoder: any): void;
-/**
- * Add Draco, Meshopt and KTX2 loaders to a GLTFLoader instance.
- * @param loader The GLTFLoader instance to add the loaders to.
- * @param context The context object containing the renderer.
- * @returns The GLTFLoader instance with the loaders added.
- */
-export declare function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Pick<Context, "renderer">): GLTFLoader;
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { Context } from "./engine_setup.js";
+export declare function setDracoDecoderPath(path: string | undefined): void;
+export declare function setDracoDecoderType(type: string | undefined): void;
+export declare function setKtx2TranscoderPath(path: string): void;
+export declare function setMeshoptDecoder(_meshoptDecoder: any): void;
+/**
+ * Add Draco, Meshopt and KTX2 loaders to a GLTFLoader instance.
+ * @param loader The GLTFLoader instance to add the loaders to.
+ * @param context The context object containing the renderer.
+ * @returns The GLTFLoader instance with the loaders added.
+ */
+export declare function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Pick<Context, "renderer">): GLTFLoader;

package/lib/engine/engine_loaders.gltf.js

@@ -1,63 +1,63 @@
-import { addDracoAndKTX2Loaders as addDracoAndKTX2LoadersGLTFProgressive, configureLoader, createLoaders, setDracoDecoderLocation, setKTX2TranscoderLocation } from '@needle-tools/gltf-progressive';
-import { getParam } from "./engine_utils.js";
-const debug = getParam("debugdecoders");
-let loaders = null;
-function ensureLoaders() {
-    if (!loaders) {
-        const res = createLoaders(null);
-        loaders = { dracoLoader: res.dracoLoader, ktx2Loader: res.ktx2Loader, meshoptDecoder: res.meshoptDecoder };
-    }
-    return loaders;
-}
-export function setDracoDecoderPath(path) {
-    if (path !== undefined && typeof path === "string") {
-        setDracoDecoderLocation(path);
-    }
-}
-export function setDracoDecoderType(type) {
-    if (type !== undefined && typeof type === "string") {
-        if (type !== "js") {
-            const loaders = ensureLoaders();
-            if (debug)
-                console.log("Setting draco decoder type to", type);
-            loaders.dracoLoader.setDecoderConfig({ type: type });
-        }
-    }
-}
-export function setKtx2TranscoderPath(path) {
-    if (path !== undefined && typeof path === "string") {
-        setKTX2TranscoderLocation(path);
-    }
-}
-export function setMeshoptDecoder(_meshoptDecoder) {
-    if (_meshoptDecoder !== undefined) {
-        const loaders = ensureLoaders();
-        loaders.meshoptDecoder = _meshoptDecoder;
-    }
-}
-/**
- * Add Draco, Meshopt and KTX2 loaders to a GLTFLoader instance.
- * @param loader The GLTFLoader instance to add the loaders to.
- * @param context The context object containing the renderer.
- * @returns The GLTFLoader instance with the loaders added.
- */
-export function addDracoAndKTX2Loaders(loader, context) {
-    const loaders = ensureLoaders();
-    if (context.renderer) {
-        loaders.ktx2Loader.detectSupport(context.renderer);
-    }
-    else
-        console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
-    addDracoAndKTX2LoadersGLTFProgressive(loader);
-    if (!loader.dracoLoader)
-        loader.setDRACOLoader(loaders.dracoLoader);
-    if (!loader.ktx2Loader)
-        loader.setKTX2Loader(loaders.ktx2Loader);
-    if (!loader.meshoptDecoder)
-        loader.setMeshoptDecoder(loaders.meshoptDecoder);
-    configureLoader(loader, {
-        progressive: true,
-    });
-    return loader;
-}
+import { addDracoAndKTX2Loaders as addDracoAndKTX2LoadersGLTFProgressive, configureLoader, createLoaders, setDracoDecoderLocation, setKTX2TranscoderLocation } from '@needle-tools/gltf-progressive';
+import { getParam } from "./engine_utils.js";
+const debug = getParam("debugdecoders");
+let loaders = null;
+function ensureLoaders() {
+    if (!loaders) {
+        const res = createLoaders(null);
+        loaders = { dracoLoader: res.dracoLoader, ktx2Loader: res.ktx2Loader, meshoptDecoder: res.meshoptDecoder };
+    }
+    return loaders;
+}
+export function setDracoDecoderPath(path) {
+    if (path !== undefined && typeof path === "string") {
+        setDracoDecoderLocation(path);
+    }
+}
+export function setDracoDecoderType(type) {
+    if (type !== undefined && typeof type === "string") {
+        if (type !== "js") {
+            const loaders = ensureLoaders();
+            if (debug)
+                console.log("Setting draco decoder type to", type);
+            loaders.dracoLoader.setDecoderConfig({ type: type });
+        }
+    }
+}
+export function setKtx2TranscoderPath(path) {
+    if (path !== undefined && typeof path === "string") {
+        setKTX2TranscoderLocation(path);
+    }
+}
+export function setMeshoptDecoder(_meshoptDecoder) {
+    if (_meshoptDecoder !== undefined) {
+        const loaders = ensureLoaders();
+        loaders.meshoptDecoder = _meshoptDecoder;
+    }
+}
+/**
+ * Add Draco, Meshopt and KTX2 loaders to a GLTFLoader instance.
+ * @param loader The GLTFLoader instance to add the loaders to.
+ * @param context The context object containing the renderer.
+ * @returns The GLTFLoader instance with the loaders added.
+ */
+export function addDracoAndKTX2Loaders(loader, context) {
+    const loaders = ensureLoaders();
+    if (context.renderer) {
+        loaders.ktx2Loader.detectSupport(context.renderer);
+    }
+    else
+        console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
+    addDracoAndKTX2LoadersGLTFProgressive(loader);
+    if (!loader.dracoLoader)
+        loader.setDRACOLoader(loaders.dracoLoader);
+    if (!loader.ktx2Loader)
+        loader.setKTX2Loader(loaders.ktx2Loader);
+    if (!loader.meshoptDecoder)
+        loader.setMeshoptDecoder(loaders.meshoptDecoder);
+    configureLoader(loader, {
+        progressive: true,
+    });
+    return loader;
+}
 //# sourceMappingURL=engine_loaders.gltf.js.map