@fps-games/editor 0.2.0-beta.3 → 0.2.1-beta.1

package/node_modules/@babylonjs/loaders/SPLAT/spz.js

@@ -0,0 +1,168 @@
+/* eslint-disable @typescript-eslint/promise-function-async */
+import { Scalar } from "@babylonjs/core/Maths/math.scalar.js";
+/**
+ * Parses SPZ data and returns a promise resolving to an IParsedPLY object.
+ * @param data The ArrayBuffer containing SPZ data.
+ * @param scene The Babylon.js scene.
+ * @param loadingOptions Options for loading Gaussian Splatting files.
+ * @returns A promise resolving to the parsed SPZ data.
+ */
+export function ParseSpz(data, scene, loadingOptions) {
+    const ubuf = new Uint8Array(data);
+    const ubufu32 = new Uint32Array(data.slice(0, 12)); // Only need ubufu32[0] to [2]
+    // debug infos
+    const splatCount = ubufu32[2];
+    const shDegree = ubuf[12];
+    const fractionalBits = ubuf[13];
+    const flags = ubuf[14];
+    const reserved = ubuf[15];
+    const version = ubufu32[1];
+    // check magic and version
+    if (reserved || ubufu32[0] != 0x5053474e || (version != 2 && version != 3)) {
+        // reserved must be 0
+        return new Promise((resolve) => {
+            resolve({ mode: 3 /* Mode.Reject */, data: buffer, hasVertexColors: false });
+        });
+    }
+    const rowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // 32
+    const buffer = new ArrayBuffer(rowOutputLength * splatCount);
+    const positionScale = 1.0 / (1 << fractionalBits);
+    const int32View = new Int32Array(1);
+    const uint8View = new Uint8Array(int32View.buffer);
+    const read24bComponent = function (u8, offset) {
+        uint8View[0] = u8[offset + 0];
+        uint8View[1] = u8[offset + 1];
+        uint8View[2] = u8[offset + 2];
+        uint8View[3] = u8[offset + 2] & 0x80 ? 0xff : 0x00;
+        return int32View[0] * positionScale;
+    };
+    let byteOffset = 16;
+    const position = new Float32Array(buffer);
+    const scale = new Float32Array(buffer);
+    const rgba = new Uint8ClampedArray(buffer);
+    const rot = new Uint8ClampedArray(buffer);
+    // positions
+    for (let i = 0; i < splatCount; i++) {
+        position[i * 8 + 0] = read24bComponent(ubuf, byteOffset + 0);
+        position[i * 8 + 1] = read24bComponent(ubuf, byteOffset + 3);
+        position[i * 8 + 2] = read24bComponent(ubuf, byteOffset + 6);
+        byteOffset += 9;
+    }
+    // colors
+    const shC0 = 0.282;
+    for (let i = 0; i < splatCount; i++) {
+        for (let component = 0; component < 3; component++) {
+            const byteValue = ubuf[byteOffset + splatCount + i * 3 + component];
+            // 0.15 is hard coded value from spz
+            // Scale factor for DC color components. To convert to RGB, we should multiply by 0.282, but it can
+            // be useful to represent base colors that are out of range if the higher spherical harmonics bands
+            // bring them back into range so we multiply by a smaller value.
+            const value = (byteValue - 127.5) / (0.15 * 255);
+            rgba[i * 32 + 24 + component] = Scalar.Clamp((0.5 + shC0 * value) * 255, 0, 255);
+        }
+        rgba[i * 32 + 24 + 3] = ubuf[byteOffset + i];
+    }
+    byteOffset += splatCount * 4;
+    // scales
+    for (let i = 0; i < splatCount; i++) {
+        scale[i * 8 + 3 + 0] = Math.exp(ubuf[byteOffset + 0] / 16.0 - 10.0);
+        scale[i * 8 + 3 + 1] = Math.exp(ubuf[byteOffset + 1] / 16.0 - 10.0);
+        scale[i * 8 + 3 + 2] = Math.exp(ubuf[byteOffset + 2] / 16.0 - 10.0);
+        byteOffset += 3;
+    }
+    // convert quaternion
+    if (version >= 3) {
+        /*
+            In version 3, rotations are represented as the smallest three components of the normalized rotation quaternion, for optimal rotation accuracy.
+            The largest component can be derived from the others and is not stored. Its index is stored on 2 bits
+            and each of the smallest three components is encoded as a 10-bit signed integer.
+        */
+        const sqrt12 = Math.SQRT1_2;
+        for (let i = 0; i < splatCount; i++) {
+            const r = [ubuf[byteOffset + 0], ubuf[byteOffset + 1], ubuf[byteOffset + 2], ubuf[byteOffset + 3]];
+            const comp = r[0] + (r[1] << 8) + (r[2] << 16) + (r[3] << 24);
+            const cmask = (1 << 9) - 1;
+            const rotation = [];
+            const iLargest = comp >>> 30;
+            let remaining = comp;
+            let sumSquares = 0;
+            for (let i = 3; i >= 0; --i) {
+                if (i !== iLargest) {
+                    const mag = remaining & cmask;
+                    const negbit = (remaining >>> 9) & 0x1;
+                    remaining = remaining >>> 10;
+                    rotation[i] = sqrt12 * (mag / cmask);
+                    if (negbit === 1) {
+                        rotation[i] = -rotation[i];
+                    }
+                    // accumulate the sum of squares
+                    sumSquares += rotation[i] * rotation[i];
+                }
+            }
+            const square = 1 - sumSquares;
+            rotation[iLargest] = Math.sqrt(Math.max(square, 0));
+            const shuffle = [3, 0, 1, 2]; // shuffle to match the order of the quaternion components in the splat file
+            for (let j = 0; j < 4; j++) {
+                rot[i * 32 + 28 + j] = Math.round(127.5 + rotation[shuffle[j]] * 127.5);
+            }
+            byteOffset += 4;
+        }
+    }
+    else {
+        /*
+            In version 2, rotations are represented as the `(x, y, z)` components of the normalized rotation quaternion. The
+            `w` component can be derived from the others and is not stored. Each component is encoded as an
+            8-bit signed integer.
+        */
+        for (let i = 0; i < splatCount; i++) {
+            const x = ubuf[byteOffset + 0];
+            const y = ubuf[byteOffset + 1];
+            const z = ubuf[byteOffset + 2];
+            const nx = x / 127.5 - 1;
+            const ny = y / 127.5 - 1;
+            const nz = z / 127.5 - 1;
+            rot[i * 32 + 28 + 1] = x;
+            rot[i * 32 + 28 + 2] = y;
+            rot[i * 32 + 28 + 3] = z;
+            const v = 1 - (nx * nx + ny * ny + nz * nz);
+            rot[i * 32 + 28 + 0] = 127.5 + Math.sqrt(v < 0 ? 0 : v) * 127.5;
+            byteOffset += 3;
+        }
+    }
+    //SH
+    if (shDegree) {
+        // shVectorCount is : 3 for dim = 1, 8 for dim = 2 and 15 for dim = 3
+        // number of vec3 vector needed per splat
+        const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1; // minus 1 because sh0 is color
+        // number of component values : 3 per vector3 (45)
+        const shComponentCount = shVectorCount * 3;
+        const textureCount = Math.ceil(shComponentCount / 16); // 4 components can be stored per texture, 4 sh per component
+        let shIndexRead = byteOffset;
+        // sh is an array of uint8array that will be used to create sh textures
+        const sh = [];
+        const engine = scene.getEngine();
+        const width = engine.getCaps().maxTextureSize;
+        const height = Math.ceil(splatCount / width);
+        // create array for the number of textures needed.
+        for (let textureIndex = 0; textureIndex < textureCount; textureIndex++) {
+            const texture = new Uint8Array(height * width * 4 * 4); // 4 components per texture, 4 sh per component
+            sh.push(texture);
+        }
+        for (let i = 0; i < splatCount; i++) {
+            for (let shIndexWrite = 0; shIndexWrite < shComponentCount; shIndexWrite++) {
+                const shValue = ubuf[shIndexRead++];
+                const textureIndex = Math.floor(shIndexWrite / 16);
+                const shArray = sh[textureIndex];
+                const byteIndexInTexture = shIndexWrite % 16; // [0..15]
+                const offsetPerSplat = i * 16; // 16 sh values per texture per splat.
+                shArray[byteIndexInTexture + offsetPerSplat] = shValue;
+            }
+        }
+        return new Promise((resolve) => {
+            resolve({ mode: 0 /* Mode.Splat */, data: buffer, hasVertexColors: false, sh: sh, trainedWithAntialiasing: !!flags });
+        });
+    }
+    return new Promise((resolve) => {
+        resolve({ mode: 0 /* Mode.Splat */, data: buffer, hasVertexColors: false, trainedWithAntialiasing: !!flags });
+    });
+}

