@itwin/core-frontend 3.0.0-extension.0 → 3.1.0-dev.11

package/lib/esm/tile/GltfReader.js

@@ -5,63 +5,262 @@
 /** @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 { getImageSourceFormatForMimeType, imageElementFromImageSource } from "../ImageUtil";
+import { assert, ByteStream, compareBooleans, compareNumbers, compareStrings, Dictionary, JsonUtils, utf8ToString } from "@itwin/core-bentley";
+import { Angle, IndexedPolyface, Matrix3d, Point2d, Point3d, Point4d, Range2d, Range3d, Transform, Vector3d, } from "@itwin/core-geometry";
+import { BatchType, ColorDef, Feature, FeatureTable, FillFlags, GlbHeader, ImageSource, LinePixels, MeshEdge, MeshEdges, MeshPolyline, OctEncodedNormal, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderTexture, TextureMapping, TextureTransparency, 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";
 import { Mesh, MeshGraphicArgs } from "../render/primitives/mesh/MeshPrimitives";
 import { RealityMeshPrimitive } from "../render/primitives/mesh/RealityMeshPrimitive";
-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* 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;
+    else if (undefined !== node.mesh)
+        return [node.mesh];
+    return [];
+}
+/** GL states that can be enabled by a [[GltfTechnique]]. Only those queried by this implementation are enumerated. */
+var GltfTechniqueState;
+(function (GltfTechniqueState) {
+    /** Enables alpha blending. */
+    GltfTechniqueState[GltfTechniqueState["Blend"] = 3042] = "Blend";
+})(GltfTechniqueState || (GltfTechniqueState = {}));
+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) {
-        this.buffer = buffer;
+    constructor(glTF, version, yAxisUp, binaryData, baseUrl) {
+        this.version = version;
+        this.glTF = glTF;
         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.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 sceneStrData = buffer.nextBytes(header.sceneStrLength);
-        const sceneStr = utf8ToString(sceneStrData);
-        if (undefined === sceneStr)
-            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);
+    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
@@ -85,56 +284,194 @@ 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, isTransparent) {
+    var _a, _b, _c, _d, _e;
+    let color = ColorDef.white;
+    if (isGltf1Material(material)) {
+        if (((_a = material.values) === null || _a === void 0 ? void 0 : _a.color) && Array.isArray(material.values.color))
+            color = 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) {
+        color = colorFromJson(material.extensions.KHR_techniques_webgl.values.u_color);
+    }
+    else if ((_e = material.pbrMetallicRoughness) === null || _e === void 0 ? void 0 : _e.baseColorFactor) {
+        color = colorFromJson(material.pbrMetallicRoughness.baseColorFactor);
+    }
+    // SPEC: Opaque materials ignore any alpha channel.
+    if (!isTransparent)
+        color = color.withTransparency(0);
+    return color;
+}
+class TransformStack {
+    constructor(transform) {
+        this._stack = [];
+        if (transform)
+            this._stack.push(transform);
+    }
+    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();
+    }
+}
+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;
+    }
+}
+function compareTextureKeys(lhs, rhs) {
+    const cmp = compareBooleans(lhs.isTransparent, rhs.isTransparent);
+    if (0 !== cmp)
+        return cmp;
+    assert(typeof lhs.id === typeof rhs.id);
+    if ("string" === typeof lhs.id) {
+        assert("string" === typeof rhs.id);
+        return compareStrings(lhs.id, rhs.id);
+    }
+    assert("number" === typeof lhs.id && "number" === typeof rhs.id);
+    return compareNumbers(lhs.id, rhs.id);
+}
 /** Deserializes [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
 export class GltfReader {
-    constructor(props, iModel, modelId, is3d, system, type = BatchType.Primary, isCanceled) {
-        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._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;
-        this._iModel = iModel;
-        this._modelId = modelId;
-        this._is3d = is3d;
-        this._system = system;
-        this._type = type;
-        this._canceled = isCanceled;
+    constructor(args) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this._resolvedTextures = new Dictionary((lhs, rhs) => compareTextureKeys(lhs, rhs));
+        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])
+                this._returnToCenter = Point3d.fromJSON(rtcCenter);
+        this._iModel = args.iModel;
+        this._is3d = true !== args.is2d;
+        this._system = (_c = args.system) !== null && _c !== void 0 ? _c : IModelApp.renderSystem;
+        this._type = (_d = args.type) !== null && _d !== void 0 ? _d : BatchType.Primary;
+        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.
+        // Perhaps some faulty tiles existed that didn't define their scenes properly?
+        let sceneNodes;
+        if (this._glTF.scenes && undefined !== this._glTF.scene)
+            sceneNodes = (_g = this._glTF.scenes[this._glTF.scene]) === null || _g === void 0 ? void 0 : _g.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 _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);
+    }
+    getTileTransform(transformToRoot, pseudoRtcBias) {
+        let transform;
+        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 (transformToRoot)
+                transform = transformToRoot.multiplyTransformTransform(transform);
+        }
+        return transform;
+    }
     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;
@@ -142,22 +479,13 @@ export class GltfReader {
             renderGraphic = renderGraphicList[0];
         else
             renderGraphic = this._system.createGraphicList(renderGraphicList);
-        let transform;
+        const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
         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)
-                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)
-                transform = transformToRoot.multiplyTransformTransform(transform);
-            range = transform.inverse().multiplyRange(contentRange);
-        }
-        renderGraphic = this._system.createBatch(renderGraphic, PackedFeatureTable.pack(featureTable), range);
+        const invTransform = transform === null || transform === void 0 ? void 0 : transform.inverse();
+        if (invTransform)
+            range = invTransform.multiplyRange(contentRange);
+        if (featureTable)
+            renderGraphic = this._system.createBatch(renderGraphic, PackedFeatureTable.pack(featureTable), range);
         if (transform) {
             const branch = new GraphicBranch(true);
             branch.add(renderGraphic);
@@ -170,12 +498,20 @@ export class GltfReader {
             graphic: renderGraphic,
         };
     }
+    readGltfAndCreateGeometry(transformToRoot, needNormals = false, needParams = false) {
+        const transformStack = new TransformStack(this.getTileTransform(transformToRoot));
+        const polyfaces = [];
+        for (const nodeKey of this._sceneNodes) {
+            const node = this._nodes[nodeKey];
+            if (node)
+                this.readNodeAndCreatePolyfaces(polyfaces, node, transformStack, needNormals, needParams);
+        }
+        return { polyfaces };
+    }
     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);
+        const realityMeshPrimitive = (this._vertexTableRequired || instances) ? undefined : RealityMeshPrimitive.createFromGltfMesh(gltfMesh);
         if (realityMeshPrimitive) {
             const realityMesh = this._system.createRealityMesh(realityMeshPrimitive);
             if (realityMesh)
@@ -196,16 +532,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
@@ -214,20 +546,14 @@ 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)
-                        meshes.push(geometry);
-                }
+                const meshes = this.readMeshPrimitives(node, featureTable, thisTransform, thisBias);
                 let renderGraphic;
                 if (0 !== meshes.length) {
                     if (1 === meshes.length) {
@@ -255,18 +581,77 @@ 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;
     }
+    readNodeAndCreatePolyfaces(polyfaces, node, transformStack, needNormals, needParams) {
+        // IMPORTANT: Do not return without popping this node from the stack.
+        transformStack.push(node);
+        const meshes = this.readMeshPrimitives(node);
+        for (const mesh of meshes) {
+            const polyface = this.polyfaceFromGltfMesh(mesh, transformStack.transform, needNormals, needParams);
+            if (polyface)
+                polyfaces.push(polyface);
+        }
+        if (node.children) {
+            for (const childId of node.children) {
+                const child = this._nodes[childId];
+                if (child)
+                    this.readNodeAndCreatePolyfaces(polyfaces, child, transformStack, needNormals, needParams);
+            }
+        }
+    }
+    polyfaceFromGltfMesh(mesh, transform, needNormals, needParams) {
+        if (!mesh.pointQParams || !mesh.points || !mesh.indices)
+            return undefined;
+        const { points, pointQParams, normals, uvs, uvQParams, indices } = mesh;
+        const includeNormals = needNormals && undefined !== normals;
+        const includeParams = needParams && undefined !== uvQParams && undefined !== uvs;
+        const polyface = IndexedPolyface.create(includeNormals, includeParams);
+        for (let i = 0; i < points.length;) {
+            const point = pointQParams.unquantize(points[i++], points[i++], points[i++]);
+            if (transform)
+                transform.multiplyPoint3d(point, point);
+            polyface.addPoint(point);
+        }
+        if (includeNormals && normals)
+            for (let i = 0; i < normals.length;)
+                polyface.addNormal(OctEncodedNormal.decodeValue(normals[i++]));
+        if (includeParams && uvs && uvQParams)
+            for (let i = 0; i < uvs.length;)
+                polyface.addParam(uvQParams.unquantize(uvs[i++], uvs[i++]));
+        let j = 0;
+        for (const index of indices) {
+            polyface.addPointIndex(index);
+            if (includeNormals)
+                polyface.addNormalIndex(index);
+            if (includeParams)
+                polyface.addParamIndex(index);
+            if (0 === (++j % 3))
+                polyface.terminateFacet();
+        }
+        return polyface;
+    }
+    // ###TODO what is the actual type of `json`?
     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;
@@ -297,8 +682,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) {
@@ -314,21 +699,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) {
@@ -341,49 +714,76 @@ 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((_h = (_g = material.pbrMetallicRoughness) === null || _g === void 0 ? void 0 : _g.baseColorTexture) === null || _h === void 0 ? void 0 : _h.index);
+        return id !== null && id !== void 0 ? id : extractId((_j = material.emissiveTexture) === 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);
+    isMaterialTransparent(material) {
+        var _a, _b;
+        if (isGltf1Material(material)) {
+            if (this._glTF.techniques && undefined !== material.technique) {
+                const technique = this._glTF.techniques[material.technique];
+                if ((_b = (_a = technique === null || technique === void 0 ? void 0 : technique.states) === null || _a === void 0 ? void 0 : _a.enable) === null || _b === void 0 ? void 0 : _b.some((state) => state === GltfTechniqueState.Blend))
+                    return true;
+            }
+            return false;
+        }
+        else {
+            // Default: OPAQUE.
+            // ###TODO support MASK. For now treat as opaque.
+            return "BLEND" === material.alphaMode;
+        }
+    }
+    createDisplayParams(material, hasBakedLighting) {
+        const isTransparent = this.isMaterialTransparent(material);
+        const textureId = this.extractTextureId(material);
+        const textureMapping = undefined !== textureId ? this.findTextureMapping(textureId, isTransparent) : undefined;
+        const color = colorFromMaterial(material, isTransparent);
         return new DisplayParams(DisplayParams.Type.Mesh, color, color, 1, LinePixels.Solid, FillFlags.Always, undefined, undefined, hasBakedLighting, textureMapping);
     }
-    extractReturnToCenter(extensions) {
-        if (extensions === undefined) {
-            return undefined;
+    readMeshPrimitives(node, featureTable, thisTransform, thisBias) {
+        const meshes = [];
+        for (const meshKey of getNodeMeshIds(node)) {
+            const nodeMesh = this._meshes[meshKey];
+            if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
+                for (const primitive of nodeMesh.primitives) {
+                    const mesh = this.readMeshPrimitive(primitive, featureTable, thisBias);
+                    if (mesh) {
+                        meshes.push(mesh);
+                        if (this._computedContentRange && mesh.pointRange) {
+                            const invTransform = thisTransform === null || thisTransform === void 0 ? void 0 : thisTransform.inverse();
+                            const meshRange = invTransform ? invTransform.multiplyRange(mesh.pointRange) : mesh.pointRange;
+                            this._computedContentRange.extendRange(meshRange);
+                        }
+                    }
+                }
+            }
         }
-        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;
+        return meshes;
     }
     readMeshPrimitive(primitive, featureTable, pseudoRtcBias) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         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);
-        if (undefined === displayParams)
+        const material = 0 < materialName.length ? this._materials[materialName] : undefined;
+        if (!material)
+            return undefined;
+        const hasBakedLighting = undefined === primitive.attributes.NORMAL || undefined !== ((_a = material.extensions) === null || _a === void 0 ? void 0 : _a.KHR_materials_unlit);
+        const displayParams = material ? this.createDisplayParams(material, hasBakedLighting) : undefined;
+        if (!displayParams)
             return undefined;
         let primitiveType = -1;
         const meshMode = JsonUtils.asInt(primitive.mode, GltfMeshMode.Triangles);
@@ -401,7 +801,6 @@ export class GltfReader {
                 assert(false);
                 return undefined;
         }
-        const isPlanar = JsonUtils.asBool(primitive.isPlanar);
         const isVolumeClassifier = this._isVolumeClassifier;
         const meshPrimitive = Mesh.create({
             displayParams,
@@ -409,7 +808,7 @@ export class GltfReader {
             type: primitiveType,
             range: Range3d.createNull(),
             is2d: !this._is3d,
-            isPlanar,
+            isPlanar: false,
             hasBakedLighting,
             isVolumeClassifier,
         });
@@ -419,12 +818,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 = (_b = material.values) === null || _b === void 0 ? void 0 : _b.texStep;
+            else
+                texStep = (_e = (_d = (_c = material.extensions) === null || _c === void 0 ? void 0 : _c.KHR_techniques_webgl) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e.u_texStep;
             if (texStep) {
                 const uvParams = [];
                 for (let i = 0; i < colorIndices.count; i++)
@@ -434,7 +833,7 @@ export class GltfReader {
                 mesh.uvQParams = paramList.params;
             }
         }
-        if ((_a = primitive.extensions) === null || _a === void 0 ? void 0 : _a.KHR_draco_mesh_compression) {
+        if ((_f = primitive.extensions) === null || _f === void 0 ? void 0 : _f.KHR_draco_mesh_compression) {
             return undefined; // Defer Draco decompression until web workers implementation.
             /*
             const dracoExtension = primitive.extensions.KHR_draco_mesh_compression;
@@ -453,8 +852,14 @@ export class GltfReader {
                     return undefined;
                 if (!displayParams.ignoreLighting && !this.readNormals(mesh, primitive.attributes, "NORMAL"))
                     return undefined;
-                if (!mesh.uvs)
-                    this.readUVParams(mesh, primitive.attributes, "TEXCOORD_0");
+                if (!mesh.uvs) {
+                    let texCoordIndex = 0;
+                    if (!isGltf1Material(material) && undefined !== ((_h = (_g = material.pbrMetallicRoughness) === null || _g === void 0 ? void 0 : _g.baseColorTexture) === null || _h === void 0 ? void 0 : _h.texCoord))
+                        texCoordIndex = JsonUtils.asInt(material.pbrMetallicRoughness.baseColorTexture.texCoord);
+                    this.readUVParams(mesh, primitive.attributes, `TEXCOORD_${texCoordIndex}`);
+                }
+                if (this._deduplicateVertices && !this.deduplicateVertices(mesh))
+                    return undefined;
                 break;
             }
             case Mesh.PrimitiveType.Polyline:
@@ -470,7 +875,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 ((_j = primitive.extensions) === null || _j === void 0 ? void 0 : _j.CESIUM_primitive_outline) {
             const data = this.readBufferData32(primitive.extensions.CESIUM_primitive_outline, "indices");
             if (data !== undefined) {
                 assert(0 === data.count % 2);
@@ -481,6 +886,37 @@ export class GltfReader {
         }
         return mesh;
     }
+    deduplicateVertices(mesh) {
+        if (!mesh.points || !mesh.indices)
+            return false;
+        const numPoints = mesh.indices.length;
+        assert(0 === numPoints % 3);
+        const indices = mesh.indices;
+        if (indices instanceof Uint16Array && numPoints > 0xffff)
+            mesh.indices = new Uint32Array(numPoints);
+        else if (indices instanceof Uint8Array && numPoints > 0xff)
+            mesh.indices = new Uint32Array(numPoints);
+        const points = new Uint16Array(3 * numPoints);
+        const normals = mesh.normals ? new Uint16Array(numPoints) : undefined;
+        const uvs = mesh.uvs ? new Uint16Array(2 * numPoints) : undefined;
+        for (let i = 0; i < numPoints; i++) {
+            const index = indices[i];
+            mesh.indices[i] = i;
+            points[i * 3 + 0] = mesh.points[index * 3 + 0];
+            points[i * 3 + 1] = mesh.points[index * 3 + 1];
+            points[i * 3 + 2] = mesh.points[index * 3 + 2];
+            if (normals)
+                normals[i] = mesh.normals[index];
+            if (uvs) {
+                uvs[i * 2 + 0] = mesh.uvs[index * 2 + 0];
+                uvs[i * 2 + 1] = mesh.uvs[index * 2 + 1];
+            }
+        }
+        mesh.points = points;
+        mesh.normals = normals;
+        mesh.uvs = uvs;
+        return true;
+    }
     /**
      *
      * @param positions quantized points
@@ -560,10 +996,22 @@ export class GltfReader {
     readBatchTable(_mesh, _json) {
     }
     readMeshIndices(mesh, json) {
-        const data = this.readBufferData16(json, "indices") || this.readBufferData32(json, "indices");
-        if (undefined === data || (!(data.buffer instanceof (Uint16Array)) && !(data.buffer instanceof (Uint32Array))))
+        var _a;
+        if (undefined !== json.indices) {
+            const data = this.readBufferData16(json, "indices") || this.readBufferData32(json, "indices");
+            if (data && (data.buffer instanceof Uint8Array || data.buffer instanceof Uint16Array || data.buffer instanceof Uint32Array)) {
+                mesh.indices = data.buffer;
+                return true;
+            }
+            return false;
+        }
+        // Non-indexed geometry. Manufacture triangle indices from points.
+        const numPoints = (_a = mesh.points) === null || _a === void 0 ? void 0 : _a.length;
+        if (undefined === numPoints || 0 !== numPoints % 3)
             return false;
-        mesh.indices = data.buffer;
+        mesh.indices = numPoints < 255 ? new Uint8Array(numPoints) : (numPoints < 0xffff ? new Uint16Array(numPoints) : new Uint32Array(numPoints));
+        for (let i = 0; i < numPoints; i++)
+            mesh.indices[i] = i;
         return true;
     }
     readNormals(mesh, json, accessorName) {
@@ -604,12 +1052,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...
@@ -684,87 +1133,149 @@ export class GltfReader {
             polylines.push(new MeshPolyline(indices));
         return true;
     }
-    async loadTextures() {
-        if (undefined === this._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);
-            }
-        }
-        const promises = new Array();
-        for (const name of Object.keys(this._textures))
-            promises.push(this.loadTexture(name, transparentTextures.has(name)));
-        if (promises.length > 0)
+    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);
+        }
+        catch (_) {
+        }
     }
-    async loadTextureImage(imageJson, samplerJson, isTransparent) {
+    resolveUrl(uri) {
         try {
-            const binaryImageJson = (imageJson.extensions && imageJson.extensions.KHR_binary_glTF) ? JsonUtils.asObject(imageJson.extensions.KHR_binary_glTF) : imageJson;
-            const bufferView = this._bufferViews[binaryImageJson.bufferView];
-            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 = bufferView.byteOffset;
-            /* -----------------------------------
-                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;
-                }
-              ------------------------------------- */
-            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;
-            }
+            return new URL(uri, this._baseUrl).toString();
         }
