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

package/lib/cjs/tile/GltfReader.d.ts

@@ -1,15 +1,453 @@
 /** @packageDocumentation
  * @module Tiles
  */
-import { ByteStream, Id64String } from "@itwin/core-bentley";
-import { Range2d, Range3d, Transform, Vector3d } from "@itwin/core-geometry";
-import { BatchType, ElementAlignedBox3d, FeatureTable, GltfBufferData, GltfBufferView, GltfDataType, MeshPolylineList, QParams2d, QParams3d, RenderTexture, TextureMapping, TileReadStatus } from "@itwin/core-common";
+import { Id64String } from "@itwin/core-bentley";
+import { Point3d, Range2d, Range3d, Transform, Vector3d } from "@itwin/core-geometry";
+import { BatchType, ElementAlignedBox3d, FeatureTable, MeshPolylineList, QParams2d, QParams3d, TextureMapping, TileReadStatus } from "@itwin/core-common";
 import { IModelConnection } from "../IModelConnection";
+import { PickableGraphicOptions } from "../render/GraphicBuilder";
 import { InstancedGraphicParams } from "../render/InstancedGraphicParams";
 import { DisplayParams } from "../render/primitives/DisplayParams";
 import { Mesh } from "../render/primitives/mesh/MeshPrimitives";
+import { RenderGraphic } from "../render/RenderGraphic";
 import { RenderSystem } from "../render/RenderSystem";
 import { TileContent } from "./internal";
