@itwin/core-frontend 3.0.0-dev.98 → 3.0.0

package/lib/cjs/tile/ImdlReader.js

@@ -7,7 +7,7 @@
  * @module Tiles
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImdlReader = exports.readElementGraphics = void 0;
+exports.ImdlReader = exports.readElementGraphics = exports.GltfHeader = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_geometry_1 = require("@itwin/core-geometry");
 const core_common_1 = require("@itwin/core-common");
@@ -16,8 +16,54 @@ const GraphicBranch_1 = require("../render/GraphicBranch");
 const AuxChannelTable_1 = require("../render/primitives/AuxChannelTable");
 const DisplayParams_1 = require("../render/primitives/DisplayParams");
 const MeshPrimitives_1 = require("../render/primitives/mesh/MeshPrimitives");
+const SurfaceParams_1 = require("../render/primitives/SurfaceParams");
 const VertexTable_1 = require("../render/primitives/VertexTable");
-const internal_1 = require("./internal");
+const PointStringParams_1 = require("../render/primitives/PointStringParams");
+const PolylineParams_1 = require("../render/primitives/PolylineParams");
+/** Header preceding "glTF" data in iMdl tile.
+ * @internal
+ */
+class GltfHeader extends core_common_1.TileHeader {
+    constructor(stream) {
+        super(stream);
+        this.scenePosition = 0;
+        this.sceneStrLength = 0;
+        this.binaryPosition = 0;
+        this.gltfLength = stream.nextUint32;
+        this.sceneStrLength = stream.nextUint32;
+        const value5 = stream.nextUint32;
+        // Early versions of the reality data tile publisher incorrectly put version 2 into header - handle these old tiles
+        // validating the chunk type.
+        if (this.version === core_common_1.GltfVersions.Version2 && value5 === core_common_1.GltfVersions.Gltf1SceneFormat)
+            this.version = core_common_1.GltfVersions.Version1;
+        if (this.version === core_common_1.GltfVersions.Version1) {
+            const gltfSceneFormat = value5;
+            if (core_common_1.GltfVersions.Gltf1SceneFormat !== gltfSceneFormat) {
+                this.invalidate();
+                return;
+            }
+            this.scenePosition = stream.curPos;
+            this.binaryPosition = stream.curPos + this.sceneStrLength;
+        }
+        else if (this.version === core_common_1.GltfVersions.Version2) {
+            const sceneChunkType = value5;
+            this.scenePosition = stream.curPos;
+            stream.curPos = stream.curPos + this.sceneStrLength;
+            const binaryLength = stream.nextUint32;
+            const binaryChunkType = stream.nextUint32;
+            if (core_common_1.GltfV2ChunkTypes.JSON !== sceneChunkType || core_common_1.GltfV2ChunkTypes.Binary !== binaryChunkType || 0 === binaryLength) {
+                this.invalidate();
+                return;
+            }
+            this.binaryPosition = stream.curPos;
+        }
+        else {
+            this.invalidate();
+        }
+    }
+    get isValid() { return core_common_1.TileFormat.Gltf === this.format; }
+}
+exports.GltfHeader = GltfHeader;
 /** Convert the byte array returned by [[TileAdmin.requestElementGraphics]] into a [[RenderGraphic]].
  * @param bytes The binary graphics data obtained from `requestElementGraphics`.
  * @param iModel The iModel with which the graphics are associated.
@@ -27,38 +73,93 @@ const internal_1 = require("./internal");
  * @public
  */
 async function readElementGraphics(bytes, iModel, modelId, is3d, options) {
-    const stream = new core_bentley_1.ByteStream(bytes.buffer);
-    const reader = ImdlReader.create(stream, iModel, modelId, is3d, IModelApp_1.IModelApp.renderSystem, undefined, undefined, undefined, undefined, options);
+    const stream = core_bentley_1.ByteStream.fromUint8Array(bytes);
+    const reader = ImdlReader.create({
+        stream, iModel, modelId, is3d, options,
+        system: IModelApp_1.IModelApp.renderSystem,
+    });
     if (!reader)
         return undefined;
     const result = await reader.read();
     return result.graphic;
 }
 exports.readElementGraphics = readElementGraphics;
