@babylonjs/viewer 7.41.0 → 7.41.1-alpha

package/dist/chunks/stlFileLoader-LRHEIFfU.esm.js

@@ -0,0 +1,238 @@
+import { am as STLFileLoaderMetadata, M as Mesh, T as Tools, V as VertexBuffer, y as registerSceneLoaderPlugin } from './index-C6hXZyZb.esm.js';
+import { A as AssetContainer } from './assetContainer-DYzO0AbX.esm.js';
+import './standardMaterial-v_D8QA4q.esm.js';
+
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+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());
+
+export { STLFileLoader };
+//# sourceMappingURL=stlFileLoader-LRHEIFfU.esm.js.map

package/dist/chunks/stlFileLoader-LRHEIFfU.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stlFileLoader-LRHEIFfU.esm.js","sources":["../../../../../dev/loaders/dist/STL/stlFileLoader.js"],"sourcesContent":["import { Tools } from \"core/Misc/tools\";\nimport { VertexBuffer } from \"core/Buffers/buffer\";\nimport { Mesh } from \"core/Meshes/mesh\";\nimport { registerSceneLoaderPlugin } from \"core/Loading/sceneLoader\";\nimport { AssetContainer } from \"core/assetContainer\";\nimport { STLFileLoaderMetadata } from \"./stlFileLoader.metadata\";\nimport \"core/Materials/standardMaterial\";\n/**\n * STL file type loader.\n * This is a babylon scene loader plugin.\n */\nexport class STLFileLoader {\n    constructor() {\n        /** @internal */\n        this.solidPattern = /solid (\\S*)([\\S\\s]*?)endsolid[ ]*(\\S*)/g;\n        /** @internal */\n        this.facetsPattern = /facet([\\s\\S]*?)endfacet/g;\n        /** @internal */\n        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;\n        /** @internal */\n        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;\n        /**\n         * Defines the name of the plugin.\n         */\n        this.name = STLFileLoaderMetadata.name;\n        /**\n         * Defines the extensions the stl loader is able to load.\n         * force data to come in as an ArrayBuffer\n         * we'll convert to string if it looks like it's an ASCII .stl\n         */\n        this.extensions = STLFileLoaderMetadata.extensions;\n    }\n    /**\n     * Import meshes into a scene.\n     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported\n     * @param scene The scene to import into\n     * @param data The data to import\n     * @param rootUrl The root url for scene and resources\n     * @param meshes The meshes array to import into\n     * @returns True if successful or false otherwise\n     */\n    importMesh(meshesNames, scene, data, rootUrl, meshes) {\n        let matches;\n        if (typeof data !== \"string\") {\n            if (this._isBinary(data)) {\n                // binary .stl\n                const babylonMesh = new Mesh(\"stlmesh\", scene);\n                this._parseBinary(babylonMesh, data);\n                if (meshes) {\n                    meshes.push(babylonMesh);\n                }\n                return true;\n            }\n            // ASCII .stl\n            // convert to string\n            data = new TextDecoder().decode(new Uint8Array(data));\n        }\n        //if arrived here, data is a string, containing the STLA data.\n        while ((matches = this.solidPattern.exec(data))) {\n            let meshName = matches[1];\n            const meshNameFromEnd = matches[3];\n            if (meshNameFromEnd && meshName != meshNameFromEnd) {\n                Tools.Error(\"Error in STL, solid name != endsolid name\");\n                return false;\n            }\n            // check meshesNames\n            if (meshesNames && meshName) {\n                if (meshesNames instanceof Array) {\n                    if (!meshesNames.indexOf(meshName)) {\n                        continue;\n                    }\n                }\n                else {\n                    if (meshName !== meshesNames) {\n                        continue;\n                    }\n                }\n            }\n            // stl mesh name can be empty as well\n            meshName = meshName || \"stlmesh\";\n            const babylonMesh = new Mesh(meshName, scene);\n            this._parseASCII(babylonMesh, matches[2]);\n            if (meshes) {\n                meshes.push(babylonMesh);\n            }\n        }\n        return true;\n    }\n    /**\n     * Load into a scene.\n     * @param scene The scene to load into\n     * @param data The data to import\n     * @param rootUrl The root url for scene and resources\n     * @returns true if successful or false otherwise\n     */\n    load(scene, data, rootUrl) {\n        const result = this.importMesh(null, scene, data, rootUrl, null);\n        return result;\n    }\n    /**\n     * Load into an asset container.\n     * @param scene The scene to load into\n     * @param data The data to import\n     * @param rootUrl The root url for scene and resources\n     * @returns The loaded asset container\n     */\n    loadAssetContainer(scene, data, rootUrl) {\n        const container = new AssetContainer(scene);\n        scene._blockEntityCollection = true;\n        this.importMesh(null, scene, data, rootUrl, container.meshes);\n        scene._blockEntityCollection = false;\n        return container;\n    }\n    _isBinary(data) {\n        // check if file size is correct for binary stl\n        const reader = new DataView(data);\n        // A Binary STL header is 80 bytes, if the data size is not great than\n        // that then it's not a binary STL.\n        if (reader.byteLength <= 80) {\n            return false;\n        }\n        const faceSize = (32 / 8) * 3 + (32 / 8) * 3 * 3 + 16 / 8;\n        const nFaces = reader.getUint32(80, true);\n        if (80 + 32 / 8 + nFaces * faceSize === reader.byteLength) {\n            return true;\n        }\n        // US-ASCII begin with 's', 'o', 'l', 'i', 'd'\n        const ascii = [115, 111, 108, 105, 100];\n        for (let off = 0; off < 5; off++) {\n            if (reader.getUint8(off) !== ascii[off]) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _parseBinary(mesh, data) {\n        const reader = new DataView(data);\n        const faces = reader.getUint32(80, true);\n        const dataOffset = 84;\n        const faceLength = 12 * 4 + 2;\n        let offset = 0;\n        const positions = new Float32Array(faces * 3 * 3);\n        const normals = new Float32Array(faces * 3 * 3);\n        const indices = new Uint32Array(faces * 3);\n        let indicesCount = 0;\n        for (let face = 0; face < faces; face++) {\n            const start = dataOffset + face * faceLength;\n            const normalX = reader.getFloat32(start, true);\n            const normalY = reader.getFloat32(start + 4, true);\n            const normalZ = reader.getFloat32(start + 8, true);\n            for (let i = 1; i <= 3; i++) {\n                const vertexstart = start + i * 12;\n                // ordering is intentional to match ascii import\n                positions[offset] = reader.getFloat32(vertexstart, true);\n                normals[offset] = normalX;\n                if (!STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {\n                    positions[offset + 2] = reader.getFloat32(vertexstart + 4, true);\n                    positions[offset + 1] = reader.getFloat32(vertexstart + 8, true);\n                    normals[offset + 2] = normalY;\n                    normals[offset + 1] = normalZ;\n                }\n                else {\n                    positions[offset + 1] = reader.getFloat32(vertexstart + 4, true);\n                    positions[offset + 2] = reader.getFloat32(vertexstart + 8, true);\n                    normals[offset + 1] = normalY;\n                    normals[offset + 2] = normalZ;\n                }\n                offset += 3;\n            }\n            if (STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {\n                indices[indicesCount] = indicesCount;\n                indices[indicesCount + 1] = indicesCount + 2;\n                indices[indicesCount + 2] = indicesCount + 1;\n                indicesCount += 3;\n            }\n            else {\n                indices[indicesCount] = indicesCount++;\n                indices[indicesCount] = indicesCount++;\n                indices[indicesCount] = indicesCount++;\n            }\n        }\n        mesh.setVerticesData(VertexBuffer.PositionKind, positions);\n        mesh.setVerticesData(VertexBuffer.NormalKind, normals);\n        mesh.setIndices(indices);\n        mesh.computeWorldMatrix(true);\n    }\n    _parseASCII(mesh, solidData) {\n        const positions = [];\n        const normals = [];\n        const indices = [];\n        let indicesCount = 0;\n        //load facets, ignoring loop as the standard doesn't define it can contain more than vertices\n        let matches;\n        while ((matches = this.facetsPattern.exec(solidData))) {\n            const facet = matches[1];\n            //one normal per face\n            const normalMatches = this.normalPattern.exec(facet);\n            this.normalPattern.lastIndex = 0;\n            if (!normalMatches) {\n                continue;\n            }\n            const normal = [Number(normalMatches[1]), Number(normalMatches[5]), Number(normalMatches[3])];\n            let vertexMatch;\n            while ((vertexMatch = this.vertexPattern.exec(facet))) {\n                if (!STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {\n                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[5]), Number(vertexMatch[3]));\n                    normals.push(normal[0], normal[1], normal[2]);\n                }\n                else {\n                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[3]), Number(vertexMatch[5]));\n                    // Flipping the second and third component because inverted\n                    // when normal was declared.\n                    normals.push(normal[0], normal[2], normal[1]);\n                }\n            }\n            if (STLFileLoader.DO_NOT_ALTER_FILE_COORDINATES) {\n                indices.push(indicesCount, indicesCount + 2, indicesCount + 1);\n                indicesCount += 3;\n            }\n            else {\n                indices.push(indicesCount++, indicesCount++, indicesCount++);\n            }\n            this.vertexPattern.lastIndex = 0;\n        }\n        this.facetsPattern.lastIndex = 0;\n        mesh.setVerticesData(VertexBuffer.PositionKind, positions);\n        mesh.setVerticesData(VertexBuffer.NormalKind, normals);\n        mesh.setIndices(indices);\n        mesh.computeWorldMatrix(true);\n    }\n}\n/**\n * Defines if Y and Z axes are swapped or not when loading an STL file.\n * The default is false to maintain backward compatibility. When set to\n * true, coordinates from the STL file are used without change.\n */\nSTLFileLoader.DO_NOT_ALTER_FILE_COORDINATES = false;\nregisterSceneLoaderPlugin(new STLFileLoader());\n//# sourceMappingURL=stlFileLoader.js.map"],"names":[],"mappings":"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"}