+/** Enumerates the types of [[GltfMeshPrimitive]] topologies. */
+declare enum GltfMeshMode {
+    Points = 0,
+    Lines = 1,
+    LineStrip = 3,
+    Triangles = 4,
+    /** Not currently supported. */
+    TriangleStrip = 5,
+    /** Not currently supported. */
+    TriangleFan = 6
+}
+/** Enumerates the basic data types supported by accessors, material values, technique uniforms, etc.
+ * @internal
+ */
+export declare enum GltfDataType {
+    SignedByte = 5120,
+    UnsignedByte = 5121,
+    SignedShort = 5122,
+    UnsignedShort = 5123,
+    UInt32 = 5125,
+    Float = 5126,
+    Rgb = 6407,
+    Rgba = 6408,
+    IntVec2 = 35667,
+    IntVec3 = 35668,
+    FloatVec2 = 35664,
+    FloatVec3 = 35665,
+    FloatVec4 = 35666,
+    FloatMat3 = 35675,
+    FloatMat4 = 35676,
+    Sampler2d = 35678
+}
+/** @internal */
+declare enum GltfMagFilter {
+    Nearest = 9728,
+    Linear = 9729
+}
+/** @internal */
+declare enum GltfMinFilter {
+    Nearest = 9728,
+    Linear = 9729,
+    NearestMipMapNearest = 9984,
+    LinearMipMapNearest = 9985,
+    NearestMipMapLinear = 9986,
+    LinearMipMapLinear = 9987
+}
+/** Describes how texture coordinates outside of the range [0..1] are handled. */
+declare enum GltfWrapMode {
+    ClampToEdge = 33071,
+    MirroredRepeat = 33648,
+    Repeat = 10497
+}
+/** Describes the intended target of a [[GltfBufferViewProps]]. */
+declare enum GltfBufferTarget {
+    ArrayBuffer = 34962,
+    ElementArrayBuffer = 24963
+}
+/** The type used to refer to an entry in a GltfDictionary in a glTF 1.0 asset. @internal */
+export declare type Gltf1Id = string;
+/** The type used to refer to an entry in a GltfDictionary in a glTF 2.0 asset. @internal */
+export declare type Gltf2Id = number;
+/** The type used to refer to an entry in a GltfDictionary. @internal */
+export declare type GltfId = Gltf1Id | Gltf2Id;
+/** A collection of resources of some type defined at the top-level of a [[Gltf]] asset.
+ * In glTF 1.0, these are defined as objects; each resource is referenced and accessed by its string key.
+ * In glTF 2.0, these are defined as arrays; each resource is referenced and accessed by its integer array index.
+ */
+interface GltfDictionary<T extends GltfChildOfRootProperty> {
+    [key: GltfId]: T | undefined;
+}
+/** Optional extensions applied to a [[GltfProperty]] to enable behavior not defined in the core specification. */
+interface GltfExtensions {
+    [key: string]: unknown | undefined;
+}
+/** The base interface provided by most objects in a glTF asset, permitting additional data to be associated with the object. */
+interface GltfProperty {
+    extensions?: GltfExtensions;
+    extras?: any;
+}
+/** The base interface provided by top-level properties of a [[Gltf]] asset. */
+interface GltfChildOfRootProperty extends GltfProperty {
+    /** Optional name, strictly for human consumption. */
+    name?: string;
+}
+/** A unit of geometry belonging to a [[GltfMesh]]. */
+interface GltfMeshPrimitive extends GltfProperty {
+    /** Maps the name of each mesh attribute semantic to the Id of the [[GltfAccessor]] providing the attribute's data. */
+    attributes: {
+        [k: string]: GltfId | undefined;
+    };
+    /** The Id of the [[GltfAccessor]] providing the vertex indices. */
+    indices?: GltfId;
+    /** The Id of the [[GltfMaterial]] to apply to the primitive when rendering. */
+    material?: GltfId;
+    /** The primitive topology type. */
+    mode?: GltfMeshMode;
+    /** Morph targets - currently unsupported. */
+    targets?: {
+        [k: string]: GltfId | undefined;
+    };
+    extensions?: GltfExtensions & {
+        /** The [CESIUM_primitive_outline](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/CESIUM_primitive_outline) extension
+         * describes how to draw outline edges for a triangle mesh.
+         */
+        CESIUM_primitive_outline?: {
+            /** The Id of the [[GltfBufferViewProps]] supplying the endpoints of each edge as indices into the triangle mesh's vertex array.
+             * The number of indices must be even; each consecutive pair of indices describes one line segment. No connectivity between
+             * line segments is implied.
+             */
+            indices?: GltfId;
+        };
+    };
+}
+/** A collection of [[GltfMeshPrimitive]]s to be rendered. Each mesh is referenced by a node. Multiple nodes can refer to the same mesh.
+ * The node's transform is applied when rendering the mesh.
+ */
+interface GltfMesh extends GltfChildOfRootProperty {
+    /** The collection of primitives to be rendered. */
+    primitives?: GltfMeshPrimitive[];
+    /** For morph targets - currently unsupported. */
+    weights?: number[];
+}
+/** Properties common to [[Gltf1Node]] and [[Gltf2Node]]. */
+interface GltfNodeBaseProps {
+    /** The Ids of the child nodes. @see [[GltfNode]]. */
+    children?: GltfId[];
+    /** Currently ignored. */
+    camera?: GltfId;
+    /** Currently ignored. */
+    skin?: GltfId;
+    /** A 4x4 column-major transformation matrix. Mutually exclusive with [[rotation]], [[scale]], and [[translation]]. */
+    matrix?: number[];
+    /** Unit quaternion as [x, y, z, w], where w is the scalar. */
+    rotation?: number[];
+    /** Non-uniform scale as [x, y, z]. */
+    scale?: number[];
+    /** Translation as [x, y, z]. */
+    translation?: number[];
+}
+/** glTF 1.0 representation of a [[GltfNode]]. Unlike a [[Gltf2Node]], a Gltf1Node may refer to any number of [[GltfMesh]]es. */
+interface Gltf1Node extends GltfChildOfRootProperty, GltfNodeBaseProps {
+    /** The Ids of the [[GltfMesh]]es to be rendered by this node.
+     * @note The spec defines this as an array of strings, but the original implementation of [[GltfReader]] was written to treat it as a string instead.
+     * In case this was because of non-spec-compliant glTF that placed a string here instead of an array, either is permitted.
+     */
+    meshes?: GltfId[] | string;
+    mesh?: never;
+    /** Currently ignored. */
+    jointName?: GltfId;
+    /** Currently ignored. */
+    skeletons?: GltfId[];
+}
+/** glTF 2.0 representation of a [[GltfNode]]. Unlike a [[Gltf1Node]], a Gltf2Node may refer to at most one [[GltfMesh]]. */
+interface Gltf2Node extends GltfChildOfRootProperty, GltfNodeBaseProps {
+    /** The Id of the [[GltfMesh]] to be rendered by this node. */
+    mesh?: GltfId;
+    meshes?: never;
+    /** Morph targets - currently ignored. */
+    weights?: number[];
+}
+/** Describes a node in a [[GltfScene]]. Each node may be associated with zero, one (glTF 2.0), or any number of (glTF 1.0) [[GltfMesh]]es.
+ * Each node may define a transform. Each node may have any number of child nodes. A child node's transform is multiplied by its parent node's transform.
+ * Some nodes may be associated with other types of data like cameras, skins, lights, etc - these types of data are currently unsupported.
+ * Rendering a node means rendering its meshes and the meshes of all of its descendants, with transforms applied.
+ * @internal
+ */
+export declare type GltfNode = Gltf1Node | Gltf2Node;
+/** Describes a scene graph that composes any number of [[GltfNode]]s to produce a rendering of the [[Gltf]] asset.
+ * An asset may define any number of scenes; the default scene is specified by [[Gltf.scene]].
+ */
+interface GltfScene extends GltfChildOfRootProperty {
+    /** The Ids of the nodes comprising the scene graph. */
+    nodes?: GltfId[];
+}
+/** Provides metadata about a [[Gltf]] asset. */
+interface GltfAsset extends GltfProperty {
+    /** A copyright message suitable for display to credit the content creator. */
+    copyright?: string;
+    /** The name of the tool that generated the asset. */
+    generator?: string;
+    /** The glTF version targeted by the asset, in the form "major.minor" where "major" and "minor" are integers. */
+    version: string;
+    /** The minimum glTF version required to properly load this asset, in the same form as [[version]].
+     * This minimum version must be no greater than [[version]].
+     */
+    minVersion?: string;
+}
+/** Describes an image such as one used for a [[GltfTexture]]. The image may be referenced by a [[uri]] or a [[bufferView]]. */
+interface GltfImage extends GltfChildOfRootProperty {
+    /** URI from which the image data can be obtained, either as a base-64-encoded data URI or an external resource.
+     * Mutually exclusive with [[bufferView]].
+     */
+    uri?: string;
+    /** The image's media type. This property is required if [[bufferView]] is defined. */
+    mimeType?: "image/jpeg" | "image/png";
+    /** The Id of the [[GltfBufferViewProps]] containing the image data. Mutually exclusive with [[uri]]. */
+    bufferView?: GltfId;
+    extensions?: GltfExtensions & {
+        /** The [KHR_binary_glTF](https://github.com/KhronosGroup/glTF/tree/main/extensions/1.0/Khronos/KHR_binary_glTF) allows an image to
+         * be embedded in a binary chunk appended to the glTF asset's JSON, instead of being referenced by an external URI.
+         * This is superseded in glTF 2.0 by support for the glb file format specification.
+         */
+        KHR_binary_glTF?: {
+            /** The Id of the [[GltfBufferViewProps]] that contains the binary image data. */
+            bufferView?: GltfId;
+            /** Required - @see [[GltfImage.mimeType]]. */
+            mimeType?: string;
+        };
+    };
+}
+/** Describes a reference to a [[GltfTexture]]. */
+interface GltfTextureInfo extends GltfProperty {
+    /** The Id of the [[GltfTexture]]. */
+    index: GltfId;
+    /** The set index of the texture's TEXCOORD attribute used for texture coordinate mapping.
+     * For example, if `texCoord` is `2`, an attribute named `TEXCOORD_2` must exist containing the texture coordinates.
+     * Default: 0.
+     */
+    texCoord?: number;
+}
+/** Describes a texture and its sampler. */
+interface GltfTexture extends GltfChildOfRootProperty {
+    /** The Id of the [[GltfSampler]] used by this texture.
+     * If undefined, a sampler with repeat wrapping and auto filtering should be used by default.
+     */
+    sampler?: GltfId;
+    /** The Id of the [[GltfImage]] used by this texture.
+     * If undefined, an extension or other mechanism should supply an alternate image source - otherwise, the behavior is undefined.
+     */
+    source?: GltfId;
+}
+/** Describes the filtering and wrapping behavior to be applied to a [[GltfTexture]].
+ * @note The implementation currently does not support MirroredRepeat and does not support different wrapping for U and V;
+ * effectively, unless `wrapS` or `wrapT` is set to ClampToEdge, the sampler will use GltfWrapMode.Repeat.
+ */
+interface GltfSampler extends GltfChildOfRootProperty {
+    /** Magnification filter. */
+    magFilter?: GltfMagFilter;
+    /** Minification filter. */
+    minFilter?: GltfMinFilter;
+    /** S (U) wrapping mode. Default: Repeat. */
+    wrapS?: GltfWrapMode;
+    /** T (V) wrapping mode. Default: Repeat. */
+    wrapT?: GltfWrapMode;
+}
+/** GL states that can be enabled by a [[GltfTechnique]]. Only those queried by this implementation are enumerated. */
+declare enum GltfTechniqueState {
+    /** Enables alpha blending. */
+    Blend = 3042
+}
+/** For glTF 1.0 only, describes shader programs and shader state associated with a [[Gltf1Material]], used to render meshes associated with the material.
+ * This implementation uses it strictly to identify techniques that require alpha blending.
+ */
+interface GltfTechnique extends GltfChildOfRootProperty {
+    /** GL render states to be applied by the technique. */
+    states?: {
+        /** An array of integers corresponding to boolean GL states that should be enabled using GL's `enable` function.
+         * For example, the value [[GltfTechniqueState.Blend]] (3042) indicates that blending should be enabled.
+         */
+        enable?: GltfTechniqueState[];
+    };
+}
+interface Gltf1Material extends GltfChildOfRootProperty {
+    diffuse?: string;
+    emission?: number[];
+    shininess?: number;
+    specular?: number[];
+    technique?: GltfId;
+    values?: {
+        texStep?: number[];
+        color?: number[];
+        tex?: number | string;
+    };
+}
+interface GltfMaterialPbrMetallicRoughness extends GltfProperty {
+    baseColorFactor?: number[];
+    baseColorTexture?: GltfTextureInfo;
+    metallicFactor?: number;
+    metallicRoughnessTexture?: GltfTextureInfo;
+}
+interface Gltf2Material extends GltfChildOfRootProperty {
+    pbrMetallicRoughness?: GltfMaterialPbrMetallicRoughness;
+    normalTexture?: unknown;
+    occlusionTexture?: unknown;
+    emissiveTexture?: GltfTextureInfo;
+    emissiveFactor?: number[];
+    alphaMode?: "OPAQUE" | "MASK" | "BLEND";
+    alphaCutoff?: number;
+    doubleSided?: boolean;
+    extensions?: GltfExtensions & {
+        /** The [KHR_materials_unlit](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_unlit) extension
+         * indicates that the material should be displayed without lighting. The extension adds no additional properties; it is effectively a boolean flag.
+         */
+        KHR_materials_unlit?: {};
+        /** The [KHR_techniques_webgl extension](https://github.com/KhronosGroup/glTF/blob/c1c12bd100e88ff468ccef1cb88cfbec56a69af2/extensions/2.0/Khronos/KHR_techniques_webgl/README.md)
+         * allows "techniques" to be associated with [[GltfMaterial]]s. Techniques can supply custom shader programs to render geometry; this was a core feature of glTF 1.0 (see [[GltfTechnique]]).
+         * Here, it is only used to extract uniform values.
+         */
+        KHR_techniques_webgl?: {
+            technique?: number;
+            values?: {
+                u_texStep?: number[];
+                u_color?: number[];
+                u_diffuse?: {
+                    index: number;
+                    texCoord: number;
+                };
+                [k: string]: unknown | undefined;
+            };
+        };
+    };
+}
+declare type GltfMaterial = Gltf1Material | Gltf2Material;
+interface GltfBuffer extends GltfChildOfRootProperty {
+    uri?: string;
+    byteLength?: number;
+}
+interface GltfBufferViewProps extends GltfChildOfRootProperty {
+    buffer: GltfId;
+    byteLength?: number;
+    byteOffset?: number;
+    byteStride?: number;
+    target?: GltfBufferTarget;
+}
+interface GltfAccessor extends GltfChildOfRootProperty {
+    bufferView?: GltfId;
+    byteOffset?: number;
+    componentType?: GltfDataType.SignedByte | GltfDataType.UnsignedByte | GltfDataType.SignedShort | GltfDataType.UnsignedShort | GltfDataType.UInt32 | GltfDataType.Float;
+    normalized?: boolean;
+    count: number;
+    type: "SCALAR" | "VEC2" | "VEC3" | "VEC4" | "MAT2" | "MAT3" | "MAT4";
+    max?: number[];
+    min?: number[];
+    sparse?: unknown;
+}
+/** Describes the top-level structure of a glTF asset.
+ * This interface, along with all of the related Gltf* types defined in this file, is primarily based upon the [official glTF 2.0 specification](https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html).
+ * However, it can also represent a [glTF 1.0](https://github.com/KhronosGroup/glTF/tree/main/specification/1.0#reference-node) asset.
+ * Some types are combined. For example, the top-level dictionaries in glTF 1.0 are objects, while in glTF 2.0 they are arrays; the GltfDictionary interface supports accessing
+ * items using either strings or numeric indexes represented by [[GltfId]].
+ * For types that differ significantly between the two specs, Gltf1* and Gltf2* versions are defined (e.g., GltfMaterial is a union of Gltf1Material and Gltf2Material).
+ * These interfaces also accommodate some deviations from both specs that are known to exist in the wild.
+ * Most aspects of the specifications that are not implemented here are omitted (e.g., skinning, animations).
+ * @internal
+ */
+export interface Gltf extends GltfProperty {
+    /** Metadata about the glTF asset.
+     * @note This property is required in glTF 2.0, but optional in 1.0.
+     */
+    asset?: GltfAsset;
+    /** The Id of the default [[GltfScene]] in [[scenes]]. */
+    scene?: GltfId;
+    extensions?: GltfExtensions & {
+        /** The [CESIUM_RTC extension](https://github.com/KhronosGroup/glTF/blob/main/extensions/1.0/Vendor/CESIUM_RTC/README.md) defines a centroid
+         * relative to which all coordinates in the asset are defined, to reduce floating-point precision errors for large coordinates.
+         */
+        CESIUM_RTC?: {
+            center?: number[];
+        };
+        /** The [KHR_techniques_webgl extension](https://github.com/KhronosGroup/glTF/blob/c1c12bd100e88ff468ccef1cb88cfbec56a69af2/extensions/2.0/Khronos/KHR_techniques_webgl/README.md)
+         * allows "techniques" to be associated with [[GltfMaterial]]s. Techniques can supply custom shader programs to render geometry; this was a core feature of glTF 1.0 (see [[GltfTechnique]]).
+         * Here, it is only used to extract uniform values.
+         */
+        KHR_techniques_webgl?: {
+            techniques?: Array<{
+                uniforms?: {
+                    [key: string]: {
+                        type: GltfDataType;
+                        value?: any;
+                    } | undefined;
+                };
+            }>;
+        };
+    };
+    /** Names of glTF extensions used in the asset. */
+    extensionsUsed?: string[];
+    /** Names of glTF extensions required to properly load the asset. */
+    extensionsRequired?: string[];
+    accessors?: GltfDictionary<GltfAccessor>;
+    /** Not currently supported. */
+    animations?: GltfDictionary<any>;
+    buffers?: GltfDictionary<GltfBuffer>;
+    bufferViews?: GltfDictionary<GltfBufferViewProps>;
+    /** Not currently used. */
+    cameras?: GltfDictionary<any>;
+    images?: GltfDictionary<GltfImage>;
+    materials?: GltfDictionary<GltfMaterial>;
+    meshes?: GltfDictionary<GltfMesh>;
+    nodes?: GltfDictionary<GltfNode>;
+    samplers?: GltfDictionary<GltfSampler>;
+    scenes?: GltfDictionary<GltfScene>;
+    /** Not currently supported. */
+    skins?: GltfDictionary<any>;
+    textures?: GltfDictionary<GltfTexture>;
+    /** For glTF 1.0 only, techniques associated with [[Gltf1Material]]s. */
+    techniques?: GltfDictionary<GltfTechnique>;
+}
+/** @internal */
+export declare type GltfDataBuffer = Uint8Array | Uint16Array | Uint32Array | Float32Array;
+/**
+ * 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 declare class GltfBufferData {
+    readonly buffer: GltfDataBuffer;
+    readonly count: number;
+    constructor(buffer: GltfDataBuffer, count: number);
+    /**
+     * 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: Uint8Array, actualType: GltfDataType, expectedType: GltfDataType, count: number): GltfBufferData | undefined;
+    private static createDataBuffer;
+}
+/**
+ * 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
+ */
+declare class GltfBufferView {
+    readonly data: Uint8Array;
+    readonly count: number;
+    readonly type: GltfDataType;
+    readonly accessor: GltfAccessor;
+    readonly stride: number;
+    get byteLength(): number;
+    constructor(data: Uint8Array, count: number, type: GltfDataType, accessor: GltfAccessor, stride: number);
+    toBufferData(desiredType: GltfDataType): GltfBufferData | undefined;
+}
 /** The result of [[GltfReader.read]].
  * @internal
  */
