@itwin/core-frontend 4.4.0-dev.9 → 4.5.0-dev.2

package/lib/cjs/tile/GltfReader.js

@@ -235,6 +235,17 @@ function colorFromMaterial(material, isTransparent) {
         color = color.withTransparency(0);
     return color;
 }
+function trsMatrix(translation, rotation, scale, result) {
+    // SPEC: To compose the local transformation matrix, TRS properties MUST be converted to matrices and postmultiplied in the T * R * S order;
+    // first the scale is applied to the vertices, then the rotation, and then the translation.
+    const scaleTf = core_geometry_1.Transform.createRefs(undefined, scale ? core_geometry_1.Matrix3d.createScale(scale[0], scale[1], scale[2]) : core_geometry_1.Matrix3d.identity);
+    const rotTf = core_geometry_1.Transform.createRefs(undefined, rotation ? core_geometry_1.Matrix3d.createFromQuaternion(core_geometry_1.Point4d.create(rotation[0], rotation[1], rotation[2], rotation[3])) : core_geometry_1.Matrix3d.identity);
+    rotTf.matrix.transposeInPlace(); // See comment on Matrix3d.createFromQuaternion
+    const transTf = core_geometry_1.Transform.createTranslation(translation ? new core_geometry_1.Point3d(translation[0], translation[1], translation[2]) : core_geometry_1.Point3d.createZero());
+    const tf = scaleTf.multiplyTransformTransform(rotTf, result);
+    transTf.multiplyTransformTransform(tf, tf);
+    return tf;
+}
 class TransformStack {
     constructor(transform) {
         this._stack = [];
@@ -255,14 +266,7 @@ class TransformStack {
             nodeTransform = core_geometry_1.Transform.createOriginAndMatrix(origin, matrix);
         }
         else if (node.rotation || node.scale || node.translation) {
-            // SPEC: To compose the local transformation matrix, TRS properties MUST be converted to matrices and postmultiplied in the T * R * S order;
-            // first the scale is applied to the vertices, then the rotation, and then the translation.
-            const scale = core_geometry_1.Transform.createRefs(undefined, node.scale ? core_geometry_1.Matrix3d.createScale(node.scale[0], node.scale[1], node.scale[2]) : core_geometry_1.Matrix3d.identity);
-            const rot = core_geometry_1.Transform.createRefs(undefined, node.rotation ? core_geometry_1.Matrix3d.createFromQuaternion(core_geometry_1.Point4d.create(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3])) : core_geometry_1.Matrix3d.identity);
-            rot.matrix.transposeInPlace(); // See comment on Matrix3d.createFromQuaternion
-            const trans = core_geometry_1.Transform.createTranslation(node.translation ? new core_geometry_1.Point3d(node.translation[0], node.translation[1], node.translation[2]) : core_geometry_1.Point3d.createZero());
-            nodeTransform = scale.multiplyTransformTransform(rot);
-            trans.multiplyTransformTransform(nodeTransform, nodeTransform);
+            nodeTransform = trsMatrix(node.translation, node.rotation, node.scale);
         }
         const top = this.transform;
         if (!top)
@@ -315,6 +319,9 @@ class GltfReader {
     traverseScene() {
         return this.traverseNodes(this._sceneNodes);
     }
+    get viewFlagOverrides() {
+        return undefined;
+    }
     getTileTransform(transformToRoot, pseudoRtcBias) {
         let transform;
         if (this._returnToCenter || pseudoRtcBias || this._yAxisUp || transformToRoot) {
@@ -358,18 +365,19 @@ class GltfReader {
             renderGraphic = renderGraphicList[0];
         else
             renderGraphic = this._system.createGraphicList(renderGraphicList);
-        const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
-        let range = contentRange;
-        const invTransform = transform?.inverse();
-        if (invTransform)
-            range = invTransform.multiplyRange(contentRange);
         if (featureTable)
-            renderGraphic = this._system.createBatch(renderGraphic, core_common_1.PackedFeatureTable.pack(featureTable), range);
-        if (transform) {
+            renderGraphic = this._system.createBatch(renderGraphic, core_common_1.PackedFeatureTable.pack(featureTable), contentRange);
+        const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
+        const viewFlagOverrides = this.viewFlagOverrides;
+        if (transform || viewFlagOverrides) {
             const branch = new GraphicBranch_1.GraphicBranch(true);
+            if (viewFlagOverrides)
+                branch.setViewFlagOverrides(viewFlagOverrides);
             branch.add(renderGraphic);
-            renderGraphic = this._system.createBranch(branch, transform);
+            renderGraphic = this._system.createBranch(branch, transform ?? core_geometry_1.Transform.createIdentity());
         }
+        const invTransform = transform?.inverse();
+        const range = invTransform ? invTransform.multiplyRange(contentRange) : contentRange;
         return {
             readStatus,
             isLeaf,
@@ -416,12 +424,76 @@ class GltfReader {
                 mesh.normals.push(new core_common_1.OctEncodedNormal(normal));
         return mesh.getGraphics(this._system, instances);
     }
-    readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, instances, pseudoRtcBias) {
+    readInstanceAttributes(node, featureTable) {
+        const ext = node.extensions?.EXT_mesh_gpu_instancing;
+        if (!ext || !ext.attributes) {
+            return undefined;
+        }
+        const translationsView = this.getBufferView(ext.attributes, "TRANSLATION");
+        const translations = translationsView?.toBufferData(GltfSchema_1.GltfDataType.Float);
+        const rotations = this.getBufferView(ext.attributes, "ROTATION")?.toBufferData(GltfSchema_1.GltfDataType.Float);
+        const scales = this.getBufferView(ext.attributes, "SCALE")?.toBufferData(GltfSchema_1.GltfDataType.Float);
+        // All attributes must specify the same count, count must be greater than zero, and at least one attribute must be specified.
+        const count = translations?.count ?? rotations?.count ?? scales?.count;
+        if (!count || (rotations && rotations.count !== count) || (scales && scales.count !== count)) {
+            return undefined;
+        }
+        const transformCenter = new core_geometry_1.Point3d();
+        const trMin = translationsView?.accessor.min;
+        const trMax = translationsView?.accessor.max;
+        if (trMin && trMax) {
+            const half = (idx) => trMin[idx] + (trMax[idx] - trMin[idx]) / 2;
+            transformCenter.set(half(0), half(1), half(2));
+        }
+        const getTranslation = (index) => {
+            if (!translations) {
+                return undefined;
+            }
+            index *= 3;
+            return [
+                translations.buffer[index + 0] - transformCenter.x,
+                translations.buffer[index + 1] - transformCenter.y,
+                translations.buffer[index + 2] - transformCenter.z,
+            ];
+        };
+        const getRotation = (index) => {
+            index *= 4;
+            return rotations ? [rotations.buffer[index], rotations.buffer[index + 1], rotations.buffer[index + 2], rotations.buffer[index + 3]] : undefined;
+        };
+        const getScale = (index) => {
+            index *= 3;
+            return scales ? [scales.buffer[index], scales.buffer[index + 1], scales.buffer[index + 2]] : undefined;
+        };
+        const transforms = new Float32Array(3 * 4 * count);
+        const transform = core_geometry_1.Transform.createIdentity();
+        for (let i = 0; i < count; i++) {
+            const tf = trsMatrix(getTranslation(i), getRotation(i), getScale(i), transform);
+            const idx = i * 3 * 4;
+            transforms[idx + 0] = tf.matrix.coffs[0];
+            transforms[idx + 1] = tf.matrix.coffs[1];
+            transforms[idx + 2] = tf.matrix.coffs[2];
+            transforms[idx + 3] = tf.origin.x;
+            transforms[idx + 4] = tf.matrix.coffs[3];
+            transforms[idx + 5] = tf.matrix.coffs[4];
+            transforms[idx + 6] = tf.matrix.coffs[5];
+            transforms[idx + 7] = tf.origin.y;
+            transforms[idx + 8] = tf.matrix.coffs[6];
+            transforms[idx + 9] = tf.matrix.coffs[7];
+            transforms[idx + 10] = tf.matrix.coffs[8];
+            transforms[idx + 11] = tf.origin.z;
+        }
+        // ###TODO? The extension currently provides no way of specifying per-instance feature Ids.
+        // For now, assume that if the feature table contains exactly one feature, all the instances belong to that feature.
+        const featureIds = featureTable && featureTable.isUniform ? new Uint8Array(3 * count) : undefined;
+        return { count, transforms, transformCenter, featureIds };
+    }
+    readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, batchInstances, pseudoRtcBias) {
         if (undefined === node)
             return core_common_1.TileReadStatus.InvalidTileData;
         // IMPORTANT: Do not return without popping this node from the stack.
         transformStack.push(node);
         const thisTransform = transformStack.transform;
+        const nodeInstances = !batchInstances && undefined !== node.mesh ? this.readInstanceAttributes(node, featureTable) : undefined;
         /**
          * This is a workaround for tiles generated by
          * context capture which have a large offset from the tileset origin that exceeds the
@@ -436,16 +508,16 @@ class GltfReader {
         for (const meshKey of (0, GltfSchema_1.getGltfNodeMeshIds)(node)) {
             const nodeMesh = this._meshes[meshKey];
             if (nodeMesh?.primitives) {
-                const meshes = this.readMeshPrimitives(node, featureTable, thisTransform, thisBias);
+                const meshes = this.readMeshPrimitives(node, featureTable, thisTransform, thisBias, nodeInstances);
                 let renderGraphic;
                 if (0 !== meshes.length) {
                     if (1 === meshes.length) {
-                        renderGraphic = this.graphicFromMeshData(meshes[0], instances);
+                        renderGraphic = this.graphicFromMeshData(meshes[0], batchInstances ?? nodeInstances);
                     }
                     else {
                         const thisList = [];
                         for (const mesh of meshes) {
-                            renderGraphic = this.graphicFromMeshData(mesh, instances);
+                            renderGraphic = this.graphicFromMeshData(mesh, batchInstances ?? nodeInstances);
                             if (undefined !== renderGraphic)
                                 thisList.push(renderGraphic);
                         }
@@ -467,7 +539,7 @@ class GltfReader {
             for (const childId of node.children) {
                 const child = this._nodes[childId];
                 if (child)
-                    this.readNodeAndCreateGraphics(renderGraphicList, child, featureTable, transformStack, instances);
+                    this.readNodeAndCreateGraphics(renderGraphicList, child, featureTable, transformStack, batchInstances ?? nodeInstances);
             }
         }
         transformStack.pop();
@@ -696,9 +768,9 @@ class GltfReader {
             // DisplayParams doesn't want a separate texture mapping if the material already has one.
             textureMapping = undefined;
         }
-        return new DisplayParams_1.DisplayParams(DisplayParams_1.DisplayParams.Type.Mesh, color, color, 1, core_common_1.LinePixels.Solid, core_common_1.FillFlags.Always, renderMaterial, undefined, hasBakedLighting, textureMapping);
+        return new DisplayParams_1.DisplayParams(DisplayParams_1.DisplayParams.Type.Mesh, color, color, 1, core_common_1.LinePixels.Solid, core_common_1.FillFlags.None, renderMaterial, undefined, hasBakedLighting, textureMapping);
     }
-    readMeshPrimitives(node, featureTable, thisTransform, thisBias) {
+    readMeshPrimitives(node, featureTable, thisTransform, thisBias, instances) {
         const meshes = [];
         for (const meshKey of (0, GltfSchema_1.getGltfNodeMeshIds)(node)) {
             const nodeMesh = this._meshes[meshKey];
@@ -708,9 +780,30 @@ class GltfReader {
                     if (mesh) {
                         meshes.push(mesh);
                         if (this._computedContentRange && mesh.pointRange) {
-                            const invTransform = thisTransform?.inverse();
-                            const meshRange = invTransform ? invTransform.multiplyRange(mesh.pointRange) : mesh.pointRange;
-                            this._computedContentRange.extendRange(meshRange);
+                            const meshRange = thisTransform ? thisTransform.multiplyRange(mesh.pointRange) : mesh.pointRange;
+                            if (!instances) {
+                                this._computedContentRange.extendRange(meshRange);
+                            }
+                            else {
+                                const tfs = instances.transforms;
+                                const nodeRange = new core_geometry_1.Range3d();
+                                const extendTransformedRange = (i, x, y, z) => {
+                                    nodeRange.extendXYZ(tfs[i + 3] + tfs[i + 0] * x + tfs[i + 1] * y + tfs[i + 2] * z, tfs[i + 7] + tfs[i + 4] * x + tfs[i + 5] * y + tfs[i + 6] * z, tfs[i + 11] + tfs[i + 8] * x + tfs[i + 9] * y + tfs[i + 10] * z);
+                                };
+                                for (let i = 0; i < tfs.length; i += 3 * 4) {
+                                    extendTransformedRange(i, meshRange.low.x, meshRange.low.y, meshRange.low.z);
+                                    extendTransformedRange(i, meshRange.low.x, meshRange.low.y, meshRange.high.z);
+                                    extendTransformedRange(i, meshRange.low.x, meshRange.high.y, meshRange.low.z);
+                                    extendTransformedRange(i, meshRange.low.x, meshRange.high.y, meshRange.high.z);
+                                    extendTransformedRange(i, meshRange.high.x, meshRange.low.y, meshRange.low.z);
+                                    extendTransformedRange(i, meshRange.high.x, meshRange.low.y, meshRange.high.z);
+                                    extendTransformedRange(i, meshRange.high.x, meshRange.high.y, meshRange.low.z);
+                                    extendTransformedRange(i, meshRange.high.x, meshRange.high.y, meshRange.high.z);
+                                }
+                                nodeRange.low.addInPlace(instances.transformCenter);
+                                nodeRange.high.addInPlace(instances.transformCenter);
+                                this._computedContentRange.extendRange(nodeRange);
+                            }
                         }
                     }
                 }
@@ -1448,6 +1541,12 @@ class GltfGraphicsReader extends GltfReader {
             this._featureTable.insert(new core_common_1.Feature(pickableId));
         }
     }
+    get viewFlagOverrides() {
+        return {
+            whiteOnWhiteReversal: false,
+            renderMode: core_common_1.RenderMode.SmoothShade,
+        };
+    }
     async read() {
         await this.resolveResources();
         return this.readGltfAndCreateGraphics(this._isLeaf, this._featureTable, this._contentRange, this._transform);