@itwin/core-frontend 3.1.0-dev.8 → 3.2.0-dev.3

package/lib/esm/tile/GltfReader.js

@@ -5,15 +5,17 @@
 /** @packageDocumentation
  * @module Tiles
  */
-import { assert, ByteStream, compareBooleans, compareNumbers, compareStrings, Dictionary, JsonUtils, utf8ToString } from "@itwin/core-bentley";
-import { Angle, Matrix3d, Point2d, Point3d, Point4d, Range2d, Range3d, Transform, Vector3d } from "@itwin/core-geometry";
+import { assert, ByteStream, compareBooleans, compareNumbers, compareStrings, Dictionary, JsonUtils, Logger, utf8ToString, } from "@itwin/core-bentley";
+import { Angle, IndexedPolyface, Matrix3d, Point2d, Point3d, Point4d, Range2d, Range3d, Transform, Vector3d, } from "@itwin/core-geometry";
 import { BatchType, ColorDef, Feature, FeatureTable, FillFlags, GlbHeader, ImageSource, LinePixels, MeshEdge, MeshEdges, MeshPolyline, OctEncodedNormal, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderTexture, TextureMapping, TextureTransparency, TileFormat, TileReadStatus, } from "@itwin/core-common";
+import { FrontendLoggerCategory } from "../FrontendLoggerCategory";
 import { getImageSourceFormatForMimeType, imageElementFromImageSource, tryImageElementFromUrl } from "../ImageUtil";
 import { IModelApp } from "../IModelApp";
 import { GraphicBranch } from "../render/GraphicBranch";
 import { DisplayParams } from "../render/primitives/DisplayParams";
-import { Mesh, MeshGraphicArgs } from "../render/primitives/mesh/MeshPrimitives";
+import { Mesh } from "../render/primitives/mesh/MeshPrimitives";
 import { RealityMeshPrimitive } from "../render/primitives/mesh/RealityMeshPrimitive";
+import { Triangle } from "../render/primitives/Primitives";
 /* eslint-disable no-restricted-syntax */
 /** Enumerates the types of [[GltfMeshPrimitive]] topologies. */
 var GltfMeshMode;
@@ -264,8 +266,8 @@ export class GltfReaderProps {
     }
 }
 /** The GltfMeshData contains the raw GLTF mesh data. If the data is suitable to create a [[RealityMesh]] directly, basically in the quantized format produced by
-  * ContextCapture, then a RealityMesh is created directly from this data.  Otherwise, the mesh primitive is populated from the raw data and a MeshPrimitive
-  * is generated.   The MeshPrimitve path is much less efficient but should be rarely used.
+  * ContextCapture, then a RealityMesh is created directly from this data. Otherwise, the mesh primitive is populated from the raw data and a MeshPrimitive
+  * is generated. The MeshPrimitve path is much less efficient but should be rarely used.
   *
   * @internal
   */