-        catch (e) {
+        catch (_) {
             return undefined;
         }
     }
-    async loadTexture(textureId, isTransparent) {
-        const textureJson = JsonUtils.asObject(this._textures[textureId]);
-        if (undefined === textureJson)
+    async resolveBuffer(buffer) {
+        if (buffer.resolvedBuffer || undefined === buffer.uri)
             return;
-        const texture = await this.loadTextureImage(this._images[textureJson.source], undefined === this._samplers ? undefined : this._samplers[textureJson.sampler], isTransparent);
-        textureJson.renderTexture = texture;
+        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);
+    }
+    resolveTexture(textureId, isTransparent) {
+        var _a;
+        const texture = this._textures[textureId];
+        if (!texture || undefined === texture.source)
+            return false;
+        const image = (_a = this._images[texture.source]) === null || _a === void 0 ? void 0 : _a.resolvedImage;
+        if (!image)
+            return false;
+        const samplerId = texture.sampler;
+        const sampler = undefined !== samplerId ? this._samplers[samplerId] : undefined;
+        // ###TODO: RenderTexture should support different wrapping behavior for U vs V, and support mirrored repeat.
+        // For now, repeat unless either explicitly clamps.
+        const textureType = GltfWrapMode.ClampToEdge === (sampler === null || sampler === void 0 ? void 0 : sampler.wrapS) || GltfWrapMode.ClampToEdge === (sampler === null || sampler === void 0 ? void 0 : sampler.wrapT) ? RenderTexture.Type.TileSection : RenderTexture.Type.Normal;
+        const renderTexture = this._system.createTexture({
+            type: textureType,
+            image: {
+                source: image,
+                transparency: isTransparent ? TextureTransparency.Mixed : TextureTransparency.Opaque,
+            },
+        });
+        return renderTexture !== null && renderTexture !== void 0 ? renderTexture : false;
+    }
+    findTextureMapping(id, isTransparent) {
+        let texture = this._resolvedTextures.get({ id, isTransparent });
+        if (undefined === texture)
+            this._resolvedTextures.set({ id, isTransparent }, texture = this.resolveTexture(id, isTransparent));
+        return 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 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]]. Exported strictly for tests.
+ * @internal
+ */
+export class GltfGraphicsReader extends GltfReader {
+    constructor(props, args) {
+        var _a, _b, _c;
+        super({
+            props,
+            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);
+            this._featureTable.insert(new Feature(pickableId));
+        }
     }
-    findTextureMapping(textureId) {
-        const textureJson = JsonUtils.asObject(this._textures[textureId]);
-        const texture = undefined !== textureJson ? textureJson.renderTexture : undefined;
-        return undefined !== texture ? new TextureMapping(texture, new TextureMapping.Params()) : undefined;
+    async read() {
+        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