@itwin/core-frontend 3.0.0-dev.99 → 3.1.0-dev.1

package/lib/esm/tile/ImdlReader.js

@@ -5,16 +5,61 @@
 /** @packageDocumentation
  * @module Tiles
  */
-import { assert, ByteStream, JsonUtils } from "@itwin/core-bentley";
+import { assert, ByteStream, JsonUtils, utf8ToString } from "@itwin/core-bentley";
 import { ClipVector, Point2d, Point3d, Range2d, Range3d, Transform } from "@itwin/core-geometry";
-import { BatchType, ColorDef, FeatureTableHeader, FillFlags, Gradient, ImageSource, ImdlHeader, LinePixels, PackedFeatureTable, PolylineTypeFlags, QParams2d, QParams3d, readTileContentDescription, RenderMaterial, RenderTexture, TextureMapping, TileReadError, TileReadStatus, } from "@itwin/core-common";
+import { BatchType, ColorDef, FeatureTableHeader, FillFlags, GltfV2ChunkTypes, GltfVersions, Gradient, ImageSource, ImdlHeader, LinePixels, PackedFeatureTable, PolylineTypeFlags, QParams2d, QParams3d, readTileContentDescription, RenderMaterial, RenderTexture, TextureMapping, TileFormat, TileHeader, TileReadError, TileReadStatus, } from "@itwin/core-common";
 import { IModelApp } from "../IModelApp";
-import { GraphicBranch } from "../render/GraphicBranch";
+import { AnimationNodeId, GraphicBranch } from "../render/GraphicBranch";
 import { AuxChannelTable } from "../render/primitives/AuxChannelTable";
 import { DisplayParams } from "../render/primitives/DisplayParams";
 import { Mesh } from "../render/primitives/mesh/MeshPrimitives";
-import { createSurfaceMaterial, isValidSurfaceType, MeshParams, PointStringParams, PolylineParams, SurfaceType, VertexIndices, VertexTable, } from "../render/primitives/VertexTable";
-import { GltfReader, GltfReaderProps } from "./internal";
+import { createSurfaceMaterial, isValidSurfaceType, SurfaceType } from "../render/primitives/SurfaceParams";
+import { MeshParams, VertexIndices, VertexTable } from "../render/primitives/VertexTable";
+import { PointStringParams } from "../render/primitives/PointStringParams";
+import { PolylineParams } from "../render/primitives/PolylineParams";
+/** Header preceding "glTF" data in iMdl tile.
+ * @internal
+ */
+export class GltfHeader extends 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 === GltfVersions.Version2 && value5 === GltfVersions.Gltf1SceneFormat)
+            this.version = GltfVersions.Version1;
+        if (this.version === GltfVersions.Version1) {
+            const gltfSceneFormat = value5;
+            if (GltfVersions.Gltf1SceneFormat !== gltfSceneFormat) {
+                this.invalidate();
+                return;
+            }
+            this.scenePosition = stream.curPos;
+            this.binaryPosition = stream.curPos + this.sceneStrLength;
+        }
+        else if (this.version === GltfVersions.Version2) {
+            const sceneChunkType = value5;
+            this.scenePosition = stream.curPos;
+            stream.curPos = stream.curPos + this.sceneStrLength;
+            const binaryLength = stream.nextUint32;
+            const binaryChunkType = stream.nextUint32;
+            if (GltfV2ChunkTypes.JSON !== sceneChunkType || GltfV2ChunkTypes.Binary !== binaryChunkType || 0 === binaryLength) {
+                this.invalidate();
+                return;
+            }
+            this.binaryPosition = stream.curPos;
+        }
+        else {
+            this.invalidate();
+        }
+    }
+    get isValid() { return TileFormat.Gltf === this.format; }
+}
 /** 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.
@@ -24,37 +69,92 @@ import { GltfReader, GltfReaderProps } from "./internal";
  * @public
  */
 export async function readElementGraphics(bytes, iModel, modelId, is3d, options) {
-    const stream = new ByteStream(bytes.buffer);
-    const reader = ImdlReader.create(stream, iModel, modelId, is3d, IModelApp.renderSystem, undefined, undefined, undefined, undefined, options);
+    const stream = ByteStream.fromUint8Array(bytes);
+    const reader = ImdlReader.create({
+        stream, iModel, modelId, is3d, options,
+        system: IModelApp.renderSystem,
+    });
     if (!reader)
         return undefined;
     const result = await reader.read();
     return result.graphic;
 }