@@ -307,8 +309,10 @@ function colorFromMaterial(material, isTransparent) {
     return color;
 }
 class TransformStack {
-    constructor() {
+    constructor(transform) {
         this._stack = [];
+        if (transform)
+            this._stack.push(transform);
     }
     get transform() {
         return this._stack.length > 0 ? this._stack[this._stack.length - 1] : undefined;
@@ -377,6 +381,7 @@ export class GltfReader {
     constructor(args) {
         var _a, _b, _c, _d, _e, _f, _g;
         this._resolvedTextures = new Dictionary((lhs, rhs) => compareTextureKeys(lhs, rhs));
+        this._dracoMeshes = new Map();
         this._glTF = args.props.glTF;
         this._version = args.props.version;
         this._yAxisUp = args.props.yAxisUp;
@@ -433,6 +438,22 @@ export class GltfReader {
     traverseScene() {
         return this.traverseNodes(this._sceneNodes);
     }
+    getTileTransform(transformToRoot, pseudoRtcBias) {
+        let transform;
+        if (this._returnToCenter || pseudoRtcBias || this._yAxisUp || transformToRoot) {
+            if (this._returnToCenter)
+                transform = Transform.createTranslation(this._returnToCenter.clone());
+            else if (pseudoRtcBias)
+                transform = Transform.createTranslationXYZ(pseudoRtcBias.x, pseudoRtcBias.y, pseudoRtcBias.z);
+            else
+                transform = Transform.createIdentity();
+            if (this._yAxisUp)
+                transform = transform.multiplyTransformMatrix3d(Matrix3d.createRotationAroundVector(Vector3d.create(1.0, 0.0, 0.0), Angle.createRadians(Angle.piOver2Radians)));
+            if (transformToRoot)
+                transform = transformToRoot.multiplyTransformTransform(transform);
+        }
+        return transform;
+    }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
         var _a;
         if (this._isCanceled)
@@ -461,21 +482,11 @@ export class GltfReader {
             renderGraphic = renderGraphicList[0];
         else
             renderGraphic = this._system.createGraphicList(renderGraphicList);
-        let transform;
+        const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
         let range = contentRange;
-        if (this._returnToCenter || pseudoRtcBias || this._yAxisUp || transformToRoot) {
-            if (this._returnToCenter)
-                transform = Transform.createTranslation(this._returnToCenter.clone());
-            else if (pseudoRtcBias)
-                transform = Transform.createTranslationXYZ(pseudoRtcBias.x, pseudoRtcBias.y, pseudoRtcBias.z);
-            else
-                transform = Transform.createIdentity();
-            if (this._yAxisUp)
-                transform = transform.multiplyTransformMatrix3d(Matrix3d.createRotationAroundVector(Vector3d.create(1.0, 0.0, 0.0), Angle.createRadians(Angle.piOver2Radians)));
-            if (transformToRoot)
-                transform = transformToRoot.multiplyTransformTransform(transform);
-            range = transform.inverse().multiplyRange(contentRange);
-        }
+        const invTransform = transform === null || transform === void 0 ? void 0 : transform.inverse();
+        if (invTransform)
+            range = invTransform.multiplyRange(contentRange);
         if (featureTable)
             renderGraphic = this._system.createBatch(renderGraphic, PackedFeatureTable.pack(featureTable), range);
         if (transform) {
@@ -490,9 +501,19 @@ export class GltfReader {
             graphic: renderGraphic,
         };
     }
-    graphicFromMeshData(gltfMesh, meshGraphicArgs, instances) {
+    readGltfAndCreateGeometry(transformToRoot, needNormals = false, needParams = false) {
+        const transformStack = new TransformStack(this.getTileTransform(transformToRoot));
+        const polyfaces = [];
+        for (const nodeKey of this._sceneNodes) {
+            const node = this._nodes[nodeKey];
+            if (node)
+                this.readNodeAndCreatePolyfaces(polyfaces, node, transformStack, needNormals, needParams);
+        }
+        return { polyfaces };
+    }
+    graphicFromMeshData(gltfMesh, instances) {
         if (!gltfMesh.points || !gltfMesh.pointRange)
-            return;
+            return gltfMesh.primitive.getGraphics(this._system, instances);
         const realityMeshPrimitive = (this._vertexTableRequired || instances) ? undefined : RealityMeshPrimitive.createFromGltfMesh(gltfMesh);
         if (realityMeshPrimitive) {
             const realityMesh = this._system.createRealityMesh(realityMeshPrimitive);
@@ -501,6 +522,7 @@ export class GltfReader {
         }
         const mesh = gltfMesh.primitive;
         const pointCount = gltfMesh.points.length / 3;
+        assert(mesh.points instanceof QPoint3dList);
         mesh.points.fromTypedArray(gltfMesh.pointRange, gltfMesh.points);
         if (mesh.triangles && gltfMesh.indices)
             mesh.triangles.addFromTypedArray(gltfMesh.indices);
@@ -512,7 +534,7 @@ export class GltfReader {
         if (gltfMesh.normals)
             for (const normal of gltfMesh.normals)
                 mesh.normals.push(new OctEncodedNormal(normal));
-        return mesh.getGraphics(meshGraphicArgs, this._system, instances);
+        return mesh.getGraphics(this._system, instances);
     }
     readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, instances, pseudoRtcBias) {
         if (undefined === node)
@@ -534,28 +556,16 @@ export class GltfReader {
         for (const meshKey of getNodeMeshIds(node)) {
             const nodeMesh = this._meshes[meshKey];
             if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
-                const meshGraphicArgs = new MeshGraphicArgs();
-                const meshes = [];
-                for (const primitive of nodeMesh.primitives) {
-                    const geometry = this.readMeshPrimitive(primitive, featureTable, thisBias);
-                    if (geometry) {
-                        meshes.push(geometry);
-                        if (this._computedContentRange && geometry.pointRange) {
-                            const invTransform = thisTransform === null || thisTransform === void 0 ? void 0 : thisTransform.inverse();
-                            const meshRange = invTransform ? invTransform.multiplyRange(geometry.pointRange) : geometry.pointRange;
-                            this._computedContentRange.extendRange(meshRange);
-                        }
-                    }
-                }
+                const meshes = this.readMeshPrimitives(node, featureTable, thisTransform, thisBias);
                 let renderGraphic;
                 if (0 !== meshes.length) {
                     if (1 === meshes.length) {
-                        renderGraphic = this.graphicFromMeshData(meshes[0], meshGraphicArgs, instances);
+                        renderGraphic = this.graphicFromMeshData(meshes[0], instances);
                     }
                     else {
                         const thisList = [];
                         for (const mesh of meshes) {
-                            renderGraphic = this.graphicFromMeshData(mesh, meshGraphicArgs, instances);
+                            renderGraphic = this.graphicFromMeshData(mesh, instances);
                             if (undefined !== renderGraphic)
                                 thisList.push(renderGraphic);
                         }
@@ -583,6 +593,54 @@ export class GltfReader {
         transformStack.pop();
         return TileReadStatus.Success;
     }
+    readNodeAndCreatePolyfaces(polyfaces, node, transformStack, needNormals, needParams) {
+        // IMPORTANT: Do not return without popping this node from the stack.
+        transformStack.push(node);
+        const meshes = this.readMeshPrimitives(node);
+        for (const mesh of meshes) {
+            const polyface = this.polyfaceFromGltfMesh(mesh, transformStack.transform, needNormals, needParams);
+            if (polyface)
+                polyfaces.push(polyface);
+        }
+        if (node.children) {
+            for (const childId of node.children) {
+                const child = this._nodes[childId];
+                if (child)
+                    this.readNodeAndCreatePolyfaces(polyfaces, child, transformStack, needNormals, needParams);
+            }
+        }
+    }
+    polyfaceFromGltfMesh(mesh, transform, needNormals, needParams) {
+        if (!mesh.pointQParams || !mesh.points || !mesh.indices)
+            return undefined;
+        const { points, pointQParams, normals, uvs, uvQParams, indices } = mesh;
+        const includeNormals = needNormals && undefined !== normals;
+        const includeParams = needParams && undefined !== uvQParams && undefined !== uvs;
+        const polyface = IndexedPolyface.create(includeNormals, includeParams);
+        for (let i = 0; i < points.length;) {
+            const point = pointQParams.unquantize(points[i++], points[i++], points[i++]);
+            if (transform)
+                transform.multiplyPoint3d(point, point);
+            polyface.addPoint(point);
+        }
+        if (includeNormals && normals)
+            for (let i = 0; i < normals.length;)
+                polyface.addNormal(OctEncodedNormal.decodeValue(normals[i++]));
+        if (includeParams && uvs && uvQParams)
+            for (let i = 0; i < uvs.length;)
+                polyface.addParam(uvQParams.unquantize(uvs[i++], uvs[i++]));
+        let j = 0;
+        for (const index of indices) {
+            polyface.addPointIndex(index);
+            if (includeNormals)
+                polyface.addNormalIndex(index);
+            if (includeParams)
+                polyface.addParamIndex(index);
+            if (0 === (++j % 3))
+                polyface.terminateFacet();
+        }
+        return polyface;
+    }
     // ###TODO what is the actual type of `json`?
     getBufferView(json, accessorName) {
         try {
@@ -700,6 +758,26 @@ export class GltfReader {
         const color = colorFromMaterial(material, isTransparent);
         return new DisplayParams(DisplayParams.Type.Mesh, color, color, 1, LinePixels.Solid, FillFlags.Always, undefined, undefined, hasBakedLighting, textureMapping);
     }
+    readMeshPrimitives(node, featureTable, thisTransform, thisBias) {
+        const meshes = [];
+        for (const meshKey of getNodeMeshIds(node)) {
+            const nodeMesh = this._meshes[meshKey];
+            if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
+                for (const primitive of nodeMesh.primitives) {
+                    const mesh = this.readMeshPrimitive(primitive, featureTable, thisBias);
+                    if (mesh) {
+                        meshes.push(mesh);
+                        if (this._computedContentRange && mesh.pointRange) {
+                            const invTransform = thisTransform === null || thisTransform === void 0 ? void 0 : thisTransform.inverse();
+                            const meshRange = invTransform ? invTransform.multiplyRange(mesh.pointRange) : mesh.pointRange;
+                            this._computedContentRange.extendRange(meshRange);
+                        }
+                    }
+                }
+            }
+        }
+        return meshes;
+    }
     readMeshPrimitive(primitive, featureTable, pseudoRtcBias) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const materialName = JsonUtils.asString(primitive.material);
@@ -736,6 +814,7 @@ export class GltfReader {
             isPlanar: false,
             hasBakedLighting,
             isVolumeClassifier,
+            quantizePositions: true,
         });
         const mesh = new GltfMeshData(meshPrimitive);
         // We don't have real colormap - just load material color.  This will be used if non-Bentley
@@ -758,16 +837,9 @@ export class GltfReader {
                 mesh.uvQParams = paramList.params;
             }
         }
-        if ((_f = primitive.extensions) === null || _f === void 0 ? void 0 : _f.KHR_draco_mesh_compression) {
-            return undefined; // Defer Draco decompression until web workers implementation.
-            /*
-            const dracoExtension = primitive.extensions.KHR_draco_mesh_compression;
-            const bufferView = this._bufferViews[dracoExtension.bufferView];
-            if (undefined === bufferView) return undefined;
-            const bufferData = this._binaryData.subarray(bufferView.byteOffset, bufferView.byteOffset + bufferView.byteLength);
-      
-            return DracoDecoder.readDracoMesh(mesh, primitive, bufferData, dracoExtension.attributes); */
-        }
+        const draco = (_f = primitive.extensions) === null || _f === void 0 ? void 0 : _f.KHR_draco_mesh_compression;
+        if (draco)
+            return this.readDracoMeshPrimitive(mesh.primitive, draco) ? mesh : undefined;
         this.readBatchTable(mesh.primitive, primitive);
         if (!this.readVertices(mesh, primitive, pseudoRtcBias))
             return undefined;
@@ -811,6 +883,61 @@ export class GltfReader {
         }
         return mesh;
     }
+    readDracoMeshPrimitive(mesh, ext) {
+        var _a, _b, _c, _d, _e, _f;
+        const draco = this._dracoMeshes.get(ext);
+        if (!draco || "triangle-list" !== draco.topology)
+            return false;
+        const indices = (_a = draco.indices) === null || _a === void 0 ? void 0 : _a.value;
+        if (!indices || (indices.length % 3) !== 0)
+            return false;
+        const pos = (_b = draco.attributes.POSITION) === null || _b === void 0 ? void 0 : _b.value;
+        if (!pos || (pos.length % 3) !== 0)
+            return false;
+        // ###TODO: I have yet to see a draco-encoded mesh with interleaved attributes. Currently not checking.
+        const triangle = new Triangle();
+        for (let i = 0; i < indices.length; i += 3) {
+            triangle.setIndices(indices[i], indices[i + 1], indices[i + 2]);
+            mesh.addTriangle(triangle);
+        }
+        let posRange;
+        const bbox = (_c = draco.header) === null || _c === void 0 ? void 0 : _c.boundingBox;
+        if (bbox) {
+            posRange = Range3d.createXYZXYZ(bbox[0][0], bbox[0][1], bbox[0][2], bbox[1][0], bbox[1][1], bbox[1][2]);
+        }
+        else {
+            posRange = Range3d.createNull();
+            for (let i = 0; i < pos.length; i += 3)
+                posRange.extendXYZ(pos[i], pos[i + 1], pos[i + 2]);
+        }
+        assert(mesh.points instanceof QPoint3dList);
+        mesh.points.params.setFromRange(posRange);
+        const pt = Point3d.createZero();
+        for (let i = 0; i < pos.length; i += 3) {
+            pt.set(pos[i], pos[i + 1], pos[i + 2]);
+            mesh.points.add(pt);
+        }
+        const normals = (_d = draco.attributes.NORMAL) === null || _d === void 0 ? void 0 : _d.value;
+        if (normals && (normals.length % 3) === 0) {
+            const vec = Vector3d.createZero();
+            for (let i = 0; i < normals.length; i += 3) {
+                vec.set(normals[i], normals[i + 1], normals[i + 2]);
+                mesh.normals.push(OctEncodedNormal.fromVector(vec));
+            }
+        }
+        const uvs = (_e = draco.attributes.TEXCOORD_0) === null || _e === void 0 ? void 0 : _e.value;
+        if (uvs && (uvs.length & 2) === 0)
+            for (let i = 0; i < uvs.length; i += 2)
+                mesh.uvParams.push(new Point2d(uvs[i], uvs[i + 1]));
+        const batchIds = (_f = draco.attributes._BATCHID) === null || _f === void 0 ? void 0 : _f.value;
+        if (batchIds && mesh.features) {
+            const featureIndices = [];
+            for (const batchId of batchIds)
+                featureIndices.push(batchId);
+            mesh.features.setIndices(featureIndices);
+        }
+        return true;
+    }
     deduplicateVertices(mesh) {
         if (!mesh.points || !mesh.indices)
             return false;
@@ -1059,6 +1186,32 @@ export class GltfReader {
         return true;
     }
     async resolveResources() {
+        var _a;
+        // Load any external images and buffers.
+        await this._resolveResources();
+        // If any meshes are draco-compressed, dynamically load the decoder module and then decode the meshes.
+        const dracoMeshes = [];
+        for (const node of this.traverseScene()) {
+            for (const meshId of getNodeMeshIds(node)) {
+                const mesh = this._meshes[meshId];
+                if (mesh === null || mesh === void 0 ? void 0 : mesh.primitives)
+                    for (const primitive of mesh.primitives)
+                        if ((_a = primitive.extensions) === null || _a === void 0 ? void 0 : _a.KHR_draco_mesh_compression)
+                            dracoMeshes.push(primitive.extensions.KHR_draco_mesh_compression);
+            }
+        }
+        if (dracoMeshes.length === 0)
+            return;
+        try {
+            const dracoLoader = (await import("@loaders.gl/draco")).DracoLoader;
+            await Promise.all(dracoMeshes.map(async (x) => this.decodeDracoMesh(x, dracoLoader)));
+        }
+        catch (err) {
+            Logger.logWarning(FrontendLoggerCategory.Render, "Failed to decode draco-encoded glTF mesh");
+            Logger.logException(FrontendLoggerCategory.Render, err);
+        }
+    }
+    async _resolveResources() {
         // ###TODO traverse the scene nodes to find resources referenced by them, instead of resolving everything - some resources may not
         // be required for the scene.
         const promises = [];
@@ -1078,6 +1231,20 @@ export class GltfReader {
         catch (_) {
         }
     }
+    async decodeDracoMesh(ext, loader) {
+        var _a, _b;
+        const bv = this._bufferViews[ext.bufferView];
+        if (!bv || !bv.byteLength)
+            return;
+        let buf = (_a = this._buffers[bv.buffer]) === null || _a === void 0 ? void 0 : _a.resolvedBuffer;
+        if (!buf)
+            return;
+        const offset = (_b = bv.byteOffset) !== null && _b !== void 0 ? _b : 0;
+        buf = buf.subarray(offset, offset + bv.byteLength);
+        const mesh = await loader.parse(buf, {}); // NB: `options` argument declared optional but will produce exception if not supplied.
+        if (mesh)
+            this._dracoMeshes.set(ext, mesh);
+    }
     resolveUrl(uri) {
         try {
             return new URL(uri, this._baseUrl).toString();