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

package/STL/index.d.ts

@@ -1 +1 @@
-export * from "./stlFileLoader";
+export * from "./stlFileLoader";

package/STL/index.js

@@ -1,2 +1,2 @@
-export * from "./stlFileLoader.js";
+export * from "./stlFileLoader";
 //# sourceMappingURL=index.js.map

package/STL/stlFileLoader.d.ts

@@ -1,64 +1,64 @@
-import { Nullable } from "@babylonjs/core/types.js";
-import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
-import { ISceneLoaderPlugin, ISceneLoaderPluginExtensions } from "@babylonjs/core/Loading/sceneLoader.js";
-import { AssetContainer } from "@babylonjs/core/assetContainer.js";
-import { Scene } from "@babylonjs/core/scene.js";
-/**
- * STL file type loader.
- * This is a babylon scene loader plugin.
- */
-export declare class STLFileLoader implements ISceneLoaderPlugin {
-    /** @hidden */
-    solidPattern: RegExp;
-    /** @hidden */
-    facetsPattern: RegExp;
-    /** @hidden */
-    normalPattern: RegExp;
-    /** @hidden */
-    vertexPattern: RegExp;
-    /**
-     * Defines the name of the plugin.
-     */
-    name: string;
-    /**
-     * Defines the extensions the stl loader is able to load.
-     * force data to come in as an ArrayBuffer
-     * we'll convert to string if it looks like it's an ASCII .stl
-     */
-    extensions: ISceneLoaderPluginExtensions;
-    /**
-     * Defines if Y and Z axes are swapped or not when loading an STL file.
-     * The default is false to maintain backward compatibility. When set to
-     * true, coordinates from the STL file are used without change.
-     */
-    static DO_NOT_ALTER_FILE_COORDINATES: boolean;
-    /**
-     * Import meshes into a scene.
-     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
-     * @param scene The scene to import into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @param meshes The meshes array to import into
-     * @returns True if successful or false otherwise
-     */
-    importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: Nullable<AbstractMesh[]>): boolean;
-    /**
-     * Load into a scene.
-     * @param scene The scene to load into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @returns true if successful or false otherwise
-     */
-    load(scene: Scene, data: any, rootUrl: string): boolean;
-    /**
-     * Load into an asset container.
-     * @param scene The scene to load into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @returns The loaded asset container
-     */
-    loadAssetContainer(scene: Scene, data: string, rootUrl: string): AssetContainer;
-    private _isBinary;
-    private _parseBinary;
-    private _parseASCII;
-}
+import { Nullable } from "@babylonjs/core/types.js";
+import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import { ISceneLoaderPlugin, ISceneLoaderPluginExtensions } from "@babylonjs/core/Loading/sceneLoader.js";
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+import { Scene } from "@babylonjs/core/scene.js";
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+export declare class STLFileLoader implements ISceneLoaderPlugin {
+    /** @hidden */
+    solidPattern: RegExp;
+    /** @hidden */
+    facetsPattern: RegExp;
+    /** @hidden */
+    normalPattern: RegExp;
+    /** @hidden */
+    vertexPattern: RegExp;
+    /**
+     * Defines the name of the plugin.
+     */
+    name: string;
+    /**
+     * Defines the extensions the stl loader is able to load.
+     * force data to come in as an ArrayBuffer
+     * we'll convert to string if it looks like it's an ASCII .stl
+     */
+    extensions: ISceneLoaderPluginExtensions;
+    /**
+     * Defines if Y and Z axes are swapped or not when loading an STL file.
+     * The default is false to maintain backward compatibility. When set to
+     * true, coordinates from the STL file are used without change.
+     */
+    static DO_NOT_ALTER_FILE_COORDINATES: boolean;
+    /**
+     * Import meshes into a scene.
+     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
+     * @param scene The scene to import into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @param meshes The meshes array to import into
+     * @returns True if successful or false otherwise
+     */
+    importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: Nullable<AbstractMesh[]>): boolean;
+    /**
+     * Load into a scene.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns true if successful or false otherwise
+     */
+    load(scene: Scene, data: any, rootUrl: string): boolean;
+    /**
+     * Load into an asset container.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns The loaded asset container
+     */
+    loadAssetContainer(scene: Scene, data: string, rootUrl: string): AssetContainer;
+    private _isBinary;
+    private _parseBinary;
+    private _parseASCII;
+}

package/STL/stlFileLoader.js

