@babylonjs/core 6.21.0 → 6.21.2

package/Meshes/Compression/dracoCompression.d.ts

@@ -1,5 +1,6 @@
-import type { IDisposable } from "../../scene";
-import { VertexData } from "../../Meshes/mesh.vertexData";
+import type { IDisposable, Scene } from "../../scene";
+import { Geometry } from "../geometry";
+import { VertexData } from "../mesh.vertexData";
 /**
  * Configuration for Draco compression
  */
@@ -50,9 +51,9 @@ export interface IDracoCompressionConfiguration {
  * Decoding will automatically fallback to the JavaScript version if WebAssembly version is not configured or if WebAssembly is not supported by the browser.
  * Use `DracoCompression.DecoderAvailable` to determine if the decoder configuration is available for the current context.
  *
- * To decode Draco compressed data, get the default DracoCompression object and call decodeMeshAsync:
+ * To decode Draco compressed data, get the default DracoCompression object and call decodeMeshToGeometryAsync:
  * ```javascript
- *     var vertexData = await DracoCompression.Default.decodeMeshAsync(data);
+ *     var geometry = await DracoCompression.Default.decodeMeshToGeometryAsync(data);
  * ```
  *
  * @see https://playground.babylonjs.com/#DMZIBD#0
@@ -95,16 +96,32 @@ export declare class DracoCompression implements IDisposable {
      * @returns a promise that resolves when ready
      */
     whenReadyAsync(): Promise<void>;
+    private _decodeMeshAsync;
     /**
-     * Decode Draco compressed mesh data to vertex data.
+     * Decode Draco compressed mesh data to Babylon geometry.
+     * @param name The name to use when creating the geometry
+     * @param scene The scene to use when creating the geometry
+     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
+     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
+     * @returns A promise that resolves with the decoded geometry
+     */
+    decodeMeshToGeometryAsync(name: string, scene: Scene, data: ArrayBuffer | ArrayBufferView, attributes?: {
+        [kind: string]: number;
+    }): Promise<Geometry>;
+    /** @internal */
+    _decodeMeshToGeometryForGltfAsync(name: string, scene: Scene, data: ArrayBuffer | ArrayBufferView, attributes: {
+        [kind: string]: number;
+    }, gltfNormalizedOverride: {
+        [kind: string]: boolean;
+    }): Promise<Geometry>;
+    /**
+     * Decode Draco compressed mesh data to Babylon vertex data.
      * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
      * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
-     * @param dividers a list of optional dividers for normalization
      * @returns A promise that resolves with the decoded vertex data
+     * @deprecated Use {@link decodeMeshToGeometryAsync} for better performance in some cases
      */
     decodeMeshAsync(data: ArrayBuffer | ArrayBufferView, attributes?: {
         [kind: string]: number;
-    }, dividers?: {
-        [kind: string]: number;
     }): Promise<VertexData>;
 }

package/Meshes/Compression/dracoCompression.js

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { Tools } from "../../Misc/tools.js";
 import { AutoReleaseWorkerPool } from "../../Misc/workerPool.js";
-import { VertexData } from "../../Meshes/mesh.vertexData.js";
+import { Geometry } from "../geometry.js";
+import { VertexBuffer } from "../buffer.js";
+import { VertexData } from "../mesh.vertexData.js";
+import { Logger } from "../../Misc/logger.js";
 function createDecoderAsync(wasmBinary) {
     return new Promise((resolve) => {
         DracoDecoderModule({ wasmBinary: wasmBinary }).then((module) => {
@@ -9,73 +12,79 @@ function createDecoderAsync(wasmBinary) {
         });
     });
 }
-function decodeMesh(decoderModule, dataView, attributes, onIndicesData, onAttributeData, dividers) {
-    const buffer = new decoderModule.DecoderBuffer();
-    buffer.Init(dataView, dataView.byteLength);
-    const decoder = new decoderModule.Decoder();
-    let geometry;
-    let status;
+function decodeMesh(decoderModule, data, attributes, onIndicesData, onAttributeData) {
+    let decoder = null;
+    let buffer = null;
+    let geometry = null;
     try {
+        decoder = new decoderModule.Decoder();
+        buffer = new decoderModule.DecoderBuffer();
+        buffer.Init(data, data.byteLength);
+        let status;
         const type = decoder.GetEncodedGeometryType(buffer);
         switch (type) {
-            case decoderModule.TRIANGULAR_MESH:
-                geometry = new decoderModule.Mesh();
-                status = decoder.DecodeBufferToMesh(buffer, geometry);
+            case decoderModule.TRIANGULAR_MESH: {
+                const mesh = new decoderModule.Mesh();
+                status = decoder.DecodeBufferToMesh(buffer, mesh);
+                if (!status.ok() || mesh.ptr === 0) {
+                    throw new Error(status.error_msg());
+                }
+                const numFaces = mesh.num_faces();
+                const numIndices = numFaces * 3;
+                const byteLength = numIndices * 4;
+                const ptr = decoderModule._malloc(byteLength);
+                try {
+                    decoder.GetTrianglesUInt32Array(mesh, byteLength, ptr);
+                    const indices = new Uint32Array(numIndices);
+                    indices.set(new Uint32Array(decoderModule.HEAPF32.buffer, ptr, numIndices));
+                    onIndicesData(indices);
+                }
+                finally {
+                    decoderModule._free(ptr);
+                }
+                geometry = mesh;
                 break;
-            case decoderModule.POINT_CLOUD:
-                geometry = new decoderModule.PointCloud();
-                status = decoder.DecodeBufferToPointCloud(buffer, geometry);
+            }
+            case decoderModule.POINT_CLOUD: {
+                const pointCloud = new decoderModule.PointCloud();
+                status = decoder.DecodeBufferToPointCloud(buffer, pointCloud);
+                if (!status.ok() || !pointCloud.ptr) {
+                    throw new Error(status.error_msg());
+                }
+                geometry = pointCloud;
                 break;
-            default:
-                throw new Error(`Invalid geometry type ${type}`);
-        }
-        if (!status.ok() || !geometry.ptr) {
-            throw new Error(status.error_msg());
-        }
-        if (type === decoderModule.TRIANGULAR_MESH) {
-            const numFaces = geometry.num_faces();
-            const numIndices = numFaces * 3;
-            const byteLength = numIndices * 4;
-            const ptr = decoderModule._malloc(byteLength);
-            try {
-                decoder.GetTrianglesUInt32Array(geometry, byteLength, ptr);
-                const indices = new Uint32Array(numIndices);
-                indices.set(new Uint32Array(decoderModule.HEAPF32.buffer, ptr, numIndices));
-                onIndicesData(indices);
             }
-            finally {
-                decoderModule._free(ptr);
+            default: {
+                throw new Error(`Invalid geometry type ${type}`);
             }
         }
-        const processAttribute = (kind, attribute, divider = 1) => {
+        const numPoints = geometry.num_points();
+        const processAttribute = (decoder, geometry, kind, attribute) => {
+            const dataType = attribute.data_type();
             const numComponents = attribute.num_components();
-            const numPoints = geometry.num_points();
+            const normalized = attribute.normalized();
+            const byteStride = attribute.byte_stride();
+            const byteOffset = attribute.byte_offset();
+            const dataTypeInfo = {
+                [decoderModule.DT_FLOAT32]: { typedArrayConstructor: Float32Array, heap: decoderModule.HEAPF32 },
+                [decoderModule.DT_INT8]: { typedArrayConstructor: Int8Array, heap: decoderModule.HEAP8 },
+                [decoderModule.DT_INT16]: { typedArrayConstructor: Int16Array, heap: decoderModule.HEAP16 },
+                [decoderModule.DT_INT32]: { typedArrayConstructor: Int32Array, heap: decoderModule.HEAP32 },
+                [decoderModule.DT_UINT8]: { typedArrayConstructor: Uint8Array, heap: decoderModule.HEAPU8 },
+                [decoderModule.DT_UINT16]: { typedArrayConstructor: Uint16Array, heap: decoderModule.HEAPU16 },
+                [decoderModule.DT_UINT32]: { typedArrayConstructor: Uint32Array, heap: decoderModule.HEAPU32 },
+            };
+            const info = dataTypeInfo[dataType];
+            if (!info) {
+                throw new Error(`Invalid data type ${dataType}`);
+            }
             const numValues = numPoints * numComponents;
-            const byteLength = numValues * Float32Array.BYTES_PER_ELEMENT;
+            const byteLength = numValues * info.typedArrayConstructor.BYTES_PER_ELEMENT;
             const ptr = decoderModule._malloc(byteLength);
             try {
-                decoder.GetAttributeDataArrayForAllPoints(geometry, attribute, decoderModule.DT_FLOAT32, byteLength, ptr);
-                const values = new Float32Array(decoderModule.HEAPF32.buffer, ptr, numValues);
-                if (kind === "color" && numComponents === 3) {
-                    const babylonData = new Float32Array(numPoints * 4);
-                    for (let i = 0, j = 0; i < babylonData.length; i += 4, j += numComponents) {
-                        babylonData[i + 0] = values[j + 0];
-                        babylonData[i + 1] = values[j + 1];
-                        babylonData[i + 2] = values[j + 2];
-                        babylonData[i + 3] = 1;
-                    }
-                    onAttributeData(kind, babylonData);
-                }
-                else {
-                    const babylonData = new Float32Array(numValues);
-                    babylonData.set(new Float32Array(decoderModule.HEAPF32.buffer, ptr, numValues));
-                    if (divider !== 1) {
-                        for (let i = 0; i < babylonData.length; i++) {
-                            babylonData[i] = babylonData[i] / divider;
-                        }
-                    }
-                    onAttributeData(kind, babylonData);
-                }
+                decoder.GetAttributeDataArrayForAllPoints(geometry, attribute, dataType, byteLength, ptr);
+                const data = new info.typedArrayConstructor(info.heap.buffer, ptr, numValues);
+                onAttributeData(kind, data.slice(), byteOffset, byteStride, normalized);
             }
             finally {
                 decoderModule._free(ptr);
@@ -85,32 +94,36 @@ function decodeMesh(decoderModule, dataView, attributes, onIndicesData, onAttrib
             for (const kind in attributes) {
                 const id = attributes[kind];
                 const attribute = decoder.GetAttributeByUniqueId(geometry, id);
-                const divider = (dividers && dividers[kind]) || 1;
-                processAttribute(kind, attribute, divider);
+                processAttribute(decoder, geometry, kind, attribute);
             }
         }
         else {
-            const nativeAttributeTypes = {
-                position: "POSITION",
-                normal: "NORMAL",
-                color: "COLOR",
-                uv: "TEX_COORD",
+            const dracoAttributeTypes = {
+                position: decoderModule.POSITION,
+                normal: decoderModule.NORMAL,
+                color: decoderModule.COLOR,
+                uv: decoderModule.TEX_COORD,
             };
-            for (const kind in nativeAttributeTypes) {
-                const id = decoder.GetAttributeId(geometry, decoderModule[nativeAttributeTypes[kind]]);
+            for (const kind in dracoAttributeTypes) {
+                const id = decoder.GetAttributeId(geometry, dracoAttributeTypes[kind]);
                 if (id !== -1) {
                     const attribute = decoder.GetAttribute(geometry, id);
-                    processAttribute(kind, attribute);
+                    processAttribute(decoder, geometry, kind, attribute);
                 }
             }
         }
+        return numPoints;
     }
     finally {
         if (geometry) {
             decoderModule.destroy(geometry);
         }
-        decoderModule.destroy(decoder);
-        decoderModule.destroy(buffer);
+        if (buffer) {
+            decoderModule.destroy(buffer);
+        }
+        if (decoder) {
+            decoderModule.destroy(decoder);
+        }
     }
 }
 /**
@@ -119,15 +132,15 @@ function decodeMesh(decoderModule, dataView, attributes, onIndicesData, onAttrib
 function worker() {
     let decoderPromise;
     onmessage = (event) => {
-        const data = event.data;
-        switch (data.id) {
+        const message = event.data;
+        switch (message.id) {
             case "init": {
-                const decoder = data.decoder;
+                const decoder = message.decoder;
                 if (decoder.url) {
                     importScripts(decoder.url);
                     decoderPromise = DracoDecoderModule({ wasmBinary: decoder.wasmBinary });
                 }
-                postMessage("done");
+                postMessage({ id: "initDone" });
                 break;
             }
             case "decodeMesh": {
@@ -135,12 +148,12 @@ function worker() {
                     throw new Error("Draco decoder module is not available");
                 }
                 decoderPromise.then((decoder) => {
-                    decodeMesh(decoder, data.dataView, data.attributes, (indices) => {
-                        postMessage({ id: "indices", value: indices }, [indices.buffer]);
-                    }, (kind, data) => {
-                        postMessage({ id: kind, value: data }, [data.buffer]);
+                    const numPoints = decodeMesh(decoder, message.dataView, message.attributes, (indices) => {
+                        postMessage({ id: "indices", data: indices }, [indices.buffer]);
+                    }, (kind, data, offset, stride, normalized) => {
+                        postMessage({ id: "attribute", kind, data, offset, stride, normalized }, [data.buffer]);
                     });
-                    postMessage("done");
+                    postMessage({ id: "decodeMeshDone", totalVertices: numPoints });
                 });
                 break;
             }
@@ -175,9 +188,9 @@ function worker() {
  * Decoding will automatically fallback to the JavaScript version if WebAssembly version is not configured or if WebAssembly is not supported by the browser.
  * Use `DracoCompression.DecoderAvailable` to determine if the decoder configuration is available for the current context.
  *
- * To decode Draco compressed data, get the default DracoCompression object and call decodeMeshAsync:
+ * To decode Draco compressed data, get the default DracoCompression object and call decodeMeshToGeometryAsync:
  * ```javascript
- *     var vertexData = await DracoCompression.Default.decodeMeshAsync(data);
+ *     var geometry = await DracoCompression.Default.decodeMeshToGeometryAsync(data);
  * ```
  *
  * @see https://playground.babylonjs.com/#DMZIBD#0
@@ -233,8 +246,8 @@ export class DracoCompression {
                             worker.removeEventListener("message", onMessage);
                             reject(error);
                         };
-                        const onMessage = (message) => {
-                            if (message.data === "done") {
+                        const onMessage = (event) => {
+                            if (event.data.id === "initDone") {
                                 worker.removeEventListener("error", onError);
                                 worker.removeEventListener("message", onMessage);
                                 resolve(worker);
@@ -289,52 +302,54 @@ export class DracoCompression {
         }
         return Promise.resolve();
     }
-    /**
-     * Decode Draco compressed mesh data to vertex data.
-     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
-     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
-     * @param dividers a list of optional dividers for normalization
-     * @returns A promise that resolves with the decoded vertex data
-     */
-    decodeMeshAsync(data, attributes, dividers) {
-        const dataView = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    _decodeMeshAsync(engine, data, attributes, gltfNormalizedOverride) {
+        const dataView = data instanceof ArrayBuffer ? new Int8Array(data) : new Int8Array(data.buffer, data.byteOffset, data.byteLength);
+        const applyGltfNormalizedOverride = (kind, normalized) => {
+            if (gltfNormalizedOverride && gltfNormalizedOverride[kind] !== undefined) {
+                if (normalized !== gltfNormalizedOverride[kind]) {
+                    Logger.Warn(`Normalized flag from Draco data (${normalized}) does not match normalized flag from glTF accessor (${gltfNormalizedOverride[kind]}). Using flag from glTF accessor.`);
+                }
+                return gltfNormalizedOverride[kind];
+            }
+            else {
+                return normalized;
+            }
+        };
         if (this._workerPoolPromise) {
             return this._workerPoolPromise.then((workerPool) => {
                 return new Promise((resolve, reject) => {
                     workerPool.push((worker, onComplete) => {
-                        const vertexData = new VertexData();
+                        let resultIndices = null;
+                        const resultAttributes = [];
                         const onError = (error) => {
                             worker.removeEventListener("error", onError);
                             worker.removeEventListener("message", onMessage);
                             reject(error);
                             onComplete();
                         };
-                        const onMessage = (message) => {
-                            if (message.data === "done") {
-                                worker.removeEventListener("error", onError);
-                                worker.removeEventListener("message", onMessage);
-                                resolve(vertexData);
-                                onComplete();
-                            }
-                            else if (message.data.id === "indices") {
-                                vertexData.indices = message.data.value;
-                            }
-                            else {
-                                // check normalization
-                                const divider = dividers && dividers[message.data.id] ? dividers[message.data.id] : 1;
-                                if (divider !== 1) {
-                                    // normalize
-                                    for (let i = 0; i < message.data.value.length; i++) {
-                                        message.data.value[i] = message.data.value[i] / divider;
-                                    }
+                        const onMessage = (event) => {
+                            const message = event.data;
+                            switch (message.id) {
+                                case "decodeMeshDone": {
+                                    worker.removeEventListener("error", onError);
+                                    worker.removeEventListener("message", onMessage);
+                                    resolve({ indices: resultIndices, attributes: resultAttributes, totalVertices: message.totalVertices });
+                                    onComplete();
+                                    break;
+                                }
+                                case "indices": {
+                                    resultIndices = message.data;
+                                    break;
+                                }
+                                case "attribute": {
+                                    resultAttributes.push(new VertexBuffer(engine, message.data, message.kind, false, undefined, message.stride, undefined, message.offset, undefined, undefined, applyGltfNormalizedOverride(message.kind, message.normalized), true));
+                                    break;
                                 }
-                                vertexData.set(message.data.value, message.data.id);
                             }
                         };
                         worker.addEventListener("error", onError);
                         worker.addEventListener("message", onMessage);
-                        const dataViewCopy = new Uint8Array(dataView.byteLength);
-                        dataViewCopy.set(new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength));
+                        const dataViewCopy = dataView.slice();
                         worker.postMessage({ id: "decodeMesh", dataView: dataViewCopy, attributes: attributes }, [dataViewCopy.buffer]);
                     });
                 });
@@ -342,17 +357,70 @@ export class DracoCompression {
         }
         if (this._decoderModulePromise) {
             return this._decoderModulePromise.then((decoder) => {
-                const vertexData = new VertexData();
-                decodeMesh(decoder.module, dataView, attributes, (indices) => {
-                    vertexData.indices = indices;
-                }, (kind, data) => {
-                    vertexData.set(data, kind);
-                }, dividers);
-                return vertexData;
+                let resultIndices = null;
+                const resultAttributes = [];
+                const numPoints = decodeMesh(decoder.module, dataView, attributes, (indices) => {
+                    resultIndices = indices;
+                }, (kind, data, offset, stride, normalized) => {
+                    resultAttributes.push(new VertexBuffer(null, data, kind, false, undefined, stride, undefined, offset, undefined, undefined, applyGltfNormalizedOverride(kind, normalized), true));
+                });
+                return { indices: resultIndices, attributes: resultAttributes, totalVertices: numPoints };
             });
         }
         throw new Error("Draco decoder module is not available");
     }
+    /**
+     * Decode Draco compressed mesh data to Babylon geometry.
+     * @param name The name to use when creating the geometry
+     * @param scene The scene to use when creating the geometry
+     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
+     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
+     * @returns A promise that resolves with the decoded geometry
+     */
+    decodeMeshToGeometryAsync(name, scene, data, attributes) {
+        return this._decodeMeshAsync(scene.getEngine(), data, attributes).then((meshData) => {
+            const geometry = new Geometry(name, scene);
+            if (meshData.indices) {
+                geometry.setIndices(meshData.indices);
+            }
+            for (const attribute of meshData.attributes) {
+                geometry.setVerticesBuffer(attribute);
+            }
+            return geometry;
+        });
+    }
+    /** @internal */
+    _decodeMeshToGeometryForGltfAsync(name, scene, data, attributes, gltfNormalizedOverride) {
+        return this._decodeMeshAsync(scene.getEngine(), data, attributes, gltfNormalizedOverride).then((meshData) => {
+            const geometry = new Geometry(name, scene);
+            if (meshData.indices) {
+                geometry.setIndices(meshData.indices);
+            }
+            for (const attribute of meshData.attributes) {
+                geometry.setVerticesBuffer(attribute);
+            }
+            return geometry;
+        });
+    }
+    /**
+     * Decode Draco compressed mesh data to Babylon vertex data.
+     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
+     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
+     * @returns A promise that resolves with the decoded vertex data
+     * @deprecated Use {@link decodeMeshToGeometryAsync} for better performance in some cases
+     */
+    decodeMeshAsync(data, attributes) {
+        return this._decodeMeshAsync(null, data, attributes).then((meshData) => {
+            const vertexData = new VertexData();
+            if (meshData.indices) {
+                vertexData.indices = meshData.indices;
+            }
+            for (const attribute of meshData.attributes) {
+                vertexData.set(attribute.getFloatData(meshData.totalVertices), attribute.getKind());
+            }
+            return vertexData;
+        });
+    }
 }
 /**
  * The configuration. Defaults to the following urls: