@itwin/core-frontend 3.0.0-dev.157 → 3.0.0-dev.159

package/lib/esm/tile/GltfReader.js

@@ -5,10 +5,11 @@
 /** @packageDocumentation
  * @module Tiles
  */
-import { assert, JsonUtils, utf8ToString } from "@itwin/core-bentley";
-import { Angle, Matrix3d, Point2d, Point3d, Range2d, Range3d, Transform, Vector3d } from "@itwin/core-geometry";
-import { BatchType, ColorDef, FillFlags, GltfBufferView, GltfDataType, GltfHeader, GltfMeshMode, ImageSource, ImageSourceFormat, LinePixels, MeshEdge, MeshEdges, MeshPolyline, OctEncodedNormal, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderTexture, TextureMapping, TileReadStatus, } from "@itwin/core-common";
+import { assert, ByteStream, JsonUtils, utf8ToString } from "@itwin/core-bentley";
+import { Angle, Matrix3d, Point2d, Point3d, Point4d, Range2d, Range3d, Transform, Vector3d } from "@itwin/core-geometry";
+import { BatchType, ColorDef, Feature, FeatureTable, FillFlags, GltfHeader, ImageSource, ImageSourceFormat, LinePixels, MeshEdge, MeshEdges, MeshPolyline, OctEncodedNormal, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderTexture, TextureMapping, TileReadStatus, } from "@itwin/core-common";
 import { getImageSourceFormatForMimeType, imageElementFromImageSource } from "../ImageUtil";
+import { IModelApp } from "../IModelApp";
 import { GraphicBranch } from "../render/GraphicBranch";
 import { DisplayParams } from "../render/primitives/DisplayParams";
 import { Mesh, MeshGraphicArgs } from "../render/primitives/mesh/MeshPrimitives";
@@ -16,22 +17,164 @@ import { RealityMeshPrimitive } from "../render/primitives/mesh/RealityMeshPrimi
 import { TextureTransparency } from "../render/RenderTexture";
 // eslint-disable-next-line prefer-const
 let forceLUT = false;
+/* eslint-disable no-restricted-syntax */
+/** Enumerates the types of [[GltfMeshPrimitive]] topologies. */
+var GltfMeshMode;
+(function (GltfMeshMode) {
+    GltfMeshMode[GltfMeshMode["Points"] = 0] = "Points";
+    GltfMeshMode[GltfMeshMode["Lines"] = 1] = "Lines";
+    GltfMeshMode[GltfMeshMode["LineStrip"] = 3] = "LineStrip";
+    GltfMeshMode[GltfMeshMode["Triangles"] = 4] = "Triangles";
+    /** Not currently supported. */
+    GltfMeshMode[GltfMeshMode["TriangleStrip"] = 5] = "TriangleStrip";
+    /** Not currently supported. */
+    GltfMeshMode[GltfMeshMode["TriangleFan"] = 6] = "TriangleFan";
+})(GltfMeshMode || (GltfMeshMode = {}));
+/** Enumerates the basic data types supported by accessors, material values, technique uniforms, etc.
+ * @internal
+ */
+export var GltfDataType;
+(function (GltfDataType) {
+    GltfDataType[GltfDataType["SignedByte"] = 5120] = "SignedByte";
+    GltfDataType[GltfDataType["UnsignedByte"] = 5121] = "UnsignedByte";
+    GltfDataType[GltfDataType["SignedShort"] = 5122] = "SignedShort";
+    GltfDataType[GltfDataType["UnsignedShort"] = 5123] = "UnsignedShort";
+    GltfDataType[GltfDataType["UInt32"] = 5125] = "UInt32";
+    GltfDataType[GltfDataType["Float"] = 5126] = "Float";
+    GltfDataType[GltfDataType["Rgb"] = 6407] = "Rgb";
+    GltfDataType[GltfDataType["Rgba"] = 6408] = "Rgba";
+    GltfDataType[GltfDataType["IntVec2"] = 35667] = "IntVec2";
+    GltfDataType[GltfDataType["IntVec3"] = 35668] = "IntVec3";
+    GltfDataType[GltfDataType["FloatVec2"] = 35664] = "FloatVec2";
+    GltfDataType[GltfDataType["FloatVec3"] = 35665] = "FloatVec3";
+    GltfDataType[GltfDataType["FloatVec4"] = 35666] = "FloatVec4";
+    GltfDataType[GltfDataType["FloatMat3"] = 35675] = "FloatMat3";
+    GltfDataType[GltfDataType["FloatMat4"] = 35676] = "FloatMat4";
+    GltfDataType[GltfDataType["Sampler2d"] = 35678] = "Sampler2d";
+})(GltfDataType || (GltfDataType = {}));
+/** @internal */
+var GltfMagFilter;
+(function (GltfMagFilter) {
+    GltfMagFilter[GltfMagFilter["Nearest"] = 9728] = "Nearest";
+    GltfMagFilter[GltfMagFilter["Linear"] = 9729] = "Linear";
+})(GltfMagFilter || (GltfMagFilter = {}));
+/** @internal */
+var GltfMinFilter;
+(function (GltfMinFilter) {
+    GltfMinFilter[GltfMinFilter["Nearest"] = 9728] = "Nearest";
+    GltfMinFilter[GltfMinFilter["Linear"] = 9729] = "Linear";
+    GltfMinFilter[GltfMinFilter["NearestMipMapNearest"] = 9984] = "NearestMipMapNearest";
+    GltfMinFilter[GltfMinFilter["LinearMipMapNearest"] = 9985] = "LinearMipMapNearest";
+    GltfMinFilter[GltfMinFilter["NearestMipMapLinear"] = 9986] = "NearestMipMapLinear";
+    GltfMinFilter[GltfMinFilter["LinearMipMapLinear"] = 9987] = "LinearMipMapLinear";
+})(GltfMinFilter || (GltfMinFilter = {}));
+/** Describes how texture coordinates outside of the range [0..1] are handled. */
+var GltfWrapMode;
+(function (GltfWrapMode) {
+    GltfWrapMode[GltfWrapMode["ClampToEdge"] = 33071] = "ClampToEdge";
+    GltfWrapMode[GltfWrapMode["MirroredRepeat"] = 33648] = "MirroredRepeat";
+    GltfWrapMode[GltfWrapMode["Repeat"] = 10497] = "Repeat";
+})(GltfWrapMode || (GltfWrapMode = {}));
+/** Describes the intended target of a [[GltfBufferViewProps]]. */
+var GltfBufferTarget;
+(function (GltfBufferTarget) {
+    GltfBufferTarget[GltfBufferTarget["ArrayBuffer"] = 34962] = "ArrayBuffer";
+    GltfBufferTarget[GltfBufferTarget["ElementArrayBuffer"] = 24963] = "ElementArrayBuffer";
+})(GltfBufferTarget || (GltfBufferTarget = {}));
+function getNodeMeshIds(node) {
+    if (undefined !== node.meshes)
+        return typeof node.meshes === "string" ? [node.meshes] : node.meshes;
+    else if (undefined !== node.mesh)
+        return [node.mesh];
+    return [];
+}
+function isGltf1Material(material) {
+    const mat1 = material;
+    return undefined !== mat1.technique || undefined !== mat1.values;
+}
+/**
+ * A chunk of binary data exposed as a typed array.
+ * The count member indicates how many elements exist. This may be less than this.buffer.length due to padding added to the
+ * binary stream to ensure correct alignment.
+ * @internal
+ */
+export class GltfBufferData {
+    constructor(buffer, count) {
+        this.buffer = buffer;
+        this.count = count;
+    }
+    /**
+     * Create a GltfBufferData of the desired type. The actual type may differ from the desired type - for example, small 32-bit integers
+     * may be represented as 8-bit or 16-bit integers instead.
+     * If the actual data type is not convertible to the desired type, this function returns undefined.
+     */
+    static create(bytes, actualType, expectedType, count) {
+        if (expectedType !== actualType) {
+            // Some data is stored in smaller data types to save space if no values exceed the maximum of the smaller type.
+            switch (expectedType) {
+                case GltfDataType.Float:
+                case GltfDataType.UnsignedByte:
+                    return undefined;
+                case GltfDataType.UnsignedShort:
+                    if (GltfDataType.UnsignedByte !== actualType)
+                        return undefined;
+                    break;
+                case GltfDataType.UInt32:
+                    if (GltfDataType.UnsignedByte !== actualType && GltfDataType.UnsignedShort !== actualType)
+                        return undefined;
+                    break;
+            }
+        }
+        const data = this.createDataBuffer(bytes, actualType);
+        return undefined !== data ? new GltfBufferData(data, count) : undefined;
+    }
+    static createDataBuffer(bytes, actualType) {
+        // NB: Endianness of typed array data is determined by the 'platform byte order'. Actual data is always little-endian.
+        // We are assuming little-endian platform. If we find a big-endian platform, we'll need to use a DataView instead.
+        switch (actualType) {
+            case GltfDataType.UnsignedByte:
+                return bytes;
+            case GltfDataType.UnsignedShort:
+                return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+            case GltfDataType.UInt32:
+                return new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+            case GltfDataType.Float:
+                return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+            default:
+                return undefined;
+        }
+    }
+}
+/**
+ * A view of a chunk of glTF binary data containing an array of elements of a specific data type.
+ * The count member indicates how many elements exist; this may be smaller than this.data.length.
+ * The count member may also indicate the number of elements of a type containing more than one value of the
+ * underlying type. For example, a buffer of 4 32-bit floating point 'vec2' elements will have a count of 4,
+ * but its data member will contain 8 32-bit floating point values (2 per vec2).
+ * The accessor member may contain additional JSON data specific to a particular buffer.
+ * @internal
+ */
+class GltfBufferView {
+    constructor(data, count, type, accessor, stride) {
+        this.data = data;
+        this.count = count;
+        this.type = type;
+        this.accessor = accessor;
+        this.stride = stride;
+    }
+    get byteLength() { return this.data.length; }
+    toBufferData(desiredType) {
+        return GltfBufferData.create(this.data, this.type, desiredType, this.count);
+    }
+}
 /** Data required for creating a [[GltfReader]] capable of deserializing [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
 export class GltfReaderProps {
-    constructor(buffer, binaryData, accessors, bufferViews, scene, nodes, meshes, materials, extensions, samplers, techniques, yAxisUp) {
+    constructor(buffer, binaryData, glTF, yAxisUp) {
         this.buffer = buffer;
         this.binaryData = binaryData;
-        this.accessors = accessors;
-        this.bufferViews = bufferViews;
-        this.scene = scene;
-        this.nodes = nodes;
-        this.meshes = meshes;
-        this.materials = materials;
-        this.extensions = extensions;
-        this.samplers = samplers;
-        this.techniques = techniques;
+        this.glTF = glTF;
         this.yAxisUp = yAxisUp;
     }
     /** Attempt to construct a new GltfReaderProps from the binary data beginning at the supplied stream's current read position. */
