@babylonjs/loaders 5.0.0-rc.5 → 5.0.0-rc.9

package/glTF/1.0/glTFBinaryExtension.js

@@ -1,61 +1,61 @@
-import { __extends } from "tslib";
-import { GLTFLoaderExtension, GLTFLoader, GLTFLoaderBase } from "./glTFLoader.js";
-import { GLTFUtils } from "./glTFLoaderUtils.js";
-import { EComponentType } from "./glTFLoaderInterfaces.js";
-var BinaryExtensionBufferName = "binary_glTF";
-/** @hidden */
-var GLTFBinaryExtension = /** @class */ (function (_super) {
-    __extends(GLTFBinaryExtension, _super);
-    function GLTFBinaryExtension() {
-        return _super.call(this, "KHR_binary_glTF") || this;
-    }
-    GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess) {
-        var extensionsUsed = data.json.extensionsUsed;
-        if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) {
-            return false;
-        }
-        this._bin = data.bin;
-        onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
-        return true;
-    };
-    GLTFBinaryExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
-        if (gltfRuntime.extensionsUsed.indexOf(this.name) === -1) {
-            return false;
-        }
-        if (id !== BinaryExtensionBufferName) {
-            return false;
-        }
-        this._bin.readAsync(0, this._bin.byteLength).then(onSuccess, function (error) { return onError(error.message); });
-        return true;
-    };
-    GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess) {
-        var texture = gltfRuntime.textures[id];
-        var source = gltfRuntime.images[texture.source];
-        if (!source.extensions || !(this.name in source.extensions)) {
-            return false;
-        }
-        var sourceExt = source.extensions[this.name];
-        var bufferView = gltfRuntime.bufferViews[sourceExt.bufferView];
-        var buffer = GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, EComponentType.UNSIGNED_BYTE);
-        onSuccess(buffer);
-        return true;
-    };
-    GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess) {
-        var shader = gltfRuntime.shaders[id];
-        if (!shader.extensions || !(this.name in shader.extensions)) {
-            return false;
-        }
-        var binaryExtensionShader = shader.extensions[this.name];
-        var bufferView = gltfRuntime.bufferViews[binaryExtensionShader.bufferView];
-        var shaderBytes = GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, EComponentType.UNSIGNED_BYTE);
-        setTimeout(function () {
-            var shaderString = GLTFUtils.DecodeBufferToText(shaderBytes);
-            onSuccess(shaderString);
-        });
-        return true;
-    };
-    return GLTFBinaryExtension;
-}(GLTFLoaderExtension));
-export { GLTFBinaryExtension };
-GLTFLoader.RegisterExtension(new GLTFBinaryExtension());
+import { __extends } from "tslib";
+import { GLTFLoaderExtension, GLTFLoader, GLTFLoaderBase } from "./glTFLoader";
+import { GLTFUtils } from "./glTFLoaderUtils";
+import { EComponentType } from "./glTFLoaderInterfaces";
+var BinaryExtensionBufferName = "binary_glTF";
+/** @hidden */
+var GLTFBinaryExtension = /** @class */ (function (_super) {
+    __extends(GLTFBinaryExtension, _super);
+    function GLTFBinaryExtension() {
+        return _super.call(this, "KHR_binary_glTF") || this;
+    }
+    GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess) {
+        var extensionsUsed = data.json.extensionsUsed;
+        if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) {
+            return false;
+        }
+        this._bin = data.bin;
+        onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
+        return true;
+    };
+    GLTFBinaryExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        if (gltfRuntime.extensionsUsed.indexOf(this.name) === -1) {
+            return false;
+        }
+        if (id !== BinaryExtensionBufferName) {
+            return false;
+        }
+        this._bin.readAsync(0, this._bin.byteLength).then(onSuccess, function (error) { return onError(error.message); });
+        return true;
+    };
+    GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess) {
+        var texture = gltfRuntime.textures[id];
+        var source = gltfRuntime.images[texture.source];
+        if (!source.extensions || !(this.name in source.extensions)) {
+            return false;
+        }
+        var sourceExt = source.extensions[this.name];
+        var bufferView = gltfRuntime.bufferViews[sourceExt.bufferView];
+        var buffer = GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, EComponentType.UNSIGNED_BYTE);
+        onSuccess(buffer);
+        return true;
+    };
+    GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess) {
+        var shader = gltfRuntime.shaders[id];
+        if (!shader.extensions || !(this.name in shader.extensions)) {
+            return false;
+        }
+        var binaryExtensionShader = shader.extensions[this.name];
+        var bufferView = gltfRuntime.bufferViews[binaryExtensionShader.bufferView];
+        var shaderBytes = GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, EComponentType.UNSIGNED_BYTE);
+        setTimeout(function () {
+            var shaderString = GLTFUtils.DecodeBufferToText(shaderBytes);
+            onSuccess(shaderString);
+        });
+        return true;
+    };
+    return GLTFBinaryExtension;
+}(GLTFLoaderExtension));
+export { GLTFBinaryExtension };
+GLTFLoader.RegisterExtension(new GLTFBinaryExtension());
 //# sourceMappingURL=glTFBinaryExtension.js.map

