Remove loaders non dist files

dist/preview release/loaders/babylon.glTF1FileLoader.d.ts

@@ -1,913 +0,0 @@
-
-
-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 {
-        /**
-         * Object that represents the glTF JSON.
-         */
-        json: Object;
-        /**
-         * The BIN chunk of a binary glTF.
-         */
-        bin: Nullable<ArrayBufferView>;
-    }
-    /**
-     * 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
-    }
-    /** @hidden */
-    interface IGLTFLoader extends IDisposable {
-        readonly state: Nullable<GLTFLoaderState>;
-        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string) => Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: IParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string) => Promise<void>;
-    }
-    /**
-     * File loader for loading glTF files into a scene.
-     */
-    class GLTFFileLoader implements IDisposable, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
-        /** @hidden */
-        static _CreateGLTFLoaderV1: (parent: GLTFFileLoader) => IGLTFLoader;
-        /** @hidden */
-        static _CreateGLTFLoaderV2: (parent: GLTFFileLoader) => IGLTFLoader;
-        /**
-         * Raised when the asset has been parsed
-         */
-        onParsedObservable: Observable<IGLTFLoaderData>;
-        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.
-         * @hidden
-         */
-        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.
-         * @hidden
-         */
-        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<string>;
-        /**
-         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        readonly onMeshLoadedObservable: Observable<AbstractMesh>;
-        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<BaseTexture>;
-        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<Material>;
-        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<Camera>;
-        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<void>;
-        private _onCompleteObserver;
-        /**
-         * Callback 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.
-         */
-        onComplete: () => void;
-        /**
-         * Observable raised when an error occurs.
-         */
-        readonly onErrorObservable: Observable<any>;
-        private _onErrorObserver;
-        /**
-         * Callback raised when an error occurs.
-         */
-        onError: (reason: any) => void;
-        /**
-         * Observable raised after the loader is disposed.
-         */
-        readonly onDisposeObservable: Observable<void>;
-        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<IGLTFLoaderExtension>;
-        private _onExtensionLoadedObserver;
-        /**
-         * Callback raised after a loader extension is created.
-         */
-        onExtensionLoaded: (extension: IGLTFLoaderExtension) => void;
-        /**
-         * Defines if the loader logging is enabled.
-         */
-        loggingEnabled: boolean;
-        /**
-         * Defines if the loader should capture performance counters.
-         */
-        capturePerformanceCounters: boolean;
-        /**
-         * Defines if the loader should validate the asset.
-         */
-        validate: boolean;
-        /**
-         * Observable raised after validation when validate is set to true. The event data is the result of the validation.
-         */
-        readonly onValidatedObservable: Observable<IGLTFValidationResults>;
-        private _onValidatedObserver;
-        /**
-         * Callback raised after a loader extension is created.
-         */
-        onValidated: (results: IGLTFValidationResults) => void;
-        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;
-        /** @hidden */
-        _clear(): 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
-         * @param fileName Defines the name of the file to load
-         * @returns a promise containg the loaded meshes, particles, skeletons and animations
-         */
-        importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string): Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: IParticleSystem[];
-            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
-         * @param fileName Defines the name of the file to load
-         * @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, fileName?: string): Promise<void>;
-        /**
-         * 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
-         * @param fileName Defines the name of the file to load
-         * @returns The loaded asset container
-         */
-        loadAssetContainerAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
-        /**
-         * 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;
-        /**
-         * The loader state or null if the loader is not active.
-         */
-        readonly loaderState: Nullable<GLTFLoaderState>;
-        /**
-         * Returns a promise that resolves when the asset is completely loaded.
-         * @returns a promise that resolves when the asset is completely loaded.
-         */
-        whenCompleteAsync(): Promise<void>;
-        private _parseAsync;
-        private _validateAsync;
-        private _getLoader;
-        private _unpackBinary;
-        private _unpackBinaryV1;
-        private _unpackBinaryV2;
-        private static _parseVersion;
-        private static _compareVersion;
-        private static _decodeBufferToText;
-        private static readonly _logSpaces;
-        private _logIndentLevel;
-        private _loggingEnabled;
-        /** @hidden */
-        _log: (message: string) => void;
-        /** @hidden */
-        _logOpen(message: string): void;
-        /** @hidden */
-        _logClose(): void;
-        private _logEnabled;
-        private _logDisabled;
-        private _capturePerformanceCounters;
-        /** @hidden */
-        _startPerformanceCounter: (counterName: string) => void;
-        /** @hidden */
-        _endPerformanceCounter: (counterName: string) => void;
-        private _startPerformanceCounterEnabled;
-        private _startPerformanceCounterDisabled;
-        private _endPerformanceCounterEnabled;
-        private _endPerformanceCounterDisabled;
-    }
-}
-
-
-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<any>;
-        source?: string;
-        babylonValue?: any;
-    }
-    interface IGLTFTechniqueCommonProfile {
-        lightingModel: string;
-        texcoordBindings: Object;
-        parameters?: Array<any>;
-    }
-    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<ArrayBufferView>) => void, onError: (message: string) => void): void;
-        static CreateTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: Nullable<ArrayBufferView>, 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;
-        state: Nullable<GLTFLoaderState>;
-        dispose(): void;
-        private _importMeshAsync;
-        /**
-        * 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: IParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        private _loadAsync;
-        /**
-        * 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<void>;
-        private _loadShadersAsync;
-        private _loadBuffersAsync;
-        private _createNodes;
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    /**
-    * Utils functions for GLTF
-    */
-    class GLTFUtils {
-        /**
-         * Sets the given "parameter" matrix
-         * @param scene: the 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;
-        private static CreateTextureAsync;
-        private static ApplyExtensions;
-    }
-}
-
-
-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;
-    }
-}

dist/preview release/loaders/babylon.objFileLoader.d.ts

@@ -1,111 +0,0 @@
-
-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;
-    }
-    class OBJFileLoader implements ISceneLoaderPluginAsync {
-        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;
-        facePattern5: 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;
-        /**
-         * 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
-         * @param fileName Defines the name of the file to load
-         * @returns a promise containg the loaded meshes, particles, skeletons and animations
-         */
-        importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string): Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: IParticleSystem[];
-            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
-         * @param fileName Defines the name of the file to load
-         * @returns a promise which completes when objects have been loaded to the scene
-         */
-        loadAsync(scene: Scene, data: string, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
-        /**
-         * 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
-         * @param fileName Defines the name of the file to load
-         * @returns The loaded asset container
-         */
-        loadAssetContainerAsync(scene: Scene, data: string, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void, fileName?: string): Promise<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<AbstractMesh>
-         * @private
-         */
-        private _parseSolid;
-    }
-}

dist/preview release/loaders/babylon.stlFileLoader.d.ts

@@ -1,17 +0,0 @@
-
-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<AbstractMesh[]>, particleSystems: Nullable<IParticleSystem[]>, skeletons: Nullable<Skeleton[]>): 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;
-        private parseBinary;
-        private parseASCII;
-    }
-}