@itwin/core-frontend 3.1.0-dev.1 → 3.1.0-dev.14

package/lib/cjs/tile/GltfReader.js

@@ -313,8 +313,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;
@@ -439,6 +441,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 +485,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,6 +504,16 @@ 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;
@@ -541,18 +559,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 +596,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 +761,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);