@@ -41,23 +184,34 @@ export class GltfReaderProps {
             return undefined;
         const binaryData = new Uint8Array(buffer.arrayBuffer, header.binaryPosition);
         buffer.curPos = header.scenePosition;
-        const sceneStrData = buffer.nextBytes(header.sceneStrLength);
-        const sceneStr = utf8ToString(sceneStrData);
-        if (undefined === sceneStr)
+        const jsonStrData = buffer.nextBytes(header.sceneStrLength);
+        const jsonStr = utf8ToString(jsonStrData);
+        if (undefined === jsonStr)
             return undefined;
         try {
-            const sceneValue = JSON.parse(sceneStr);
-            const nodes = JsonUtils.asObject(sceneValue.nodes);
-            const meshes = JsonUtils.asObject(sceneValue.meshes);
-            const materialValues = JsonUtils.asObject(sceneValue.materials);
-            const accessors = JsonUtils.asObject(sceneValue.accessors);
-            const bufferViews = JsonUtils.asObject(sceneValue.bufferViews);
-            const extensions = JsonUtils.asObject(sceneValue.extensions);
-            const samplers = JsonUtils.asObject(sceneValue.samplers);
-            const techniques = JsonUtils.asObject(sceneValue.techniques);
-            if (undefined === meshes)
-                return undefined;
-            return new GltfReaderProps(buffer, binaryData, accessors, bufferViews, sceneValue, nodes, meshes, materialValues, extensions, samplers, techniques, yAxisUp);
+            const json = JSON.parse(jsonStr);
+            const asset = JsonUtils.asObject(json.asset);
+            if (header.version === 2 && !asset)
+                return undefined; // asset is required in glTF 2.0
+            const glTF = {
+                asset,
+                scene: JsonUtils.asString(json.scene),
+                extensions: JsonUtils.asObject(json.extensions),
+                extensionsUsed: JsonUtils.asArray(json.extensionsUsed),
+                extensionsRequired: JsonUtils.asArray(json.extensionsRequired),
+                accessors: JsonUtils.asObject(json.accessors),
+                buffers: JsonUtils.asObject(json.buffers),
+                bufferViews: JsonUtils.asObject(json.bufferViews),
+                images: JsonUtils.asObject(json.images),
+                materials: JsonUtils.asObject(json.materials),
+                meshes: JsonUtils.asObject(json.meshes),
+                nodes: JsonUtils.asObject(json.nodes),
+                samplers: JsonUtils.asObject(json.samplers),
+                scenes: JsonUtils.asObject(json.scenes),
+                textures: JsonUtils.asObject(json.textures),
+                techniques: JsonUtils.asObject(json.techniques),
+            };
+            return glTF.meshes ? new GltfReaderProps(buffer, binaryData, glTF, yAxisUp) : undefined;
         }
         catch (e) {
             return undefined;
@@ -85,57 +239,123 @@ export class GltfMeshData {
     }
   }
 -------------------------------------- */
+const emptyDict = {};
+function colorFromJson(values) {
+    return ColorDef.from(values[0] * 255, values[1] * 255, values[2] * 255, (1.0 - values[3]) * 255);
+}
+function colorFromMaterial(material) {
+    var _a, _b, _c, _d, _e;
+    if (material) {
+        if (isGltf1Material(material)) {
+            if (((_a = material.values) === null || _a === void 0 ? void 0 : _a.color) && Array.isArray(material.values.color))
+                return colorFromJson(material.values.color);
+        }
+        else if ((_d = (_c = (_b = material.extensions) === null || _b === void 0 ? void 0 : _b.KHR_techniques_webgl) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d.u_color) {
+            return colorFromJson(material.extensions.KHR_techniques_webgl.values.u_color);
+        }
+        else if ((_e = material.pbrMetallicRoughness) === null || _e === void 0 ? void 0 : _e.baseColorFactor) {
+            return colorFromJson(material.pbrMetallicRoughness.baseColorFactor);
+        }
+    }
+    return ColorDef.white;
+}
+class TransformStack {
+    constructor() {
+        this._stack = [];
+    }
+    get transform() {
+        return this._stack.length > 0 ? this._stack[this._stack.length - 1] : undefined;
+    }
+    get isEmpty() {
+        return 0 === this._stack.length;
+    }
+    push(node) {
+        let nodeTransform;
+        if (node.matrix) {
+            const origin = Point3d.create(node.matrix[12], node.matrix[13], node.matrix[14]);
+            const matrix = Matrix3d.createRowValues(node.matrix[0], node.matrix[4], node.matrix[8], node.matrix[1], node.matrix[5], node.matrix[9], node.matrix[2], node.matrix[6], node.matrix[10]);
+            nodeTransform = 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 = Transform.createRefs(undefined, node.scale ? Matrix3d.createScale(node.scale[0], node.scale[1], node.scale[2]) : Matrix3d.identity);
+            const rot = Transform.createRefs(undefined, node.rotation ? Matrix3d.createFromQuaternion(Point4d.create(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3])) : Matrix3d.identity);
+            rot.matrix.transposeInPlace(); // See comment on Matrix3d.createFromQuaternion
+            const trans = Transform.createTranslation(node.translation ? new Point3d(node.translation[0], node.translation[1], node.translation[2]) : Point3d.createZero());
+            nodeTransform = scale.multiplyTransformTransform(rot);
+            trans.multiplyTransformTransform(nodeTransform, nodeTransform);
+        }
+        const top = this.transform;
+        if (!top)
+            this._stack.push(nodeTransform);
+        else
+            this._stack.push(nodeTransform ? top.multiplyTransformTransform(nodeTransform) : top);
+    }
+    pop() {
+        assert(this._stack.length > 0);
+        this._stack.pop();
+    }
+}
 /** Deserializes [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
 export class GltfReader {
-    constructor(props, iModel, modelId, is3d, system, type = BatchType.Primary, isCanceled, deduplicateVertices = false) {
+    constructor(props, iModel, is3d, system, type = BatchType.Primary, isCanceled, deduplicateVertices = false) {
+        var _a, _b, _c;
         this._buffer = props.buffer;
-        this._scene = props.scene;
         this._binaryData = props.binaryData;
-        this._accessors = props.accessors;
-        this._bufferViews = props.bufferViews;
-        this._meshes = props.meshes;
-        this._nodes = props.nodes;
-        this._materialValues = props.materials;
-        this._samplers = props.samplers;
-        this._techniques = props.techniques;
-        this._extensions = props.extensions;
+        this._glTF = props.glTF;
         this._yAxisUp = props.yAxisUp;
-        this._returnToCenter = this.extractReturnToCenter(props.extensions);
-        this._textures = props.scene.textures;
-        this._images = props.scene.images;
-        this._renderMaterials = props.scene.renderMaterials;
-        this._namedTextures = props.scene.namedTextures;
+        const rtcCenter = (_b = (_a = props.glTF.extensions) === null || _a === void 0 ? void 0 : _a.CESIUM_RTC) === null || _b === void 0 ? void 0 : _b.center;
+        if (rtcCenter && 3 === rtcCenter.length)
+            if (0 !== rtcCenter[0] || 0 !== rtcCenter[1] || 0 !== rtcCenter[2])
+                this._returnToCenter = Point3d.fromJSON(rtcCenter);
         this._iModel = iModel;
-        this._modelId = modelId;
         this._is3d = is3d;
         this._system = system;
         this._type = type;
         this._canceled = isCanceled;
         this._deduplicateVertices = deduplicateVertices;
+        // The original implementation of GltfReader would process and produce graphics for every node in glTF.nodes.
+        // What it's *supposed* to do is process the nodes in glTF.scenes[glTF.scene].nodes
+        // Some nodes may not be referenced by the configured scene, or only indirectly via GltfNode.children.
+        // Perhaps some faulty tiles existed that didn't define their scenes properly?
+        let sceneNodes;
+        if (this._glTF.scenes && undefined !== this._glTF.scene)
+            sceneNodes = (_c = this._glTF.scenes[this._glTF.scene]) === null || _c === void 0 ? void 0 : _c.nodes;
+        if (!sceneNodes)
+            sceneNodes = Object.keys(this._nodes);
+        this._sceneNodes = sceneNodes;
     }
+    get _nodes() { var _a; return (_a = this._glTF.nodes) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _meshes() { var _a; return (_a = this._glTF.meshes) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _accessors() { var _a; return (_a = this._glTF.accessors) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _bufferViews() { var _a; return (_a = this._glTF.bufferViews) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _materialValues() { var _a; return (_a = this._glTF.materials) !== null && _a !== void 0 ? _a : emptyDict; }
     get _isCanceled() { return undefined !== this._canceled && this._canceled(this); }
     get _isVolumeClassifier() { return BatchType.VolumeClassifier === this._type; }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
         var _a;
         if (this._isCanceled)
             return { readStatus: TileReadStatus.Canceled, isLeaf };
-        if (this._returnToCenter !== undefined || ((_a = this._nodes[0]) === null || _a === void 0 ? void 0 : _a.matrix) !== undefined || (pseudoRtcBias !== undefined && pseudoRtcBias.magnitude() < 1.0E5))
+        // If contentRange was not supplied, we will compute it as we read the meshes.
+        if (!contentRange)
+            this._computedContentRange = contentRange = Range3d.createNull();
+        else
+            this._computedContentRange = undefined;
+        // ###TODO this looks like a hack? Why does it assume the first node's transform is special, or that the transform will be specified as a matrix instead of translation+rot+scale?
+        if (this._returnToCenter || ((_a = this._nodes[0]) === null || _a === void 0 ? void 0 : _a.matrix) || (pseudoRtcBias && pseudoRtcBias.magnitude() < 1.0E5))
             pseudoRtcBias = undefined;
-        const childNodes = new Set();
-        for (const key of Object.keys(this._nodes)) {
-            const node = this._nodes[key];
-            if (node.children)
-                for (const child of node.children)
-                    childNodes.add(child.toString());
-        }
+        const transformStack = new TransformStack();
         const renderGraphicList = [];
         let readStatus = TileReadStatus.InvalidTileData;
-        for (const nodeKey of Object.keys(this._nodes))
-            if (!childNodes.has(nodeKey))
-                if (TileReadStatus.Success !== (readStatus = this.readNodeAndCreateGraphics(renderGraphicList, this._nodes[nodeKey], featureTable, undefined, instances, pseudoRtcBias)))
-                    return { readStatus, isLeaf };
+        for (const nodeKey of this._sceneNodes) {
+            assert(transformStack.isEmpty);
+            const node = this._nodes[nodeKey];
+            if (node && TileReadStatus.Success !== (readStatus = this.readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, instances, pseudoRtcBias)))
+                return { readStatus, isLeaf };
+        }
         if (0 === renderGraphicList.length)
             return { readStatus: TileReadStatus.InvalidTileData, isLeaf };
         let renderGraphic;
@@ -145,20 +365,21 @@ export class GltfReader {
             renderGraphic = this._system.createGraphicList(renderGraphicList);
         let transform;
         let range = contentRange;
-        if (undefined !== this._returnToCenter || undefined !== pseudoRtcBias || this._yAxisUp || undefined !== transformToRoot) {
-            if (undefined !== this._returnToCenter)
-                transform = Transform.createTranslationXYZ(this._returnToCenter[0], this._returnToCenter[1], this._returnToCenter[2]);
-            else if (undefined !== pseudoRtcBias)
+        if (this._returnToCenter || pseudoRtcBias || this._yAxisUp || transformToRoot) {
+            if (this._returnToCenter)
+                transform = Transform.createTranslation(this._returnToCenter.clone());
+            else if (pseudoRtcBias)
                 transform = Transform.createTranslationXYZ(pseudoRtcBias.x, pseudoRtcBias.y, pseudoRtcBias.z);
             else
                 transform = Transform.createIdentity();
             if (this._yAxisUp)
                 transform = transform.multiplyTransformMatrix3d(Matrix3d.createRotationAroundVector(Vector3d.create(1.0, 0.0, 0.0), Angle.createRadians(Angle.piOver2Radians)));
-            if (undefined !== transformToRoot)
+            if (transformToRoot)
                 transform = transformToRoot.multiplyTransformTransform(transform);
             range = transform.inverse().multiplyRange(contentRange);
         }
-        renderGraphic = this._system.createBatch(renderGraphic, PackedFeatureTable.pack(featureTable), range);
+        if (featureTable)
+            renderGraphic = this._system.createBatch(renderGraphic, PackedFeatureTable.pack(featureTable), range);
         if (transform) {
             const branch = new GraphicBranch(true);
             branch.add(renderGraphic);
@@ -172,10 +393,8 @@ export class GltfReader {
         };
     }
     graphicFromMeshData(gltfMesh, meshGraphicArgs, instances) {
-        if (!gltfMesh.points || !gltfMesh.pointRange) {
-            assert(false);
+        if (!gltfMesh.points || !gltfMesh.pointRange)
             return;
-        }
         const realityMeshPrimitive = (forceLUT || instances) ? undefined : RealityMeshPrimitive.createFromGltfMesh(gltfMesh);
         if (realityMeshPrimitive) {
             const realityMesh = this._system.createRealityMesh(realityMeshPrimitive);
@@ -197,16 +416,12 @@ export class GltfReader {
                 mesh.normals.push(new OctEncodedNormal(normal));
         return mesh.getGraphics(meshGraphicArgs, this._system, instances);
     }
-    readNodeAndCreateGraphics(renderGraphicList, node, featureTable, parentTransform, instances, pseudoRtcBias) {
+    readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, instances, pseudoRtcBias) {
         if (undefined === node)
             return TileReadStatus.InvalidTileData;
-        let thisTransform = parentTransform;
-        let thisBias;
-        if (Array.isArray(node.matrix)) {
-            const jTrans = node.matrix;
-            const nodeTransform = Transform.createOriginAndMatrix(Point3d.create(jTrans[12], jTrans[13], jTrans[14]), Matrix3d.createRowValues(jTrans[0], jTrans[4], jTrans[8], jTrans[1], jTrans[5], jTrans[9], jTrans[2], jTrans[6], jTrans[10]));
-            thisTransform = thisTransform ? thisTransform.multiplyTransformTransform(nodeTransform) : nodeTransform;
-        }
+        // IMPORTANT: Do not return without popping this node from the stack.
+        transformStack.push(node);
+        const thisTransform = transformStack.transform;
         /**
          * This is a workaround for tiles generated by
          * context capture which have a large offset from the tileset origin that exceeds the
@@ -215,19 +430,24 @@ export class GltfReader {
          * as the vertices are supplied in a quantized format, applying the RTC bias to
          * quantization origin will make these tiles work correctly.
          */
-        if (undefined !== pseudoRtcBias) {
+        let thisBias;
+        if (undefined !== pseudoRtcBias)
             thisBias = (undefined === thisTransform) ? pseudoRtcBias : thisTransform.matrix.multiplyInverse(pseudoRtcBias);
-        }
-        const meshKey = node.meshes ? node.meshes : node.mesh;
-        if (undefined !== meshKey) {
+        for (const meshKey of getNodeMeshIds(node)) {
             const nodeMesh = this._meshes[meshKey];
-            if (nodeMesh) {
+            if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
                 const meshGraphicArgs = new MeshGraphicArgs();
                 const meshes = [];
                 for (const primitive of nodeMesh.primitives) {
                     const geometry = this.readMeshPrimitive(primitive, featureTable, thisBias);
-                    if (undefined !== geometry)
+                    if (geometry) {
                         meshes.push(geometry);
+                        if (this._computedContentRange && geometry.pointRange) {
+                            const invTransform = thisTransform === null || thisTransform === void 0 ? void 0 : thisTransform.inverse();
+                            const meshRange = invTransform ? invTransform.multiplyRange(geometry.pointRange) : geometry.pointRange;
+                            this._computedContentRange.extendRange(meshRange);
+                        }
+                    }
                 }
                 let renderGraphic;
                 if (0 !== meshes.length) {
@@ -256,11 +476,16 @@ export class GltfReader {
             }
         }
         if (node.children) {
-            for (const child of node.children)
-                this.readNodeAndCreateGraphics(renderGraphicList, this._nodes[child], featureTable, thisTransform, instances);
+            for (const childId of node.children) {
+                const child = this._nodes[childId];
+                if (child)
+                    this.readNodeAndCreateGraphics(renderGraphicList, child, featureTable, transformStack, instances);
+            }
         }
+        transformStack.pop();
         return TileReadStatus.Success;
     }
+    // ###TODO what is the actual type of `json`?
     getBufferView(json, accessorName) {
         try {
             const accessorValue = JsonUtils.asString(json[accessorName]);
@@ -315,21 +540,9 @@ export class GltfReader {
         return undefined !== view ? view.toBufferData(type) : undefined;
     }
     readFeatureIndices(_json) { return undefined; }
-    colorFromJson(values) { return ColorDef.from(values[0] * 255, values[1] * 255, values[2] * 255, (1.0 - values[3]) * 255); }
-    colorFromMaterial(materialJson) {
-        if (materialJson) {
-            if (materialJson.values && Array.isArray(materialJson.values.color))
-                return this.colorFromJson(materialJson.values.color);
-            else if (materialJson.pbrMetallicRoughness && Array.isArray(materialJson.pbrMetallicRoughness.baseColorFactor))
-                return this.colorFromJson(materialJson.pbrMetallicRoughness.baseColorFactor);
-            else if (materialJson.extensions && materialJson.extensions.KHR_techniques_webgl && materialJson.extensions.KHR_techniques_webgl.values && materialJson.extensions.KHR_techniques_webgl.values.u_color)
-                return this.colorFromJson(materialJson.extensions.KHR_techniques_webgl.values.u_color);
-        }
-        return ColorDef.white;
-    }
-    extractTextureId(materialJson) {
+    extractTextureId(material) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        if (typeof materialJson !== "object")
+        if (typeof material !== "object")
             return undefined;
         const extractId = (value) => {
             switch (typeof value) {
@@ -342,48 +555,36 @@ export class GltfReader {
             }
         };
         // Bimium's shader value...almost certainly obsolete at this point.
-        let id = extractId((_a = materialJson.values) === null || _a === void 0 ? void 0 : _a.tex);
-        if (undefined !== id)
-            return id;
+        if (isGltf1Material(material))
+            return (_a = material.diffuse) !== null && _a !== void 0 ? _a : extractId((_b = material.values) === null || _b === void 0 ? void 0 : _b.tex);
         // KHR_techniques_webgl extension
-        const techniques = (_c = (_b = this._extensions) === null || _b === void 0 ? void 0 : _b.KHR_techniques_webgl) === null || _c === void 0 ? void 0 : _c.techniques;
-        const ext = Array.isArray(techniques) ? (_d = materialJson.extensions) === null || _d === void 0 ? void 0 : _d.KHR_techniques_webgl : undefined;
-        if (undefined !== ext && typeof ext.values === "object") {
+        const techniques = (_d = (_c = this._glTF.extensions) === null || _c === void 0 ? void 0 : _c.KHR_techniques_webgl) === null || _d === void 0 ? void 0 : _d.techniques;
+        const ext = Array.isArray(techniques) ? (_e = material.extensions) === null || _e === void 0 ? void 0 : _e.KHR_techniques_webgl : undefined;
+        if (techniques && undefined !== ext && typeof (ext.values) === "object") {
             const uniforms = typeof ext.technique === "number" ? techniques[ext.technique].uniforms : undefined;
             if (typeof uniforms === "object") {
                 for (const uniformName of Object.keys(uniforms)) {
                     const uniform = uniforms[uniformName];
                     if (typeof uniform === "object" && uniform.type === GltfDataType.Sampler2d)
-                        return extractId((_e = ext.values[uniformName]) === null || _e === void 0 ? void 0 : _e.index);
+                        return extractId((_f = ext.values[uniformName]) === null || _f === void 0 ? void 0 : _f.index);
                 }
             }
         }
-        id = extractId((_f = materialJson.diffuseTexture) === null || _f === void 0 ? void 0 : _f.index);
-        id = id !== null && id !== void 0 ? id : extractId((_g = materialJson.emissiveTexture) === null || _g === void 0 ? void 0 : _g.index);
-        return id !== null && id !== void 0 ? id : extractId((_j = (_h = materialJson.pbrMetallicRoughness) === null || _h === void 0 ? void 0 : _h.baseColorTexture) === null || _j === void 0 ? void 0 : _j.index);
+        const id = extractId((_g = material.emissiveTexture) === null || _g === void 0 ? void 0 : _g.index);
+        return id !== null && id !== void 0 ? id : extractId((_j = (_h = material.pbrMetallicRoughness) === null || _h === void 0 ? void 0 : _h.baseColorTexture) === null || _j === void 0 ? void 0 : _j.index);
     }
     createDisplayParams(materialJson, hasBakedLighting) {
         const textureId = this.extractTextureId(materialJson);
         const textureMapping = undefined !== textureId ? this.findTextureMapping(textureId) : undefined;
-        const color = this.colorFromMaterial(materialJson);
+        const color = colorFromMaterial(materialJson);
         return new DisplayParams(DisplayParams.Type.Mesh, color, color, 1, LinePixels.Solid, FillFlags.Always, undefined, undefined, hasBakedLighting, textureMapping);
     }
-    extractReturnToCenter(extensions) {
-        if (extensions === undefined) {
-            return undefined;
-        }
-        const cesiumRtc = JsonUtils.asObject(extensions.CESIUM_RTC);
-        if (cesiumRtc === undefined)
-            return undefined;
-        const rtc = JsonUtils.asArray(cesiumRtc.center);
-        return (rtc[0] === 0.0 && rtc[1] === 0.0 && rtc[2] === 0.0) ? undefined : rtc;
-    }
     readMeshPrimitive(primitive, featureTable, pseudoRtcBias) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f;
         const materialName = JsonUtils.asString(primitive.material);
         const hasBakedLighting = undefined === primitive.attributes.NORMAL;
-        const materialValue = 0 < materialName.length ? JsonUtils.asObject(this._materialValues[materialName]) : undefined;
-        const displayParams = this.createDisplayParams(materialValue, hasBakedLighting);
+        const material = 0 < materialName.length ? this._materialValues[materialName] : undefined;
+        const displayParams = this.createDisplayParams(material, hasBakedLighting);
         if (undefined === displayParams)
             return undefined;
         let primitiveType = -1;
@@ -420,12 +621,12 @@ export class GltfReader {
         // uv parameters to pick the colors out of the color map texture.
         meshPrimitive.colorMap.insert(displayParams.fillColor.tbgr); // White...
         const colorIndices = this.readBufferData16(primitive.attributes, "_COLORINDEX");
-        if (undefined !== colorIndices) {
+        if (undefined !== colorIndices && material) {
             let texStep;
-            if (materialValue.values !== undefined && Array.isArray(materialValue.values.texStep))
-                texStep = materialValue.values.texStep;
-            else if (materialValue.extensions && materialValue.extensions.KHR_techniques_webgl && materialValue.extensions.KHR_techniques_webgl.values && Array.isArray(materialValue.extensions.KHR_techniques_webgl.values.u_texStep))
-                texStep = materialValue.extensions.KHR_techniques_webgl.values.u_texStep;
+            if (isGltf1Material(material))
+                texStep = (_a = material.values) === null || _a === void 0 ? void 0 : _a.texStep;
+            else
+                texStep = (_d = (_c = (_b = material.extensions) === null || _b === void 0 ? void 0 : _b.KHR_techniques_webgl) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d.u_texStep;
             if (texStep) {
                 const uvParams = [];
                 for (let i = 0; i < colorIndices.count; i++)
@@ -435,7 +636,7 @@ export class GltfReader {
                 mesh.uvQParams = paramList.params;
             }
         }
-        if ((_a = primitive.extensions) === null || _a === void 0 ? void 0 : _a.KHR_draco_mesh_compression) {
+        if ((_e = primitive.extensions) === null || _e === void 0 ? void 0 : _e.KHR_draco_mesh_compression) {
             return undefined; // Defer Draco decompression until web workers implementation.
             /*
             const dracoExtension = primitive.extensions.KHR_draco_mesh_compression;
@@ -473,7 +674,7 @@ export class GltfReader {
         }
         if (displayParams.textureMapping && !mesh.uvs)
             return undefined;
-        if ((_b = primitive.extensions) === null || _b === void 0 ? void 0 : _b.CESIUM_primitive_outline) {
+        if ((_f = primitive.extensions) === null || _f === void 0 ? void 0 : _f.CESIUM_primitive_outline) {
             const data = this.readBufferData32(primitive.extensions.CESIUM_primitive_outline, "indices");
             if (data !== undefined) {
                 assert(0 === data.count % 2);
@@ -717,25 +918,28 @@ export class GltfReader {
         return true;
     }
     async loadTextures() {
-        if (undefined === this._textures)
+        var _a, _b;
+        if (undefined === this._glTF.textures)
             return;
         const transparentTextures = new Set();
-        for (const name of Object.keys(this._materialValues)) {
-            const materialValue = this._materialValues[name];
-            let technique;
-            if (undefined !== materialValue.values &&
-                undefined !== materialValue.values.tex &&
-                undefined !== materialValue.technique &&
-                undefined !== (technique = this._techniques[materialValue.technique]) &&
-                undefined !== technique.states &&
-                Array.isArray(technique.states.enable)) {
-                for (const enable of technique.states.enable)
-                    if (enable === 3042)
-                        transparentTextures.add(materialValue.values.tex);
+        if (this._glTF.techniques) {
+            for (const name of Object.keys(this._materialValues)) {
+                const material = this._materialValues[name];
+                if (material && isGltf1Material(material) && undefined !== material.technique && undefined !== ((_a = material.values) === null || _a === void 0 ? void 0 : _a.tex)) {
+                    const technique = this._glTF.techniques[material.technique];
+                    if ((_b = technique === null || technique === void 0 ? void 0 : technique.states) === null || _b === void 0 ? void 0 : _b.enable) {
+                        for (const enable of technique.states.enable) {
+                            if (3042 === enable) { // 3042 = BLEND
+                                transparentTextures.add(material.values.tex.toString());
+                                break;
+                            }
+                        }
+                    }
+                }
             }
         }
         const promises = new Array();
-        for (const name of Object.keys(this._textures))
+        for (const name of Object.keys(this._glTF.textures))
             promises.push(this.loadTexture(name, transparentTextures.has(name)));
         if (promises.length > 0)
             await Promise.all(promises);
@@ -744,6 +948,8 @@ export class GltfReader {
         try {
             const binaryImageJson = (imageJson.extensions && imageJson.extensions.KHR_binary_glTF) ? JsonUtils.asObject(imageJson.extensions.KHR_binary_glTF) : imageJson;
             const bufferView = this._bufferViews[binaryImageJson.bufferView];
+            if (!(bufferView === null || bufferView === void 0 ? void 0 : bufferView.byteOffset) || !(bufferView === null || bufferView === void 0 ? void 0 : bufferView.byteLength))
+                return undefined;
             const mimeType = JsonUtils.asString(binaryImageJson.mimeType);
             const format = getImageSourceFormatForMimeType(mimeType);
             if (undefined === format)
@@ -787,16 +993,51 @@ export class GltfReader {
         }
     }
     async loadTexture(textureId, isTransparent) {
-        const textureJson = JsonUtils.asObject(this._textures[textureId]);
+        if (!this._glTF.textures || !this._glTF.images)
+            return;
+        const textureJson = JsonUtils.asObject(this._glTF.textures[textureId]);
         if (undefined === textureJson)
             return;
-        const texture = await this.loadTextureImage(this._images[textureJson.source], undefined === this._samplers ? undefined : this._samplers[textureJson.sampler], isTransparent);
+        const texture = await this.loadTextureImage(this._glTF.images[textureJson.source], this._glTF.samplers ? this._glTF.samplers[textureJson.sampler] : undefined, isTransparent);
         textureJson.renderTexture = texture;
     }
     findTextureMapping(textureId) {
-        const textureJson = JsonUtils.asObject(this._textures[textureId]);
+        const textureJson = this._glTF.textures ? JsonUtils.asObject(this._glTF.textures[textureId]) : undefined;
         const texture = undefined !== textureJson ? textureJson.renderTexture : undefined;
         return undefined !== texture ? new TextureMapping(texture, new TextureMapping.Params()) : undefined;
     }
 }
+/** Produce a [[RenderGraphic]] from a [glTF](https://www.khronos.org/gltf/) asset suitable for use in [view decorations]($docs/learning/frontend/ViewDecorations).
+ * @returns a graphic produced from the glTF asset's default scene, or `undefined` if a graphic could not be produced from the asset.
+ * @note Support for the full [glTF 2.0 specification](https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html) is currently a work in progress.
+ * If a particular glTF asset fails to load and/or display properly, please
+ * [submit an issue](https://github.com/iTwin/itwinjs-core/issues).
+ * @see [Example decorator]($docs/learning/frontend/ViewDecorations#gltf-decorations) for an example of a decorator that reads and displays a glTF asset.
+ * @public
+ */
+export async function readGltfGraphics(args) {
+    const stream = new ByteStream(args.gltf.buffer);
+    const props = GltfReaderProps.create(stream, true); // glTF supports exactly one coordinate system with y axis up.
+    const reader = props ? new Reader(props, args) : undefined;
+    if (!reader)
+        return undefined;
+    const result = await reader.read();
+    return result.graphic;
+}
+/** Implements [[readGltfGraphics]]. */
+class Reader extends GltfReader {
+    constructor(props, args) {
+        var _a, _b, _c;
+        super(props, args.iModel, false, IModelApp.renderSystem);
+        const pickableId = (_a = args.pickableOptions) === null || _a === void 0 ? void 0 : _a.id;
+        if (pickableId) {
+            this._featureTable = new FeatureTable(1, (_c = (_b = args.pickableOptions) === null || _b === void 0 ? void 0 : _b.modelId) !== null && _c !== void 0 ? _c : pickableId, BatchType.Primary);
+            this._featureTable.insert(new Feature(pickableId));
+        }
+    }
+    async read() {
+        await this.loadTextures();
+        return this.readGltfAndCreateGraphics(true, this._featureTable, undefined);
+    }
+}
 //# sourceMappingURL=GltfReader.js.map