@itwin/core-frontend 3.0.0-dev.167 → 3.0.0-dev.172

package/lib/esm/tile/GltfReader.js

@@ -7,8 +7,8 @@
  */
 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 { BatchType, ColorDef, Feature, FeatureTable, FillFlags, GlbHeader, ImageSource, LinePixels, MeshEdge, MeshEdges, MeshPolyline, OctEncodedNormal, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderTexture, TextureMapping, TileFormat, TileReadStatus, } from "@itwin/core-common";
+import { getImageSourceFormatForMimeType, imageElementFromImageSource, tryImageElementFromUrl } from "../ImageUtil";
 import { IModelApp } from "../IModelApp";
 import { GraphicBranch } from "../render/GraphicBranch";
 import { DisplayParams } from "../render/primitives/DisplayParams";
@@ -79,6 +79,19 @@ var GltfBufferTarget;
     GltfBufferTarget[GltfBufferTarget["ArrayBuffer"] = 34962] = "ArrayBuffer";
     GltfBufferTarget[GltfBufferTarget["ElementArrayBuffer"] = 24963] = "ElementArrayBuffer";
 })(GltfBufferTarget || (GltfBufferTarget = {}));
+function* dictionaryIterator(dict) {
+    if (Array.isArray(dict)) {
+        for (const elem of dict)
+            yield elem;
+    }
+    else {
+        for (const key of Object.keys(dict)) {
+            const value = dict[key];
+            if (undefined !== value)
+                yield value;
+        }
+    }
+}
 function getNodeMeshIds(node) {
     if (undefined !== node.meshes)
         return typeof node.meshes === "string" ? [node.meshes] : node.meshes;
@@ -169,50 +182,80 @@ class GltfBufferView {
  * @internal
  */
 export class GltfReaderProps {
-    constructor(binaryData, glTF, yAxisUp) {
-        this.binaryData = binaryData;
+    constructor(glTF, version, yAxisUp, binaryData, baseUrl) {
+        this.version = version;
         this.glTF = glTF;
+        this.binaryData = binaryData;
         this.yAxisUp = yAxisUp;
+        this.baseUrl = baseUrl;
     }
     /** Attempt to construct a new GltfReaderProps from the binary data beginning at the supplied stream's current read position. */
-    static create(buffer, yAxisUp = false) {
-        const header = new GltfHeader(buffer);
-        if (!header.isValid)
-            return undefined;
-        const binaryData = new Uint8Array(buffer.arrayBuffer, header.binaryPosition);
-        buffer.curPos = header.scenePosition;
-        const jsonStrData = buffer.nextBytes(header.sceneStrLength);
-        const jsonStr = utf8ToString(jsonStrData);
-        if (undefined === jsonStr)
-            return undefined;
-        try {
-            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(binaryData, glTF, yAxisUp) : undefined;
+    static create(source, yAxisUp = false, baseUrl) {
+        let version;
+        let json;
+        let binaryData;
+        if (source instanceof Uint8Array) {
+            // It may be JSON - check for magic indicating glb.
+            const buffer = ByteStream.fromUint8Array(source);
+            if (TileFormat.Gltf !== buffer.nextUint32) {
+                try {
+                    const utf8Json = utf8ToString(source);
+                    if (!utf8Json)
+                        return undefined;
+                    json = JSON.parse(utf8Json);
+                    version = 2;
+                }
+                catch (_) {
+                    return undefined;
+                }
+            }
+            else {
+                buffer.reset();
+                const header = new GlbHeader(buffer);
+                if (!header.isValid)
+                    return undefined;
+                version = header.version;
+                if (header.binaryChunk)
+                    binaryData = new Uint8Array(source.buffer, source.byteOffset + header.binaryChunk.offset, header.binaryChunk.length);
+                try {
+                    const jsonBytes = new Uint8Array(source.buffer, source.byteOffset + header.jsonChunk.offset, header.jsonChunk.length);
+                    const jsonStr = utf8ToString(jsonBytes);
+                    if (undefined === jsonStr)
+                        return undefined;
+                    json = JSON.parse(jsonStr);
+                }
+                catch (_) {
+                    return undefined;
+                }
+            }
         }
-        catch (e) {
-            return undefined;
+        else {
+            version = 2; // ###TODO verify against source.asset?.version
+            json = source;
         }
+        // asset is required in glTF 2, optional in glTF 1
+        const asset = JsonUtils.asObject(json.asset);
+        if (version === 2 && !asset)
+            return undefined;
+        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(glTF, version, yAxisUp, binaryData, baseUrl) : undefined;
     }
 }
 /** The GltfMeshData contains the raw GLTF mesh data. If the data is suitable to create a [[RealityMesh]] directly, basically in the quantized format produced by
@@ -294,15 +337,30 @@ class TransformStack {
         this._stack.pop();
     }
 }
+function* traverseNodes(ids, nodes, traversed) {
+    for (const id of ids) {
+        if (traversed.has(id))
+            throw new Error("Cycle detected while traversing glTF nodes");
+        const node = nodes[id];
+        if (!node)
+            continue;
+        traversed.add(id);
+        yield node;
+        if (node.children)
+            for (const child of traverseNodes(node.children, nodes, traversed))
+                yield child;
+    }
+}
 /** Deserializes [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
 export class GltfReader {
     constructor(args) {
         var _a, _b, _c, _d, _e, _f, _g;
-        this._binaryData = args.props.binaryData;
         this._glTF = args.props.glTF;
+        this._version = args.props.version;
         this._yAxisUp = args.props.yAxisUp;
+        this._baseUrl = args.props.baseUrl;
         const rtcCenter = (_b = (_a = args.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])
@@ -314,6 +372,12 @@ export class GltfReader {
         this._canceled = args.shouldAbort;
         this._deduplicateVertices = (_e = args.deduplicateVertices) !== null && _e !== void 0 ? _e : false;
         this._vertexTableRequired = (_f = args.vertexTableRequired) !== null && _f !== void 0 ? _f : false;
+        const binaryData = args.props.binaryData;
+        if (binaryData) {
+            const buffer = this._buffers[this._version === 2 ? 0 : "binary_glTF"];
+            if (buffer && undefined === buffer.uri)
+                buffer.resolvedBuffer = binaryData;
+        }
         // 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.
@@ -329,9 +393,26 @@ export class GltfReader {
     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 _materials() { var _a; return (_a = this._glTF.materials) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _samplers() { var _a; return (_a = this._glTF.samplers) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _textures() { var _a; return (_a = this._glTF.textures) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _images() { var _a; return (_a = this._glTF.images) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _buffers() { var _a; return (_a = this._glTF.buffers) !== null && _a !== void 0 ? _a : emptyDict; }
     get _isCanceled() { return undefined !== this._canceled && this._canceled(this); }
     get _isVolumeClassifier() { return BatchType.VolumeClassifier === this._type; }
+    /** Traverse the nodes specified by their Ids, recursing into their child nodes.
+     * @param nodeIds The Ids of the nodes to traverse.
+     * @throws Error if a node appears more than once during traversal
+     */
+    traverseNodes(nodeIds) {
+        return traverseNodes(nodeIds, this._nodes, new Set());
+    }
+    /** Traverse the nodes specified by their scene, recursing into their child nodes.
+     * @throws Error if a node appears more than once during traversal
+     */
+    traverseScene() {
+        return this.traverseNodes(this._sceneNodes);
+    }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
         var _a;
         if (this._isCanceled)
@@ -486,10 +567,16 @@ export class GltfReader {
     getBufferView(json, accessorName) {
         try {
             const accessorValue = JsonUtils.asString(json[accessorName]);
-            const accessor = 0 < accessorValue.length ? JsonUtils.asObject(this._accessors[accessorValue]) : undefined;
-            const bufferViewAccessorValue = undefined !== accessor ? JsonUtils.asString(accessor.bufferView) : "";
-            const bufferView = 0 < bufferViewAccessorValue.length ? JsonUtils.asObject(this._bufferViews[bufferViewAccessorValue]) : undefined;
-            if (undefined === accessor)
+            const accessor = accessorValue ? this._accessors[accessorValue] : undefined;
+            if (!accessor)
+                return undefined;
+            const bufferViewAccessorValue = accessor.bufferView;
+            const bufferView = undefined !== bufferViewAccessorValue ? this._bufferViews[bufferViewAccessorValue] : undefined;
+            if (!bufferView || undefined === bufferView.buffer)
+                return undefined;
+            const buffer = this._buffers[bufferView.buffer];
+            const bufferData = buffer === null || buffer === void 0 ? void 0 : buffer.resolvedBuffer;
+            if (!bufferData)
                 return undefined;
             const type = accessor.componentType;
             let dataSize = 0;
@@ -520,8 +607,8 @@ export class GltfReader {
             const offset = ((bufferView && bufferView.byteOffset) ? bufferView.byteOffset : 0) + (accessor.byteOffset ? accessor.byteOffset : 0);
             const length = byteStride * accessor.count;
             // 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);
+            const aligned = 0 === (bufferData.byteOffset + offset) % dataSize;
+            const bytes = aligned ? bufferData.subarray(offset, offset + length) : bufferData.slice(offset, offset + length);
             return new GltfBufferView(bytes, accessor.count, type, accessor, byteStride / dataSize);
         }
         catch (e) {
@@ -580,8 +667,8 @@ export class GltfReader {
         var _a, _b, _c, _d, _e, _f;
         const materialName = JsonUtils.asString(primitive.material);
         const hasBakedLighting = undefined === primitive.attributes.NORMAL;
-        const material = 0 < materialName.length ? this._materialValues[materialName] : undefined;
-        const displayParams = this.createDisplayParams(material, hasBakedLighting);
+        const material = 0 < materialName.length ? this._materials[materialName] : undefined;
+        const displayParams = material ? this.createDisplayParams(material, hasBakedLighting) : undefined;
         if (undefined === displayParams)
             return undefined;
         let primitiveType = -1;
@@ -600,7 +687,6 @@ export class GltfReader {
                 assert(false);
                 return undefined;
         }
-        const isPlanar = JsonUtils.asBool(primitive.isPlanar);
         const isVolumeClassifier = this._isVolumeClassifier;
         const meshPrimitive = Mesh.create({
             displayParams,
@@ -608,7 +694,7 @@ export class GltfReader {
             type: primitiveType,
             range: Range3d.createNull(),
             is2d: !this._is3d,
-            isPlanar,
+            isPlanar: false,
             hasBakedLighting,
             isVolumeClassifier,
         });
@@ -834,12 +920,13 @@ export class GltfReader {
     }
     readUVParams(mesh, json, accessorName) {
         const view = this.getBufferView(json, accessorName);
-        let data;
         if (view === undefined)
             return false;
         switch (view.type) {
             case GltfDataType.Float: {
-                data = this.readBufferDataFloat(json, accessorName);
+                const data = this.readBufferDataFloat(json, accessorName);
+                if (!data)
+                    return false;
                 mesh.uvRange = Range2d.createNull();
                 for (let i = 0; i < data.count; i++) {
                     const index = view.stride * i; // 2 float per param...
@@ -914,14 +1001,91 @@ export class GltfReader {
             polylines.push(new MeshPolyline(indices));
         return true;
     }
-    async loadTextures() {
+    async resolveResources() {
+        // ###TODO traverse the scene nodes to find resources referenced by them, instead of resolving everything - some resources may not
+        // be required for the scene.
+        const promises = [];
+        try {
+            for (const buffer of dictionaryIterator(this._buffers))
+                if (!buffer.resolvedBuffer)
+                    promises.push(this.resolveBuffer(buffer));
+            await Promise.all(promises);
+            if (this._isCanceled)
+                return;
+            promises.length = 0;
+            for (const image of dictionaryIterator(this._images))
+                if (!image.resolvedImage)
+                    promises.push(this.resolveImage(image));
+            await Promise.all(promises);
+            if (this._isCanceled)
+                return;
+            this.resolveTextures();
+        }
+        catch (_) {
+        }
+    }
+    resolveUrl(uri) {
+        try {
+            return new URL(uri, this._baseUrl).toString();
+        }
+        catch (_) {
+            return undefined;
+        }
+    }
+    async resolveBuffer(buffer) {
+        if (buffer.resolvedBuffer || undefined === buffer.uri)
+            return;
+        try {
+            const url = this.resolveUrl(buffer.uri);
+            const response = url ? await fetch(url) : undefined;
+            if (this._isCanceled)
+                return;
+            const data = await (response === null || response === void 0 ? void 0 : response.arrayBuffer());
+            if (this._isCanceled)
+                return;
+            if (data)
+                buffer.resolvedBuffer = new Uint8Array(data);
+        }
+        catch (_) {
+            //
+        }
+    }
+    async resolveImage(image) {
+        var _a, _b, _c;
+        if (image.resolvedImage)
+            return;
+        const bvSrc = undefined !== image.bufferView ? image : (_a = image.extensions) === null || _a === void 0 ? void 0 : _a.KHR_binary_glTF;
+        if (undefined !== (bvSrc === null || bvSrc === void 0 ? void 0 : bvSrc.bufferView)) {
+            const format = undefined !== bvSrc.mimeType ? getImageSourceFormatForMimeType(bvSrc.mimeType) : undefined;
+            const bufferView = this._bufferViews[bvSrc.bufferView];
+            if (undefined === format || !bufferView || !bufferView.byteLength || bufferView.byteLength < 0)
+                return;
+            const bufferData = (_b = this._buffers[bufferView.buffer]) === null || _b === void 0 ? void 0 : _b.resolvedBuffer;
+            if (!bufferData)
+                return;
+            const offset = (_c = bufferView.byteOffset) !== null && _c !== void 0 ? _c : 0;
+            const bytes = bufferData.subarray(offset, offset + bufferView.byteLength);
+            try {
+                image.resolvedImage = await imageElementFromImageSource(new ImageSource(bytes, format));
+            }
+            catch (_) {
+                //
+            }
+            return;
+        }
+        const url = undefined !== image.uri ? this.resolveUrl(image.uri) : undefined;
+        if (undefined !== url)
+            image.resolvedImage = await tryImageElementFromUrl(url);
+    }
+    resolveTextures() {
         var _a, _b;
         if (undefined === this._glTF.textures)
             return;
+        // ###TODO this seems pretty hacky, and won't work for glTF 2.0 even if the KHR_techniques_webgl extension is used...
         const transparentTextures = new Set();
         if (this._glTF.techniques) {
-            for (const name of Object.keys(this._materialValues)) {
-                const material = this._materialValues[name];
+            for (const name of Object.keys(this._materials)) {
+                const material = this._materials[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) {
@@ -935,74 +1099,42 @@ export class GltfReader {
                 }
             }
         }
-        const promises = new Array();
-        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);
-    }
-    async loadTextureImage(imageJson, samplerJson, isTransparent) {
-        var _a;
-        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 || undefined === bufferView.byteLength || bufferView.byteLength <= 0)
-                return undefined;
-            const mimeType = JsonUtils.asString(binaryImageJson.mimeType);
-            const format = getImageSourceFormatForMimeType(mimeType);
-            if (undefined === format)
-                return undefined;
-            let textureType = RenderTexture.Type.Normal;
-            if (undefined !== samplerJson &&
-                (undefined !== samplerJson.wrapS || undefined !== samplerJson.wrapT))
-                textureType = RenderTexture.Type.TileSection;
-            const offset = (_a = bufferView.byteOffset) !== null && _a !== void 0 ? _a : 0;
-            /* -----------------------------------
-                const jpegArray = this._binaryData.slice(offset, offset + bufferView.byteLength);
-                const jpegArrayBuffer = jpegArray.buffer;
-                const workerOp = new ImageDecodeWorkerOperation(jpegArrayBuffer, mimeType);
-                try {
-                  const imageBitmap = await GltfReader.webWorkerManager.queueOperation(workerOp)
-                  return this._isCanceled ? undefined : this._system.createTextureFromImage(imageBitmap, isTransparent && ImageSourceFormat.Png === format, this._iModel, textureParams))
-                } catch {
-                  return undefined;
+        for (const node of this.traverseScene()) {
+            for (const meshId of getNodeMeshIds(node)) {
+                const mesh = this._meshes[meshId];
+                if (!(mesh === null || mesh === void 0 ? void 0 : mesh.primitives))
+                    continue;
+                for (const primitive of mesh.primitives) {
+                    const material = undefined !== primitive.material ? this._materials[primitive.material] : undefined;
+                    const textureId = material ? this.extractTextureId(material) : undefined;
+                    if (undefined !== textureId)
+                        this.resolveTexture(textureId, transparentTextures.has(textureId));
                 }
-              ------------------------------------- */
-            const bytes = this._binaryData.subarray(offset, offset + bufferView.byteLength);
-            const imageSource = new ImageSource(bytes, format);
-            try {
-                const image = await imageElementFromImageSource(imageSource);
-                if (this._isCanceled)
-                    return undefined;
-                return this._system.createTexture({
-                    type: textureType,
-                    image: {
-                        source: image,
-                        transparency: isTransparent && ImageSourceFormat.Png === format ? TextureTransparency.Translucent : TextureTransparency.Opaque,
-                    },
-                });
-            }
-            catch {
-                return undefined;
             }
         }
-        catch (e) {
-            return undefined;
-        }
     }
-    async loadTexture(textureId, isTransparent) {
-        if (!this._glTF.textures || !this._glTF.images)
+    resolveTexture(textureId, isTransparent) {
+        var _a;
+        const texture = this._textures[textureId];
+        if (!texture || texture.resolvedTexture || undefined === texture.source)
             return;
-        const textureJson = JsonUtils.asObject(this._glTF.textures[textureId]);
-        if (undefined === textureJson)
+        const image = (_a = this._images[texture.source]) === null || _a === void 0 ? void 0 : _a.resolvedImage;
+        if (!image)
             return;
-        const texture = await this.loadTextureImage(this._glTF.images[textureJson.source], this._glTF.samplers ? this._glTF.samplers[textureJson.sampler] : undefined, isTransparent);
-        textureJson.renderTexture = texture;
+        const samplerId = texture.sampler;
+        const sampler = undefined !== samplerId ? this._samplers[samplerId] : undefined;
+        const textureType = undefined !== (sampler === null || sampler === void 0 ? void 0 : sampler.wrapS) || undefined !== (sampler === null || sampler === void 0 ? void 0 : sampler.wrapT) ? RenderTexture.Type.TileSection : RenderTexture.Type.Normal;
+        texture.resolvedTexture = this._system.createTexture({
+            type: textureType,
+            image: {
+                source: image,
+                transparency: isTransparent ? TextureTransparency.Translucent : TextureTransparency.Opaque,
+            },
+        });
     }
     findTextureMapping(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;
+        const texture = this._textures[textureId];
+        return (texture === null || texture === void 0 ? void 0 : texture.resolvedTexture) ? new TextureMapping(texture.resolvedTexture, 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).
@@ -1014,16 +1146,17 @@ export class GltfReader {
  * @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;
+    const props = GltfReaderProps.create(args.gltf, true, args.baseUrl); // glTF supports exactly one coordinate system with y axis up.
+    const reader = props ? new GltfGraphicsReader(props, args) : undefined;
     if (!reader)
         return undefined;
     const result = await reader.read();
     return result.graphic;
 }
-/** Implements [[readGltfGraphics]]. */
-class Reader extends GltfReader {
+/** Implements [[readGltfGraphics]]. Exported strictly for tests.
+ * @internal
+ */
+export class GltfGraphicsReader extends GltfReader {
     constructor(props, args) {
         var _a, _b, _c;
         super({
@@ -1031,6 +1164,7 @@ class Reader extends GltfReader {
             iModel: args.iModel,
             vertexTableRequired: true,
         });
+        this.binaryData = props.binaryData;
         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);
@@ -1038,8 +1172,12 @@ class Reader extends GltfReader {
         }
     }
     async read() {
-        await this.loadTextures();
+        await this.resolveResources();
         return this.readGltfAndCreateGraphics(true, this._featureTable, undefined);
     }
+    get nodes() { return this._nodes; }
+    get scenes() { var _a; return (_a = this._glTF.scenes) !== null && _a !== void 0 ? _a : emptyDict; }
+    get sceneNodes() { return this._sceneNodes; }
+    get textures() { return this._textures; }
 }
 //# sourceMappingURL=GltfReader.js.map