+const nodeIdRegex = /Node_(.*)/;
+function extractNodeId(nodeName) {
+    const match = nodeName.match(nodeIdRegex);
+    (0, core_bentley_1.assert)(!!match && match.length === 2);
+    if (!match || match.length !== 2)
+        return 0;
+    const nodeId = Number.parseInt(match[1], 10);
+    (0, core_bentley_1.assert)(!Number.isNaN(nodeId));
+    return Number.isNaN(nodeId) ? 0 : nodeId;
+}
 /** Deserializes tile content in iMdl format. These tiles contain element geometry encoded into a format optimized for the imodeljs webgl renderer.
  * @internal
  */
-class ImdlReader extends internal_1.GltfReader {
-    constructor(props, iModel, modelId, is3d, system, type, loadEdges, isCanceled, sizeMultiplier, options) {
-        var _a;
-        super(props, iModel, modelId, is3d, system, type, isCanceled);
+class ImdlReader {
+    constructor(imdl, binaryPosition, args) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this._patternGeometry = new Map();
-        this._sizeMultiplier = sizeMultiplier;
-        this._loadEdges = loadEdges;
-        this._options = options !== null && options !== void 0 ? options : {};
-        this._patternSymbols = (_a = props.scene.patternSymbols) !== null && _a !== void 0 ? _a : {};
+        this._buffer = args.stream;
+        this._binaryData = new Uint8Array(this._buffer.arrayBuffer, binaryPosition);
+        this._animationNodes = core_bentley_1.JsonUtils.asObject(imdl.animationNodes);
+        this._bufferViews = imdl.bufferViews;
+        this._meshes = imdl.meshes;
+        this._nodes = imdl.nodes;
+        this._materialValues = (_a = imdl.materials) !== null && _a !== void 0 ? _a : {};
+        this._renderMaterials = (_b = imdl.renderMaterials) !== null && _b !== void 0 ? _b : {};
+        this._namedTextures = (_c = imdl.namedTextures) !== null && _c !== void 0 ? _c : {};
+        this._patternSymbols = (_d = imdl.patternSymbols) !== null && _d !== void 0 ? _d : {};
+        this._iModel = args.iModel;
+        this._modelId = args.modelId;
+        this._is3d = args.is3d;
+        this._system = args.system;
+        this._type = (_e = args.type) !== null && _e !== void 0 ? _e : core_common_1.BatchType.Primary;
+        this._canceled = args.isCanceled;
+        this._sizeMultiplier = args.sizeMultiplier;
+        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;
     }
+    get _isCanceled() { return undefined !== this._canceled && this._canceled(this); }
+    get _isVolumeClassifier() { return core_common_1.BatchType.VolumeClassifier === this._type; }
     /** Attempt to initialize an ImdlReader to deserialize iModel tile data beginning at the stream's current position. */
-    static create(stream, iModel, modelId, is3d, system, type = core_common_1.BatchType.Primary, loadEdges = true, isCanceled, sizeMultiplier, options) {
-        const header = new core_common_1.ImdlHeader(stream);
-        if (!header.isValid || !header.isReadableVersion)
+    static create(args) {
+        const imdlHeader = new core_common_1.ImdlHeader(args.stream);
+        if (!imdlHeader.isValid || !imdlHeader.isReadableVersion)
             return undefined;
         // The feature table follows the iMdl header
-        if (!this.skipFeatureTable(stream))
+        if (!this.skipFeatureTable(args.stream))
             return undefined;
         // A glTF header follows the feature table
-        const props = internal_1.GltfReaderProps.create(stream, false);
-        return undefined !== props ? new ImdlReader(props, iModel, modelId, is3d, system, type, loadEdges, isCanceled, sizeMultiplier, options) : undefined;
+        const gltfHeader = new GltfHeader(args.stream);
+        if (!gltfHeader.isValid)
+            return undefined;
+        args.stream.curPos = gltfHeader.scenePosition;
+        const sceneStrData = args.stream.nextBytes(gltfHeader.sceneStrLength);
+        const sceneStr = (0, core_bentley_1.utf8ToString)(sceneStrData);
+        if (!sceneStr)
+            return undefined;
+        try {
+            const sceneValue = JSON.parse(sceneStr);
+            const imdl = {
+                scene: core_bentley_1.JsonUtils.asString(sceneValue.scene),
+                scenes: core_bentley_1.JsonUtils.asArray(sceneValue.scenes),
+                animationNodes: core_bentley_1.JsonUtils.asObject(sceneValue.animationNodes),
+                bufferViews: core_bentley_1.JsonUtils.asObject(sceneValue.bufferViews),
+                meshes: core_bentley_1.JsonUtils.asObject(sceneValue.meshes),
+                nodes: core_bentley_1.JsonUtils.asObject(sceneValue.nodes),
+                materials: core_bentley_1.JsonUtils.asObject(sceneValue.materials),
+                renderMaterials: core_bentley_1.JsonUtils.asObject(sceneValue.renderMaterials),
+                namedTextures: core_bentley_1.JsonUtils.asObject(sceneValue.namedTextures),
+                patternSymbols: core_bentley_1.JsonUtils.asObject(sceneValue.patternSymbols),
+            };
+            return undefined !== imdl.meshes ? new ImdlReader(imdl, gltfHeader.binaryPosition, args) : undefined;
+        }
+        catch (_) {
+            return undefined;
+        }
     }
     /** Attempt to deserialize the tile data */
     async read() {
@@ -82,8 +183,6 @@ class ImdlReader extends internal_1.GltfReader {
         return this.finishRead(content.isLeaf, featureTable, content.contentRange, content.emptySubRangeMask, content.sizeMultiplier);
     }
     /** @internal */
-    extractReturnToCenter(_extensions) { return undefined; }
-    /** @internal */
     createDisplayParams(json) {
         const type = core_bentley_1.JsonUtils.asInt(json.type, DisplayParams_1.DisplayParams.Type.Mesh);
         const lineColor = core_common_1.ColorDef.create(core_bentley_1.JsonUtils.asInt(json.lineColor));
@@ -121,33 +220,34 @@ class ImdlReader extends internal_1.GltfReader {
     }
     /** @internal */
     materialFromJson(key) {
-        if (this._renderMaterials === undefined || this._renderMaterials[key] === undefined)
-            return undefined;
-        let material = this._system.findMaterial(key, this._iModel);
-        if (!material) {
-            const materialJson = this._renderMaterials[key];
-            const materialParams = new core_common_1.RenderMaterial.Params(key);
-            materialParams.diffuseColor = this.colorDefFromMaterialJson(materialJson.diffuseColor);
-            if (materialJson.diffuse !== undefined)
-                materialParams.diffuse = core_bentley_1.JsonUtils.asDouble(materialJson.diffuse);
-            materialParams.specularColor = this.colorDefFromMaterialJson(materialJson.specularColor);
-            if (materialJson.specular !== undefined)
-                materialParams.specular = core_bentley_1.JsonUtils.asDouble(materialJson.specular);
-            materialParams.reflectColor = this.colorDefFromMaterialJson(materialJson.reflectColor);
-            if (materialJson.reflect !== undefined)
-                materialParams.reflect = core_bentley_1.JsonUtils.asDouble(materialJson.reflect);
-            if (materialJson.specularExponent !== undefined)
-                materialParams.specularExponent = materialJson.specularExponent;
-            if (undefined !== materialJson.transparency)
-                materialParams.alpha = 1.0 - materialJson.transparency;
-            materialParams.refract = core_bentley_1.JsonUtils.asDouble(materialJson.refract);
-            materialParams.shadows = core_bentley_1.JsonUtils.asBool(materialJson.shadows);
-            materialParams.ambient = core_bentley_1.JsonUtils.asDouble(materialJson.ambient);
-            if (undefined !== materialJson.textureMapping)
-                materialParams.textureMapping = this.textureMappingFromJson(materialJson.textureMapping.texture);
-            material = this._system.createMaterial(materialParams, this._iModel);
-        }
-        return material;
+        const material = this._system.findMaterial(key, this._iModel);
+        if (material)
+            return material;
+        if (!this._renderMaterials)
+            return undefined;
+        const materialJson = this._renderMaterials[key];
+        if (!materialJson)
+            return undefined;
+        const materialParams = new core_common_1.RenderMaterial.Params(key);
+        materialParams.diffuseColor = this.colorDefFromMaterialJson(materialJson.diffuseColor);
+        if (materialJson.diffuse !== undefined)
+            materialParams.diffuse = core_bentley_1.JsonUtils.asDouble(materialJson.diffuse);
+        materialParams.specularColor = this.colorDefFromMaterialJson(materialJson.specularColor);
+        if (materialJson.specular !== undefined)
+            materialParams.specular = core_bentley_1.JsonUtils.asDouble(materialJson.specular);
+        materialParams.reflectColor = this.colorDefFromMaterialJson(materialJson.reflectColor);
+        if (materialJson.reflect !== undefined)
+            materialParams.reflect = core_bentley_1.JsonUtils.asDouble(materialJson.reflect);
+        if (materialJson.specularExponent !== undefined)
+            materialParams.specularExponent = materialJson.specularExponent;
+        if (undefined !== materialJson.transparency)
+            materialParams.alpha = 1.0 - materialJson.transparency;
+        materialParams.refract = core_bentley_1.JsonUtils.asDouble(materialJson.refract);
+        materialParams.shadows = core_bentley_1.JsonUtils.asBool(materialJson.shadows);
+        materialParams.ambient = core_bentley_1.JsonUtils.asDouble(materialJson.ambient);
+        if (undefined !== materialJson.textureMapping)
+            materialParams.textureMapping = this.textureMappingFromJson(materialJson.textureMapping.texture);
+        return this._system.createMaterial(materialParams, this._iModel);
     }
     textureMappingFromJson(json) {
         if (undefined === json)
@@ -221,7 +321,7 @@ class ImdlReader extends internal_1.GltfReader {
             const texBytes = this._binaryData.subarray(byteOffset, byteOffset + byteLength);
             const format = namedTex.format;
             const source = new core_common_1.ImageSource(texBytes, format);
-            return this._system.createTextureFromSource({ source, ownership, type: textureType });
+            return this._system.createTextureFromSource({ source, ownership, type: textureType, transparency: namedTex.transparency });
         }
         // bufferViewJson was undefined, so attempt to request the texture directly from the backend
         // eslint-disable-next-line deprecation/deprecation
@@ -240,7 +340,7 @@ class ImdlReader extends internal_1.GltfReader {
         if (this._buffer.isPastTheEnd)
             return undefined;
         let animNodesArray;
-        const animationNodes = core_bentley_1.JsonUtils.asObject(this._scene.animationNodes);
+        const animationNodes = this._animationNodes;
         if (undefined !== animationNodes) {
             const bytesPerId = core_bentley_1.JsonUtils.asInt(animationNodes.bytesPerId);
             const bufferViewId = core_bentley_1.JsonUtils.asString(animationNodes.bufferView);
@@ -418,7 +518,7 @@ class ImdlReader extends internal_1.GltfReader {
         const indices = this.readVertexIndices(primitive.indices);
         if (undefined === indices)
             return undefined;
-        const params = new VertexTable_1.PointStringParams(vertices, indices, displayParams.width);
+        const params = new PointStringParams_1.PointStringParams(vertices, indices, displayParams.width);
         return this._system.createPointStringGeometry(params, viewIndependentOrigin);
     }
     readTesselatedPolyline(json) {
@@ -436,7 +536,7 @@ class ImdlReader extends internal_1.GltfReader {
         let flags = core_common_1.PolylineTypeFlags.Normal;
         if (DisplayParams_1.DisplayParams.RegionEdgeType.Outline === displayParams.regionEdgeType)
             flags = (undefined === displayParams.gradient || displayParams.gradient.isOutlined) ? core_common_1.PolylineTypeFlags.Edge : core_common_1.PolylineTypeFlags.Outline;
-        const params = new VertexTable_1.PolylineParams(vertices, polyline, displayParams.width, displayParams.linePixels, isPlanar, flags);
+        const params = new PolylineParams_1.PolylineParams(vertices, polyline, displayParams.width, displayParams.linePixels, isPlanar, flags);
         return this._system.createPolylineGeometry(params, viewIndependentOrigin);
     }
     readSurface(mesh, displayParams) {
@@ -447,7 +547,7 @@ class ImdlReader extends internal_1.GltfReader {
         if (undefined === indices)
             return undefined;
         const type = surf.type;
-        if (!(0, VertexTable_1.isValidSurfaceType)(type))
+        if (!(0, SurfaceParams_1.isValidSurfaceType)(type))
             return undefined;
         const texture = undefined !== displayParams.textureMapping ? displayParams.textureMapping.texture : undefined;
         let material;
@@ -463,7 +563,7 @@ class ImdlReader extends internal_1.GltfReader {
             };
         }
         else {
-            material = (0, VertexTable_1.createSurfaceMaterial)(displayParams.material);
+            material = (0, SurfaceParams_1.createSurfaceMaterial)(displayParams.material);
         }
         const textureMapping = undefined !== texture ? { texture, alwaysDisplayed: core_bentley_1.JsonUtils.asBool(surf.alwaysDisplayTexture) } : undefined;
         return {
@@ -486,10 +586,27 @@ class ImdlReader extends internal_1.GltfReader {
         const normalPairs = this.findBuffer(json.normalPairs);
         return undefined !== segments && undefined !== normalPairs ? { normalPairs, indices: segments.indices, endPointAndQuadIndices: segments.endPointAndQuadIndices } : undefined;
     }
+    readIndexedEdges(json) {
+        const indices = this.readVertexIndices(json.indices);
+        const edgeTable = this.findBuffer(json.edges);
+        if (!indices || !edgeTable)
+            return undefined;
+        return {
+            indices,
+            edges: {
+                data: edgeTable,
+                width: json.width,
+                height: json.height,
+                silhouettePadding: json.silhouettePadding,
+                numSegments: json.numSegments,
+            },
+        };
+    }
     readEdges(json, displayParams) {
         let segments;
         let silhouettes;
         let polylines;
+        let indexed;
         let succeeded = false;
         if (undefined !== json.segments && undefined === (segments = this.readSegmentEdges(json.segments)))
             return { succeeded };
@@ -497,13 +614,16 @@ class ImdlReader extends internal_1.GltfReader {
             return { succeeded };
         if (undefined !== json.polylines && undefined === (polylines = this.readTesselatedPolyline(json.polylines)))
             return { succeeded };
+        if (undefined !== json.indexed && undefined === (indexed = this.readIndexedEdges(json.indexed)))
+            return { succeeded };
         succeeded = true;
         let params;
-        if (undefined !== segments || undefined !== silhouettes || undefined !== polylines) {
+        if (segments || silhouettes || polylines || indexed) {
             params = {
                 segments,
                 silhouettes,
                 polylines,
+                indexed,
                 weight: displayParams.width,
                 linePixels: displayParams.linePixels,
             };
@@ -516,7 +636,7 @@ class ImdlReader extends internal_1.GltfReader {
             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 && VertexTable_1.SurfaceType.VolumeClassifier !== surface.type) {
+        if (this._loadEdges && undefined !== primitive.edges && SurfaceParams_1.SurfaceType.VolumeClassifier !== surface.type) {
             const edgeResult = this.readEdges(primitive.edges, displayParams);
             if (!edgeResult.succeeded)
                 return undefined;
@@ -585,29 +705,41 @@ class ImdlReader extends internal_1.GltfReader {
             }
         }
         else {
+            const readBranch = (primitives, nodeId, animationId) => {
+                const branch = new GraphicBranch_1.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, core_geometry_1.Transform.createIdentity()));
+            };
             for (const nodeKey of Object.keys(this._nodes)) {
-                const meshValue = this._meshes[this._nodes[nodeKey]];
+                const nodeValue = this._nodes[nodeKey];
+                const meshValue = undefined !== nodeValue ? this._meshes[nodeValue] : undefined;
                 const primitives = meshValue === null || meshValue === void 0 ? void 0 : meshValue.primitives;
                 if (!primitives || !meshValue)
                     continue;
                 const layerId = meshValue.layer;
                 if ("Node_Root" === nodeKey) {
-                    for (const primitive of primitives) {
-                        const graphic = this.readMeshGraphic(primitive);
-                        if (undefined !== graphic)
-                            graphics.push(graphic);
+                    // 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, GraphicBranch_1.AnimationNodeId.Untransformed, undefined);
+                    }
+                    else {
+                        for (const primitive of primitives) {
+                            const graphic = this.readMeshGraphic(primitive);
+                            if (undefined !== graphic)
+                                graphics.push(graphic);
+                        }
                     }
                 }
                 else if (undefined === layerId) {
-                    const branch = new GraphicBranch_1.GraphicBranch(true);
-                    branch.animationId = `${this._modelId}_${nodeKey}`;
-                    for (const primitive of primitives) {
-                        const graphic = this.readMeshGraphic(primitive);
-                        if (undefined !== graphic)
-                            branch.add(graphic);
-                    }
-                    if (!branch.isEmpty)
-                        graphics.push(this._system.createBranch(branch, core_geometry_1.Transform.createIdentity()));
+                    readBranch(primitives, extractNodeId(nodeKey), `${this._modelId}_${nodeKey}`);
                 }
                 else {
                     const layerGraphics = [];