package/glTF/1.0/glTFLoader.d.ts

@@ -1,136 +1,136 @@
-import { IGLTFRuntime } from "./glTFLoaderInterfaces";
-import { Nullable } from "@babylonjs/core/types.js";
-import { Material } from "@babylonjs/core/Materials/material.js";
-import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
-import { ISceneLoaderAsyncResult, ISceneLoaderProgressEvent } from "@babylonjs/core/Loading/sceneLoader.js";
-import { Scene } from "@babylonjs/core/scene.js";
-import { IGLTFLoader, IGLTFLoaderData } from "../glTFFileLoader";
-import { AssetContainer } from "@babylonjs/core/assetContainer.js";
-/**
- * Implementation of the base glTF spec
- * @hidden
- */
-export declare class GLTFLoaderBase {
-    static CreateRuntime(parsedData: any, scene: Scene, rootUrl: string): IGLTFRuntime;
-    static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
-    static LoadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: Nullable<ArrayBufferView>) => void, onError: (message: string) => void): void;
-    static CreateTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: Nullable<ArrayBufferView>, onSuccess: (texture: Texture) => void): void;
-    static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string | ArrayBuffer) => void, onError?: (message: string) => void): void;
-    static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
-}
-/**
- * glTF V1 Loader
- * @hidden
- */
-export declare class GLTFLoader implements IGLTFLoader {
-    static Extensions: {
-        [name: string]: GLTFLoaderExtension;
-    };
-    static RegisterExtension(extension: GLTFLoaderExtension): void;
-    dispose(): void;
-    private _importMeshAsync;
-    /**
-     * Imports one or more meshes from a loaded gltf file and adds them to the scene
-     * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
-     * @param scene the scene the meshes should be added to
-     * @param assetContainer defines the asset container to use (can be null)
-     * @param data gltf data containing information of the meshes in a loaded file
-     * @param rootUrl root url to load from
-     * @param onProgress event that fires when loading progress has occured
-     * @returns a promise containg the loaded meshes, particles, skeletons and animations
-     */
-    importMeshAsync(meshesNames: any, scene: Scene, assetContainer: Nullable<AssetContainer>, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void): Promise<ISceneLoaderAsyncResult>;
-    private _loadAsync;
-    /**
-     * Imports all objects from a loaded gltf file and adds them to the scene
-     * @param scene the scene the objects should be added to
-     * @param data gltf data containing information of the meshes in a loaded file
-     * @param rootUrl root url to load from
-     * @param onProgress event that fires when loading progress has occured
-     * @returns a promise which completes when objects have been loaded to the scene
-     */
-    loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void): Promise<void>;
-    private _loadShadersAsync;
-    private _loadBuffersAsync;
-    private _createNodes;
-}
-/** @hidden */
-export declare abstract class GLTFLoaderExtension {
-    private _name;
-    constructor(name: string);
-    get name(): string;
-    /**
-     * Defines an override for loading the runtime
-     * Return true to stop further extensions from loading the runtime
-     * @param scene
-     * @param data
-     * @param rootUrl
-     * @param onSuccess
-     * @param onError
-     */
-    loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): boolean;
-    /**
-     * Defines an onverride for creating gltf runtime
-     * Return true to stop further extensions from creating the runtime
-     * @param gltfRuntime
-     * @param onSuccess
-     * @param onError
-     */
-    loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): boolean;
-    /**
-     * Defines an override for loading buffers
-     * Return true to stop further extensions from loading this buffer
-     * @param gltfRuntime
-     * @param id
-     * @param onSuccess
-     * @param onError
-     * @param onProgress
-     */
-    loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): boolean;
-    /**
-     * Defines an override for loading texture buffers
-     * Return true to stop further extensions from loading this texture data
-     * @param gltfRuntime
-     * @param id
-     * @param onSuccess
-     * @param onError
-     */
-    loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
-    /**
-     * Defines an override for creating textures
-     * Return true to stop further extensions from loading this texture
-     * @param gltfRuntime
-     * @param id
-     * @param buffer
-     * @param onSuccess
-     * @param onError
-     */
-    createTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: ArrayBufferView, onSuccess: (texture: Texture) => void, onError: (message: string) => void): boolean;
-    /**
-     * Defines an override for loading shader strings
-     * Return true to stop further extensions from loading this shader data
-     * @param gltfRuntime
-     * @param id
-     * @param onSuccess
-     * @param onError
-     */
-    loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
-    /**
-     * Defines an override for loading materials
-     * Return true to stop further extensions from loading this material
-     * @param gltfRuntime
-     * @param id
-     * @param onSuccess
-     * @param onError
-     */
-    loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
-    static LoadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): void;
-    static LoadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): void;
-    static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (bufferView: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
-    static LoadTextureAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
-    static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderData: string | ArrayBuffer) => void, onError: (message: string) => void): void;
-    static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
-    private static _LoadTextureBufferAsync;
-    private static _CreateTextureAsync;
-    private static _ApplyExtensions;
-}
+import { IGLTFRuntime } from "./glTFLoaderInterfaces";
+import { Nullable } from "@babylonjs/core/types.js";
+import { Material } from "@babylonjs/core/Materials/material.js";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { ISceneLoaderAsyncResult, ISceneLoaderProgressEvent } from "@babylonjs/core/Loading/sceneLoader.js";
+import { Scene } from "@babylonjs/core/scene.js";
+import { IGLTFLoader, IGLTFLoaderData } from "../glTFFileLoader";
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+/**
+ * Implementation of the base glTF spec
+ * @hidden
+ */
+export declare class GLTFLoaderBase {
+    static CreateRuntime(parsedData: any, scene: Scene, rootUrl: string): IGLTFRuntime;
+    static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
+    static LoadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: Nullable<ArrayBufferView>) => void, onError: (message: string) => void): void;
+    static CreateTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: Nullable<ArrayBufferView>, onSuccess: (texture: Texture) => void): void;
+    static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string | ArrayBuffer) => void, onError?: (message: string) => void): void;
+    static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
+}
+/**
+ * glTF V1 Loader
+ * @hidden
+ */
+export declare class GLTFLoader implements IGLTFLoader {
+    static Extensions: {
+        [name: string]: GLTFLoaderExtension;
+    };
+    static RegisterExtension(extension: GLTFLoaderExtension): void;
+    dispose(): void;
+    private _importMeshAsync;
+    /**
+     * Imports one or more meshes from a loaded gltf file and adds them to the scene
+     * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
+     * @param scene the scene the meshes should be added to
+     * @param assetContainer defines the asset container to use (can be null)
+     * @param data gltf data containing information of the meshes in a loaded file
+     * @param rootUrl root url to load from
+     * @param onProgress event that fires when loading progress has occured
+     * @returns a promise containg the loaded meshes, particles, skeletons and animations
+     */
+    importMeshAsync(meshesNames: any, scene: Scene, assetContainer: Nullable<AssetContainer>, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void): Promise<ISceneLoaderAsyncResult>;
+    private _loadAsync;
+    /**
+     * Imports all objects from a loaded gltf file and adds them to the scene
+     * @param scene the scene the objects should be added to
+     * @param data gltf data containing information of the meshes in a loaded file
+     * @param rootUrl root url to load from
+     * @param onProgress event that fires when loading progress has occured
+     * @returns a promise which completes when objects have been loaded to the scene
+     */
+    loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void): Promise<void>;
+    private _loadShadersAsync;
+    private _loadBuffersAsync;
+    private _createNodes;
+}
+/** @hidden */
+export declare abstract class GLTFLoaderExtension {
+    private _name;
+    constructor(name: string);
+    get name(): string;
+    /**
+     * Defines an override for loading the runtime
+     * Return true to stop further extensions from loading the runtime
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onSuccess
+     * @param onError
+     */
+    loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): boolean;
+    /**
+     * Defines an onverride for creating gltf runtime
+     * Return true to stop further extensions from creating the runtime
+     * @param gltfRuntime
+     * @param onSuccess
+     * @param onError
+     */
+    loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): boolean;
+    /**
+     * Defines an override for loading buffers
+     * Return true to stop further extensions from loading this buffer
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     * @param onProgress
+     */
+    loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): boolean;
+    /**
+     * Defines an override for loading texture buffers
+     * Return true to stop further extensions from loading this texture data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
+    /**
+     * Defines an override for creating textures
+     * Return true to stop further extensions from loading this texture
+     * @param gltfRuntime
+     * @param id
+     * @param buffer
+     * @param onSuccess
+     * @param onError
+     */
+    createTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: ArrayBufferView, onSuccess: (texture: Texture) => void, onError: (message: string) => void): boolean;
+    /**
+     * Defines an override for loading shader strings
+     * Return true to stop further extensions from loading this shader data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
+    /**
+     * Defines an override for loading materials
+     * Return true to stop further extensions from loading this material
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
+    static LoadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): void;
+    static LoadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): void;
+    static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (bufferView: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
+    static LoadTextureAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
+    static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderData: string | ArrayBuffer) => void, onError: (message: string) => void): void;
+    static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
+    private static _LoadTextureBufferAsync;
+    private static _CreateTextureAsync;
+    private static _ApplyExtensions;
+}