@itwin/core-frontend 5.0.0-dev.4 → 5.0.0-dev.41

package/lib/esm/tile/GltfReader.js

@@ -358,6 +358,12 @@ export class GltfReader {
                 featureTable.insertWithIndex(this._instanceFeatures[instanceFeatureId], instanceFeatureId);
             }
         }
+        if (this._meshFeatures.length > 0 && this._idMap) {
+            featureTable = new FeatureTable(this._meshFeatures.length, featureTableModelId);
+            for (let meshFeatureId = 0; meshFeatureId < this._meshFeatures.length; meshFeatureId++) {
+                featureTable.insertWithIndex(this._meshFeatures[meshFeatureId], meshFeatureId);
+            }
+        }
         if (0 === templateNodes.length)
             return { readStatus: TileReadStatus.InvalidTileData, isLeaf };
         // Compute range in tileset/world space.
@@ -715,7 +721,9 @@ export class GltfReader {
         this._dracoMeshes = new Map();
         this._containsPointCloud = false;
         this._instanceFeatures = [];
+        this._meshFeatures = [];
         this._instanceElementIdToFeatureId = new Map();
+        this._meshElementIdToFeatureIndex = new Map();
         /** The glTF spec says that if GltfSampler.wrapS/T are omitted, they default to Repeat.
          * However, the reality data service serves tiles that lack any wrapS/T property, and we want those clamped to edge, not repeated.
          * (We also don't want to produce mip-maps for them, which is determined indirectly from the wrap mode).
@@ -1246,8 +1254,69 @@ export class GltfReader {
     }
     readBatchTable(_mesh, _json) {
     }
-    readPrimitiveFeatures(_primitive) {
-        return undefined;
+    readPrimitiveFeatures(primitive) {
+        const ext = primitive.extensions?.EXT_mesh_features;
+        if (!ext || !primitive.attributes || !this._structuralMetadata || !this._idMap) {
+            return undefined;
+        }
+        let vertexCount = 0;
+        const featureIdBuffers = new Map();
+        for (const featureIdDesc of ext.featureIds) {
+            if (featureIdDesc.attribute === undefined) {
+                continue;
+            }
+            const bufferView = this.getBufferView(primitive.attributes, `_FEATURE_ID_${featureIdDesc.attribute}`);
+            const bufferData = bufferView?.toBufferData(bufferView.type);
+            const buffer = bufferData?.buffer;
+            if (!bufferView || !buffer) {
+                return undefined;
+            }
+            vertexCount = bufferData.count ?? 0;
+            featureIdBuffers.set(featureIdDesc.attribute, { buffer, stride: bufferView.stride });
+        }
+        const itwinFeatureIndices = [];
+        const vertexPropsMap = new Map();
+        for (let vertexId = 0; vertexId < vertexCount; vertexId++) {
+            let vertexUniqueId = "";
+            for (const featureIdDesc of ext.featureIds) {
+                if (featureIdDesc.attribute === undefined) {
+                    continue;
+                }
+                const { buffer, stride } = featureIdBuffers.get(featureIdDesc.attribute);
+                const featureId = buffer[vertexId * stride];
+                const propertyTableId = featureIdDesc.propertyTable ?? 0;
+                vertexUniqueId = `${vertexUniqueId}-${featureId}-${propertyTableId}`;
+            }
+            let vertexElementId;
+            if (!vertexPropsMap.has(vertexUniqueId)) {
+                const vertexProps = {};
+                for (const featureIdDesc of ext.featureIds) {
+                    if (featureIdDesc.attribute === undefined) {
+                        continue;
+                    }
+                    const { buffer, stride } = featureIdBuffers.get(featureIdDesc.attribute);
+                    const featureId = buffer[vertexId * stride];
+                    const table = this._structuralMetadata.tables[featureIdDesc.propertyTable ?? 0];
+                    vertexProps[table.name] = {};
+                    for (const entries of table.entries) {
+                        if (entries.values[featureId] !== undefined) {
+                            vertexProps[table.name][entries.name] = entries.values[featureId];
+                        }
+                    }
+                }
+                vertexElementId = this._idMap.getBatchId(vertexProps);
+                vertexPropsMap.set(vertexUniqueId, vertexElementId);
+                //  If the element id is already assigned to a previous vertex,
+                //  reuse the previous feature id to avoid collision in the feature table
+                if (!this._meshElementIdToFeatureIndex.has(vertexElementId)) {
+                    this._meshElementIdToFeatureIndex.set(vertexElementId, this._meshFeatures.length);
+                    this._meshFeatures.push(new Feature(vertexElementId));
+                }
+            }
+            vertexElementId = vertexPropsMap.get(vertexUniqueId) ?? "";
+            itwinFeatureIndices.push(this._meshElementIdToFeatureIndex.get(vertexElementId) ?? 0);
+        }
+        return itwinFeatureIndices;
     }
     readMeshIndices(mesh, json) {
         if (undefined !== json.indices) {
@@ -1684,6 +1753,14 @@ export class GltfGraphicsReader extends GltfReader {
             renderMode: RenderMode.SmoothShade,
         };
     }
+    get meshElementIdToFeatureIndex() {
+        return this._meshElementIdToFeatureIndex;
+    }
+    readMeshPrimitive(primitive, featureTable, pseudoRtcBias) {
+        const meshes = super.readMeshPrimitive(primitive, featureTable, pseudoRtcBias);
+        this.meshes = meshes instanceof GltfMeshData ? meshes : undefined;
+        return meshes;
+    }
     getGltfStructuralMetadataBuffer(id, type) {
         const bufferView = this._bufferViews[id];
         if (!bufferView || undefined === bufferView.buffer)