@babylonjs/loaders 5.0.0-beta.8 → 5.0.0-beta.8-snapshot

package/glTF/2.0/glTFLoader.d.ts

@@ -1,357 +0,0 @@
-import { Nullable } from "@babylonjs/core/types";
-import { Camera } from "@babylonjs/core/Cameras/camera";
-import { AnimationGroup } from "@babylonjs/core/Animations/animationGroup";
-import { Material } from "@babylonjs/core/Materials/material";
-import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode";
-import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh";
-import { Mesh } from "@babylonjs/core/Meshes/mesh";
-import { ISceneLoaderAsyncResult, ISceneLoaderProgressEvent } from "@babylonjs/core/Loading/sceneLoader";
-import { Scene } from "@babylonjs/core/scene";
-import { IProperty } from "babylonjs-gltf2interface";
-import { IGLTF, ISampler, INode, IScene, IMesh, IAccessor, ICamera, IAnimation, IAnimationChannel, IBuffer, IBufferView, IMaterial, ITextureInfo, ITexture, IImage, IMeshPrimitive, IArrayItem as IArrItem } from "./glTFLoaderInterfaces";
-import { IGLTFLoaderExtension } from "./glTFLoaderExtension";
-import { IGLTFLoader, GLTFFileLoader, IGLTFLoaderData } from "../glTFFileLoader";
-import { IAnimatable } from '@babylonjs/core/Animations/animatable.interface';
-import { IDataBuffer } from '@babylonjs/core/Misc/dataReader';
-import { Light } from '@babylonjs/core/Lights/light';
-import { AssetContainer } from "@babylonjs/core/assetContainer";
-/**
- * Helper class for working with arrays when loading the glTF asset
- */
-export declare class ArrayItem {
-    /**
-     * Gets an item from the given array.
-     * @param context The context when loading the asset
-     * @param array The array to get the item from
-     * @param index The index to the array
-     * @returns The array item
-     */
-    static Get<T>(context: string, array: ArrayLike<T> | undefined, index: number | undefined): T;
-    /**
-     * Assign an `index` field to each item of the given array.
-     * @param array The array of items
-     */
-    static Assign(array?: IArrItem[]): void;
-}
-/**
- * The glTF 2.0 loader
- */
-export declare class GLTFLoader implements IGLTFLoader {
-    /** @hidden */
-    _completePromises: Promise<any>[];
-    /** @hidden */
-    _assetContainer: Nullable<AssetContainer>;
-    /** Storage */
-    _babylonLights: Light[];
-    /** @hidden */
-    _disableInstancedMesh: number;
-    private readonly _parent;
-    private readonly _extensions;
-    private _disposed;
-    private _rootUrl;
-    private _fileName;
-    private _uniqueRootUrl;
-    private _gltf;
-    private _bin;
-    private _babylonScene;
-    private _rootBabylonMesh;
-    private _defaultBabylonMaterialData;
-    private _postSceneLoadActions;
-    private static _RegisteredExtensions;
-    /**
-     * The default glTF sampler.
-     */
-    static readonly DefaultSampler: ISampler;
-    /**
-     * Registers a loader extension.
-     * @param name The name of the loader extension.
-     * @param factory The factory function that creates the loader extension.
-     */
-    static RegisterExtension(name: string, factory: (loader: GLTFLoader) => IGLTFLoaderExtension): void;
-    /**
-     * Unregisters a loader extension.
-     * @param name The name of the loader extension.
-     * @returns A boolean indicating whether the extension has been unregistered
-     */
-    static UnregisterExtension(name: string): boolean;
-    /**
-     * The object that represents the glTF JSON.
-     */
-    get gltf(): IGLTF;
-    /**
-     * The BIN chunk of a binary glTF.
-     */
-    get bin(): Nullable<IDataBuffer>;
-    /**
-     * The parent file loader.
-     */
-    get parent(): GLTFFileLoader;
-    /**
-     * The Babylon scene when loading the asset.
-     */
-    get babylonScene(): Scene;
-    /**
-     * The root Babylon mesh when loading the asset.
-     */
-    get rootBabylonMesh(): Nullable<Mesh>;
-    /** @hidden */
-    constructor(parent: GLTFFileLoader);
-    /** @hidden */
-    dispose(): void;
-    /** @hidden */
-    importMeshAsync(meshesNames: any, scene: Scene, container: Nullable<AssetContainer>, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<ISceneLoaderAsyncResult>;
-    /** @hidden */
-    loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
-    private _loadAsync;
-    private _loadData;
-    private _setupData;
-    private _loadExtensions;
-    private _checkExtensions;
-    private _createRootNode;
-    /**
-     * Loads a glTF scene.
-     * @param context The context when loading the asset
-     * @param scene The glTF scene property
-     * @returns A promise that resolves when the load is complete
-     */
-    loadSceneAsync(context: string, scene: IScene): Promise<void>;
-    private _forEachPrimitive;
-    private _getGeometries;
-    private _getMeshes;
-    private _getTransformNodes;
-    private _getSkeletons;
-    private _getAnimationGroups;
-    private _startAnimations;
-    /**
-     * Loads a glTF node.
-     * @param context The context when loading the asset
-     * @param node The glTF node property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
-     */
-    loadNodeAsync(context: string, node: INode, assign?: (babylonTransformNode: TransformNode) => void): Promise<TransformNode>;
-    private _loadMeshAsync;
-    /**
-     * @hidden Define this method to modify the default behavior when loading data for mesh primitives.
-     * @param context The context when loading the asset
-     * @param name The mesh name when loading the asset
-     * @param node The glTF node when loading the asset
-     * @param mesh The glTF mesh when loading the asset
-     * @param primitive The glTF mesh primitive property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
-     */
-    _loadMeshPrimitiveAsync(context: string, name: string, node: INode, mesh: IMesh, primitive: IMeshPrimitive, assign: (babylonMesh: AbstractMesh) => void): Promise<AbstractMesh>;
-    private _loadVertexDataAsync;
-    private _createMorphTargets;
-    private _loadMorphTargetsAsync;
-    private _loadMorphTargetVertexDataAsync;
-    private static _LoadTransform;
-    private _loadSkinAsync;
-    private _loadBones;
-    private _findSkeletonRootNode;
-    private _loadBone;
-    private _loadSkinInverseBindMatricesDataAsync;
-    private _updateBoneMatrices;
-    private _getNodeMatrix;
-    /**
-     * Loads a glTF camera.
-     * @param context The context when loading the asset
-     * @param camera The glTF camera property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded Babylon camera when the load is complete
-     */
-    loadCameraAsync(context: string, camera: ICamera, assign?: (babylonCamera: Camera) => void): Promise<Camera>;
-    private _loadAnimationsAsync;
-    /**
-     * Loads a glTF animation.
-     * @param context The context when loading the asset
-     * @param animation The glTF animation property
-     * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
-     */
-    loadAnimationAsync(context: string, animation: IAnimation): Promise<AnimationGroup>;
-    /**
-     * @hidden Loads a glTF animation channel.
-     * @param context The context when loading the asset
-     * @param animationContext The context of the animation when loading the asset
-     * @param animation The glTF animation property
-     * @param channel The glTF animation channel property
-     * @param babylonAnimationGroup The babylon animation group property
-     * @param animationTargetOverride The babylon animation channel target override property. My be null.
-     * @returns A void promise when the channel load is complete
-     */
-    _loadAnimationChannelAsync(context: string, animationContext: string, animation: IAnimation, channel: IAnimationChannel, babylonAnimationGroup: AnimationGroup, animationTargetOverride?: Nullable<IAnimatable>): Promise<void>;
-    private _loadAnimationSamplerAsync;
-    /**
-     * Loads a glTF buffer.
-     * @param context The context when loading the asset
-     * @param buffer The glTF buffer property
-     * @param byteOffset The byte offset to use
-     * @param byteLength The byte length to use
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    loadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Promise<ArrayBufferView>;
-    /**
-     * Loads a glTF buffer view.
-     * @param context The context when loading the asset
-     * @param bufferView The glTF buffer view property
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    loadBufferViewAsync(context: string, bufferView: IBufferView): Promise<ArrayBufferView>;
-    private _loadAccessorAsync;
-    /** @hidden */
-    _loadFloatAccessorAsync(context: string, accessor: IAccessor): Promise<Float32Array>;
-    private _loadIndicesAccessorAsync;
-    private _loadVertexBufferViewAsync;
-    private _loadVertexAccessorAsync;
-    private _loadMaterialMetallicRoughnessPropertiesAsync;
-    /** @hidden */
-    _loadMaterialAsync(context: string, material: IMaterial, babylonMesh: Nullable<Mesh>, babylonDrawMode: number, assign?: (babylonMaterial: Material) => void): Promise<Material>;
-    private _createDefaultMaterial;
-    /**
-     * Creates a Babylon material from a glTF material.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonDrawMode The draw mode for the Babylon material
-     * @returns The Babylon material
-     */
-    createMaterial(context: string, material: IMaterial, babylonDrawMode: number): Material;
-    /**
-     * Loads properties from a glTF material into a Babylon material.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonMaterial The Babylon material
-     * @returns A promise that resolves when the load is complete
-     */
-    loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void>;
-    /**
-     * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonMaterial The Babylon material
-     * @returns A promise that resolves when the load is complete
-     */
-    loadMaterialBasePropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void>;
-    /**
-     * Loads the alpha properties from a glTF material into a Babylon material.
-     * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonMaterial The Babylon material
-     */
-    loadMaterialAlphaProperties(context: string, material: IMaterial, babylonMaterial: Material): void;
-    /**
-     * Loads a glTF texture info.
-     * @param context The context when loading the asset
-     * @param textureInfo The glTF texture info property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded Babylon texture when the load is complete
-     */
-    loadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign?: (babylonTexture: BaseTexture) => void): Promise<BaseTexture>;
-    /** @hidden */
-    _loadTextureAsync(context: string, texture: ITexture, assign?: (babylonTexture: BaseTexture) => void): Promise<BaseTexture>;
-    /** @hidden */
-    _createTextureAsync(context: string, sampler: ISampler, image: IImage, assign?: (babylonTexture: BaseTexture) => void, textureLoaderOptions?: any, useSRGBBuffer?: boolean): Promise<BaseTexture>;
-    private _loadSampler;
-    /**
-     * Loads a glTF image.
-     * @param context The context when loading the asset
-     * @param image The glTF image property
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    loadImageAsync(context: string, image: IImage): Promise<ArrayBufferView>;
-    /**
-     * Loads a glTF uri.
-     * @param context The context when loading the asset
-     * @param property The glTF property associated with the uri
-     * @param uri The base64 or relative uri
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    loadUriAsync(context: string, property: IProperty, uri: string): Promise<ArrayBufferView>;
-    /**
-     * Adds a JSON pointer to the metadata of the Babylon object at `<object>.metadata.gltf.pointers`.
-     * @param babylonObject the Babylon object with metadata
-     * @param pointer the JSON pointer
-     */
-    static AddPointerMetadata(babylonObject: {
-        metadata: any;
-    }, pointer: string): void;
-    private static _GetTextureWrapMode;
-    private static _GetTextureSamplingMode;
-    private static _GetTypedArrayConstructor;
-    private static _GetTypedArray;
-    private static _GetNumComponents;
-    private static _ValidateUri;
-    /** @hidden */
-    static _GetDrawMode(context: string, mode: number | undefined): number;
-    private _compileMaterialsAsync;
-    private _compileShadowGeneratorsAsync;
-    private _forEachExtensions;
-    private _applyExtensions;
-    private _extensionsOnLoading;
-    private _extensionsOnReady;
-    private _extensionsLoadSceneAsync;
-    private _extensionsLoadNodeAsync;
-    private _extensionsLoadCameraAsync;
-    private _extensionsLoadVertexDataAsync;
-    private _extensionsLoadMeshPrimitiveAsync;
-    private _extensionsLoadMaterialAsync;
-    private _extensionsCreateMaterial;
-    private _extensionsLoadMaterialPropertiesAsync;
-    private _extensionsLoadTextureInfoAsync;
-    private _extensionsLoadTextureAsync;
-    private _extensionsLoadAnimationAsync;
-    private _extensionsLoadSkinAsync;
-    private _extensionsLoadUriAsync;
-    private _extensionsLoadBufferViewAsync;
-    private _extensionsLoadBufferAsync;
-    /**
-     * Helper method called by a loader extension to load an glTF extension.
-     * @param context The context when loading the asset
-     * @param property The glTF property to load the extension from
-     * @param extensionName The name of the extension to load
-     * @param actionAsync The action to run
-     * @returns The promise returned by actionAsync or null if the extension does not exist
-     */
-    static LoadExtensionAsync<TExtension = any, TResult = void>(context: string, property: IProperty, extensionName: string, actionAsync: (extensionContext: string, extension: TExtension) => Nullable<Promise<TResult>>): Nullable<Promise<TResult>>;
-    /**
-     * Helper method called by a loader extension to load a glTF extra.
-     * @param context The context when loading the asset
-     * @param property The glTF property to load the extra from
-     * @param extensionName The name of the extension to load
-     * @param actionAsync The action to run
-     * @returns The promise returned by actionAsync or null if the extra does not exist
-     */
-    static LoadExtraAsync<TExtra = any, TResult = void>(context: string, property: IProperty, extensionName: string, actionAsync: (extraContext: string, extra: TExtra) => Nullable<Promise<TResult>>): Nullable<Promise<TResult>>;
-    /**
-     * Checks for presence of an extension.
-     * @param name The name of the extension to check
-     * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
-     */
-    isExtensionUsed(name: string): boolean;
-    /**
-     * Increments the indentation level and logs a message.
-     * @param message The message to log
-     */
-    logOpen(message: string): void;
-    /**
-     * Decrements the indentation level.
-     */
-    logClose(): void;
-    /**
-     * Logs a message
-     * @param message The message to log
-     */
-    log(message: string): void;
-    /**
-     * Starts a performance counter.
-     * @param counterName The name of the performance counter
-     */
-    startPerformanceCounter(counterName: string): void;
-    /**
-     * Ends a performance counter.
-     * @param counterName The name of the performance counter
-     */
-    endPerformanceCounter(counterName: string): void;
-}