package/node_modules/@babylonjs/loaders/STL/index.d.ts

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

package/node_modules/@babylonjs/loaders/STL/index.js

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

package/node_modules/@babylonjs/loaders/STL/stlFileLoader.d.ts

@@ -0,0 +1,78 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import type { ISceneLoaderPlugin } from "@babylonjs/core/Loading/sceneLoader.js";
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import { STLFileLoaderMetadata } from "./stlFileLoader.metadata.js";
+import "@babylonjs/core/Materials/standardMaterial.js";
+declare module "@babylonjs/core/Loading/sceneLoader.js" {
+    interface SceneLoaderPluginOptions {
+        /**
+         * Defines options for the stl loader.
+         */
+        [STLFileLoaderMetadata.name]: {};
+    }
+}
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+export declare class STLFileLoader implements ISceneLoaderPlugin {
+    /** @internal */
+    solidPattern: RegExp;
+    /** @internal */
+    facetsPattern: RegExp;
+    /** @internal */
+    normalPattern: RegExp;
+    /** @internal */
+    vertexPattern: RegExp;
+    /**
+     * Defines the name of the plugin.
+     */
+    readonly 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
+     */
+    readonly extensions: {
+        readonly ".stl": {
+            readonly isBinary: 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.
+     */
+    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/node_modules/@babylonjs/loaders/STL/stlFileLoader.js

@@ -0,0 +1,238 @@
+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 { RegisterSceneLoaderPlugin } from "@babylonjs/core/Loading/sceneLoader.js";
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+import { STLFileLoaderMetadata } from "./stlFileLoader.metadata.js";
+import "@babylonjs/core/Materials/standardMaterial.js";
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+export class STLFileLoader {
+    constructor() {
+        /** @internal */
+        this.solidPattern = /solid (\S*)([\S\s]*?)endsolid[ ]*(\S*)/g;
+        /** @internal */
+        this.facetsPattern = /facet([\s\S]*?)endfacet/g;
+        /** @internal */
+        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;
+        /** @internal */
+        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 = STLFileLoaderMetadata.name;
+        /**
+         * 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 = STLFileLoaderMetadata.extensions;
+    }
+    /**
+     * 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, scene, data, rootUrl, meshes) {
+        let matches;
+        if (typeof data !== "string") {
+            if (this._isBinary(data)) {
+                // binary .stl
+                const babylonMesh = new Mesh("stlmesh", scene);
+                this._parseBinary(babylonMesh, data);
+                if (meshes) {
+                    meshes.push(babylonMesh);
+                }
+                return true;
+            }
+            // ASCII .stl
+            // convert to string
+            data = new TextDecoder().decode(new Uint8Array(data));
+        }
+        //if arrived here, data is a string, containing the STLA data.
+        while ((matches = this.solidPattern.exec(data))) {
+            let meshName = matches[1];
+            const meshNameFromEnd = matches[3];
+            if (meshNameFromEnd && 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";
+            const 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
+     */
+    load(scene, data, rootUrl) {
+        const 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
+     */
+    loadAssetContainer(scene, data, rootUrl) {
+        const container = new AssetContainer(scene);
+        scene._blockEntityCollection = true;
+        this.importMesh(null, scene, data, rootUrl, container.meshes);
+        scene._blockEntityCollection = false;
+        return container;
+    }
+    _isBinary(data) {
+        // check if file size is correct for binary stl
+        const 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;
+        }
+        const faceSize = (32 / 8) * 3 + (32 / 8) * 3 * 3 + 16 / 8;
+        const nFaces = reader.getUint32(80, true);
+        if (80 + 32 / 8 + nFaces * faceSize === reader.byteLength) {
+            return true;
+        }
+        // US-ASCII begin with 's', 'o', 'l', 'i', 'd'
+        const ascii = [115, 111, 108, 105, 100];
+        for (let off = 0; off < 5; off++) {
+            if (reader.getUint8(off) !== ascii[off]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _parseBinary(mesh, data) {
+        const reader = new DataView(data);
+        const faces = reader.getUint32(80, true);
+        const dataOffset = 84;
+        const faceLength = 12 * 4 + 2;
+        let offset = 0;
+        const positions = new Float32Array(faces * 3 * 3);
+        const normals = new Float32Array(faces * 3 * 3);
+        const indices = new Uint32Array(faces * 3);
+        let indicesCount = 0;
+        for (let face = 0; face < faces; face++) {
+            const start = dataOffset + face * faceLength;
+            const normalX = reader.getFloat32(start, true);
+            const normalY = reader.getFloat32(start + 4, true);
+            const normalZ = reader.getFloat32(start + 8, true);
+            for (let i = 1; i <= 3; i++) {
+                const 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;
+            }
+            if (STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {
+                indices[indicesCount] = indicesCount;
+                indices[indicesCount + 1] = indicesCount + 2;
+                indices[indicesCount + 2] = indicesCount + 1;
+                indicesCount += 3;
+            }
+            else {
+                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);
+    }
+    _parseASCII(mesh, solidData) {
+        const positions = [];
+        const normals = [];
+        const indices = [];
+        let indicesCount = 0;
+        //load facets, ignoring loop as the standard doesn't define it can contain more than vertices
+        let matches;
+        while ((matches = this.facetsPattern.exec(solidData))) {
+            const facet = matches[1];
+            //one normal per face
+            const normalMatches = this.normalPattern.exec(facet);
+            this.normalPattern.lastIndex = 0;
+            if (!normalMatches) {
+                continue;
+            }
+            const normal = [Number(normalMatches[1]), Number(normalMatches[5]), Number(normalMatches[3])];
+            let vertexMatch;
+            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]);
+                }
+            }
+            if (STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {
+                indices.push(indicesCount, indicesCount + 2, indicesCount + 1);
+                indicesCount += 3;
+            }
+            else {
+                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;
+RegisterSceneLoaderPlugin(new STLFileLoader());

package/node_modules/@babylonjs/loaders/STL/stlFileLoader.metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const STLFileLoaderMetadata: {
+    readonly name: "stl";
+    readonly extensions: {
+        readonly ".stl": {
+            readonly isBinary: true;
+        };
+    };
+};

package/node_modules/@babylonjs/loaders/STL/stlFileLoader.metadata.js

@@ -0,0 +1,7 @@
+export const STLFileLoaderMetadata = {
+    name: "stl",
+    extensions: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        ".stl": { isBinary: true },
+    },
+};

package/node_modules/@babylonjs/loaders/bvh/license.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 herzig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@babylonjs/loaders/dynamic.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Registers the async plugin factories for all built-in loaders.
+ * Loaders will be dynamically imported on demand, only when a SceneLoader load operation needs each respective loader.
+ */
+export declare function registerBuiltInLoaders(): void;

package/node_modules/@babylonjs/loaders/dynamic.js

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { RegisterSceneLoaderPlugin } from "@babylonjs/core/Loading/sceneLoader.js";
+import { BVHFileLoaderMetadata } from "./BVH/bvhFileLoader.metadata.js";
+import { GLTFFileLoaderMetadata } from "./glTF/glTFFileLoader.metadata.js";
+import { OBJFileLoaderMetadata } from "./OBJ/objFileLoader.metadata.js";
+import { SPLATFileLoaderMetadata } from "./SPLAT/splatFileLoader.metadata.js";
+import { STLFileLoaderMetadata } from "./STL/stlFileLoader.metadata.js";
+import { registerBuiltInGLTFExtensions } from "./glTF/2.0/Extensions/dynamic.js";
+/**
+ * Registers the async plugin factories for all built-in loaders.
+ * Loaders will be dynamically imported on demand, only when a SceneLoader load operation needs each respective loader.
+ */
+export function registerBuiltInLoaders() {
+    // Register the BVH loader.
+    RegisterSceneLoaderPlugin({
+        ...BVHFileLoaderMetadata,
+        createPlugin: async (options) => {
+            const { BVHFileLoader } = await import("./BVH/bvhFileLoader.js");
+            return new BVHFileLoader(options[BVHFileLoaderMetadata.name]);
+        },
+    });
+    // Register the glTF loader (2.0) specifically/only.
+    RegisterSceneLoaderPlugin({
+        ...GLTFFileLoaderMetadata,
+        createPlugin: async (options) => {
+            const { GLTFFileLoader } = await import("./glTF/2.0/glTFLoader.js");
+            return new GLTFFileLoader(options[GLTFFileLoaderMetadata.name]);
+        },
+    });
+    // Register the built-in glTF (2.0) extensions.
+    registerBuiltInGLTFExtensions();
+    // Register the OBJ loader.
+    RegisterSceneLoaderPlugin({
+        ...OBJFileLoaderMetadata,
+        createPlugin: async (options) => {
+            const { OBJFileLoader } = await import("./OBJ/objFileLoader.js");
+            return new OBJFileLoader(options[OBJFileLoaderMetadata.name]);
+        },
+    });
+    // Register the SPLAT loader.
+    RegisterSceneLoaderPlugin({
+        ...SPLATFileLoaderMetadata,
+        createPlugin: async (options) => {
+            const { SPLATFileLoader } = await import("./SPLAT/splatFileLoader.js");
+            return new SPLATFileLoader(options[SPLATFileLoaderMetadata.name]);
+        },
+    });
+    // Register the STL loader.
+    RegisterSceneLoaderPlugin({
+        ...STLFileLoaderMetadata,
+        createPlugin: async () => {
+            const { STLFileLoader } = await import("./STL/stlFileLoader.js");
+            return new STLFileLoader();
+        },
+    });
+}

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFBinaryExtension.d.ts

@@ -0,0 +1,16 @@
+import { GLTFLoaderExtension } from "./glTFLoader.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { IGLTFLoaderData } from "../glTFFileLoader.js";
+import type { IGLTFRuntime } from "./glTFLoaderInterfaces.js";
+/**
+ * @internal
+ * @deprecated
+ */
+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;
+}

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFBinaryExtension.js

@@ -0,0 +1,64 @@
+import { GLTFLoaderExtension, GLTFLoader, GLTFLoaderBase } from "./glTFLoader.js";
+import { GLTFUtils } from "./glTFLoaderUtils.js";
+import { EComponentType } from "./glTFLoaderInterfaces.js";
+const BinaryExtensionBufferName = "binary_glTF";
+/**
+ * @internal
+ * @deprecated
+ */
+export class GLTFBinaryExtension extends GLTFLoaderExtension {
+    constructor() {
+        super("KHR_binary_glTF");
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    loadRuntimeAsync(scene, data, rootUrl, onSuccess) {
+        const 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;
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    loadBufferAsync(gltfRuntime, id, onSuccess, onError) {
+        if (gltfRuntime.extensionsUsed.indexOf(this.name) === -1) {
+            return false;
+        }
+        if (id !== BinaryExtensionBufferName) {
+            return false;
+        }
+        // eslint-disable-next-line github/no-then
+        this._bin.readAsync(0, this._bin.byteLength).then(onSuccess, (error) => onError(error.message));
+        return true;
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    loadTextureBufferAsync(gltfRuntime, id, onSuccess) {
+        const texture = gltfRuntime.textures[id];
+        const source = gltfRuntime.images[texture.source];
+        if (!source.extensions || !(this.name in source.extensions)) {
+            return false;
+        }
+        const sourceExt = source.extensions[this.name];
+        const bufferView = gltfRuntime.bufferViews[sourceExt.bufferView];
+        const buffer = GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, EComponentType.UNSIGNED_BYTE);
+        onSuccess(buffer);
+        return true;
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    loadShaderStringAsync(gltfRuntime, id, onSuccess) {
+        const shader = gltfRuntime.shaders[id];
+        if (!shader.extensions || !(this.name in shader.extensions)) {
+            return false;
+        }
+        const binaryExtensionShader = shader.extensions[this.name];
+        const bufferView = gltfRuntime.bufferViews[binaryExtensionShader.bufferView];
+        const shaderBytes = GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, EComponentType.UNSIGNED_BYTE);
+        setTimeout(() => {
+            const shaderString = GLTFUtils.DecodeBufferToText(shaderBytes);
+            onSuccess(shaderString);
+        });
+        return true;
+    }
+}
+GLTFLoader.RegisterExtension(new GLTFBinaryExtension());