@babylonjs/loaders/glTF/1.0/glTFLoaderInterfaces.d.ts

The Babylon.js file loaders library is an extension you can use to load different 3D file types into a Babylon scene.

import { Bone } from "@babylonjs/core/Bones/bone";
import { Skeleton } from "@babylonjs/core/Bones/skeleton";
import { Texture } from "@babylonjs/core/Materials/Textures/texture";
import { Node } from "@babylonjs/core/node";
import { Scene } from "@babylonjs/core/scene";
/**
* Enums
* @hidden
*/
export declare enum EComponentType {
    BYTE = 5120,
    UNSIGNED_BYTE = 5121,
    SHORT = 5122,
    UNSIGNED_SHORT = 5123,
    FLOAT = 5126
}
/** @hidden */
export declare enum EShaderType {
    FRAGMENT = 35632,
    VERTEX = 35633
}
/** @hidden */
export declare 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
}
/** @hidden */
export declare enum ETextureWrapMode {
    CLAMP_TO_EDGE = 33071,
    MIRRORED_REPEAT = 33648,
    REPEAT = 10497
}
/** @hidden */
export declare enum ETextureFilterType {
    NEAREST = 9728,
    LINEAR = 9728,
    NEAREST_MIPMAP_NEAREST = 9984,
    LINEAR_MIPMAP_NEAREST = 9985,
    NEAREST_MIPMAP_LINEAR = 9986,
    LINEAR_MIPMAP_LINEAR = 9987
}
/** @hidden */
export declare enum ETextureFormat {
    ALPHA = 6406,
    RGB = 6407,
    RGBA = 6408,
    LUMINANCE = 6409,
    LUMINANCE_ALPHA = 6410
}
/** @hidden */
export declare enum ECullingType {
    FRONT = 1028,
    BACK = 1029,
    FRONT_AND_BACK = 1032
}
/** @hidden */
export declare 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
}
/** @hidden */
export interface IGLTFProperty {
    extensions?: {
        [key: string]: any;
    };
    extras?: Object;
}
/** @hidden */
export interface IGLTFChildRootProperty extends IGLTFProperty {
    name?: string;
}
/** @hidden */
export interface IGLTFAccessor extends IGLTFChildRootProperty {
    bufferView: string;
    byteOffset: number;
    byteStride: number;
    count: number;
    type: string;
    componentType: EComponentType;
    max?: number[];
    min?: number[];
    name?: string;
}
/** @hidden */
export interface IGLTFBufferView extends IGLTFChildRootProperty {
    buffer: string;
    byteOffset: number;
    byteLength: number;
    byteStride: number;
    target?: number;
}
/** @hidden */
export interface IGLTFBuffer extends IGLTFChildRootProperty {
    uri: string;
    byteLength?: number;
    type?: string;
}
/** @hidden */
export interface IGLTFShader extends IGLTFChildRootProperty {
    uri: string;
    type: EShaderType;
}
/** @hidden */
export interface IGLTFProgram extends IGLTFChildRootProperty {
    attributes: string[];
    fragmentShader: string;
    vertexShader: string;
}
/** @hidden */
export interface IGLTFTechniqueParameter {
    type: number;
    count?: number;
    semantic?: string;
    node?: string;
    value?: number | boolean | string | Array<any>;
    source?: string;
    babylonValue?: any;
}
/** @hidden */
export interface IGLTFTechniqueCommonProfile {
    lightingModel: string;
    texcoordBindings: Object;
    parameters?: Array<any>;
}
/** @hidden */
export interface IGLTFTechniqueStatesFunctions {
    blendColor?: number[];
    blendEquationSeparate?: number[];
    blendFuncSeparate?: number[];
    colorMask: boolean[];
    cullFace: number[];
}
/** @hidden */
export interface IGLTFTechniqueStates {
    enable: number[];
    functions: IGLTFTechniqueStatesFunctions;
}
/** @hidden */
export interface IGLTFTechnique extends IGLTFChildRootProperty {
    parameters: {
        [key: string]: IGLTFTechniqueParameter;
    };
    program: string;
    attributes: {
        [key: string]: string;
    };
    uniforms: {
        [key: string]: string;
    };
    states: IGLTFTechniqueStates;
}
/** @hidden */
export interface IGLTFMaterial extends IGLTFChildRootProperty {
    technique?: string;
    values: string[];
}
/** @hidden */
export interface IGLTFMeshPrimitive extends IGLTFProperty {
    attributes: {
        [key: string]: string;
    };
    indices: string;
    material: string;
    mode?: number;
}
/** @hidden */
export interface IGLTFMesh extends IGLTFChildRootProperty {
    primitives: IGLTFMeshPrimitive[];
}
/** @hidden */
export interface IGLTFImage extends IGLTFChildRootProperty {
    uri: string;
}
/** @hidden */
export interface IGLTFSampler extends IGLTFChildRootProperty {
    magFilter?: number;
    minFilter?: number;
    wrapS?: number;
    wrapT?: number;
}
/** @hidden */
export interface IGLTFTexture extends IGLTFChildRootProperty {
    sampler: string;
    source: string;
    format?: ETextureFormat;
    internalFormat?: ETextureFormat;
    target?: number;
    type?: number;
    babylonTexture?: Texture;
}
/** @hidden */
export interface IGLTFAmbienLight {
    color?: number[];
}
/** @hidden */
export interface IGLTFDirectionalLight {
    color?: number[];
}
/** @hidden */
export interface IGLTFPointLight {
    color?: number[];
    constantAttenuation?: number;
    linearAttenuation?: number;
    quadraticAttenuation?: number;
}
/** @hidden */
export interface IGLTFSpotLight {
    color?: number[];
    constantAttenuation?: number;
    fallOfAngle?: number;
    fallOffExponent?: number;
    linearAttenuation?: number;
    quadraticAttenuation?: number;
}
/** @hidden */
export interface IGLTFLight extends IGLTFChildRootProperty {
    type: string;
}
/** @hidden */
export interface IGLTFCameraOrthographic {
    xmag: number;
    ymag: number;
    zfar: number;
    znear: number;
}
/** @hidden */
export interface IGLTFCameraPerspective {
    aspectRatio: number;
    yfov: number;
    zfar: number;
    znear: number;
}
/** @hidden */
export interface IGLTFCamera extends IGLTFChildRootProperty {
    type: string;
}
/** @hidden */
export interface IGLTFAnimationChannelTarget {
    id: string;
    path: string;
}
/** @hidden */
export interface IGLTFAnimationChannel {
    sampler: string;
    target: IGLTFAnimationChannelTarget;
}
/** @hidden */
export interface IGLTFAnimationSampler {
    input: string;
    output: string;
    interpolation?: string;
}
/** @hidden */
export interface IGLTFAnimation extends IGLTFChildRootProperty {
    channels?: IGLTFAnimationChannel[];
    parameters?: {
        [key: string]: string;
    };
    samplers?: {
        [key: string]: IGLTFAnimationSampler;
    };
}
/** @hidden */
export interface IGLTFNodeInstanceSkin {
    skeletons: string[];
    skin: string;
    meshes: string[];
}
/** @hidden */
export interface IGLTFSkins extends IGLTFChildRootProperty {
    bindShapeMatrix: number[];
    inverseBindMatrices: string;
    jointNames: string[];
    babylonSkeleton?: Skeleton;
}
/** @hidden */
export 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;
}
/** @hidden */
export interface IGLTFScene extends IGLTFChildRootProperty {
    nodes: string[];
}
/** @hidden */
export 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[];
}
/** @hidden */
export interface INodeToRoot {
    bone: Bone;
    node: IGLTFNode;
    id: string;
}
/** @hidden */
export interface IJointNode {
    node: IGLTFNode;
    id: string;
}