@itwin/core-frontend 3.3.0-dev.9 → 3.4.0-dev.10

package/lib/esm/tile/ImdlReader.js

@@ -15,6 +15,7 @@ import { DisplayParams } from "../render/primitives/DisplayParams";
 import { Mesh } from "../render/primitives/mesh/MeshPrimitives";
 import { createSurfaceMaterial, isValidSurfaceType, SurfaceType } from "../render/primitives/SurfaceParams";
 import { MeshParams, VertexIndices, VertexTable } from "../render/primitives/VertexTable";
+import { splitMeshParams, splitPointStringParams, splitPolylineParams } from "../render/primitives/VertexTableSplitter";
 import { PointStringParams } from "../render/primitives/PointStringParams";
 import { PolylineParams } from "../render/primitives/PolylineParams";
 /** Header preceding "glTF" data in iMdl tile.
@@ -117,6 +118,7 @@ export class ImdlReader {
         this._loadEdges = (_f = args.loadEdges) !== null && _f !== void 0 ? _f : true;
         this._options = (_g = args.options) !== null && _g !== void 0 ? _g : {};
         this._containsTransformNodes = (_h = args.containsTransformNodes) !== null && _h !== void 0 ? _h : false;
+        this._timeline = args.timeline;
     }
     get _isCanceled() { return undefined !== this._canceled && this._canceled(this); }
     get _isVolumeClassifier() { return BatchType.VolumeClassifier === this._type; }
@@ -408,12 +410,18 @@ export class ImdlReader {
             return undefined;
         return this._system.createGraphicBranch(branch, Transform.createIdentity(), { clipVolume });
     }
+    readMeshGeometry(primitive) {
+        const geometry = this.readPrimitiveGeometry(primitive);
+        if (!geometry)
+            return undefined;
+        const instances = this.readInstances(primitive);
+        return { geometry, instances };
+    }
     readMeshGraphic(primitive) {
         if (primitive.type === "areaPattern")
             return this.readAreaPattern(primitive);
-        const instances = this.readInstances(primitive);
-        const geometry = this.readPrimitiveGeometry(primitive);
-        return geometry ? this._system.createRenderGraphic(geometry, instances) : undefined;
+        const geom = this.readMeshGeometry(primitive);
+        return geom ? this._system.createRenderGraphic(geom.geometry, geom.instances) : undefined;
     }
     findBuffer(bufferViewId) {
         if (typeof bufferViewId !== "string" || 0 === bufferViewId.length)
@@ -513,13 +521,6 @@ export class ImdlReader {
         const bytes = this.findBuffer(bufferName);
         return undefined !== bytes ? new VertexIndices(bytes) : undefined;
     }
-    createPointStringGeometry(primitive, displayParams, vertices, viewIndependentOrigin) {
-        const indices = this.readVertexIndices(primitive.indices);
-        if (undefined === indices)
-            return undefined;
-        const params = new PointStringParams(vertices, indices, displayParams.width);
-        return this._system.createPointStringGeometry(params, viewIndependentOrigin);
-    }
     readTesselatedPolyline(json) {
         const indices = this.readVertexIndices(json.indices);
         const prevIndices = this.readVertexIndices(json.prevIndices);
@@ -528,16 +529,6 @@ export class ImdlReader {
             return undefined;
         return { indices, prevIndices, nextIndicesAndParams };
     }
-    createPolylineGeometry(primitive, displayParams, vertices, isPlanar, viewIndependentOrigin) {
-        const polyline = this.readTesselatedPolyline(primitive);
-        if (undefined === polyline)
-            return undefined;
-        let flags = PolylineTypeFlags.Normal;
-        if (DisplayParams.RegionEdgeType.Outline === displayParams.regionEdgeType)
-            flags = (undefined === displayParams.gradient || displayParams.gradient.isOutlined) ? PolylineTypeFlags.Edge : PolylineTypeFlags.Outline;
-        const params = new PolylineParams(vertices, polyline, displayParams.width, displayParams.linePixels, isPlanar, flags);
-        return this._system.createPolylineGeometry(params, viewIndependentOrigin);
-    }
     readSurface(mesh, displayParams) {
         const surf = mesh.surface;
         if (undefined === surf)
@@ -629,23 +620,7 @@ export class ImdlReader {
         }
         return { succeeded, params };
     }
-    createMeshGeometry(primitive, displayParams, vertices, isPlanar, auxChannels, viewIndependentOrigin) {
-        const surface = this.readSurface(primitive, displayParams);
-        if (undefined === surface)
-            return undefined;
-        // ###TODO: Tile generator shouldn't bother producing edges for classification meshes in the first place...
-        let edgeParams;
-        if (this._loadEdges && undefined !== primitive.edges && SurfaceType.VolumeClassifier !== surface.type) {
-            const edgeResult = this.readEdges(primitive.edges, displayParams);
-            if (!edgeResult.succeeded)
-                return undefined;
-            else
-                edgeParams = edgeResult.params;
-        }
-        const params = new MeshParams(vertices, surface, edgeParams, isPlanar, auxChannels);
-        return this._system.createMeshGeometry(params, viewIndependentOrigin);
-    }
-    readPrimitiveGeometry(primitive) {
+    readPrimitiveParams(primitive) {
         var _a;
         const materialName = (_a = primitive.material) !== null && _a !== void 0 ? _a : "";
         const materialValue = 0 < materialName.length ? JsonUtils.asObject(this._materialValues[materialName]) : undefined;
@@ -660,17 +635,67 @@ export class ImdlReader {
         const viOrigin = primitive.viewIndependentOrigin ? Point3d.fromJSON(primitive.viewIndependentOrigin) : undefined;
         const isPlanar = !this._is3d || JsonUtils.asBool(primitive.isPlanar);
         switch (primitive.type) {
-            case Mesh.PrimitiveType.Mesh:
-                return this.createMeshGeometry(primitive, displayParams, vertices, isPlanar, this.readAuxChannelTable(primitive), viOrigin);
-            case Mesh.PrimitiveType.Polyline:
-                return this.createPolylineGeometry(primitive, displayParams, vertices, isPlanar, viOrigin);
-            case Mesh.PrimitiveType.Point:
-                return this.createPointStringGeometry(primitive, displayParams, vertices, viOrigin);
+            case Mesh.PrimitiveType.Mesh: {
+                const surface = this.readSurface(primitive, displayParams);
+                if (!surface)
+                    return undefined;
+                // ###TODO: Tile generator shouldn't bother producing edges for classification meshes in the first place...
+                let edgeParams;
+                if (this._loadEdges && undefined !== primitive.edges && SurfaceType.VolumeClassifier !== surface.type) {
+                    const edgeResult = this.readEdges(primitive.edges, displayParams);
+                    if (!edgeResult.succeeded)
+                        return undefined;
+                    else
+                        edgeParams = edgeResult.params;
+                }
+                return {
+                    params: new MeshParams(vertices, surface, edgeParams, isPlanar, this.readAuxChannelTable(primitive)),
+                    type: "mesh",
+                    viOrigin,
+                };
+            }
+            case Mesh.PrimitiveType.Polyline: {
+                const polyline = this.readTesselatedPolyline(primitive);
+                if (!polyline)
+                    return undefined;
+                let flags = PolylineTypeFlags.Normal;
+                if (DisplayParams.RegionEdgeType.Outline === displayParams.regionEdgeType)
+                    flags = (undefined === displayParams.gradient || displayParams.gradient.isOutlined) ? PolylineTypeFlags.Edge : PolylineTypeFlags.Outline;
+                return {
+                    params: new PolylineParams(vertices, polyline, displayParams.width, displayParams.linePixels, isPlanar, flags),
+                    type: "polyline",
+                    viOrigin,
+                };
+            }
+            case Mesh.PrimitiveType.Point: {
+                const indices = this.readVertexIndices(primitive.indices);
+                if (undefined === indices)
+                    return undefined;
+                return {
+                    params: new PointStringParams(vertices, indices, displayParams.width),
+                    type: "point",
+                    viOrigin,
+                };
+            }
             default:
                 assert(false, "unhandled primitive type");
                 return undefined;
         }
     }
+    readPrimitiveGeometry(primitive) {
+        const prim = this.readPrimitiveParams(primitive);
+        return prim ? this.createPrimitiveGeometry(prim) : undefined;
+    }
+    createPrimitiveGeometry(prim) {
+        switch (prim.type) {
+            case "mesh":
+                return this._system.createMeshGeometry(prim.params, prim.viOrigin);
+            case "polyline":
+                return this._system.createPolylineGeometry(prim.params, prim.viOrigin);
+            case "point":
+                return this._system.createPointStringGeometry(prim.params, prim.viOrigin);
+        }
+    }
     getPatternGeometry(patternName) {
         let geometry = this._patternGeometry.get(patternName);
         if (geometry)
@@ -687,6 +712,103 @@ export class ImdlReader {
         this._patternGeometry.set(patternName, geometry);
         return geometry;
     }
+    readAnimationBranches(output, mesh, featureTable) {
+        const timeline = this._timeline;
+        assert(undefined !== timeline);
+        const primitives = mesh.primitives;
+        if (!primitives)
+            return;
+        const branchesByNodeId = new Map();
+        const getBranch = (nodeId) => {
+            let branch = branchesByNodeId.get(nodeId);
+            if (!branch) {
+                branchesByNodeId.set(nodeId, branch = new GraphicBranch(true));
+                branch.animationNodeId = nodeId;
+                branch.animationId = `${this._modelId}_Node_${nodeId}`;
+            }
+            return branch;
+        };
+        featureTable.populateAnimationNodeIds((elemIdPair) => {
+            var _a;
+            const elementTimeline = timeline.getTimelineForElement(elemIdPair.lower, elemIdPair.upper);
+            return (_a = elementTimeline === null || elementTimeline === void 0 ? void 0 : elementTimeline.batchId) !== null && _a !== void 0 ? _a : 0;
+        }, timeline.maxBatchId);
+        const discreteNodeIds = timeline.discreteBatchIds;
+        const computeNodeId = (_id, featureIndex) => {
+            const nodeId = featureTable.getAnimationNodeId(featureIndex);
+            return 0 !== nodeId && discreteNodeIds.has(nodeId) ? nodeId : 0;
+        };
+        const splitArgs = {
+            maxDimension: this._system.maxTextureSize,
+            computeNodeId,
+            featureTable,
+        };
+        for (const primitive of primitives) {
+            if (primitive.type === "areaPattern") {
+                // ###TODO animated area patterns.
+                const gf = this.readAreaPattern(primitive);
+                if (gf)
+                    getBranch(AnimationNodeId.Untransformed).add(gf);
+            }
+            else {
+                const prim = this.readPrimitiveParams(primitive);
+                if (!prim)
+                    continue;
+                const viOrigin = prim.viOrigin;
+                switch (prim.type) {
+                    case "mesh": {
+                        const split = splitMeshParams({ ...splitArgs, params: prim.params });
+                        for (const [nodeId, params] of split) {
+                            const geometry = this.createPrimitiveGeometry({ params, viOrigin, type: "mesh" });
+                            const instances = undefined; // ###TODO support splitting instances (currently animation tile trees do not permit instancing).
+                            const graphic = geometry ? this._system.createRenderGraphic(geometry, instances) : undefined;
+                            if (graphic)
+                                getBranch(nodeId).add(graphic);
+                        }
+                        break;
+                    }
+                    case "point": {
+                        const split = splitPointStringParams({ ...splitArgs, params: prim.params });
+                        for (const [nodeId, params] of split) {
+                            const geometry = this.createPrimitiveGeometry({ params, viOrigin, type: "point" });
+                            const instances = undefined; // ###TODO support splitting instances (currently animation tile trees do not permit instancing).
+                            const graphic = geometry ? this._system.createRenderGraphic(geometry, instances) : undefined;
+                            if (graphic)
+                                getBranch(nodeId).add(graphic);
+                        }
+                        break;
+                    }
+                    case "polyline": {
+                        const split = splitPolylineParams({ ...splitArgs, params: prim.params });
+                        for (const [nodeId, params] of split) {
+                            const geometry = this.createPrimitiveGeometry({ params, viOrigin, type: "polyline" });
+                            const instances = undefined; // ###TODO support splitting instances (currently animation tile trees do not permit instancing).
+                            const graphic = geometry ? this._system.createRenderGraphic(geometry, instances) : undefined;
+                            if (graphic)
+                                getBranch(nodeId).add(graphic);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        for (const branch of branchesByNodeId.values()) {
+            assert(!branch.isEmpty);
+            output.push(this._system.createBranch(branch, Transform.createIdentity()));
+        }
+    }
+    readBranch(output, primitives, nodeId, animationId) {
+        const branch = new GraphicBranch(true);
+        branch.animationId = animationId;
+        branch.animationNodeId = nodeId;
+        for (const primitive of primitives) {
+            const graphic = this.readMeshGraphic(primitive);
+            if (graphic)
+                branch.add(graphic);
+        }
+        if (!branch.isEmpty)
+            output.push(this._system.createBranch(branch, Transform.createIdentity()));
+    }
     finishRead(isLeaf, featureTable, contentRange, emptySubRangeMask, sizeMultiplier) {
         const graphics = [];
         if (undefined === this._nodes.Node_Root) {
@@ -704,18 +826,6 @@ export class ImdlReader {
             }
         }
         else {
-            const readBranch = (primitives, nodeId, animationId) => {
-                const branch = new GraphicBranch(true);
-                branch.animationId = animationId;
-                branch.animationNodeId = nodeId;
-                for (const primitive of primitives) {
-                    const graphic = this.readMeshGraphic(primitive);
-                    if (graphic)
-                        branch.add(graphic);
-                }
-                if (!branch.isEmpty)
-                    graphics.push(this._system.createBranch(branch, Transform.createIdentity()));
-            };
             for (const nodeKey of Object.keys(this._nodes)) {
                 const nodeValue = this._nodes[nodeKey];
                 const meshValue = undefined !== nodeValue ? this._meshes[nodeValue] : undefined;
@@ -724,10 +834,14 @@ export class ImdlReader {
                     continue;
                 const layerId = meshValue.layer;
                 if ("Node_Root" === nodeKey) {
-                    // If transform nodes exist in the tile tree, then we need to create a branch for Node_Root so that elements not associated with
-                    // any node in the schedule script can be grouped together.
-                    if (this._containsTransformNodes) {
-                        readBranch(primitives, AnimationNodeId.Untransformed, undefined);
+                    if (this._timeline) {
+                        // Split up the root node into transform nodes.
+                        this.readAnimationBranches(graphics, meshValue, featureTable);
+                    }
+                    else if (this._containsTransformNodes) {
+                        // If transform nodes exist in the tile tree, then we need to create a branch for Node_Root so that elements not associated with
+                        // any node in the schedule script can be grouped together.
+                        this.readBranch(graphics, primitives, AnimationNodeId.Untransformed, undefined);
                     }
                     else {
                         for (const primitive of primitives) {
@@ -738,7 +852,7 @@ export class ImdlReader {
                     }
                 }
                 else if (undefined === layerId) {
-                    readBranch(primitives, extractNodeId(nodeKey), `${this._modelId}_${nodeKey}`);
+                    this.readBranch(graphics, primitives, extractNodeId(nodeKey), `${this._modelId}_${nodeKey}`);
                 }
                 else {
                     const layerGraphics = [];