@@ -1,234 +1,234 @@
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
-import { SceneLoader } from "@babylonjs/core/Loading/sceneLoader.js";
-import { AssetContainer } from "@babylonjs/core/assetContainer.js";
-/**
- * STL file type loader.
- * This is a babylon scene loader plugin.
- */
-var STLFileLoader = /** @class */ (function () {
-    function STLFileLoader() {
-        /** @hidden */
-        this.solidPattern = /solid (\S*)([\S\s]*?)endsolid[ ]*(\S*)/g;
-        /** @hidden */
-        this.facetsPattern = /facet([\s\S]*?)endfacet/g;
-        /** @hidden */
-        this.normalPattern = /normal[\s]+([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/g;
-        /** @hidden */
-        this.vertexPattern = /vertex[\s]+([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/g;
-        /**
-         * Defines the name of the plugin.
-         */
-        this.name = "stl";
-        /**
-         * Defines the extensions the stl loader is able to load.
-         * force data to come in as an ArrayBuffer
-         * we'll convert to string if it looks like it's an ASCII .stl
-         */
-        this.extensions = {
-            ".stl": { isBinary: true },
-        };
-    }
-    /**
-     * Import meshes into a scene.
-     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
-     * @param scene The scene to import into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @param meshes The meshes array to import into
-     * @returns True if successful or false otherwise
-     */
-    STLFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes) {
-        var matches;
-        if (typeof data !== "string") {
-            if (this._isBinary(data)) {
-                // binary .stl
-                var babylonMesh = new Mesh("stlmesh", scene);
-                this._parseBinary(babylonMesh, data);
-                if (meshes) {
-                    meshes.push(babylonMesh);
-                }
-                return true;
-            }
-            // ASCII .stl
-            // convert to string
-            var array_buffer = new Uint8Array(data);
-            var str = "";
-            for (var i = 0; i < data.byteLength; i++) {
-                str += String.fromCharCode(array_buffer[i]); // implicitly assumes little-endian
-            }
-            data = str;
-        }
-        //if arrived here, data is a string, containing the STLA data.
-        while ((matches = this.solidPattern.exec(data))) {
-            var meshName = matches[1];
-            var meshNameFromEnd = matches[3];
-            if (meshName != meshNameFromEnd) {
-                Tools.Error("Error in STL, solid name != endsolid name");
-                return false;
-            }
-            // check meshesNames
-            if (meshesNames && meshName) {
-                if (meshesNames instanceof Array) {
-                    if (!meshesNames.indexOf(meshName)) {
-                        continue;
-                    }
-                }
-                else {
-                    if (meshName !== meshesNames) {
-                        continue;
-                    }
-                }
-            }
-            // stl mesh name can be empty as well
-            meshName = meshName || "stlmesh";
-            var babylonMesh = new Mesh(meshName, scene);
-            this._parseASCII(babylonMesh, matches[2]);
-            if (meshes) {
-                meshes.push(babylonMesh);
-            }
-        }
-        return true;
-    };
-    /**
-     * Load into a scene.
-     * @param scene The scene to load into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @returns true if successful or false otherwise
-     */
-    STLFileLoader.prototype.load = function (scene, data, rootUrl) {
-        var result = this.importMesh(null, scene, data, rootUrl, null);
-        return result;
-    };
-    /**
-     * Load into an asset container.
-     * @param scene The scene to load into
-     * @param data The data to import
-     * @param rootUrl The root url for scene and resources
-     * @returns The loaded asset container
-     */
-    STLFileLoader.prototype.loadAssetContainer = function (scene, data, rootUrl) {
-        var container = new AssetContainer(scene);
-        scene._blockEntityCollection = true;
-        this.importMesh(null, scene, data, rootUrl, container.meshes);
-        scene._blockEntityCollection = false;
-        return container;
-    };
-    STLFileLoader.prototype._isBinary = function (data) {
-        // check if file size is correct for binary stl
-        var reader = new DataView(data);
-        // A Binary STL header is 80 bytes, if the data size is not great than
-        // that then it's not a binary STL.
-        if (reader.byteLength <= 80) {
-            return false;
-        }
-        var faceSize = (32 / 8) * 3 + (32 / 8) * 3 * 3 + 16 / 8;
-        var nFaces = reader.getUint32(80, true);
-        if (80 + 32 / 8 + nFaces * faceSize === reader.byteLength) {
-            return true;
-        }
-        // check characters higher than ASCII to confirm binary
-        var fileLength = reader.byteLength;
-        for (var index = 0; index < fileLength; index++) {
-            if (reader.getUint8(index) > 127) {
-                return true;
-            }
-        }
-        return false;
-    };
-    STLFileLoader.prototype._parseBinary = function (mesh, data) {
-        var reader = new DataView(data);
-        var faces = reader.getUint32(80, true);
-        var dataOffset = 84;
-        var faceLength = 12 * 4 + 2;
-        var offset = 0;
-        var positions = new Float32Array(faces * 3 * 3);
-        var normals = new Float32Array(faces * 3 * 3);
-        var indices = new Uint32Array(faces * 3);
-        var indicesCount = 0;
-        for (var face = 0; face < faces; face++) {
-            var start = dataOffset + face * faceLength;
-            var normalX = reader.getFloat32(start, true);
-            var normalY = reader.getFloat32(start + 4, true);
-            var normalZ = reader.getFloat32(start + 8, true);
-            for (var i = 1; i <= 3; i++) {
-                var vertexstart = start + i * 12;
-                // ordering is intentional to match ascii import
-                positions[offset] = reader.getFloat32(vertexstart, true);
-                normals[offset] = normalX;
-                if (!STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {
-                    positions[offset + 2] = reader.getFloat32(vertexstart + 4, true);
-                    positions[offset + 1] = reader.getFloat32(vertexstart + 8, true);
-                    normals[offset + 2] = normalY;
-                    normals[offset + 1] = normalZ;
-                }
-                else {
-                    positions[offset + 1] = reader.getFloat32(vertexstart + 4, true);
-                    positions[offset + 2] = reader.getFloat32(vertexstart + 8, true);
-                    normals[offset + 1] = normalY;
-                    normals[offset + 2] = normalZ;
-                }
-                offset += 3;
-            }
-            indices[indicesCount] = indicesCount++;
-            indices[indicesCount] = indicesCount++;
-            indices[indicesCount] = indicesCount++;
-        }
-        mesh.setVerticesData(VertexBuffer.PositionKind, positions);
-        mesh.setVerticesData(VertexBuffer.NormalKind, normals);
-        mesh.setIndices(indices);
-        mesh.computeWorldMatrix(true);
-    };
-    STLFileLoader.prototype._parseASCII = function (mesh, solidData) {
-        var positions = [];
-        var normals = [];
-        var indices = [];
-        var indicesCount = 0;
-        //load facets, ignoring loop as the standard doesn't define it can contain more than vertices
-        var matches;
-        while ((matches = this.facetsPattern.exec(solidData))) {
-            var facet = matches[1];
-            //one normal per face
-            var normalMatches = this.normalPattern.exec(facet);
-            this.normalPattern.lastIndex = 0;
-            if (!normalMatches) {
-                continue;
-            }
-            var normal = [Number(normalMatches[1]), Number(normalMatches[5]), Number(normalMatches[3])];
-            var vertexMatch = void 0;
-            while ((vertexMatch = this.vertexPattern.exec(facet))) {
-                if (!STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {
-                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[5]), Number(vertexMatch[3]));
-                    normals.push(normal[0], normal[1], normal[2]);
-                }
-                else {
-                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[3]), Number(vertexMatch[5]));
-                    // Flipping the second and third component because inverted
-                    // when normal was declared.
-                    normals.push(normal[0], normal[2], normal[1]);
-                }
-            }
-            indices.push(indicesCount++, indicesCount++, indicesCount++);
-            this.vertexPattern.lastIndex = 0;
-        }
-        this.facetsPattern.lastIndex = 0;
-        mesh.setVerticesData(VertexBuffer.PositionKind, positions);
-        mesh.setVerticesData(VertexBuffer.NormalKind, normals);
-        mesh.setIndices(indices);
-        mesh.computeWorldMatrix(true);
-    };
-    /**
-     * Defines if Y and Z axes are swapped or not when loading an STL file.
-     * The default is false to maintain backward compatibility. When set to
-     * true, coordinates from the STL file are used without change.
-     */
-    STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES = false;
-    return STLFileLoader;
-}());
-export { STLFileLoader };
-if (SceneLoader) {
-    SceneLoader.RegisterPlugin(new STLFileLoader());
-}
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { SceneLoader } from "@babylonjs/core/Loading/sceneLoader.js";
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+var STLFileLoader = /** @class */ (function () {
+    function STLFileLoader() {
+        /** @hidden */
+        this.solidPattern = /solid (\S*)([\S\s]*?)endsolid[ ]*(\S*)/g;
+        /** @hidden */
+        this.facetsPattern = /facet([\s\S]*?)endfacet/g;
+        /** @hidden */
+        this.normalPattern = /normal[\s]+([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/g;
+        /** @hidden */
+        this.vertexPattern = /vertex[\s]+([-+]?[0-9]+\.?[0-9]*([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+[\s]+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/g;
+        /**
+         * Defines the name of the plugin.
+         */
+        this.name = "stl";
+        /**
+         * Defines the extensions the stl loader is able to load.
+         * force data to come in as an ArrayBuffer
+         * we'll convert to string if it looks like it's an ASCII .stl
+         */
+        this.extensions = {
+            ".stl": { isBinary: true },
+        };
+    }
+    /**
+     * Import meshes into a scene.
+     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
+     * @param scene The scene to import into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @param meshes The meshes array to import into
+     * @returns True if successful or false otherwise
+     */
+    STLFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes) {
+        var matches;
+        if (typeof data !== "string") {
+            if (this._isBinary(data)) {
+                // binary .stl
+                var babylonMesh = new Mesh("stlmesh", scene);
+                this._parseBinary(babylonMesh, data);
+                if (meshes) {
+                    meshes.push(babylonMesh);
+                }
+                return true;
+            }
+            // ASCII .stl
+            // convert to string
+            var array_buffer = new Uint8Array(data);
+            var str = "";
+            for (var i = 0; i < data.byteLength; i++) {
+                str += String.fromCharCode(array_buffer[i]); // implicitly assumes little-endian
+            }
+            data = str;
+        }
+        //if arrived here, data is a string, containing the STLA data.
+        while ((matches = this.solidPattern.exec(data))) {
+            var meshName = matches[1];
+            var meshNameFromEnd = matches[3];
+            if (meshName != meshNameFromEnd) {
+                Tools.Error("Error in STL, solid name != endsolid name");
+                return false;
+            }
+            // check meshesNames
+            if (meshesNames && meshName) {
+                if (meshesNames instanceof Array) {
+                    if (!meshesNames.indexOf(meshName)) {
+                        continue;
+                    }
+                }
+                else {
+                    if (meshName !== meshesNames) {
+                        continue;
+                    }
+                }
+            }
+            // stl mesh name can be empty as well
+            meshName = meshName || "stlmesh";
+            var babylonMesh = new Mesh(meshName, scene);
+            this._parseASCII(babylonMesh, matches[2]);
+            if (meshes) {
+                meshes.push(babylonMesh);
+            }
+        }
+        return true;
+    };
+    /**
+     * Load into a scene.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns true if successful or false otherwise
+     */
+    STLFileLoader.prototype.load = function (scene, data, rootUrl) {
+        var result = this.importMesh(null, scene, data, rootUrl, null);
+        return result;
+    };
+    /**
+     * Load into an asset container.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns The loaded asset container
+     */
+    STLFileLoader.prototype.loadAssetContainer = function (scene, data, rootUrl) {
+        var container = new AssetContainer(scene);
+        scene._blockEntityCollection = true;
+        this.importMesh(null, scene, data, rootUrl, container.meshes);
+        scene._blockEntityCollection = false;
+        return container;
+    };
+    STLFileLoader.prototype._isBinary = function (data) {
+        // check if file size is correct for binary stl
+        var reader = new DataView(data);
+        // A Binary STL header is 80 bytes, if the data size is not great than
+        // that then it's not a binary STL.
+        if (reader.byteLength <= 80) {
+            return false;
+        }
+        var faceSize = (32 / 8) * 3 + (32 / 8) * 3 * 3 + 16 / 8;
+        var nFaces = reader.getUint32(80, true);
+        if (80 + 32 / 8 + nFaces * faceSize === reader.byteLength) {
+            return true;
+        }
+        // check characters higher than ASCII to confirm binary
+        var fileLength = reader.byteLength;
+        for (var index = 0; index < fileLength; index++) {
+            if (reader.getUint8(index) > 127) {
+                return true;
+            }
+        }
+        return false;
+    };
+    STLFileLoader.prototype._parseBinary = function (mesh, data) {
+        var reader = new DataView(data);
+        var faces = reader.getUint32(80, true);
+        var dataOffset = 84;
+        var faceLength = 12 * 4 + 2;
+        var offset = 0;
+        var positions = new Float32Array(faces * 3 * 3);
+        var normals = new Float32Array(faces * 3 * 3);
+        var indices = new Uint32Array(faces * 3);
+        var indicesCount = 0;
+        for (var face = 0; face < faces; face++) {
+            var start = dataOffset + face * faceLength;
+            var normalX = reader.getFloat32(start, true);
+            var normalY = reader.getFloat32(start + 4, true);
+            var normalZ = reader.getFloat32(start + 8, true);
+            for (var i = 1; i <= 3; i++) {
+                var vertexstart = start + i * 12;
+                // ordering is intentional to match ascii import
+                positions[offset] = reader.getFloat32(vertexstart, true);
+                normals[offset] = normalX;
+                if (!STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {
+                    positions[offset + 2] = reader.getFloat32(vertexstart + 4, true);
+                    positions[offset + 1] = reader.getFloat32(vertexstart + 8, true);
+                    normals[offset + 2] = normalY;
+                    normals[offset + 1] = normalZ;
+                }
+                else {
+                    positions[offset + 1] = reader.getFloat32(vertexstart + 4, true);
+                    positions[offset + 2] = reader.getFloat32(vertexstart + 8, true);
+                    normals[offset + 1] = normalY;
+                    normals[offset + 2] = normalZ;
+                }
+                offset += 3;
+            }
+            indices[indicesCount] = indicesCount++;
+            indices[indicesCount] = indicesCount++;
+            indices[indicesCount] = indicesCount++;
+        }
+        mesh.setVerticesData(VertexBuffer.PositionKind, positions);
+        mesh.setVerticesData(VertexBuffer.NormalKind, normals);
+        mesh.setIndices(indices);
+        mesh.computeWorldMatrix(true);
+    };
+    STLFileLoader.prototype._parseASCII = function (mesh, solidData) {
+        var positions = [];
+        var normals = [];
+        var indices = [];
+        var indicesCount = 0;
+        //load facets, ignoring loop as the standard doesn't define it can contain more than vertices
+        var matches;
+        while ((matches = this.facetsPattern.exec(solidData))) {
+            var facet = matches[1];
+            //one normal per face
+            var normalMatches = this.normalPattern.exec(facet);
+            this.normalPattern.lastIndex = 0;
+            if (!normalMatches) {
+                continue;
+            }
+            var normal = [Number(normalMatches[1]), Number(normalMatches[5]), Number(normalMatches[3])];
+            var vertexMatch = void 0;
+            while ((vertexMatch = this.vertexPattern.exec(facet))) {
+                if (!STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {
+                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[5]), Number(vertexMatch[3]));
+                    normals.push(normal[0], normal[1], normal[2]);
+                }
+                else {
+                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[3]), Number(vertexMatch[5]));
+                    // Flipping the second and third component because inverted
+                    // when normal was declared.
+                    normals.push(normal[0], normal[2], normal[1]);
+                }
+            }
+            indices.push(indicesCount++, indicesCount++, indicesCount++);
+            this.vertexPattern.lastIndex = 0;
+        }
+        this.facetsPattern.lastIndex = 0;
+        mesh.setVerticesData(VertexBuffer.PositionKind, positions);
+        mesh.setVerticesData(VertexBuffer.NormalKind, normals);
+        mesh.setIndices(indices);
+        mesh.computeWorldMatrix(true);
+    };
+    /**
+     * Defines if Y and Z axes are swapped or not when loading an STL file.
+     * The default is false to maintain backward compatibility. When set to
+     * true, coordinates from the STL file are used without change.
+     */
+    STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES = false;
+    return STLFileLoader;
+}());
+export { STLFileLoader };
+if (SceneLoader) {
+    SceneLoader.RegisterPlugin(new STLFileLoader());
+}
 //# sourceMappingURL=stlFileLoader.js.map

package/glTF/1.0/glTFBinaryExtension.d.ts

@@ -1,13 +1,13 @@
-import { GLTFLoaderExtension } from "./glTFLoader";
-import { Scene } from "@babylonjs/core/scene.js";
-import { IGLTFLoaderData } from "../glTFFileLoader";
-import { IGLTFRuntime } from "./glTFLoaderInterfaces";
-/** @hidden */
-export declare class GLTFBinaryExtension extends GLTFLoaderExtension {
-    private _bin;
-    constructor();
-    loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void): boolean;
-    loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
-    loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void): boolean;
-    loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void): boolean;
-}
+import { GLTFLoaderExtension } from "./glTFLoader";
+import { Scene } from "@babylonjs/core/scene.js";
+import { IGLTFLoaderData } from "../glTFFileLoader";
+import { IGLTFRuntime } from "./glTFLoaderInterfaces";
+/** @hidden */
+export declare class GLTFBinaryExtension extends GLTFLoaderExtension {
+    private _bin;
+    constructor();
+    loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void): boolean;
+    loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
+    loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void): boolean;
+    loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void): boolean;
+}