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

package/lib/cjs/tile/GltfReader.js

@@ -7,11 +7,12 @@
  * @module Tiles
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GltfReader = exports.GltfMeshData = exports.GltfReaderProps = void 0;
+exports.readGltfGraphics = exports.GltfReader = exports.GltfMeshData = exports.GltfReaderProps = exports.GltfBufferData = exports.GltfDataType = 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");
 const ImageUtil_1 = require("../ImageUtil");
+const IModelApp_1 = require("../IModelApp");
 const GraphicBranch_1 = require("../render/GraphicBranch");
 const DisplayParams_1 = require("../render/primitives/DisplayParams");
 const MeshPrimitives_1 = require("../render/primitives/mesh/MeshPrimitives");
@@ -19,22 +20,165 @@ const RealityMeshPrimitive_1 = require("../render/primitives/mesh/RealityMeshPri
 const RenderTexture_1 = require("../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
+ */
+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 = exports.GltfDataType || (exports.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
+ */
+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;
+        }
+    }
+}
+exports.GltfBufferData = GltfBufferData;
+/**
+ * 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
  */
 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. */
@@ -44,23 +188,34 @@ class GltfReaderProps {
             return undefined;
         const binaryData = new Uint8Array(buffer.arrayBuffer, header.binaryPosition);
         buffer.curPos = header.scenePosition;
-        const sceneStrData = buffer.nextBytes(header.sceneStrLength);
-        const sceneStr = (0, core_bentley_1.utf8ToString)(sceneStrData);
-        if (undefined === sceneStr)
+        const jsonStrData = buffer.nextBytes(header.sceneStrLength);
+        const jsonStr = (0, core_bentley_1.utf8ToString)(jsonStrData);
+        if (undefined === jsonStr)
             return undefined;
         try {
-            const sceneValue = JSON.parse(sceneStr);
-            const nodes = core_bentley_1.JsonUtils.asObject(sceneValue.nodes);
-            const meshes = core_bentley_1.JsonUtils.asObject(sceneValue.meshes);
-            const materialValues = core_bentley_1.JsonUtils.asObject(sceneValue.materials);
-            const accessors = core_bentley_1.JsonUtils.asObject(sceneValue.accessors);
-            const bufferViews = core_bentley_1.JsonUtils.asObject(sceneValue.bufferViews);
-            const extensions = core_bentley_1.JsonUtils.asObject(sceneValue.extensions);
-            const samplers = core_bentley_1.JsonUtils.asObject(sceneValue.samplers);
-            const techniques = core_bentley_1.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 = core_bentley_1.JsonUtils.asObject(json.asset);
+            if (header.version === 2 && !asset)
+                return undefined; // asset is required in glTF 2.0
+            const glTF = {
+                asset,
+                scene: core_bentley_1.JsonUtils.asString(json.scene),
+                extensions: core_bentley_1.JsonUtils.asObject(json.extensions),
+                extensionsUsed: core_bentley_1.JsonUtils.asArray(json.extensionsUsed),
+                extensionsRequired: core_bentley_1.JsonUtils.asArray(json.extensionsRequired),
+                accessors: core_bentley_1.JsonUtils.asObject(json.accessors),
+                buffers: core_bentley_1.JsonUtils.asObject(json.buffers),
+                bufferViews: core_bentley_1.JsonUtils.asObject(json.bufferViews),
+                images: core_bentley_1.JsonUtils.asObject(json.images),
+                materials: core_bentley_1.JsonUtils.asObject(json.materials),
+                meshes: core_bentley_1.JsonUtils.asObject(json.meshes),
+                nodes: core_bentley_1.JsonUtils.asObject(json.nodes),
+                samplers: core_bentley_1.JsonUtils.asObject(json.samplers),
+                scenes: core_bentley_1.JsonUtils.asObject(json.scenes),
+                textures: core_bentley_1.JsonUtils.asObject(json.textures),
+                techniques: core_bentley_1.JsonUtils.asObject(json.techniques),
+            };
+            return glTF.meshes ? new GltfReaderProps(buffer, binaryData, glTF, yAxisUp) : undefined;
         }
         catch (e) {
             return undefined;
@@ -90,57 +245,123 @@ exports.GltfMeshData = GltfMeshData;
     }
   }
 -------------------------------------- */