package/dist/chunks/tgaTextureLoader-2ekJC0En.esm.js

@@ -0,0 +1,349 @@
+import { L as Logger } from './index-C6hXZyZb.esm.js';
+
+//private static _TYPE_NO_DATA = 0;
+const _TYPE_INDEXED = 1;
+const _TYPE_RGB = 2;
+const _TYPE_GREY = 3;
+const _TYPE_RLE_INDEXED = 9;
+const _TYPE_RLE_RGB = 10;
+const _TYPE_RLE_GREY = 11;
+const _ORIGIN_MASK = 0x30;
+const _ORIGIN_SHIFT = 0x04;
+const _ORIGIN_BL = 0x00;
+const _ORIGIN_BR = 0x01;
+const _ORIGIN_UL = 0x02;
+const _ORIGIN_UR = 0x03;
+/**
+ * Gets the header of a TGA file
+ * @param data defines the TGA data
+ * @returns the header
+ */
+function GetTGAHeader(data) {
+    let offset = 0;
+    const header = {
+        id_length: data[offset++],
+        colormap_type: data[offset++],
+        image_type: data[offset++],
+        colormap_index: data[offset++] | (data[offset++] << 8),
+        colormap_length: data[offset++] | (data[offset++] << 8),
+        colormap_size: data[offset++],
+        origin: [data[offset++] | (data[offset++] << 8), data[offset++] | (data[offset++] << 8)],
+        width: data[offset++] | (data[offset++] << 8),
+        height: data[offset++] | (data[offset++] << 8),
+        pixel_size: data[offset++],
+        flags: data[offset++],
+    };
+    return header;
+}
+/**
+ * Uploads TGA content to a Babylon Texture
+ * @internal
+ */
+function UploadContent(texture, data) {
+    // Not enough data to contain header ?
+    if (data.length < 19) {
+        Logger.Error("Unable to load TGA file - Not enough data to contain header");
+        return;
+    }
+    // Read Header
+    let offset = 18;
+    const header = GetTGAHeader(data);
+    // Assume it's a valid Targa file.
+    if (header.id_length + offset > data.length) {
+        Logger.Error("Unable to load TGA file - Not enough data");
+        return;
+    }
+    // Skip not needed data
+    offset += header.id_length;
+    let use_rle = false;
+    let use_pal = false;
+    let use_grey = false;
+    // Get some informations.
+    switch (header.image_type) {
+        case _TYPE_RLE_INDEXED:
+            use_rle = true;
+        // eslint-disable-next-line no-fallthrough
+        case _TYPE_INDEXED:
+            use_pal = true;
+            break;
+        case _TYPE_RLE_RGB:
+            use_rle = true;
+        // eslint-disable-next-line no-fallthrough
+        case _TYPE_RGB:
+            // use_rgb = true;
+            break;
+        case _TYPE_RLE_GREY:
+            use_rle = true;
+        // eslint-disable-next-line no-fallthrough
+        case _TYPE_GREY:
+            use_grey = true;
+            break;
+    }
+    let pixel_data;
+    // var numAlphaBits = header.flags & 0xf;
+    const pixel_size = header.pixel_size >> 3;
+    const pixel_total = header.width * header.height * pixel_size;
+    // Read palettes
+    let palettes;
+    if (use_pal) {
+        palettes = data.subarray(offset, (offset += header.colormap_length * (header.colormap_size >> 3)));
+    }
+    // Read LRE
+    if (use_rle) {
+        pixel_data = new Uint8Array(pixel_total);
+        let c, count, i;
+        let localOffset = 0;
+        const pixels = new Uint8Array(pixel_size);
+        while (offset < pixel_total && localOffset < pixel_total) {
+            c = data[offset++];
+            count = (c & 0x7f) + 1;
+            // RLE pixels
+            if (c & 0x80) {
+                // Bind pixel tmp array
+                for (i = 0; i < pixel_size; ++i) {
+                    pixels[i] = data[offset++];
+                }
+                // Copy pixel array
+                for (i = 0; i < count; ++i) {
+                    pixel_data.set(pixels, localOffset + i * pixel_size);
+                }
+                localOffset += pixel_size * count;
+            }
+            // Raw pixels
+            else {
+                count *= pixel_size;
+                for (i = 0; i < count; ++i) {
+                    pixel_data[localOffset + i] = data[offset++];
+                }
+                localOffset += count;
+            }
+        }
+    }
+    // RAW Pixels
+    else {
+        pixel_data = data.subarray(offset, (offset += use_pal ? header.width * header.height : pixel_total));
+    }
+    // Load to texture
+    let x_start, y_start, x_step, y_step, y_end, x_end;
+    switch ((header.flags & _ORIGIN_MASK) >> _ORIGIN_SHIFT) {
+        default:
+        case _ORIGIN_UL:
+            x_start = 0;
+            x_step = 1;
+            x_end = header.width;
+            y_start = 0;
+            y_step = 1;
+            y_end = header.height;
+            break;
+        case _ORIGIN_BL:
+            x_start = 0;
+            x_step = 1;
+            x_end = header.width;
+            y_start = header.height - 1;
+            y_step = -1;
+            y_end = -1;
+            break;
+        case _ORIGIN_UR:
+            x_start = header.width - 1;
+            x_step = -1;
+            x_end = -1;
+            y_start = 0;
+            y_step = 1;
+            y_end = header.height;
+            break;
+        case _ORIGIN_BR:
+            x_start = header.width - 1;
+            x_step = -1;
+            x_end = -1;
+            y_start = header.height - 1;
+            y_step = -1;
+            y_end = -1;
+            break;
+    }
+    // Load the specify method
+    const func = "_getImageData" + (use_grey ? "Grey" : "") + header.pixel_size + "bits";
+    const imageData = TGATools[func](header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
+    const engine = texture.getEngine();
+    engine._uploadDataToTextureDirectly(texture, imageData);
+}
+/**
+ * @internal
+ */
+function _getImageData8bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end) {
+    const image = pixel_data, colormap = palettes;
+    const width = header.width, height = header.height;
+    let color, i = 0, x, y;
+    const imageData = new Uint8Array(width * height * 4);
+    for (y = y_start; y !== y_end; y += y_step) {
+        for (x = x_start; x !== x_end; x += x_step, i++) {
+            color = image[i];
+            imageData[(x + width * y) * 4 + 3] = 255;
+            imageData[(x + width * y) * 4 + 2] = colormap[color * 3 + 0];
+            imageData[(x + width * y) * 4 + 1] = colormap[color * 3 + 1];
+            imageData[(x + width * y) * 4 + 0] = colormap[color * 3 + 2];
+        }
+    }
+    return imageData;
+}
+/**
+ * @internal
+ */
+function _getImageData16bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end) {
+    const image = pixel_data;
+    const width = header.width, height = header.height;
+    let color, i = 0, x, y;
+    const imageData = new Uint8Array(width * height * 4);
+    for (y = y_start; y !== y_end; y += y_step) {
+        for (x = x_start; x !== x_end; x += x_step, i += 2) {
+            color = image[i + 0] + (image[i + 1] << 8); // Inversed ?
+            const r = ((((color & 0x7c00) >> 10) * 255) / 0x1f) | 0;
+            const g = ((((color & 0x03e0) >> 5) * 255) / 0x1f) | 0;
+            const b = (((color & 0x001f) * 255) / 0x1f) | 0;
+            imageData[(x + width * y) * 4 + 0] = r;
+            imageData[(x + width * y) * 4 + 1] = g;
+            imageData[(x + width * y) * 4 + 2] = b;
+            imageData[(x + width * y) * 4 + 3] = color & 0x8000 ? 0 : 255;
+        }
+    }
+    return imageData;
+}
+/**
+ * @internal
+ */
+function _getImageData24bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end) {
+    const image = pixel_data;
+    const width = header.width, height = header.height;
+    let i = 0, x, y;
+    const imageData = new Uint8Array(width * height * 4);
+    for (y = y_start; y !== y_end; y += y_step) {
+        for (x = x_start; x !== x_end; x += x_step, i += 3) {
+            imageData[(x + width * y) * 4 + 3] = 255;
+            imageData[(x + width * y) * 4 + 2] = image[i + 0];
+            imageData[(x + width * y) * 4 + 1] = image[i + 1];
+            imageData[(x + width * y) * 4 + 0] = image[i + 2];
+        }
+    }
+    return imageData;
+}
+/**
+ * @internal
+ */
+function _getImageData32bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end) {
+    const image = pixel_data;
+    const width = header.width, height = header.height;
+    let i = 0, x, y;
+    const imageData = new Uint8Array(width * height * 4);
+    for (y = y_start; y !== y_end; y += y_step) {
+        for (x = x_start; x !== x_end; x += x_step, i += 4) {
+            imageData[(x + width * y) * 4 + 2] = image[i + 0];
+            imageData[(x + width * y) * 4 + 1] = image[i + 1];
+            imageData[(x + width * y) * 4 + 0] = image[i + 2];
+            imageData[(x + width * y) * 4 + 3] = image[i + 3];
+        }
+    }
+    return imageData;
+}
+/**
+ * @internal
+ */
+function _getImageDataGrey8bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end) {
+    const image = pixel_data;
+    const width = header.width, height = header.height;
+    let color, i = 0, x, y;
+    const imageData = new Uint8Array(width * height * 4);
+    for (y = y_start; y !== y_end; y += y_step) {
+        for (x = x_start; x !== x_end; x += x_step, i++) {
+            color = image[i];
+            imageData[(x + width * y) * 4 + 0] = color;
+            imageData[(x + width * y) * 4 + 1] = color;
+            imageData[(x + width * y) * 4 + 2] = color;
+            imageData[(x + width * y) * 4 + 3] = 255;
+        }
+    }
+    return imageData;
+}
+/**
+ * @internal
+ */
+function _getImageDataGrey16bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end) {
+    const image = pixel_data;
+    const width = header.width, height = header.height;
+    let i = 0, x, y;
+    const imageData = new Uint8Array(width * height * 4);
+    for (y = y_start; y !== y_end; y += y_step) {
+        for (x = x_start; x !== x_end; x += x_step, i += 2) {
+            imageData[(x + width * y) * 4 + 0] = image[i + 0];
+            imageData[(x + width * y) * 4 + 1] = image[i + 0];
+            imageData[(x + width * y) * 4 + 2] = image[i + 0];
+            imageData[(x + width * y) * 4 + 3] = image[i + 1];
+        }
+    }
+    return imageData;
+}
+/**
+ * Based on jsTGALoader - Javascript loader for TGA file
+ * By Vincent Thibault
+ * @see http://blog.robrowser.com/javascript-tga-loader.html
+ */
+const TGATools = {
+    /**
+     * Gets the header of a TGA file
+     * @param data defines the TGA data
+     * @returns the header
+     */
+    GetTGAHeader,
+    /**
+     * Uploads TGA content to a Babylon Texture
+     * @internal
+     */
+    UploadContent,
+    /** @internal */
+    _getImageData8bits,
+    /** @internal */
+    _getImageData16bits,
+    /** @internal */
+    _getImageData24bits,
+    /** @internal */
+    _getImageData32bits,
+    /** @internal */
+    _getImageDataGrey8bits,
+    /** @internal */
+    _getImageDataGrey16bits,
+};
+
+/**
+ * Implementation of the TGA Texture Loader.
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+class _TGATextureLoader {
+    constructor() {
+        /**
+         * Defines whether the loader supports cascade loading the different faces.
+         */
+        this.supportCascades = false;
+    }
+    /**
+     * Uploads the cube texture data to the WebGL texture. It has already been bound.
+     */
+    loadCubeData() {
+        // eslint-disable-next-line no-throw-literal
+        throw ".env not supported in Cube.";
+    }
+    /**
+     * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+     * @param data contains the texture data
+     * @param texture defines the BabylonJS internal texture
+     * @param callback defines the method to call once ready to upload
+     */
+    loadData(data, texture, callback) {
+        const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const header = GetTGAHeader(bytes);
+        callback(header.width, header.height, texture.generateMipMaps, false, () => {
+            UploadContent(texture, bytes);
+        });
+    }
+}
+
+export { _TGATextureLoader };
+//# sourceMappingURL=tgaTextureLoader-2ekJC0En.esm.js.map