@itwin/core-frontend 3.1.0-dev.7 → 3.2.0-dev.1

package/lib/cjs/tile/GltfReader.js

@@ -6,17 +6,38 @@
 /** @packageDocumentation
  * @module Tiles
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GltfGraphicsReader = exports.readGltfGraphics = exports.GltfReader = exports.GltfMeshData = exports.GltfReaderProps = exports.GltfBufferData = exports.GltfDataType = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_geometry_1 = require("@itwin/core-geometry");
 const core_common_1 = require("@itwin/core-common");
+const FrontendLoggerCategory_1 = require("../FrontendLoggerCategory");
 const ImageUtil_1 = require("../ImageUtil");
 const IModelApp_1 = require("../IModelApp");
 const GraphicBranch_1 = require("../render/GraphicBranch");
 const DisplayParams_1 = require("../render/primitives/DisplayParams");
 const MeshPrimitives_1 = require("../render/primitives/mesh/MeshPrimitives");
 const RealityMeshPrimitive_1 = require("../render/primitives/mesh/RealityMeshPrimitive");
+const Primitives_1 = require("../render/primitives/Primitives");
 /* eslint-disable no-restricted-syntax */
 /** Enumerates the types of [[GltfMeshPrimitive]] topologies. */
 var GltfMeshMode;
@@ -269,8 +290,8 @@ class GltfReaderProps {
 }
 exports.GltfReaderProps = 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
   */
@@ -313,8 +334,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;
@@ -383,6 +406,7 @@ class GltfReader {
     constructor(args) {
         var _a, _b, _c, _d, _e, _f, _g;
         this._resolvedTextures = new core_bentley_1.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;
@@ -439,6 +463,22 @@ class GltfReader {
     traverseScene() {
         return this.traverseNodes(this._sceneNodes);
     }
+    getTileTransform(transformToRoot, pseudoRtcBias) {
+        let transform;
+        if (this._returnToCenter || pseudoRtcBias || this._yAxisUp || transformToRoot) {
+            if (this._returnToCenter)
+                transform = core_geometry_1.Transform.createTranslation(this._returnToCenter.clone());
+            else if (pseudoRtcBias)
+                transform = core_geometry_1.Transform.createTranslationXYZ(pseudoRtcBias.x, pseudoRtcBias.y, pseudoRtcBias.z);
+            else
+                transform = core_geometry_1.Transform.createIdentity();
+            if (this._yAxisUp)
+                transform = transform.multiplyTransformMatrix3d(core_geometry_1.Matrix3d.createRotationAroundVector(core_geometry_1.Vector3d.create(1.0, 0.0, 0.0), core_geometry_1.Angle.createRadians(core_geometry_1.Angle.piOver2Radians)));
+            if (transformToRoot)
+                transform = transformToRoot.multiplyTransformTransform(transform);
+        }
+        return transform;
+    }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
         var _a;
         if (this._isCanceled)
@@ -467,21 +507,11 @@ 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 = core_geometry_1.Transform.createTranslation(this._returnToCenter.clone());
-            else if (pseudoRtcBias)
-                transform = core_geometry_1.Transform.createTranslationXYZ(pseudoRtcBias.x, pseudoRtcBias.y, pseudoRtcBias.z);
-            else
-                transform = core_geometry_1.Transform.createIdentity();
-            if (this._yAxisUp)
-                transform = transform.multiplyTransformMatrix3d(core_geometry_1.Matrix3d.createRotationAroundVector(core_geometry_1.Vector3d.create(1.0, 0.0, 0.0), core_geometry_1.Angle.createRadians(core_geometry_1.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, core_common_1.PackedFeatureTable.pack(featureTable), range);
         if (transform) {
@@ -496,9 +526,19 @@ class GltfReader {
             graphic: renderGraphic,
         };
     }
+    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, meshGraphicArgs, instances) {
         if (!gltfMesh.points || !gltfMesh.pointRange)
-            return;
+            return gltfMesh.primitive.getGraphics(meshGraphicArgs, this._system, instances);
         const realityMeshPrimitive = (this._vertexTableRequired || instances) ? undefined : RealityMeshPrimitive_1.RealityMeshPrimitive.createFromGltfMesh(gltfMesh);
         if (realityMeshPrimitive) {
             const realityMesh = this._system.createRealityMesh(realityMeshPrimitive);
@@ -541,18 +581,7 @@ class GltfReader {
             const nodeMesh = this._meshes[meshKey];
             if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
                 const meshGraphicArgs = new MeshPrimitives_1.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) {
@@ -589,6 +618,54 @@ class GltfReader {
         transformStack.pop();
         return core_common_1.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 = core_geometry_1.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(core_common_1.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 {
@@ -706,6 +783,26 @@ class GltfReader {
         const color = colorFromMaterial(material, isTransparent);
         return new DisplayParams_1.DisplayParams(DisplayParams_1.DisplayParams.Type.Mesh, color, color, 1, core_common_1.LinePixels.Solid, core_common_1.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 = core_bentley_1.JsonUtils.asString(primitive.material);
@@ -764,16 +861,9 @@ 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;
@@ -817,6 +907,60 @@ 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 Primitives_1.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 = core_geometry_1.Range3d.createXYZXYZ(bbox[0][0], bbox[0][1], bbox[0][2], bbox[1][0], bbox[1][1], bbox[1][2]);
+        }
+        else {
+            posRange = core_geometry_1.Range3d.createNull();
+            for (let i = 0; i < pos.length; i += 3)
+                posRange.extendXYZ(pos[i], pos[i + 1], pos[i + 2]);
+        }
+        mesh.points.params.setFromRange(posRange);
+        const pt = core_geometry_1.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 = core_geometry_1.Vector3d.createZero();
+            for (let i = 0; i < normals.length; i += 3) {
+                vec.set(normals[i], normals[i + 1], normals[i + 2]);
+                mesh.normals.push(core_common_1.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 core_geometry_1.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;
@@ -1065,6 +1209,32 @@ 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 Promise.resolve().then(() => __importStar(require("@loaders.gl/draco")))).DracoLoader;
+            await Promise.all(dracoMeshes.map(async (x) => this.decodeDracoMesh(x, dracoLoader)));
+        }
+        catch (err) {
+            core_bentley_1.Logger.logWarning(FrontendLoggerCategory_1.FrontendLoggerCategory.Render, "Failed to decode draco-encoded glTF mesh");
+            core_bentley_1.Logger.logException(FrontendLoggerCategory_1.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 = [];
@@ -1084,6 +1254,20 @@ 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();