nanogl-gltf

import Gltf from "../Gltf"; import IOInterface from "./IOInterface"; import { ExtensionList } from "../extensions/Registry"; import Gltf2 from "../types/Gltf2"; import { ElementOfType, PropertyType, AnyElement, PromiseElementForProperty } from "../types/Elements"; import GltfTypes from "../types/GltfTypes"; import "../extensions/DefaultExtension"; import { GltfLoaderOptions } from "./GltfLoaderOptions"; import { IMaterial } from "../elements/Material"; import { AbortSignal } from "@azure/abort-controller"; export declare class PendingElement { readonly data: Gltf2.IProperty; readonly promise: Promise<AnyElement>; constructor(data: Gltf2.IProperty, element: Promise<AnyElement>); } /** * This class is used to load a Gltf file and its resources, including extensions processing. */ export default class GltfLoader { /** * Gltf object which will be filled with the data from the Gltf file */ gltf: Gltf; /** * Gltf file path */ _url: string; /** * Resolved base directory of the Gltf file */ _baseUrl: string; /** * Implementation of IOInterface made for GLTFs */ gltfIO: IOInterface; /** * Gltf data file content, parsed as JSON from the GLTF/GLB file */ _data: Gltf2.IGLTF; /** * If the loaded file is a GLB file (binary GLTF), data such as images or shaders can be stored as base64-encoded binary data directly in the GLB file. * This buffer contains the decoded data. */ _glbData?: ArrayBuffer; /** * List of extensions activated on this loader */ _extensions: ExtensionList; /** * Map of all created elements from the Gltf data file, by uuid */ _elements: Map<string, Promise<AnyElement>>; /** * List of elements that are being created, waiting to be resolved and added to the Gltf object */ _pendingElements: PendingElement[]; /** * Map of all elements of the Gltf data file, ordered by type */ _byType: Map<GltfTypes, Promise<AnyElement>[]>; /** * Map of all properties of the Gltf data file, ordered by type */ _propertyMaps: Map<GltfTypes, Gltf2.Property[]>; /** * Abort signal if you want to be able to cancel the request at any time */ readonly abortSignal: AbortSignal; /** * Texture's minFilter to use when there is no specified one in this loader's options or in textures' samplers * @default GL_LINEAR */ readonly defaultTextureFilter: GLenum; /** * @param gltfIO Implementation of IOInterface made for GLTFs * @param url Gltf file path * @param options Options for Gltf loader */ constructor(gltfIO: IOInterface, url: string, options?: GltfLoaderOptions); /** * Load and return the gltf file */ load(): Promise<Gltf>; /** * Parse the buffer then prepare it for loading by adding uuids, types and indexes * If the buffer represents a GLTF file (plain JSON), il will be parsed directly. * If the buffer represents a GLB file (binary), it will be first decoded, then parsed. * @param buffer Buffer to unpack */ unpack(buffer: ArrayBuffer): void; /** * Decode a buffer representing a binary GLB file, then parse it and prepare it for loading * @param buffer Buffer to unpack */ unpackGlb(buffer: ArrayBuffer): void; /** * Resolve an absolute file path relative to this loader base directory * @param uri URI to resolve */ resolveUri(uri: string): string; /** * Load a buffer from an URI, if no URI is provided the _glbData buffer will be returned * @param uri URI to load */ loadBufferUri: (uri?: string) => Promise<ArrayBuffer>; /** * If element has no name or extras, give it the ones from the data * @param data Data to add * @param element Element to add data on */ parseCommonGltfProperty(data: P, element: ElementOfType<PropertyType>): void; /** * Create a Gltf element from its raw data, with extension handling if needed. * @param data Element data coming from the .gltf file */ _createElement(data: P): PromiseElementForProperty; /** * Create a Gltf element from its raw data, passing it through all the loader's extensions. * If no extension handles this specific element, a basic corresponding element will be created. * @param data Element data coming from the .gltf file */ _createElementInstance(data: P): PromiseElementForProperty; /** * Some extensions may want to modify the element after it has been created, this method will call all the extensions that want to do so. * @param data Element data coming from the .gltf file * @param element Corresponding element already created */ _extensionsAccept(data: P, element: ElementOfType<PropertyType>): PromiseElementForProperty; /** * Load an element from its data, if the element is already loaded it will be returned directly. * @param data Data to load */ _loadElement(data: P): PromiseElementForProperty; /** * Provide a default material if needed. Used for Primitives that don't have a material. */ loadDefaultMaterial(): Promise<IMaterial>; /** * Get the array of elements of a given type. If the array doesn't exist, it will be created. * @param type Type of elements to get */ private _getElementHolder; /** * Get an element of a given type and index. If the element doesn't exist, it will be created by retrieving its data from the Gltf data file. * @param type Element's type * @param index Element's index */ getElement<T extends GltfTypes>(type: T, index: number): Promise<ElementOfType<T>>; /** * Parse all prepared elements of the Gltf data file, create them and add them to the Gltf object */ parseAll(): Promise<void>; /** * Load multiple elements from their data * @param dataList Array of elements to load */ private _loadElements; /** * Wait for all pending elements creation to complete and register them in Gltf object */ resolveElements(): Promise<void>; /** * Parse the Gltf data and prepare it for loading * @param gltfData Gltf data to parse */ prepareGltfDatas(gltfData: Gltf2.IGLTF): void; /** * Prepare multiple Gltf properties for loading, having the same type and parent * @param elementsData Elements to prepare * @param type Elements' type * @param parent Elements' parent */ prepareGltfProperties(elementsData: Gltf2.Property[], type: GltfTypes, parent: Gltf2.Property): void; /** * Prepare multiple Gltf root properties for loading, having the same type and parent. * A root property is a property that doesn't have a parent in the Gltf data. * @param elementsData Elements to prepare * @param type Elements' type * @param parent Elements' parent */ prepareGltfRootProperties(elementsData: Gltf2.Property[], type: GltfTypes, parent: Gltf2.Property): void; /** * Prepare Gltf property for loading by adding him a uuid, a type, an index and a parent * @param element Element to prepare * @param type Element's type * @param index Element's index * @param parent Element's parent */ prepareGltfProperty(element: Gltf2.Property, type: GltfTypes, index: number, parent: Gltf2.Property): void; }