+const emptyDict = {};
+function colorFromJson(values) {
+    return core_common_1.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 core_common_1.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 = core_geometry_1.Point3d.create(node.matrix[12], node.matrix[13], node.matrix[14]);
+            const matrix = core_geometry_1.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 = core_geometry_1.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 = core_geometry_1.Transform.createRefs(undefined, node.scale ? core_geometry_1.Matrix3d.createScale(node.scale[0], node.scale[1], node.scale[2]) : core_geometry_1.Matrix3d.identity);
+            const rot = core_geometry_1.Transform.createRefs(undefined, node.rotation ? core_geometry_1.Matrix3d.createFromQuaternion(core_geometry_1.Point4d.create(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3])) : core_geometry_1.Matrix3d.identity);
+            rot.matrix.transposeInPlace(); // See comment on Matrix3d.createFromQuaternion
+            const trans = core_geometry_1.Transform.createTranslation(node.translation ? new core_geometry_1.Point3d(node.translation[0], node.translation[1], node.translation[2]) : core_geometry_1.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() {
+        (0, core_bentley_1.assert)(this._stack.length > 0);
+        this._stack.pop();
+    }
+}
 /** Deserializes [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
 class GltfReader {
-    constructor(props, iModel, modelId, is3d, system, type = core_common_1.BatchType.Primary, isCanceled, deduplicateVertices = false) {
+    constructor(props, iModel, is3d, system, type = core_common_1.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 = core_geometry_1.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 core_common_1.BatchType.VolumeClassifier === this._type; }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
         var _a;
         if (this._isCanceled)
             return { readStatus: core_common_1.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 = core_geometry_1.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 = core_common_1.TileReadStatus.InvalidTileData;
-        for (const nodeKey of Object.keys(this._nodes))
-            if (!childNodes.has(nodeKey))
-                if (core_common_1.TileReadStatus.Success !== (readStatus = this.readNodeAndCreateGraphics(renderGraphicList, this._nodes[nodeKey], featureTable, undefined, instances, pseudoRtcBias)))
-                    return { readStatus, isLeaf };
+        for (const nodeKey of this._sceneNodes) {
+            (0, core_bentley_1.assert)(transformStack.isEmpty);
+            const node = this._nodes[nodeKey];
+            if (node && core_common_1.TileReadStatus.Success !== (readStatus = this.readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, instances, pseudoRtcBias)))
+                return { readStatus, isLeaf };
+        }
         if (0 === renderGraphicList.length)
             return { readStatus: core_common_1.TileReadStatus.InvalidTileData, isLeaf };
         let renderGraphic;
@@ -150,20 +371,21 @@ 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 = core_geometry_1.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 = core_geometry_1.Transform.createTranslation(this._returnToCenter.clone());
+            else if (pseudoRtcBias)
                 transform = core_geometry_1.Transform.createTranslationXYZ(pseudoRtcBias.x, pseudoRtcBias.y, pseudoRtcBias.z);
             else
                 transform = core_geometry_1.Transform.createIdentity();
             if (this._yAxisUp)
                 transform = transform.multiplyTransformMatrix3d(core_geometry_1.Matrix3d.createRotationAroundVector(core_geometry_1.Vector3d.create(1.0, 0.0, 0.0), core_geometry_1.Angle.createRadians(core_geometry_1.Angle.piOver2Radians)));
-            if (undefined !== transformToRoot)
+            if (transformToRoot)
                 transform = transformToRoot.multiplyTransformTransform(transform);
             range = transform.inverse().multiplyRange(contentRange);
         }
-        renderGraphic = this._system.createBatch(renderGraphic, core_common_1.PackedFeatureTable.pack(featureTable), range);
+        if (featureTable)
+            renderGraphic = this._system.createBatch(renderGraphic, core_common_1.PackedFeatureTable.pack(featureTable), range);
         if (transform) {
             const branch = new GraphicBranch_1.GraphicBranch(true);
             branch.add(renderGraphic);
@@ -177,10 +399,8 @@ class GltfReader {
         };
     }
     graphicFromMeshData(gltfMesh, meshGraphicArgs, instances) {
-        if (!gltfMesh.points || !gltfMesh.pointRange) {
-            (0, core_bentley_1.assert)(false);
+        if (!gltfMesh.points || !gltfMesh.pointRange)
             return;
-        }
         const realityMeshPrimitive = (forceLUT || instances) ? undefined : RealityMeshPrimitive_1.RealityMeshPrimitive.createFromGltfMesh(gltfMesh);
         if (realityMeshPrimitive) {
             const realityMesh = this._system.createRealityMesh(realityMeshPrimitive);
@@ -202,16 +422,12 @@ class GltfReader {
                 mesh.normals.push(new core_common_1.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 core_common_1.TileReadStatus.InvalidTileData;
-        let thisTransform = parentTransform;
-        let thisBias;
-        if (Array.isArray(node.matrix)) {
-            const jTrans = node.matrix;
-            const nodeTransform = core_geometry_1.Transform.createOriginAndMatrix(core_geometry_1.Point3d.create(jTrans[12], jTrans[13], jTrans[14]), core_geometry_1.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
@@ -220,19 +436,24 @@ 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 MeshPrimitives_1.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) {
@@ -261,11 +482,16 @@ 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 core_common_1.TileReadStatus.Success;
     }
+    // ###TODO what is the actual type of `json`?
     getBufferView(json, accessorName) {
         try {
             const accessorValue = core_bentley_1.JsonUtils.asString(json[accessorName]);
@@ -277,14 +503,14 @@ class GltfReader {
             const type = accessor.componentType;
             let dataSize = 0;
             switch (type) {
-                case core_common_1.GltfDataType.UnsignedByte:
+                case GltfDataType.UnsignedByte:
                     dataSize = 1;
                     break;
-                case core_common_1.GltfDataType.UnsignedShort:
+                case GltfDataType.UnsignedShort:
                     dataSize = 2;
                     break;
-                case core_common_1.GltfDataType.UInt32:
-                case core_common_1.GltfDataType.Float:
+                case GltfDataType.UInt32:
+                case GltfDataType.Float:
                     dataSize = 4;
                     break;
                 default:
@@ -305,36 +531,24 @@ class GltfReader {
             // If the data is misaligned (Scalable mesh tile publisher) use slice to copy -- else use subarray.
             // assert(0 === offset % dataSize);
             const bytes = (0 === (this._binaryData.byteOffset + offset) % dataSize) ? this._binaryData.subarray(offset, offset + length) : this._binaryData.slice(offset, offset + length);
-            return new core_common_1.GltfBufferView(bytes, accessor.count, type, accessor, byteStride / dataSize);
+            return new GltfBufferView(bytes, accessor.count, type, accessor, byteStride / dataSize);
         }
         catch (e) {
             return undefined;
         }
     }
-    readBufferData32(json, accessorName) { return this.readBufferData(json, accessorName, core_common_1.GltfDataType.UInt32); }
-    readBufferData16(json, accessorName) { return this.readBufferData(json, accessorName, core_common_1.GltfDataType.UnsignedShort); }
-    readBufferData8(json, accessorName) { return this.readBufferData(json, accessorName, core_common_1.GltfDataType.UnsignedByte); }
-    readBufferDataFloat(json, accessorName) { return this.readBufferData(json, accessorName, core_common_1.GltfDataType.Float); }
+    readBufferData32(json, accessorName) { return this.readBufferData(json, accessorName, GltfDataType.UInt32); }
+    readBufferData16(json, accessorName) { return this.readBufferData(json, accessorName, GltfDataType.UnsignedShort); }
+    readBufferData8(json, accessorName) { return this.readBufferData(json, accessorName, GltfDataType.UnsignedByte); }
+    readBufferDataFloat(json, accessorName) { return this.readBufferData(json, accessorName, GltfDataType.Float); }
     readBufferData(json, accessorName, type) {
         const view = this.getBufferView(json, accessorName);
         return undefined !== view ? view.toBufferData(type) : undefined;
     }
     readFeatureIndices(_json) { return undefined; }
-    colorFromJson(values) { return core_common_1.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 core_common_1.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) {
@@ -347,60 +561,48 @@ 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 === core_common_1.GltfDataType.Sampler2d)
-                        return extractId((_e = ext.values[uniformName]) === null || _e === void 0 ? void 0 : _e.index);
+                    if (typeof uniform === "object" && uniform.type === GltfDataType.Sampler2d)
+                        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_1.DisplayParams(DisplayParams_1.DisplayParams.Type.Mesh, color, color, 1, core_common_1.LinePixels.Solid, core_common_1.FillFlags.Always, undefined, undefined, hasBakedLighting, textureMapping);
     }
-    extractReturnToCenter(extensions) {
-        if (extensions === undefined) {
-            return undefined;
-        }
-        const cesiumRtc = core_bentley_1.JsonUtils.asObject(extensions.CESIUM_RTC);
-        if (cesiumRtc === undefined)
-            return undefined;
-        const rtc = core_bentley_1.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 = core_bentley_1.JsonUtils.asString(primitive.material);
         const hasBakedLighting = undefined === primitive.attributes.NORMAL;
-        const materialValue = 0 < materialName.length ? core_bentley_1.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;
-        const meshMode = core_bentley_1.JsonUtils.asInt(primitive.mode, core_common_1.GltfMeshMode.Triangles);
+        const meshMode = core_bentley_1.JsonUtils.asInt(primitive.mode, GltfMeshMode.Triangles);
         switch (meshMode) {
-            case core_common_1.GltfMeshMode.Lines:
+            case GltfMeshMode.Lines:
                 primitiveType = MeshPrimitives_1.Mesh.PrimitiveType.Polyline;
                 break;
-            case core_common_1.GltfMeshMode.Points:
+            case GltfMeshMode.Points:
                 primitiveType = MeshPrimitives_1.Mesh.PrimitiveType.Point;
                 break;
-            case core_common_1.GltfMeshMode.Triangles:
+            case GltfMeshMode.Triangles:
                 primitiveType = MeshPrimitives_1.Mesh.PrimitiveType.Mesh;
                 break;
             default:
@@ -425,12 +627,12 @@ 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++)
@@ -440,7 +642,7 @@ 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;
@@ -478,7 +680,7 @@ 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) {
                 (0, core_bentley_1.assert)(0 === data.count % 2);
@@ -530,8 +732,8 @@ class GltfReader {
         const view = this.getBufferView(primitive.attributes, "POSITION");
         if (undefined === view)
             return false;
-        if (core_common_1.GltfDataType.Float === view.type) {
-            const buffer = view.toBufferData(core_common_1.GltfDataType.Float);
+        if (GltfDataType.Float === view.type) {
+            const buffer = view.toBufferData(GltfDataType.Float);
             if (undefined === buffer)
                 return false;
             const strideSkip = view.stride - 3;
@@ -550,7 +752,7 @@ class GltfReader {
             mesh.points = positions.toTypedArray();
         }
         else {
-            if (core_common_1.GltfDataType.UnsignedShort !== view.type)
+            if (GltfDataType.UnsignedShort !== view.type)
                 return false;
             const extensions = core_bentley_1.JsonUtils.asObject(view.accessor.extensions);
             const quantized = undefined !== extensions ? core_bentley_1.JsonUtils.asObject(extensions.WEB3D_quantized_attributes) : undefined;
@@ -560,7 +762,7 @@ class GltfReader {
             const rangeMax = core_bentley_1.JsonUtils.asArray(quantized.decodedMax);
             if (undefined === rangeMin || undefined === rangeMax)
                 return false;
-            const buffer = view.toBufferData(core_common_1.GltfDataType.UnsignedShort);
+            const buffer = view.toBufferData(GltfDataType.UnsignedShort);
             if (undefined === buffer || !(buffer.buffer instanceof Uint16Array))
                 return false;
             (0, core_bentley_1.assert)(buffer.buffer instanceof Uint16Array);
@@ -608,8 +810,8 @@ class GltfReader {
         if (undefined === view)
             return false;
         switch (view.type) {
-            case core_common_1.GltfDataType.Float: {
-                const data = view.toBufferData(core_common_1.GltfDataType.Float);
+            case GltfDataType.Float: {
+                const data = view.toBufferData(GltfDataType.Float);
                 if (undefined === data)
                     return false;
                 mesh.normals = new Uint16Array(data.count);
@@ -621,8 +823,8 @@ class GltfReader {
                 }
                 return true;
             }
-            case core_common_1.GltfDataType.UnsignedByte: {
-                const data = view.toBufferData(core_common_1.GltfDataType.UnsignedByte);
+            case GltfDataType.UnsignedByte: {
+                const data = view.toBufferData(GltfDataType.UnsignedByte);
                 if (undefined === data)
                     return false;
                 // ###TODO: we shouldn't have to allocate OctEncodedNormal objects...just use uint16s / numbers...
@@ -645,7 +847,7 @@ class GltfReader {
         if (view === undefined)
             return false;
         switch (view.type) {
-            case core_common_1.GltfDataType.Float: {
+            case GltfDataType.Float: {
                 data = this.readBufferDataFloat(json, accessorName);
                 mesh.uvRange = core_geometry_1.Range2d.createNull();
                 for (let i = 0; i < data.count; i++) {
@@ -661,7 +863,7 @@ class GltfReader {
                 }
                 return true;
             }
-            case core_common_1.GltfDataType.UnsignedShort: {
+            case GltfDataType.UnsignedShort: {
                 const extensions = core_bentley_1.JsonUtils.asObject(view.accessor.extensions);
                 const quantized = undefined !== extensions ? core_bentley_1.JsonUtils.asObject(extensions.WEB3D_quantized_attributes) : undefined;
                 if (undefined === quantized)
@@ -670,7 +872,7 @@ class GltfReader {
                 const rangeMax = core_bentley_1.JsonUtils.asArray(quantized.decodedMax);
                 if (undefined === rangeMin || undefined === rangeMax)
                     return false;
-                const qData = view.toBufferData(core_common_1.GltfDataType.UnsignedShort);
+                const qData = view.toBufferData(GltfDataType.UnsignedShort);
                 if (undefined === qData || !(qData.buffer instanceof Uint16Array))
                     return false;
                 mesh.uvRange = core_geometry_1.Range2d.createXYXY(rangeMin[0], rangeMin[1], rangeMax[0], rangeMax[1]);
@@ -722,25 +924,28 @@ 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);
@@ -749,6 +954,8 @@ class GltfReader {
         try {
             const binaryImageJson = (imageJson.extensions && imageJson.extensions.KHR_binary_glTF) ? core_bentley_1.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 = core_bentley_1.JsonUtils.asString(binaryImageJson.mimeType);
             const format = (0, ImageUtil_1.getImageSourceFormatForMimeType)(mimeType);
             if (undefined === format)
@@ -792,17 +999,53 @@ class GltfReader {
         }
     }
     async loadTexture(textureId, isTransparent) {
-        const textureJson = core_bentley_1.JsonUtils.asObject(this._textures[textureId]);
+        if (!this._glTF.textures || !this._glTF.images)
+            return;
+        const textureJson = core_bentley_1.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 = core_bentley_1.JsonUtils.asObject(this._textures[textureId]);
+        const textureJson = this._glTF.textures ? core_bentley_1.JsonUtils.asObject(this._glTF.textures[textureId]) : undefined;
         const texture = undefined !== textureJson ? textureJson.renderTexture : undefined;
         return undefined !== texture ? new core_common_1.TextureMapping(texture, new core_common_1.TextureMapping.Params()) : undefined;
     }
 }
 exports.GltfReader = GltfReader;
+/** 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
+ */
+async function readGltfGraphics(args) {
+    const stream = new core_bentley_1.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;
+}
+exports.readGltfGraphics = readGltfGraphics;
+/** Implements [[readGltfGraphics]]. */
+class Reader extends GltfReader {
+    constructor(props, args) {
+        var _a, _b, _c;
+        super(props, args.iModel, false, IModelApp_1.IModelApp.renderSystem);
+        const pickableId = (_a = args.pickableOptions) === null || _a === void 0 ? void 0 : _a.id;
+        if (pickableId) {
+            this._featureTable = new core_common_1.FeatureTable(1, (_c = (_b = args.pickableOptions) === null || _b === void 0 ? void 0 : _b.modelId) !== null && _c !== void 0 ? _c : pickableId, core_common_1.BatchType.Primary);
+            this._featureTable.insert(new core_common_1.Feature(pickableId));
+        }
+    }
+    async read() {
+        await this.loadTextures();
+        return this.readGltfAndCreateGraphics(true, this._featureTable, undefined);
+    }
+}
 //# sourceMappingURL=GltfReader.js.map