@itwin/core-frontend 5.8.0-dev.1 → 5.8.0-dev.3

package/lib/esm/tile/GltfReader.js

@@ -200,7 +200,7 @@ 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.
+  * is generated. The MeshPrimitive path is much less efficient but should be rarely used.
   *
   * @internal
   */
@@ -487,7 +487,8 @@ export class GltfReader {
             }),
         };
     }
-    readGltfAndCreateGeometry(transformToRoot, needNormals = false, needParams = false) {
+    async readGltfAndCreateGeometry(transformToRoot, needNormals = false, needParams = false) {
+        await this.resolveResources();
         const transformStack = new TransformStack(this.getTileTransform(transformToRoot));
         const polyfaces = [];
         for (const nodeKey of this._sceneNodes) {
@@ -722,9 +723,18 @@ export class GltfReader {
         }
     }
     polyfaceFromGltfMesh(mesh, transform, needNormals, needParams) {
-        if (!mesh.pointQParams || !mesh.points || !mesh.indices)
+        if (mesh.pointQParams && mesh.points && mesh.indices)
+            return this.polyfaceFromQuantizedData(mesh.pointQParams, mesh.points, mesh.indices, mesh.normals, mesh.uvQParams, mesh.uvs, transform, needNormals, needParams);
+        const meshPrim = mesh.primitive;
+        const triangles = meshPrim.triangles;
+        const points = meshPrim.points;
+        if (!triangles || triangles.isEmpty || points.length === 0)
             return undefined;
-        const { points, pointQParams, normals, uvs, uvQParams, indices } = mesh;
+        // This will likely only be the case for Draco-compressed meshes-- see where readDracoMeshPrimitive is called within readMeshPrimitive
+        // That is the only case where mesh.primitive is populated but mesh.pointQParams, mesh.points, & mesh.indices are not
+        return this.polyfaceFromMeshPrimitive(triangles, points, meshPrim.normals, meshPrim.uvParams, transform, needNormals, needParams);
+    }
+    polyfaceFromQuantizedData(pointQParams, points, indices, normals, uvQParams, uvs, transform, needNormals, needParams) {
         const includeNormals = needNormals && undefined !== normals;
         const includeParams = needParams && undefined !== uvQParams && undefined !== uvs;
         const polyface = IndexedPolyface.create(includeNormals, includeParams);
@@ -752,6 +762,46 @@ export class GltfReader {
         }
         return polyface;
     }
+    polyfaceFromMeshPrimitive(triangles, points, normals, uvParams, transform, needNormals, needParams) {
+        const includeNormals = needNormals && normals.length > 0;
+        const includeParams = needParams && uvParams.length > 0;
+        const polyface = IndexedPolyface.create(includeNormals, includeParams);
+        if (points instanceof QPoint3dList) {
+            for (let i = 0; i < points.length; i++) {
+                const point = points.unquantize(i);
+                if (transform)
+                    transform.multiplyPoint3d(point, point);
+                polyface.addPoint(point);
+            }
+        }
+        else {
+            const center = points.range.center;
+            for (const pt of points) {
+                const point = pt.plus(center);
+                if (transform)
+                    transform.multiplyPoint3d(point, point);
+                polyface.addPoint(point);
+            }
+        }
+        if (includeNormals)
+            for (const normal of normals)
+                polyface.addNormal(OctEncodedNormal.decodeValue(normal.value));
+        if (includeParams)
+            for (const uv of uvParams)
+                polyface.addParam(uv);
+        const indices = triangles.indices;
+        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 {