///
///
declare module 'babylonjs-loaders' {
export = BABYLON;
}
declare module BABYLON {
class STLFileLoader implements ISceneLoaderPlugin {
solidPattern: RegExp;
facetsPattern: RegExp;
normalPattern: RegExp;
vertexPattern: RegExp;
name: string;
extensions: ISceneLoaderPluginExtensions;
importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: Nullable, particleSystems: Nullable, skeletons: Nullable): boolean;
load(scene: Scene, data: any, rootUrl: string): boolean;
loadAssetContainer(scene: Scene, data: string, rootUrl: string, onError?: (message: string, exception?: any) => void): AssetContainer;
private isBinary(data);
private parseBinary(mesh, data);
private parseASCII(mesh, solidData);
}
}
declare module BABYLON {
/**
* Class reading and parsing the MTL file bundled with the obj file.
*/
class MTLFileLoader {
materials: BABYLON.StandardMaterial[];
/**
* This function will read the mtl file and create each material described inside
* This function could be improve by adding :
* -some component missing (Ni, Tf...)
* -including the specific options available
*
* @param scene
* @param data
* @param rootUrl
*/
parseMTL(scene: BABYLON.Scene, data: string | ArrayBuffer, rootUrl: string): void;
/**
* Gets the texture for the material.
*
* If the material is imported from input file,
* We sanitize the url to ensure it takes the textre from aside the material.
*
* @param rootUrl The root url to load from
* @param value The value stored in the mtl
* @return The Texture
*/
private static _getTexture(rootUrl, value, scene);
}
class OBJFileLoader implements ISceneLoaderPlugin {
static OPTIMIZE_WITH_UV: boolean;
static INVERT_Y: boolean;
name: string;
extensions: string;
obj: RegExp;
group: RegExp;
mtllib: RegExp;
usemtl: RegExp;
smooth: RegExp;
vertexPattern: RegExp;
normalPattern: RegExp;
uvPattern: RegExp;
facePattern1: RegExp;
facePattern2: RegExp;
facePattern3: RegExp;
facePattern4: RegExp;
/**
* Calls synchronously the MTL file attached to this obj.
* Load function or importMesh function don't enable to load 2 files in the same time asynchronously.
* Without this function materials are not displayed in the first frame (but displayed after).
* In consequence it is impossible to get material information in your HTML file
*
* @param url The URL of the MTL file
* @param rootUrl
* @param onSuccess Callback function to be called when the MTL file is loaded
* @private
*/
private _loadMTL(url, rootUrl, onSuccess);
importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: Nullable, particleSystems: Nullable, skeletons: Nullable): boolean;
load(scene: Scene, data: string, rootUrl: string): boolean;
loadAssetContainer(scene: Scene, data: string, rootUrl: string, onError?: (message: string, exception?: any) => void): AssetContainer;
/**
* Read the OBJ file and create an Array of meshes.
* Each mesh contains all information given by the OBJ and the MTL file.
* i.e. vertices positions and indices, optional normals values, optional UV values, optional material
*
* @param meshesNames
* @param scene BABYLON.Scene The scene where are displayed the data
* @param data String The content of the obj file
* @param rootUrl String The path to the folder
* @returns Array
* @private
*/
private _parseSolid(meshesNames, scene, data, rootUrl);
}
}
declare module BABYLON {
/**
* Mode that determines the coordinate system to use.
*/
enum GLTFLoaderCoordinateSystemMode {
/**
* Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.
*/
AUTO = 0,
/**
* Sets the useRightHandedSystem flag on the scene.
*/
FORCE_RIGHT_HANDED = 1,
}
/**
* Mode that determines what animations will start.
*/
enum GLTFLoaderAnimationStartMode {
/**
* No animation will start.
*/
NONE = 0,
/**
* The first animation will start.
*/
FIRST = 1,
/**
* All animations will start.
*/
ALL = 2,
}
/**
* Interface that contains the data for the glTF asset.
*/
interface IGLTFLoaderData {
/**
* JSON that represents the glTF.
*/
json: Object;
/**
* The BIN chunk of a binary glTF
*/
bin: Nullable;
}
/**
* Interface for extending the loader.
*/
interface IGLTFLoaderExtension {
/**
* The name of this extension.
*/
readonly name: string;
/**
* Defines whether this extension is enabled.
*/
enabled: boolean;
}
/**
* Loader state.
*/
enum GLTFLoaderState {
/**
* The asset is loading.
*/
LOADING = 0,
/**
* The asset is ready for rendering.
*/
READY = 1,
/**
* The asset is completely loaded.
*/
COMPLETE = 2,
}
/**
* Loader interface.
*/
interface IGLTFLoader extends IDisposable {
/**
* Mode that determines the coordinate system to use.
*/
coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
/**
* Mode that determines what animations will start.
*/
animationStartMode: GLTFLoaderAnimationStartMode;
/**
* Defines if the loader should compile materials.
*/
compileMaterials: boolean;
/**
* Defines if the loader should also compile materials with clip planes.
*/
useClipPlane: boolean;
/**
* Defines if the loader should compile shadow generators.
*/
compileShadowGenerators: boolean;
/**
* Defines if the Alpha blended materials are only applied as coverage.
* If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
* If true, no extra effects are applied to transparent pixels.
*/
transparencyAsCoverage: boolean;
/**
* Function called before loading a url referenced by the asset.
*/
preprocessUrlAsync: (url: string) => Promise;
/**
* Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
*/
onMeshLoadedObservable: Observable;
/**
* Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
*/
onTextureLoadedObservable: Observable;
/**
* Observable raised when the loader creates a material after parsing the glTF properties of the material.
*/
onMaterialLoadedObservable: Observable;
/**
* Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
*/
onCameraLoadedObservable: Observable;
/**
* Observable raised when the asset is completely loaded, immediately before the loader is disposed.
* For assets with LODs, raised when all of the LODs are complete.
* For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
*/
onCompleteObservable: Observable;
/**
* Observable raised after the loader is disposed.
*/
onDisposeObservable: Observable;
/**
* Observable raised after a loader extension is created.
* Set additional options for a loader extension in this event.
*/
onExtensionLoadedObservable: Observable;
/**
* Loader state or null if the loader is not active.
*/
state: Nullable;
/**
* Imports meshes from the given data and adds them to the scene.
*/
importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<{
meshes: AbstractMesh[];
particleSystems: ParticleSystem[];
skeletons: Skeleton[];
animationGroups: AnimationGroup[];
}>;
/**
* Loads all objects from the given data and adds them to the scene.
*/
loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise;
}
/**
* File loader for loading glTF files into a scene.
*/
class GLTFFileLoader implements IDisposable, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
/**
* Factory function that creates a glTF 1.0 loader
*/
static CreateGLTFLoaderV1: () => IGLTFLoader;
/**
* Factory function that creates a glTF 2.0 loader
*/
static CreateGLTFLoaderV2: () => IGLTFLoader;
/**
* Raised when the asset has been parsed
*/
onParsedObservable: Observable;
private _onParsedObserver;
/**
* Raised when the asset has been parsed
*/
onParsed: (loaderData: IGLTFLoaderData) => void;
/**
* Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
* Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
* Defaults to true.
*/
static IncrementalLoading: boolean;
/**
* Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
* Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
*/
static HomogeneousCoordinates: boolean;
/**
* The coordinate system mode. Defaults to AUTO.
*/
coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
/**
* The animation start mode. Defaults to FIRST.
*/
animationStartMode: GLTFLoaderAnimationStartMode;
/**
* Defines if the loader should compile materials before raising the success callback. Defaults to false.
*/
compileMaterials: boolean;
/**
* Defines if the loader should also compile materials with clip planes. Defaults to false.
*/
useClipPlane: boolean;
/**
* Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
*/
compileShadowGenerators: boolean;
/**
* Defines if the Alpha blended materials are only applied as coverage.
* If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
* If true, no extra effects are applied to transparent pixels.
*/
transparencyAsCoverage: boolean;
/**
* Function called before loading a url referenced by the asset.
*/
preprocessUrlAsync: (url: string) => Promise;
/**
* Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
*/
readonly onMeshLoadedObservable: Observable;
private _onMeshLoadedObserver;
/**
* Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
*/
onMeshLoaded: (mesh: AbstractMesh) => void;
/**
* Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
*/
readonly onTextureLoadedObservable: Observable;
private _onTextureLoadedObserver;
/**
* Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
*/
onTextureLoaded: (texture: BaseTexture) => void;
/**
* Observable raised when the loader creates a material after parsing the glTF properties of the material.
*/
readonly onMaterialLoadedObservable: Observable;
private _onMaterialLoadedObserver;
/**
* Callback raised when the loader creates a material after parsing the glTF properties of the material.
*/
onMaterialLoaded: (material: Material) => void;
/**
* Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
*/
readonly onCameraLoadedObservable: Observable;
private _onCameraLoadedObserver;
/**
* Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
*/
onCameraLoaded: (camera: Camera) => void;
/**
* Observable raised when the asset is completely loaded, immediately before the loader is disposed.
* For assets with LODs, raised when all of the LODs are complete.
* For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
*/
readonly onCompleteObservable: Observable;
private _onCompleteObserver;
/**
* Callback raised when the asset is completely loaded, immediately before the loader is disposed.
*/
onComplete: () => void;
/**
* Observable raised after the loader is disposed.
*/
readonly onDisposeObservable: Observable;
private _onDisposeObserver;
/**
* Callback raised after the loader is disposed.
*/
onDispose: () => void;
/**
* Observable raised after a loader extension is created.
* Set additional options for a loader extension in this event.
*/
readonly onExtensionLoadedObservable: Observable;
private _onExtensionLoadedObserver;
/**
* Callback raised after a loader extension is created.
*/
onExtensionLoaded: (extension: IGLTFLoaderExtension) => void;
/**
* Returns a promise that resolves when the asset is completely loaded.
* @returns a promise that resolves when the asset is completely loaded.
*/
whenCompleteAsync(): Promise;
/**
* The loader state or null if the loader is not active.
*/
readonly loaderState: Nullable;
private _loader;
/**
* Name of the loader ("gltf")
*/
name: string;
/**
* Supported file extensions of the loader (.gltf, .glb)
*/
extensions: ISceneLoaderPluginExtensions;
/**
* Disposes the loader, releases resources during load, and cancels any outstanding requests.
*/
dispose(): void;
/**
* Imports one or more meshes from the loaded glTF data and adds them to the scene
* @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
* @param scene the scene the meshes should be added to
* @param data the glTF data to load
* @param rootUrl root url to load from
* @param onProgress event that fires when loading progress has occured
* @returns a promise containg the loaded meshes, particles, skeletons and animations
*/
importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
meshes: AbstractMesh[];
particleSystems: ParticleSystem[];
skeletons: Skeleton[];
animationGroups: AnimationGroup[];
}>;
/**
* Imports all objects from the loaded glTF data and adds them to the scene
* @param scene the scene the objects should be added to
* @param data the glTF data to load
* @param rootUrl root url to load from
* @param onProgress event that fires when loading progress has occured
* @returns a promise which completes when objects have been loaded to the scene
*/
loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise;
/**
* Load into an asset container.
* @param scene The scene to load into
* @param data The data to import
* @param rootUrl The root url for scene and resources
* @param onProgress The callback when the load progresses
* @returns The loaded asset container
*/
loadAssetContainerAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise;
/**
* If the data string can be loaded directly.
* @param data string contianing the file data
* @returns if the data can be loaded directly
*/
canDirectLoad(data: string): boolean;
/**
* Rewrites a url by combining a root url and response url.
*/
rewriteRootURL: (rootUrl: string, responseURL?: string) => string;
/**
* Instantiates a glTF file loader plugin.
* @returns the created plugin
*/
createPlugin(): ISceneLoaderPlugin | ISceneLoaderPluginAsync;
private _parse(data);
private _getLoader(loaderData);
private static _parseBinary(data);
private static _parseV1(binaryReader);
private static _parseV2(binaryReader);
private static _parseVersion(version);
private static _compareVersion(a, b);
private static _decodeBufferToText(buffer);
}
}
declare module BABYLON.GLTF1 {
/**
* Enums
*/
enum EComponentType {
BYTE = 5120,
UNSIGNED_BYTE = 5121,
SHORT = 5122,
UNSIGNED_SHORT = 5123,
FLOAT = 5126,
}
enum EShaderType {
FRAGMENT = 35632,
VERTEX = 35633,
}
enum EParameterType {
BYTE = 5120,
UNSIGNED_BYTE = 5121,
SHORT = 5122,
UNSIGNED_SHORT = 5123,
INT = 5124,
UNSIGNED_INT = 5125,
FLOAT = 5126,
FLOAT_VEC2 = 35664,
FLOAT_VEC3 = 35665,
FLOAT_VEC4 = 35666,
INT_VEC2 = 35667,
INT_VEC3 = 35668,
INT_VEC4 = 35669,
BOOL = 35670,
BOOL_VEC2 = 35671,
BOOL_VEC3 = 35672,
BOOL_VEC4 = 35673,
FLOAT_MAT2 = 35674,
FLOAT_MAT3 = 35675,
FLOAT_MAT4 = 35676,
SAMPLER_2D = 35678,
}
enum ETextureWrapMode {
CLAMP_TO_EDGE = 33071,
MIRRORED_REPEAT = 33648,
REPEAT = 10497,
}
enum ETextureFilterType {
NEAREST = 9728,
LINEAR = 9728,
NEAREST_MIPMAP_NEAREST = 9984,
LINEAR_MIPMAP_NEAREST = 9985,
NEAREST_MIPMAP_LINEAR = 9986,
LINEAR_MIPMAP_LINEAR = 9987,
}
enum ETextureFormat {
ALPHA = 6406,
RGB = 6407,
RGBA = 6408,
LUMINANCE = 6409,
LUMINANCE_ALPHA = 6410,
}
enum ECullingType {
FRONT = 1028,
BACK = 1029,
FRONT_AND_BACK = 1032,
}
enum EBlendingFunction {
ZERO = 0,
ONE = 1,
SRC_COLOR = 768,
ONE_MINUS_SRC_COLOR = 769,
DST_COLOR = 774,
ONE_MINUS_DST_COLOR = 775,
SRC_ALPHA = 770,
ONE_MINUS_SRC_ALPHA = 771,
DST_ALPHA = 772,
ONE_MINUS_DST_ALPHA = 773,
CONSTANT_COLOR = 32769,
ONE_MINUS_CONSTANT_COLOR = 32770,
CONSTANT_ALPHA = 32771,
ONE_MINUS_CONSTANT_ALPHA = 32772,
SRC_ALPHA_SATURATE = 776,
}
/**
* Interfaces
*/
interface IGLTFProperty {
extensions?: {
[key: string]: any;
};
extras?: Object;
}
interface IGLTFChildRootProperty extends IGLTFProperty {
name?: string;
}
interface IGLTFAccessor extends IGLTFChildRootProperty {
bufferView: string;
byteOffset: number;
byteStride: number;
count: number;
type: string;
componentType: EComponentType;
max?: number[];
min?: number[];
name?: string;
}
interface IGLTFBufferView extends IGLTFChildRootProperty {
buffer: string;
byteOffset: number;
byteLength: number;
byteStride: number;
target?: number;
}
interface IGLTFBuffer extends IGLTFChildRootProperty {
uri: string;
byteLength?: number;
type?: string;
}
interface IGLTFShader extends IGLTFChildRootProperty {
uri: string;
type: EShaderType;
}
interface IGLTFProgram extends IGLTFChildRootProperty {
attributes: string[];
fragmentShader: string;
vertexShader: string;
}
interface IGLTFTechniqueParameter {
type: number;
count?: number;
semantic?: string;
node?: string;
value?: number | boolean | string | Array;
source?: string;
babylonValue?: any;
}
interface IGLTFTechniqueCommonProfile {
lightingModel: string;
texcoordBindings: Object;
parameters?: Array;
}
interface IGLTFTechniqueStatesFunctions {
blendColor?: number[];
blendEquationSeparate?: number[];
blendFuncSeparate?: number[];
colorMask: boolean[];
cullFace: number[];
}
interface IGLTFTechniqueStates {
enable: number[];
functions: IGLTFTechniqueStatesFunctions;
}
interface IGLTFTechnique extends IGLTFChildRootProperty {
parameters: {
[key: string]: IGLTFTechniqueParameter;
};
program: string;
attributes: {
[key: string]: string;
};
uniforms: {
[key: string]: string;
};
states: IGLTFTechniqueStates;
}
interface IGLTFMaterial extends IGLTFChildRootProperty {
technique?: string;
values: string[];
}
interface IGLTFMeshPrimitive extends IGLTFProperty {
attributes: {
[key: string]: string;
};
indices: string;
material: string;
mode?: number;
}
interface IGLTFMesh extends IGLTFChildRootProperty {
primitives: IGLTFMeshPrimitive[];
}
interface IGLTFImage extends IGLTFChildRootProperty {
uri: string;
}
interface IGLTFSampler extends IGLTFChildRootProperty {
magFilter?: number;
minFilter?: number;
wrapS?: number;
wrapT?: number;
}
interface IGLTFTexture extends IGLTFChildRootProperty {
sampler: string;
source: string;
format?: ETextureFormat;
internalFormat?: ETextureFormat;
target?: number;
type?: number;
babylonTexture?: Texture;
}
interface IGLTFAmbienLight {
color?: number[];
}
interface IGLTFDirectionalLight {
color?: number[];
}
interface IGLTFPointLight {
color?: number[];
constantAttenuation?: number;
linearAttenuation?: number;
quadraticAttenuation?: number;
}
interface IGLTFSpotLight {
color?: number[];
constantAttenuation?: number;
fallOfAngle?: number;
fallOffExponent?: number;
linearAttenuation?: number;
quadraticAttenuation?: number;
}
interface IGLTFLight extends IGLTFChildRootProperty {
type: string;
}
interface IGLTFCameraOrthographic {
xmag: number;
ymag: number;
zfar: number;
znear: number;
}
interface IGLTFCameraPerspective {
aspectRatio: number;
yfov: number;
zfar: number;
znear: number;
}
interface IGLTFCamera extends IGLTFChildRootProperty {
type: string;
}
interface IGLTFAnimationChannelTarget {
id: string;
path: string;
}
interface IGLTFAnimationChannel {
sampler: string;
target: IGLTFAnimationChannelTarget;
}
interface IGLTFAnimationSampler {
input: string;
output: string;
interpolation?: string;
}
interface IGLTFAnimation extends IGLTFChildRootProperty {
channels?: IGLTFAnimationChannel[];
parameters?: {
[key: string]: string;
};
samplers?: {
[key: string]: IGLTFAnimationSampler;
};
}
interface IGLTFNodeInstanceSkin {
skeletons: string[];
skin: string;
meshes: string[];
}
interface IGLTFSkins extends IGLTFChildRootProperty {
bindShapeMatrix: number[];
inverseBindMatrices: string;
jointNames: string[];
babylonSkeleton?: Skeleton;
}
interface IGLTFNode extends IGLTFChildRootProperty {
camera?: string;
children: string[];
skin?: string;
jointName?: string;
light?: string;
matrix: number[];
mesh?: string;
meshes?: string[];
rotation?: number[];
scale?: number[];
translation?: number[];
babylonNode?: Node;
}
interface IGLTFScene extends IGLTFChildRootProperty {
nodes: string[];
}
/**
* Runtime
*/
interface IGLTFRuntime {
extensions: {
[key: string]: any;
};
accessors: {
[key: string]: IGLTFAccessor;
};
buffers: {
[key: string]: IGLTFBuffer;
};
bufferViews: {
[key: string]: IGLTFBufferView;
};
meshes: {
[key: string]: IGLTFMesh;
};
lights: {
[key: string]: IGLTFLight;
};
cameras: {
[key: string]: IGLTFCamera;
};
nodes: {
[key: string]: IGLTFNode;
};
images: {
[key: string]: IGLTFImage;
};
textures: {
[key: string]: IGLTFTexture;
};
shaders: {
[key: string]: IGLTFShader;
};
programs: {
[key: string]: IGLTFProgram;
};
samplers: {
[key: string]: IGLTFSampler;
};
techniques: {
[key: string]: IGLTFTechnique;
};
materials: {
[key: string]: IGLTFMaterial;
};
animations: {
[key: string]: IGLTFAnimation;
};
skins: {
[key: string]: IGLTFSkins;
};
currentScene?: Object;
scenes: {
[key: string]: IGLTFScene;
};
extensionsUsed: string[];
extensionsRequired?: string[];
buffersCount: number;
shaderscount: number;
scene: Scene;
rootUrl: string;
loadedBufferCount: number;
loadedBufferViews: {
[name: string]: ArrayBufferView;
};
loadedShaderCount: number;
importOnlyMeshes: boolean;
importMeshesNames?: string[];
dummyNodes: Node[];
}
/**
* Bones
*/
interface INodeToRoot {
bone: Bone;
node: IGLTFNode;
id: string;
}
interface IJointNode {
node: IGLTFNode;
id: string;
}
}
declare module BABYLON.GLTF1 {
/**
* Implementation of the base glTF spec
*/
class GLTFLoaderBase {
static CreateRuntime(parsedData: any, scene: Scene, rootUrl: string): IGLTFRuntime;
static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
static LoadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: Nullable) => void, onError: (message: string) => void): void;
static CreateTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: Nullable, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string | ArrayBuffer) => void, onError?: (message: string) => void): void;
static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
}
/**
* glTF V1 Loader
*/
class GLTFLoader implements IGLTFLoader {
static Extensions: {
[name: string]: GLTFLoaderExtension;
};
static RegisterExtension(extension: GLTFLoaderExtension): void;
coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
animationStartMode: GLTFLoaderAnimationStartMode;
compileMaterials: boolean;
useClipPlane: boolean;
compileShadowGenerators: boolean;
transparencyAsCoverage: boolean;
preprocessUrlAsync: (url: string) => Promise;
readonly onMeshLoadedObservable: Observable;
readonly onTextureLoadedObservable: Observable;
readonly onMaterialLoadedObservable: Observable;
readonly onCameraLoadedObservable: Observable;
readonly onCompleteObservable: Observable;
readonly onDisposeObservable: Observable;
readonly onExtensionLoadedObservable: Observable;
state: Nullable;
dispose(): void;
private _importMeshAsync(meshesNames, scene, data, rootUrl, onSuccess, onProgress?, onError?);
/**
* Imports one or more meshes from a loaded gltf file and adds them to the scene
* @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
* @param scene the scene the meshes should be added to
* @param data gltf data containing information of the meshes in a loaded file
* @param rootUrl root url to load from
* @param onProgress event that fires when loading progress has occured
* @returns a promise containg the loaded meshes, particles, skeletons and animations
*/
importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
meshes: AbstractMesh[];
particleSystems: ParticleSystem[];
skeletons: Skeleton[];
animationGroups: AnimationGroup[];
}>;
private _loadAsync(scene, data, rootUrl, onSuccess, onProgress?, onError?);
/**
* Imports all objects from a loaded gltf file and adds them to the scene
* @param scene the scene the objects should be added to
* @param data gltf data containing information of the meshes in a loaded file
* @param rootUrl root url to load from
* @param onProgress event that fires when loading progress has occured
* @returns a promise which completes when objects have been loaded to the scene
*/
loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise;
private _loadShadersAsync(gltfRuntime, onload);
private _loadBuffersAsync(gltfRuntime, onLoad, onProgress?);
private _createNodes(gltfRuntime);
}
}
declare module BABYLON.GLTF1 {
/**
* Utils functions for GLTF
*/
class GLTFUtils {
/**
* Sets the given "parameter" matrix
* @param scene: the {BABYLON.Scene} object
* @param source: the source node where to pick the matrix
* @param parameter: the GLTF technique parameter
* @param uniformName: the name of the shader's uniform
* @param shaderMaterial: the shader material
*/
static SetMatrix(scene: Scene, source: Node, parameter: IGLTFTechniqueParameter, uniformName: string, shaderMaterial: ShaderMaterial | Effect): void;
/**
* Sets the given "parameter" matrix
* @param shaderMaterial: the shader material
* @param uniform: the name of the shader's uniform
* @param value: the value of the uniform
* @param type: the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
*/
static SetUniform(shaderMaterial: ShaderMaterial | Effect, uniform: string, value: any, type: number): boolean;
/**
* Returns the wrap mode of the texture
* @param mode: the mode value
*/
static GetWrapMode(mode: number): number;
/**
* Returns the byte stride giving an accessor
* @param accessor: the GLTF accessor objet
*/
static GetByteStrideFromType(accessor: IGLTFAccessor): number;
/**
* Returns the texture filter mode giving a mode value
* @param mode: the filter mode value
*/
static GetTextureFilterMode(mode: number): ETextureFilterType;
static GetBufferFromBufferView(gltfRuntime: IGLTFRuntime, bufferView: IGLTFBufferView, byteOffset: number, byteLength: number, componentType: EComponentType): ArrayBufferView;
/**
* Returns a buffer from its accessor
* @param gltfRuntime: the GLTF runtime
* @param accessor: the GLTF accessor
*/
static GetBufferFromAccessor(gltfRuntime: IGLTFRuntime, accessor: IGLTFAccessor): any;
/**
* Decodes a buffer view into a string
* @param view: the buffer view
*/
static DecodeBufferToText(view: ArrayBufferView): string;
/**
* Returns the default material of gltf. Related to
* https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
* @param scene: the Babylon.js scene
*/
static GetDefaultMaterial(scene: Scene): ShaderMaterial;
private static _DefaultMaterial;
}
}
declare module BABYLON.GLTF1 {
abstract class GLTFLoaderExtension {
private _name;
constructor(name: string);
readonly name: string;
/**
* Defines an override for loading the runtime
* Return true to stop further extensions from loading the runtime
*/
loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): boolean;
/**
* Defines an onverride for creating gltf runtime
* Return true to stop further extensions from creating the runtime
*/
loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): boolean;
/**
* Defines an override for loading buffers
* Return true to stop further extensions from loading this buffer
*/
loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): boolean;
/**
* Defines an override for loading texture buffers
* Return true to stop further extensions from loading this texture data
*/
loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
/**
* Defines an override for creating textures
* Return true to stop further extensions from loading this texture
*/
createTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: ArrayBufferView, onSuccess: (texture: Texture) => void, onError: (message: string) => void): boolean;
/**
* Defines an override for loading shader strings
* Return true to stop further extensions from loading this shader data
*/
loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
/**
* Defines an override for loading materials
* Return true to stop further extensions from loading this material
*/
loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
static LoadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): void;
static LoadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): void;
static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (bufferView: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
static LoadTextureAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderData: string | ArrayBuffer) => void, onError: (message: string) => void): void;
static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
private static LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
private static CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
private static ApplyExtensions(func, defaultFunc);
}
}
declare module BABYLON.GLTF1 {
class GLTFBinaryExtension extends GLTFLoaderExtension {
private _bin;
constructor();
loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void, onError: (message: string) => void): boolean;
loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
}
}
declare module BABYLON.GLTF1 {
class GLTFMaterialsCommonExtension extends GLTFLoaderExtension {
constructor();
loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError: (message: string) => void): boolean;
loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
private _loadTexture(gltfRuntime, id, material, propertyPath, onError);
}
}
declare module BABYLON.GLTF2 {
/** @hidden */
interface _IArrayItem {
_index: number;
}
/** @hidden */
class _ArrayItem {
/** @hidden */
static Assign(values?: _IArrayItem[]): void;
}
}
declare module BABYLON.GLTF2 {
/** @hidden */
interface _ILoaderAccessor extends IAccessor, _IArrayItem {
_data?: Promise;
_babylonVertexBuffer?: Promise;
}
/** @hidden */
interface _ILoaderAnimationChannel extends IAnimationChannel, _IArrayItem {
}
/** @hidden */
interface _ILoaderAnimationSamplerData {
input: Float32Array;
interpolation: AnimationSamplerInterpolation;
output: Float32Array;
}
/** @hidden */
interface _ILoaderAnimationSampler extends IAnimationSampler, _IArrayItem {
_data: Promise<_ILoaderAnimationSamplerData>;
}
/** @hidden */
interface _ILoaderAnimation extends IAnimation, _IArrayItem {
channels: _ILoaderAnimationChannel[];
samplers: _ILoaderAnimationSampler[];
_babylonAnimationGroup?: AnimationGroup;
}
/** @hidden */
interface _ILoaderBuffer extends IBuffer, _IArrayItem {
_data?: Promise;
}
/** @hidden */
interface _ILoaderBufferView extends IBufferView, _IArrayItem {
_data?: Promise;
_babylonBuffer?: Promise;
}
/** @hidden */
interface _ILoaderCamera extends ICamera, _IArrayItem {
}
/** @hidden */
interface _ILoaderImage extends IImage, _IArrayItem {
_objectURL?: Promise;
}
/** @hidden */
interface _ILoaderMaterial extends IMaterial, _IArrayItem {
_babylonData?: {
[drawMode: number]: {
material: Material;
meshes: AbstractMesh[];
loaded: Promise;
};
};
}
/** @hidden */
interface _ILoaderMesh extends IMesh, _IArrayItem {
primitives: _ILoaderMeshPrimitive[];
}
/** @hidden */
interface _ILoaderMeshPrimitive extends IMeshPrimitive, _IArrayItem {
}
/** @hidden */
interface _ILoaderNode extends INode, _IArrayItem {
_parent: _ILoaderNode;
_babylonMesh?: Mesh;
_primitiveBabylonMeshes?: Mesh[];
_babylonAnimationTargets?: Node[];
_numMorphTargets?: number;
}
/** @hidden */
interface _ILoaderSamplerData {
noMipMaps: boolean;
samplingMode: number;
wrapU: number;
wrapV: number;
}
/** @hidden */
interface _ILoaderSampler extends ISampler, _IArrayItem {
_data?: _ILoaderSamplerData;
}
/** @hidden */
interface _ILoaderScene extends IScene, _IArrayItem {
}
/** @hidden */
interface _ILoaderSkin extends ISkin, _IArrayItem {
_babylonSkeleton?: Skeleton;
_loaded?: Promise;
}
/** @hidden */
interface _ILoaderTexture extends ITexture, _IArrayItem {
}
/** @hidden */
interface _ILoaderGLTF extends IGLTF {
accessors?: _ILoaderAccessor[];
animations?: _ILoaderAnimation[];
buffers?: _ILoaderBuffer[];
bufferViews?: _ILoaderBufferView[];
cameras?: _ILoaderCamera[];
images?: _ILoaderImage[];
materials?: _ILoaderMaterial[];
meshes?: _ILoaderMesh[];
nodes?: _ILoaderNode[];
samplers?: _ILoaderSampler[];
scenes?: _ILoaderScene[];
skins?: _ILoaderSkin[];
textures?: _ILoaderTexture[];
}
}
/**
* Defines the module used to import/export glTF 2.0 assets
*/
declare module BABYLON.GLTF2 {
/**
* Loader for loading a glTF 2.0 asset
*/
class GLTFLoader implements IGLTFLoader {
/** @hidden */
_gltf: _ILoaderGLTF;
/** @hidden */
_babylonScene: Scene;
/** @hidden */
_completePromises: Promise[];
private _disposed;
private _state;
private _extensions;
private _rootUrl;
private _rootBabylonMesh;
private _defaultSampler;
private _defaultBabylonMaterials;
private _progressCallback?;
private _requests;
private static _ExtensionNames;
private static _ExtensionFactories;
/** @hidden */
static _Register(name: string, factory: (loader: GLTFLoader) => GLTFLoaderExtension): void;
/**
* Mode that determines the coordinate system to use.
*/
coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
/**
* Mode that determines what animations will start.
*/
animationStartMode: GLTFLoaderAnimationStartMode;
/**
* Defines if the loader should compile materials.
*/
compileMaterials: boolean;
/**
* Defines if the loader should also compile materials with clip planes.
*/
useClipPlane: boolean;
/**
* Defines if the loader should compile shadow generators.
*/
compileShadowGenerators: boolean;
/**
* Defines if the Alpha blended materials are only applied as coverage.
* If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
* If true, no extra effects are applied to transparent pixels.
*/
transparencyAsCoverage: boolean;
/**
* Function called before loading a url referenced by the asset.
*/
preprocessUrlAsync: (url: string) => Promise;
/**
* Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
*/
readonly onMeshLoadedObservable: Observable;
/**
* Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
*/
readonly onTextureLoadedObservable: Observable;
/**
* Observable raised when the loader creates a material after parsing the glTF properties of the material.
*/
readonly onMaterialLoadedObservable: Observable;
/**
* Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
*/
readonly onCameraLoadedObservable: Observable;
/**
* Observable raised when the asset is completely loaded, immediately before the loader is disposed.
* For assets with LODs, raised when all of the LODs are complete.
* For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
*/
readonly onCompleteObservable: Observable;
/**
* Observable raised after the loader is disposed.
*/
readonly onDisposeObservable: Observable;
/**
* Observable raised after a loader extension is created.
* Set additional options for a loader extension in this event.
*/
readonly onExtensionLoadedObservable: Observable;
/**
* Loader state or null if the loader is not active.
*/
readonly state: Nullable;
/**
* Disposes the loader, releases resources during load, and cancels any outstanding requests.
*/
dispose(): void;
/**
* Imports one or more meshes from the loaded glTF data and adds them to the scene
* @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
* @param scene the scene the meshes should be added to
* @param data the glTF data to load
* @param rootUrl root url to load from
* @param onProgress event that fires when loading progress has occured
* @returns a promise containg the loaded meshes, particles, skeletons and animations
*/
importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
meshes: AbstractMesh[];
particleSystems: ParticleSystem[];
skeletons: Skeleton[];
animationGroups: AnimationGroup[];
}>;
/**
* Imports all objects from the loaded glTF data and adds them to the scene
* @param scene the scene the objects should be added to
* @param data the glTF data to load
* @param rootUrl root url to load from
* @param onProgress event that fires when loading progress has occured
* @returns a promise which completes when objects have been loaded to the scene
*/
loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise;
private _loadAsync(nodes, scene, data, rootUrl, onProgress?);
private _loadData(data);
private _setupData();
private _loadExtensions();
private _checkExtensions();
private _createRootNode();
private _loadNodesAsync(nodes);
/** @hidden */
_loadSceneAsync(context: string, scene: _ILoaderScene): Promise;
private _forEachPrimitive(node, callback);
private _getMeshes();
private _getSkeletons();
private _getAnimationGroups();
private _startAnimations();
/** @hidden */
_loadNodeAsync(context: string, node: _ILoaderNode): Promise;
private _loadMeshAsync(context, node, mesh, babylonMesh);
private _loadPrimitiveAsync(context, node, mesh, primitive, babylonMesh);
private _loadVertexDataAsync(context, primitive, babylonMesh);
private _createMorphTargets(context, node, mesh, primitive, babylonMesh);
private _loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry);
private _loadMorphTargetVertexDataAsync(context, babylonGeometry, attributes, babylonMorphTarget);
private static _LoadTransform(node, babylonNode);
private _loadSkinAsync(context, node, mesh, skin);
private _loadBones(context, skin);
private _loadBone(node, skin, babylonBones);
private _loadSkinInverseBindMatricesDataAsync(context, skin);
private _updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
private _getNodeMatrix(node);
private _loadCamera(context, camera, babylonMesh);
private _loadAnimationsAsync();
private _loadAnimationAsync(context, animation);
private _loadAnimationChannelAsync(context, animationContext, animation, channel, babylonAnimationGroup);
private _loadAnimationSamplerAsync(context, sampler);
private _loadBufferAsync(context, buffer);
/** @hidden */
_loadBufferViewAsync(context: string, bufferView: _ILoaderBufferView): Promise;
private _loadIndicesAccessorAsync(context, accessor);
private _loadFloatAccessorAsync(context, accessor);
/** @hidden */
_loadVertexBufferViewAsync(context: string, bufferView: _ILoaderBufferView, kind: string): Promise;
private _loadVertexAccessorAsync(context, accessor, kind);
private _getDefaultMaterial(drawMode);
private _loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial);
/** @hidden */
_loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Promise;
/** @hidden */
_createMaterial(name: string, drawMode: number): PBRMaterial;
/** @hidden */
_loadMaterialBasePropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): Promise;
/** @hidden */
_loadMaterialAlphaProperties(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): void;
/** @hidden */
_loadTextureAsync(context: string, textureInfo: ITextureInfo, assign: (texture: Texture) => void): Promise;
private _loadSampler(context, sampler);
private _loadImageAsync(context, image);
/** @hidden */
_loadUriAsync(context: string, uri: string): Promise;
private _onProgress();
/** @hidden */
static _GetProperty(context: string, array: ArrayLike | undefined, index: number | undefined): T;
private static _GetTextureWrapMode(context, mode);
private static _GetTextureSamplingMode(context, magFilter?, minFilter?);
private static _GetTypedArray(context, componentType, bufferView, byteOffset, length);
private static _GetNumComponents(context, type);
private static _ValidateUri(uri);
private static _GetDrawMode(context, mode);
private _compileMaterialsAsync();
private _compileShadowGeneratorsAsync();
private _clear();
/** @hidden */
_applyExtensions(actionAsync: (extension: GLTFLoaderExtension) => Nullable>): Nullable>;
}
}
declare module BABYLON.GLTF2 {
/**
* Abstract class that can be implemented to extend existing glTF loader behavior.
*/
abstract class GLTFLoaderExtension implements IGLTFLoaderExtension, IDisposable {
enabled: boolean;
readonly abstract name: string;
protected _loader: GLTFLoader;
constructor(loader: GLTFLoader);
dispose(): void;
/** Override this method to modify the default behavior for loading scenes. */
protected _loadSceneAsync(context: string, node: _ILoaderScene): Nullable>;
/** Override this method to modify the default behavior for loading nodes. */
protected _loadNodeAsync(context: string, node: _ILoaderNode): Nullable>;
/** Override this method to modify the default behavior for loading mesh primitive vertex data. */
protected _loadVertexDataAsync(context: string, primitive: _ILoaderMeshPrimitive, babylonMesh: Mesh): Nullable>;
/** Override this method to modify the default behavior for loading materials. */
protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable>;
/** Override this method to modify the default behavior for loading uris. */
protected _loadUriAsync(context: string, uri: string): Nullable>;
/** Helper method called by a loader extension to load an glTF extension. */
protected _loadExtensionAsync(context: string, property: IProperty, actionAsync: (extensionContext: string, extension: TProperty) => Promise): Nullable>;
/** Helper method called by the loader to allow extensions to override loading scenes. */
static _LoadSceneAsync(loader: GLTFLoader, context: string, scene: _ILoaderScene): Nullable>;
/** Helper method called by the loader to allow extensions to override loading nodes. */
static _LoadNodeAsync(loader: GLTFLoader, context: string, node: _ILoaderNode): Nullable>;
/** Helper method called by the loader to allow extensions to override loading mesh primitive vertex data. */
static _LoadVertexDataAsync(loader: GLTFLoader, context: string, primitive: _ILoaderMeshPrimitive, babylonMesh: Mesh): Nullable>;
/** Helper method called by the loader to allow extensions to override loading materials. */
static _LoadMaterialAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable>;
/** Helper method called by the loader to allow extensions to override loading uris. */
static _LoadUriAsync(loader: GLTFLoader, context: string, uri: string): Nullable>;
}
}
/**
* Defines the module of the glTF 2.0 loader extensions.
*/
declare module BABYLON.GLTF2.Extensions {
}
declare module BABYLON.GLTF2.Extensions {
/**
* [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_lod)
*/
class MSFT_lod extends GLTFLoaderExtension {
readonly name: string;
/**
* Maximum number of LODs to load, starting from the lowest LOD.
*/
maxLODsToLoad: number;
private _loadingNodeLOD;
private _loadNodeSignals;
private _loadingMaterialLOD;
private _loadMaterialSignals;
protected _loadNodeAsync(context: string, node: _ILoaderNode): Nullable>;
protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable>;
protected _loadUriAsync(context: string, uri: string): Nullable>;
/**
* Gets an array of LOD properties from lowest to highest.
*/
private _getLODs(context, property, array, ids);
}
}
declare module BABYLON.GLTF2.Extensions {
/** @hidden */
class MSFT_minecraftMesh extends GLTFLoaderExtension {
readonly name: string;
constructor(loader: GLTFLoader);
private _onMaterialLoaded;
}
}
declare module BABYLON.GLTF2.Extensions {
/** @hidden */
class MSFT_sRGBFactors extends GLTFLoaderExtension {
readonly name: string;
constructor(loader: GLTFLoader);
private _onMaterialLoaded;
}
}
declare module BABYLON.GLTF2.Extensions {
/**
* [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression)
*/
class KHR_draco_mesh_compression extends GLTFLoaderExtension {
readonly name: string;
private _dracoCompression;
constructor(loader: GLTFLoader);
dispose(): void;
protected _loadVertexDataAsync(context: string, primitive: _ILoaderMeshPrimitive, babylonMesh: Mesh): Nullable>;
}
}
declare module BABYLON.GLTF2.Extensions {
/**
* [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness)
*/
class KHR_materials_pbrSpecularGlossiness extends GLTFLoaderExtension {
readonly name: string;
protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable>;
private _loadSpecularGlossinessPropertiesAsync(context, material, properties, babylonMaterial);
}
}
declare module BABYLON.GLTF2.Extensions {
/**
* [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
*/
class KHR_materials_unlit extends GLTFLoaderExtension {
readonly name: string;
protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable>;
private _loadUnlitPropertiesAsync(context, material, babylonMaterial);
}
}
declare module BABYLON.GLTF2.Extensions {
/**
* [Specification](https://github.com/MiiBond/glTF/tree/khr_lights_v1/extensions/Khronos/KHR_lights) (Experimental)
*/
class KHR_lights extends GLTFLoaderExtension {
readonly name: string;
protected _loadSceneAsync(context: string, scene: _ILoaderScene): Nullable>;
protected _loadNodeAsync(context: string, node: _ILoaderNode): Nullable>;
private readonly _lights;
}
}