@itwin/core-frontend 4.6.0-dev.3 → 4.6.0-dev.6

package/lib/esm/tile/GltfReader.js

@@ -13,6 +13,7 @@ import { GraphicBranch } from "../render/GraphicBranch";
 import { RealityMeshParams } from "../render/RealityMeshParams";
 import { Mesh } from "../render/primitives/mesh/MeshPrimitives";
 import { Triangle } from "../render/primitives/Primitives";
+import { decodeMeshoptBuffer } from "./internal";
 import { DisplayParams } from "../common/render/primitives/DisplayParams";
 import { FrontendLoggerCategory } from "../common/FrontendLoggerCategory";
 import { getImageSourceFormatForMimeType, imageBitmapFromImageSource, imageElementFromImageSource, tryImageElementFromUrl } from "../common/ImageUtil";
@@ -581,10 +582,15 @@ export class GltfReader {
                 return undefined;
             const bufferViewAccessorValue = accessor.bufferView;
             const bufferView = undefined !== bufferViewAccessorValue ? this._bufferViews[bufferViewAccessorValue] : undefined;
-            if (!bufferView || undefined === bufferView.buffer)
+            if (!bufferView)
                 return undefined;
-            const buffer = this._buffers[bufferView.buffer];
-            const bufferData = buffer?.resolvedBuffer;
+            let bufferData = bufferView.resolvedBuffer;
+            if (!bufferData) {
+                if (undefined === bufferView.buffer)
+                    return undefined;
+                const buffer = this._buffers[bufferView.buffer];
+                bufferData = buffer?.resolvedBuffer;
+            }
             if (!bufferData)
                 return undefined;
             const type = accessor.componentType;
@@ -791,7 +797,7 @@ export class GltfReader {
     readMeshPrimitive(primitive, featureTable, pseudoRtcBias) {
         const meshMode = JsonUtils.asInt(primitive.mode, GltfMeshMode.Triangles);
         if (meshMode === GltfMeshMode.Points /* && !this._vertexTableRequired */) {
-            const pointCloud = this.readPointCloud(primitive, undefined !== featureTable);
+            const pointCloud = this.readPointCloud2(primitive, undefined !== featureTable);
             if (pointCloud)
                 return pointCloud;
         }
@@ -909,23 +915,60 @@ export class GltfReader {
         }
         return mesh;
     }
-    readPointCloud(primitive, hasFeatures) {
+    readPointCloud2(primitive, hasFeatures) {
+        let pointRange;
+        let positions;
+        let qparams;
         const posView = this.getBufferView(primitive.attributes, "POSITION");
-        if (!posView || GltfDataType.Float !== posView.type)
-            return undefined;
-        const posData = posView.toBufferData(GltfDataType.Float);
-        if (!(posData?.buffer instanceof Float32Array))
-            return undefined;
+        switch (posView?.type) {
+            case GltfDataType.Float: {
+                const posData = posView.toBufferData(GltfDataType.Float);
+                if (!(posData?.buffer instanceof Float32Array)) {
+                    return undefined;
+                }
+                positions = posData.buffer;
+                const strideSkip = posView.stride - 3;
+                pointRange = new Range3d();
+                for (let i = 0; i < positions.length; i += strideSkip) {
+                    pointRange.extendXYZ(positions[i++], positions[i++], positions[i++]);
+                }
+                qparams = QParams3d.fromOriginAndScale(new Point3d(0, 0, 0), new Point3d(1, 1, 1));
+                break;
+            }
+            case GltfDataType.UnsignedByte:
+            case GltfDataType.UnsignedShort: {
+                const posData = posView.toBufferData(posView.type);
+                if (!(posData?.buffer instanceof Uint8Array || posData?.buffer instanceof Uint16Array)) {
+                    return undefined;
+                }
+                positions = posData.buffer;
+                let min, max;
+                const ext = posView.accessor.extensions?.WEB3D_quantized_attributes;
+                if (ext) {
+                    min = ext.decodedMin;
+                    max = ext.decodedMax;
+                }
+                else {
+                    // Assume KHR_mesh_quantization...
+                    min = posView.accessor.min;
+                    max = posView.accessor.max;
+                }
+                if (undefined === min || undefined === max) {
+                    return undefined;
+                }
+                pointRange = Range3d.createXYZXYZ(min[0], min[1], min[2], max[0], max[1], max[2]);
+                qparams = QParams3d.fromRange(pointRange);
+                break;
+            }
+            default:
+                return undefined;
+        }
         const colorView = this.getBufferView(primitive.attributes, "COLOR_0");
         if (!colorView || GltfDataType.UnsignedByte !== colorView.type)
             return undefined;
         const colorData = colorView.toBufferData(GltfDataType.UnsignedByte);
         if (!(colorData?.buffer instanceof Uint8Array))
             return undefined;
-        const strideSkip = posView.stride - 3;
-        const pointRange = new Range3d();
-        for (let i = 0; i < posData.buffer.length; i += strideSkip)
-            pointRange.extendXYZ(posData.buffer[i++], posData.buffer[i++], posData.buffer[i++]);
         let colors = colorData.buffer;
         if ("VEC4" === colorView.accessor.type) {
             // ###TODO support transparent point clouds
@@ -938,13 +981,14 @@ export class GltfReader {
             }
         }
         const features = new FeatureIndex();
-        if (hasFeatures)
+        if (hasFeatures) {
             features.type = FeatureIndexType.Uniform;
+        }
         this._containsPointCloud = true;
         return {
             type: "pointcloud",
-            positions: posData.buffer,
-            qparams: QParams3d.fromOriginAndScale(new Point3d(0, 0, 0), new Point3d(1, 1, 1)),
+            positions,
+            qparams,
             pointRange,
             colors,
             colorFormat: "rgb",
@@ -1073,10 +1117,18 @@ export class GltfReader {
         else {
             if (GltfDataType.UnsignedShort !== view.type)
                 return false;
+            let rangeMin, rangeMax;
             const quantized = view.accessor.extensions?.WEB3D_quantized_attributes;
-            const rangeMin = quantized?.decodedMin;
-            const rangeMax = quantized?.decodedMax;
-            if (!rangeMin || !rangeMax) // required by spec...
+            if (quantized) {
+                rangeMin = quantized.decodedMin;
+                rangeMax = quantized.decodedMax;
+            }
+            else {
+                // Assume KHR_mesh_quantization...
+                rangeMin = view.accessor.min;
+                rangeMax = view.accessor.max;
+            }
+            if (undefined === rangeMin || undefined === rangeMax) // required by spec...
                 return false;
             // ###TODO apply WEB3D_quantized_attributes.decodeMatrix? Have not encountered in the wild; glTF 1.0 only.
             const buffer = view.toBufferData(GltfDataType.UnsignedShort);
@@ -1276,6 +1328,26 @@ export class GltfReader {
     async resolveResources() {
         // Load any external images and buffers.
         await this._resolveResources();
+        // Decompress any meshopt-compressed buffer views
+        const decodeMeshoptBuffers = [];
+        for (const bv of gltfDictionaryIterator(this._bufferViews)) {
+            const ext = bv.extensions?.EXT_meshopt_compression;
+            if (ext) {
+                const bufferData = this._buffers[ext.buffer]?.resolvedBuffer;
+                if (bufferData) {
+                    const source = new Uint8Array(bufferData.buffer, bufferData.byteOffset + (ext.byteOffset ?? 0), ext.byteLength ?? 0);
+                    const decode = async () => {
+                        bv.resolvedBuffer = await decodeMeshoptBuffer(source, ext);
+                        if (bv.resolvedBuffer) {
+                            bv.byteLength = bv.resolvedBuffer.byteLength;
+                            bv.byteOffset = 0;
+                        }
+                    };
+                    decodeMeshoptBuffers.push(decode());
+                }
+            }
+        }
+        await Promise.all(decodeMeshoptBuffers);
         // If any meshes are draco-compressed, dynamically load the decoder module and then decode the meshes.
         const dracoMeshes = [];
         for (const node of this.traverseScene()) {