+const nodeIdRegex = /Node_(.*)/;
+function extractNodeId(nodeName) {
+    const match = nodeName.match(nodeIdRegex);
+    assert(!!match && match.length === 2);
+    if (!match || match.length !== 2)
+        return 0;
+    const nodeId = Number.parseInt(match[1], 10);
+    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
  */
-export class ImdlReader extends GltfReader {
-    constructor(props, iModel, modelId, is3d, system, type, loadEdges, isCanceled, sizeMultiplier, options) {
-        var _a;
-        super(props, iModel, modelId, is3d, system, type, isCanceled);
+export 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 = 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 : 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 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 = BatchType.Primary, loadEdges = true, isCanceled, sizeMultiplier, options) {
-        const header = new ImdlHeader(stream);
-        if (!header.isValid || !header.isReadableVersion)
+    static create(args) {
+        const imdlHeader = new 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 = 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 = utf8ToString(sceneStrData);
+        if (!sceneStr)
+            return undefined;
+        try {
+            const sceneValue = JSON.parse(sceneStr);
+            const imdl = {
+                scene: JsonUtils.asString(sceneValue.scene),
+                scenes: JsonUtils.asArray(sceneValue.scenes),
+                animationNodes: JsonUtils.asObject(sceneValue.animationNodes),
+                bufferViews: JsonUtils.asObject(sceneValue.bufferViews),
+                meshes: JsonUtils.asObject(sceneValue.meshes),
+                nodes: JsonUtils.asObject(sceneValue.nodes),
+                materials: JsonUtils.asObject(sceneValue.materials),
+                renderMaterials: JsonUtils.asObject(sceneValue.renderMaterials),
+                namedTextures: JsonUtils.asObject(sceneValue.namedTextures),
+                patternSymbols: 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() {
@@ -78,8 +178,6 @@ export class ImdlReader extends GltfReader {
         return this.finishRead(content.isLeaf, featureTable, content.contentRange, content.emptySubRangeMask, content.sizeMultiplier);
     }
     /** @internal */
-    extractReturnToCenter(_extensions) { return undefined; }
-    /** @internal */
     createDisplayParams(json) {
         const type = JsonUtils.asInt(json.type, DisplayParams.Type.Mesh);
         const lineColor = ColorDef.create(JsonUtils.asInt(json.lineColor));
@@ -117,33 +215,36 @@ export class ImdlReader extends GltfReader {
     }
     /** @internal */
     materialFromJson(key) {
-        if (this._renderMaterials === undefined || this._renderMaterials[key] === undefined)
+        const material = this._system.findMaterial(key, this._iModel);
+        if (material)
+            return material;
+        if (!this._renderMaterials)
             return undefined;
-        let material = this._system.findMaterial(key, this._iModel);
-        if (!material) {
-            const materialJson = this._renderMaterials[key];
-            const materialParams = new RenderMaterial.Params(key);
-            materialParams.diffuseColor = this.colorDefFromMaterialJson(materialJson.diffuseColor);
-            if (materialJson.diffuse !== undefined)
-                materialParams.diffuse = JsonUtils.asDouble(materialJson.diffuse);
-            materialParams.specularColor = this.colorDefFromMaterialJson(materialJson.specularColor);
-            if (materialJson.specular !== undefined)
-                materialParams.specular = JsonUtils.asDouble(materialJson.specular);
-            materialParams.reflectColor = this.colorDefFromMaterialJson(materialJson.reflectColor);
-            if (materialJson.reflect !== undefined)
-                materialParams.reflect = JsonUtils.asDouble(materialJson.reflect);
-            if (materialJson.specularExponent !== undefined)
-                materialParams.specularExponent = materialJson.specularExponent;
-            if (undefined !== materialJson.transparency)
-                materialParams.alpha = 1.0 - materialJson.transparency;
-            materialParams.refract = JsonUtils.asDouble(materialJson.refract);
-            materialParams.shadows = JsonUtils.asBool(materialJson.shadows);
-            materialParams.ambient = 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 materialJson = this._renderMaterials[key];
+        if (!materialJson)
+            return undefined;
+        // eslint-disable-next-line deprecation/deprecation
+        const materialParams = new RenderMaterial.Params(key);
+        materialParams.diffuseColor = this.colorDefFromMaterialJson(materialJson.diffuseColor);
+        if (materialJson.diffuse !== undefined)
+            materialParams.diffuse = JsonUtils.asDouble(materialJson.diffuse);
+        materialParams.specularColor = this.colorDefFromMaterialJson(materialJson.specularColor);
+        if (materialJson.specular !== undefined)
+            materialParams.specular = JsonUtils.asDouble(materialJson.specular);
+        materialParams.reflectColor = this.colorDefFromMaterialJson(materialJson.reflectColor);
+        if (materialJson.reflect !== undefined)
+            materialParams.reflect = JsonUtils.asDouble(materialJson.reflect);
+        if (materialJson.specularExponent !== undefined)
+            materialParams.specularExponent = materialJson.specularExponent;
+        if (undefined !== materialJson.transparency)
+            materialParams.alpha = 1.0 - materialJson.transparency;
+        materialParams.refract = JsonUtils.asDouble(materialJson.refract);
+        materialParams.shadows = JsonUtils.asBool(materialJson.shadows);
+        materialParams.ambient = JsonUtils.asDouble(materialJson.ambient);
+        if (undefined !== materialJson.textureMapping)
+            materialParams.textureMapping = this.textureMappingFromJson(materialJson.textureMapping.texture);
+        // eslint-disable-next-line deprecation/deprecation
+        return this._system.createMaterial(materialParams, this._iModel);
     }
     textureMappingFromJson(json) {
         if (undefined === json)
@@ -217,7 +318,7 @@ export class ImdlReader extends GltfReader {
             const texBytes = this._binaryData.subarray(byteOffset, byteOffset + byteLength);
             const format = namedTex.format;
             const source = new 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
@@ -236,7 +337,7 @@ export class ImdlReader extends GltfReader {
         if (this._buffer.isPastTheEnd)
             return undefined;
         let animNodesArray;
-        const animationNodes = JsonUtils.asObject(this._scene.animationNodes);
+        const animationNodes = this._animationNodes;
         if (undefined !== animationNodes) {
             const bytesPerId = JsonUtils.asInt(animationNodes.bytesPerId);
             const bufferViewId = JsonUtils.asString(animationNodes.bufferView);
@@ -482,10 +583,27 @@ export class ImdlReader extends 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 };
@@ -493,13 +611,16 @@ export class ImdlReader extends 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,
             };
@@ -581,29 +702,41 @@ export class ImdlReader extends GltfReader {
             }
         }
         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 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, 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(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, Transform.createIdentity()));
+                    readBranch(primitives, extractNodeId(nodeKey), `${this._modelId}_${nodeKey}`);
                 }
                 else {
                     const layerGraphics = [];