@@ -20,21 +458,14 @@ export interface GltfReaderResult extends TileContent {
  * @internal
  */
 export declare class GltfReaderProps {
-    readonly buffer: ByteStream;
-    readonly binaryData: Uint8Array;
-    readonly accessors: any;
-    readonly bufferViews: any;
-    readonly scene: any;
-    readonly nodes: any;
-    readonly meshes: any;
-    readonly materials: any;
-    readonly extensions: any;
-    readonly samplers: any;
-    readonly techniques: any;
+    readonly version: number;
+    readonly glTF: Gltf;
     readonly yAxisUp: boolean;
+    readonly binaryData?: Uint8Array;
+    readonly baseUrl?: string;
     private constructor();
     /** Attempt to construct a new GltfReaderProps from the binary data beginning at the supplied stream's current read position. */
-    static create(buffer: ByteStream, yAxisUp?: boolean): GltfReaderProps | undefined;
+    static create(source: Uint8Array | Gltf, yAxisUp?: boolean, baseUrl?: string): GltfReaderProps | 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
   * ContextCapture, then a RealityMesh is created directly from this data.  Otherwise, the mesh primitive is populated from the raw data and a MeshPrimitive
@@ -51,62 +482,113 @@ export declare class GltfMeshData {
     uvQParams?: QParams2d;
     uvs?: Uint16Array;
     uvRange?: Range2d;
-    indices?: Uint16Array | Uint32Array;
+    indices?: Uint8Array | Uint16Array | Uint32Array;
     constructor(props: Mesh);
 }
 /** A function that returns true if deserialization of the data supplied by the reader should abort.
  * @internal
  */
 export declare type ShouldAbortReadGltf = (reader: GltfReader) => boolean;
+/** Arguments to [[GltfReader]] constructor.
+ * @internal
+ */
+export interface GltfReaderArgs {
+    /** Properties of the glTF source. */
+    props: GltfReaderProps;
+    /** The iModel with which the graphics are to be associated. */
+    iModel: IModelConnection;
+    /** If true, create 2d graphics. */
+    is2d?: boolean;
+    /** The render system that will produce the graphics. Defaults to [[IModelApp.renderSystem]]. */
+    system?: RenderSystem;
+    /** The type of batch to create. Defaults to [BatchType.Primary]($common).
+     * @see [[RenderSystem.createBatch]].
+     */
+    type?: BatchType;
+    /** An optional function that, if supplied, is invoked periodically to determine if the process of producing graphics from the glTF should terminate early. */
+    shouldAbort?: ShouldAbortReadGltf;
+    /** If true, each vertex in the graphics should belong to exactly one triangle. This is less efficient than sharing vertices between adjoining triangles, but
+     * sometimes required - for example, for [ViewFlags.wiremesh]($common).
+     */
+    deduplicateVertices?: boolean;
+    /** If true, the graphics produced will always use a [[VertexTable]]; otherwise, where possible a [[RealityMeshPrimitive]] will be used instead.
+     * Reality meshes are simpler but do not support some features like lighting.
+     */
+    vertexTableRequired?: boolean;
+}
 /** Deserializes [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
 export declare abstract class GltfReader {
-    protected readonly _buffer: ByteStream;
-    protected readonly _scene: any;
-    protected readonly _accessors: any;
-    protected readonly _bufferViews: any;
-    protected readonly _meshes: any;
-    protected readonly _nodes: any;
-    protected readonly _batchData: any;
-    protected readonly _materialValues: any;
-    protected readonly _textures: any;
-    protected readonly _renderMaterials: any;
-    protected readonly _namedTextures: any;
-    protected readonly _images: any;
-    protected readonly _samplers: any;
-    protected readonly _techniques: any;
-    protected readonly _extensions: any;
-    protected readonly _binaryData: Uint8Array;
+    protected readonly _glTF: Gltf;
+    protected readonly _version: number;
     protected readonly _iModel: IModelConnection;
     protected readonly _is3d: boolean;
-    protected readonly _modelId: Id64String;
     protected readonly _system: RenderSystem;
-    protected readonly _returnToCenter: number[] | undefined;
+    protected readonly _returnToCenter?: Point3d;
     protected readonly _yAxisUp: boolean;
+    protected readonly _baseUrl?: string;
     protected readonly _type: BatchType;
+    protected readonly _deduplicateVertices: boolean;
+    protected readonly _vertexTableRequired: boolean;
     private readonly _canceled?;
+    protected readonly _sceneNodes: GltfId[];
+    protected _computedContentRange?: ElementAlignedBox3d;
+    private readonly _resolvedTextures;
+    protected get _nodes(): GltfDictionary<GltfNode>;
+    protected get _meshes(): GltfDictionary<GltfMesh>;
+    protected get _accessors(): GltfDictionary<GltfAccessor>;
+    protected get _bufferViews(): GltfDictionary<GltfBufferViewProps>;
+    protected get _materials(): GltfDictionary<GltfMaterial>;
+    protected get _samplers(): GltfDictionary<GltfSampler>;
+    protected get _textures(): GltfDictionary<GltfTexture>;
+    protected get _images(): GltfDictionary<GltfImage & {
+        resolvedImage?: HTMLImageElement;
+    }>;
+    protected get _buffers(): GltfDictionary<GltfBuffer & {
+        resolvedBuffer?: Uint8Array;
+    }>;
     /** Asynchronously deserialize the tile data and return the result. */
     abstract read(): Promise<GltfReaderResult>;
     protected get _isCanceled(): boolean;
     protected get _isVolumeClassifier(): boolean;
-    protected readGltfAndCreateGraphics(isLeaf: boolean, featureTable: FeatureTable, contentRange: ElementAlignedBox3d, transformToRoot?: Transform, pseudoRtcBias?: Vector3d, instances?: InstancedGraphicParams): GltfReaderResult;
+    /** 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: Iterable<GltfId>): Iterable<GltfNode>;
+    /** Traverse the nodes specified by their scene, recursing into their child nodes.
+     * @throws Error if a node appears more than once during traversal
+     */
+    traverseScene(): Iterable<GltfNode>;
+    protected readGltfAndCreateGraphics(isLeaf: boolean, featureTable: FeatureTable | undefined, contentRange: ElementAlignedBox3d | undefined, transformToRoot?: Transform, pseudoRtcBias?: Vector3d, instances?: InstancedGraphicParams): GltfReaderResult;
     private graphicFromMeshData;
     private readNodeAndCreateGraphics;
-    getBufferView(json: any, accessorName: string): GltfBufferView | undefined;
-    readBufferData32(json: any, accessorName: string): GltfBufferData | undefined;
-    readBufferData16(json: any, accessorName: string): GltfBufferData | undefined;
-    readBufferData8(json: any, accessorName: string): GltfBufferData | undefined;
-    readBufferDataFloat(json: any, accessorName: string): GltfBufferData | undefined;
-    protected constructor(props: GltfReaderProps, iModel: IModelConnection, modelId: Id64String, is3d: boolean, system: RenderSystem, type?: BatchType, isCanceled?: ShouldAbortReadGltf);
-    protected readBufferData(json: any, accessorName: string, type: GltfDataType): GltfBufferData | undefined;
+    getBufferView(json: {
+        [k: string]: any;
+    }, accessorName: string): GltfBufferView | undefined;
+    readBufferData32(json: {
+        [k: string]: any;
+    }, accessorName: string): GltfBufferData | undefined;
+    readBufferData16(json: {
+        [k: string]: any;
+    }, accessorName: string): GltfBufferData | undefined;
+    readBufferData8(json: {
+        [k: string]: any;
+    }, accessorName: string): GltfBufferData | undefined;
+    readBufferDataFloat(json: {
+        [k: string]: any;
+    }, accessorName: string): GltfBufferData | undefined;
+    protected constructor(args: GltfReaderArgs);
+    protected readBufferData(json: {
+        [k: string]: any;
+    }, accessorName: string, type: GltfDataType): GltfBufferData | undefined;
     protected readFeatureIndices(_json: any): number[] | undefined;
-    private colorFromJson;
-    private colorFromMaterial;
     private extractTextureId;
-    protected createDisplayParams(materialJson: any, hasBakedLighting: boolean): DisplayParams | undefined;
-    protected extractReturnToCenter(extensions: any): number[] | undefined;
-    protected readMeshPrimitive(primitive: any, featureTable?: FeatureTable, pseudoRtcBias?: Vector3d): GltfMeshData | undefined;
+    private isMaterialTransparent;
+    protected createDisplayParams(material: GltfMaterial, hasBakedLighting: boolean): DisplayParams | undefined;
+    protected readMeshPrimitive(primitive: GltfMeshPrimitive, featureTable?: FeatureTable, pseudoRtcBias?: Vector3d): GltfMeshData | undefined;
+    private deduplicateVertices;
     /**
      *
      * @param positions quantized points
@@ -116,15 +598,72 @@ export declare abstract class GltfReader {
      * capacity of 32 bit integers. This is essentially an ad hoc RTC applied at read time.
      */
     private readVertices;
-    protected readIndices(json: any, accessorName: string): number[] | undefined;
+    protected readIndices(json: {
+        [k: string]: any;
+    }, accessorName: string): number[] | undefined;
     protected readBatchTable(_mesh: Mesh, _json: any): void;
-    protected readMeshIndices(mesh: GltfMeshData, json: any): boolean;
-    protected readNormals(mesh: GltfMeshData, json: any, accessorName: string): boolean;
+    protected readMeshIndices(mesh: GltfMeshData, json: {
+        [k: string]: any;
+    }): boolean;
+    protected readNormals(mesh: GltfMeshData, json: {
+        [k: string]: any;
+    }, accessorName: string): boolean;
     private readUVParams;
-    protected readPolylines(polylines: MeshPolylineList, json: any, accessorName: string, disjoint: boolean): boolean;
-    protected loadTextures(): Promise<void>;
-    protected loadTextureImage(imageJson: any, samplerJson: any, isTransparent: boolean): Promise<RenderTexture | undefined>;
-    protected loadTexture(textureId: string, isTransparent: boolean): Promise<void>;
-    protected findTextureMapping(textureId: string): TextureMapping | undefined;
+    protected readPolylines(polylines: MeshPolylineList, json: {
+        [k: string]: any;
+    }, accessorName: string, disjoint: boolean): boolean;
+    protected resolveResources(): Promise<void>;
+    private resolveUrl;
+    private resolveBuffer;
+    private resolveImage;
+    private resolveTexture;
+    protected findTextureMapping(id: string, isTransparent: boolean): TextureMapping | undefined;
+}
+/** Arguments supplied to [[readGltfGraphics]] to produce a [[RenderGraphic]] from a [glTF](https://www.khronos.org/gltf/) asset.
+ * @public
+ */
+export interface ReadGltfGraphicsArgs {
+    /** A representation of the glTF data as one of:
+     *  - The binary data in glb format as a Uint8Array; or
+     *  - A JSON object conforming to the [glTF 2.0 specification](https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html); or
+     *  - A Uint8Array containing the utf8-encoded stringified JSON of an object conforming to the [glTF 2.0 specification](https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html).
+     */
+    gltf: Uint8Array | Object;
+    /** The iModel with which the graphics will be associated - typically obtained from the [[Viewport]] into which they will be drawn. */
+    iModel: IModelConnection;
+    /** Options for making the graphic [pickable]($docs/learning/frontend/ViewDecorations#pickable-view-graphic-decorations).
+     * Only the [[PickableGraphicOptions.id]] property is required to make the graphics pickable. If a `modelId` is also supplied and differs from the `id`,
+     * the graphics will also be selectable.
+     */
+    pickableOptions?: PickableGraphicOptions & {
+        modelId?: Id64String;
+    };
+    /** The base URL for any relative URIs in the glTF. Typically, this is the same as the URL for the glTF asset itself.
+     * If not supplied, relative URIs cannot be resolved. For glTF assets containing no relative URIs, this is not required.
+     */
+    baseUrl?: string;
+}
+/** 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 declare function readGltfGraphics(args: ReadGltfGraphicsArgs): Promise<RenderGraphic | undefined>;
+/** Implements [[readGltfGraphics]]. Exported strictly for tests.
+ * @internal
+ */
+export declare class GltfGraphicsReader extends GltfReader {
+    private readonly _featureTable?;
+    readonly binaryData?: Uint8Array;
+    constructor(props: GltfReaderProps, args: ReadGltfGraphicsArgs);
+    read(): Promise<GltfReaderResult>;
+    get nodes(): GltfDictionary<GltfNode>;
+    get scenes(): GltfDictionary<GltfScene>;
+    get sceneNodes(): GltfId[];
+    get textures(): GltfDictionary<GltfTexture>;
 }
+export {};
 //# sourceMappingURL=GltfReader.d.ts.map