@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/gui-editor/dist/babylon.guiEditor.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: any;
+export = _exports;
+export const __babylonjs_gui_editor: any;

package/dist/types/node_modules/@babylonjs/gui-editor/dist/babylon.guiEditor.max.d.ts

@@ -0,0 +1,2 @@
+export = __WEBPACK_EXTERNAL_MODULE_gui_2D_controls_container__;
+export = __WEBPACK_EXTERNAL_MODULE_gui_2D_controls_container__;

package/dist/types/node_modules/@babylonjs/inspector/dist/babylon.inspector.bundle.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: any;
+export = _exports;
+export const __babylonjs_inspector: any;

package/dist/types/node_modules/@babylonjs/inspector/dist/babylon.inspector.bundle.max.d.ts

@@ -0,0 +1,2 @@
+export = __WEBPACK_EXTERNAL_MODULE_gui_2D_adtInstrumentation__;
+export = __WEBPACK_EXTERNAL_MODULE_gui_2D_adtInstrumentation__;

package/dist/types/node_modules/@babylonjs/loaders/OBJ/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./mtlFileLoader.js";
+export * from "./objLoadingOptions.js";
+export * from "./solidParser.js";
+export * from "./objFileLoader.js";

package/dist/types/node_modules/@babylonjs/loaders/OBJ/mtlFileLoader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Class reading and parsing the MTL file bundled with the obj file.
+ */
+export class MTLFileLoader {
+    /**
+     * Gets the texture for the material.
+     *
+     * If the material is imported from input file,
+     * We sanitize the url to ensure it takes the texture from aside the material.
+     *
+     * @param rootUrl The root url to load from
+     * @param value The value stored in the mtl
+     * @param scene
+     * @returns The Texture
+     */
+    static _GetTexture(rootUrl: any, value: any, scene: any): Texture | null;
+    /**
+     * All material loaded from the mtl will be set here
+     */
+    materials: any[];
+    /**
+     * 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 defines the scene the material will be created in
+     * @param data defines the mtl data to parse
+     * @param rootUrl defines the rooturl to use in order to load relative dependencies
+     * @param assetContainer defines the asset container to store the material in (can be null)
+     */
+    parseMTL(scene: any, data: any, rootUrl: any, assetContainer: any): void;
+}
+export namespace MTLFileLoader {
+    const INVERT_TEXTURE_Y: boolean;
+}
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";

package/dist/types/node_modules/@babylonjs/loaders/OBJ/objFileLoader.d.ts

@@ -0,0 +1,116 @@
+/**
+ * OBJ file type loader.
+ * This is a babylon scene loader plugin.
+ */
+export class OBJFileLoader {
+    static set INVERT_TEXTURE_Y(arg: boolean);
+    /**
+     * Invert Y-Axis of referenced textures on load
+     */
+    static get INVERT_TEXTURE_Y(): boolean;
+    static get _DefaultLoadingOptions(): {
+        computeNormals: boolean;
+        optimizeNormals: boolean;
+        importVertexColors: boolean;
+        invertY: boolean;
+        invertTextureY: boolean;
+        UVScaling: Vector2;
+        materialLoadingFailsSilently: boolean;
+        optimizeWithUV: boolean;
+        skipMaterials: boolean;
+    };
+    /**
+     * Creates loader for .OBJ files
+     *
+     * @param loadingOptions options for loading and parsing OBJ/MTL files.
+     */
+    constructor(loadingOptions: any);
+    /**
+     * Defines the name of the plugin.
+     */
+    name: string;
+    /**
+     * Defines the extension the plugin is able to load.
+     */
+    extensions: string;
+    _assetContainer: AssetContainer | null;
+    _loadingOptions: any;
+    /**
+     * 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 defines where to load data from
+     * @param onSuccess Callback function to be called when the MTL file is loaded
+     * @param onFailure
+     */
+    _loadMTL(url: any, rootUrl: any, onSuccess: any, onFailure: any): void;
+    /**
+     * Instantiates a OBJ file loader plugin.
+     * @returns the created plugin
+     */
+    createPlugin(): OBJFileLoader;
+    /**
+     * If the data string can be loaded directly.
+     * @returns if the data can be loaded directly
+     */
+    canDirectLoad(): boolean;
+    /**
+     * Imports one or more meshes from the loaded OBJ 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 OBJ data to load
+     * @param rootUrl root url to load from
+     * @returns a promise containing the loaded meshes, particles, skeletons and animations
+     */
+    importMeshAsync(meshesNames: any, scene: any, data: any, rootUrl: any): Promise<{
+        meshes: any[];
+        particleSystems: never[];
+        skeletons: never[];
+        animationGroups: never[];
+        transformNodes: never[];
+        geometries: never[];
+        lights: never[];
+    }>;
+    /**
+     * Imports all objects from the loaded OBJ data and adds them to the scene
+     * @param scene the scene the objects should be added to
+     * @param data the OBJ data to load
+     * @param rootUrl root url to load from
+     * @returns a promise which completes when objects have been loaded to the scene
+     */
+    loadAsync(scene: any, data: any, rootUrl: any): 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
+     * @returns The loaded asset container
+     */
+    loadAssetContainerAsync(scene: any, data: any, rootUrl: any): 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 defines a string or array of strings of the mesh names that should be loaded from the file
+     * @param scene defines the scene where are displayed the data
+     * @param data defines the content of the obj file
+     * @param rootUrl defines the path to the folder
+     * @returns the list of loaded meshes
+     */
+    _parseSolid(meshesNames: any, scene: any, data: any, rootUrl: any): Promise<any[]>;
+}
+export namespace OBJFileLoader {
+    const OPTIMIZE_WITH_UV: boolean;
+    const INVERT_Y: boolean;
+    const IMPORT_VERTEX_COLORS: boolean;
+    const COMPUTE_NORMALS: boolean;
+    const OPTIMIZE_NORMALS: boolean;
+    const UV_SCALING: Vector2;
+    const SKIP_MATERIALS: boolean;
+    const MATERIAL_LOADING_FAILS_SILENTLY: boolean;
+}
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/loaders/OBJ/objLoadingOptions.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/node_modules/@babylonjs/loaders/OBJ/solidParser.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Class used to load mesh data from OBJ content
+ */
+export class SolidParser {
+    /**
+     * Creates a new SolidParser
+     * @param materialToUse defines the array to fill with the list of materials to use (it will be filled by the parse function)
+     * @param babylonMeshesArray defines the array to fill with the list of loaded meshes (it will be filled by the parse function)
+     * @param loadingOptions defines the loading options to use
+     */
+    constructor(materialToUse: any, babylonMeshesArray: any, loadingOptions: any);
+    _positions: any[];
+    _normals: any[];
+    _uvs: any[];
+    _colors: any[];
+    _meshesFromObj: any[];
+    _indicesForBabylon: any[];
+    _wrappedPositionForBabylon: any[];
+    _wrappedUvsForBabylon: any[];
+    _wrappedColorsForBabylon: any[];
+    _wrappedNormalsForBabylon: any[];
+    _tuplePosNorm: any[];
+    _curPositionInIndices: number;
+    _hasMeshes: boolean;
+    _unwrappedPositionsForBabylon: any[];
+    _unwrappedColorsForBabylon: any[];
+    _unwrappedNormalsForBabylon: any[];
+    _unwrappedUVForBabylon: any[];
+    _triangles: any[];
+    _materialNameFromObj: string;
+    _objMeshName: string;
+    _increment: number;
+    _isFirstMaterial: boolean;
+    _grayColor: Color4;
+    _materialToUse: any;
+    _babylonMeshesArray: any;
+    _loadingOptions: any;
+    /**
+     * Search for obj in the given array.
+     * This function is called to check if a couple of data already exists in an array.
+     *
+     * If found, returns the index of the founded tuple index. Returns -1 if not found
+     * @param arr Array<{ normals: Array<number>, idx: Array<number> }>
+     * @param obj Array<number>
+     * @returns {boolean}
+     */
+    _isInArray(arr: any, obj: any): boolean;
+    _isInArrayUV(arr: any, obj: any): any;
+    /**
+     * This function set the data for each triangle.
+     * Data are position, normals and uvs
+     * If a tuple of (position, normal) is not set, add the data into the corresponding array
+     * If the tuple already exist, add only their indice
+     *
+     * @param indicePositionFromObj Integer The index in positions array
+     * @param indiceUvsFromObj Integer The index in uvs array
+     * @param indiceNormalFromObj Integer The index in normals array
+     * @param positionVectorFromOBJ Vector3 The value of position at index objIndice
+     * @param textureVectorFromOBJ Vector3 The value of uvs
+     * @param normalsVectorFromOBJ Vector3 The value of normals at index objNormale
+     * @param positionColorsFromOBJ
+     */
+    _setData(indicePositionFromObj: any, indiceUvsFromObj: any, indiceNormalFromObj: any, positionVectorFromOBJ: any, textureVectorFromOBJ: any, normalsVectorFromOBJ: any, positionColorsFromOBJ: any): void;
+    /**
+     * Transform Vector() and BABYLON.Color() objects into numbers in an array
+     */
+    _unwrapData(): void;
+    /**
+     * Create triangles from polygons
+     * It is important to notice that a triangle is a polygon
+     * We get 5 patterns of face defined in OBJ File :
+     * facePattern1 = ["1","2","3","4","5","6"]
+     * facePattern2 = ["1/1","2/2","3/3","4/4","5/5","6/6"]
+     * facePattern3 = ["1/1/1","2/2/2","3/3/3","4/4/4","5/5/5","6/6/6"]
+     * facePattern4 = ["1//1","2//2","3//3","4//4","5//5","6//6"]
+     * facePattern5 = ["-1/-1/-1","-2/-2/-2","-3/-3/-3","-4/-4/-4","-5/-5/-5","-6/-6/-6"]
+     * Each pattern is divided by the same method
+     * @param faces Array[String] The indices of elements
+     * @param v Integer The variable to increment
+     */
+    _getTriangles(faces: any, v: any): void;
+    /**
+     * Create triangles and push the data for each polygon for the pattern 1
+     * In this pattern we get vertice positions
+     * @param face
+     * @param v
+     */
+    _setDataForCurrentFaceWithPattern1(face: any, v: any): void;
+    /**
+     * Create triangles and push the data for each polygon for the pattern 2
+     * In this pattern we get vertice positions and uvsu
+     * @param face
+     * @param v
+     */
+    _setDataForCurrentFaceWithPattern2(face: any, v: any): void;
+    /**
+     * Create triangles and push the data for each polygon for the pattern 3
+     * In this pattern we get vertice positions, uvs and normals
+     * @param face
+     * @param v
+     */
+    _setDataForCurrentFaceWithPattern3(face: any, v: any): void;
+    /**
+     * Create triangles and push the data for each polygon for the pattern 4
+     * In this pattern we get vertice positions and normals
+     * @param face
+     * @param v
+     */
+    _setDataForCurrentFaceWithPattern4(face: any, v: any): void;
+    _setDataForCurrentFaceWithPattern5(face: any, v: any): void;
+    _addPreviousObjMesh(): void;
+    _handledMesh: any;
+    _optimizeNormals(mesh: any): void;
+    /**
+     * Function used to parse an OBJ string
+     * @param meshesNames defines the list of meshes to load (all if not defined)
+     * @param data defines the OBJ string
+     * @param scene defines the hosting scene
+     * @param assetContainer defines the asset container to load data in
+     * @param onFileToLoadFound defines a callback that will be called if a MTL file is found
+     */
+    parse(meshesNames: any, data: any, scene: any, assetContainer: any, onFileToLoadFound: any): void;
+}
+export namespace SolidParser {
+    const ObjectDescriptor: RegExp;
+    const GroupDescriptor: RegExp;
+    const MtlLibGroupDescriptor: RegExp;
+    const UseMtlDescriptor: RegExp;
+    const SmoothDescriptor: RegExp;
+    const VertexPattern: RegExp;
+    const NormalPattern: RegExp;
+    const UVPattern: RegExp;
+    const FacePattern1: RegExp;
+    const FacePattern2: RegExp;
+    const FacePattern3: RegExp;
+    const FacePattern4: RegExp;
+    const FacePattern5: RegExp;
+}
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/loaders/STL/index.d.ts

@@ -0,0 +1 @@
+export * from "./stlFileLoader.js";

package/dist/types/node_modules/@babylonjs/loaders/STL/stlFileLoader.d.ts

@@ -0,0 +1,61 @@
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+export class STLFileLoader {
+    /** @internal */
+    solidPattern: RegExp;
+    /** @internal */
+    facetsPattern: RegExp;
+    /** @internal */
+    normalPattern: RegExp;
+    /** @internal */
+    vertexPattern: RegExp;
+    /**
+     * Defines the name of the plugin.
+     */
+    name: string;
+    /**
+     * Defines the extensions the stl loader is able to load.
+     * force data to come in as an ArrayBuffer
+     * we'll convert to string if it looks like it's an ASCII .stl
+     */
+    extensions: {
+        ".stl": {
+            isBinary: boolean;
+        };
+    };
+    /**
+     * Import meshes into a scene.
+     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
+     * @param scene The scene to import into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @param meshes The meshes array to import into
+     * @returns True if successful or false otherwise
+     */
+    importMesh(meshesNames: any, scene: any, data: any, rootUrl: any, meshes: any): boolean;
+    /**
+     * Load into a scene.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns true if successful or false otherwise
+     */
+    load(scene: any, data: any, rootUrl: any): boolean;
+    /**
+     * 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
+     * @returns The loaded asset container
+     */
+    loadAssetContainer(scene: any, data: any, rootUrl: any): AssetContainer;
+    _isBinary(data: any): boolean;
+    _parseBinary(mesh: any, data: any, rightHanded: any): void;
+    _parseASCII(mesh: any, solidData: any, rightHanded: any): void;
+}
+export namespace STLFileLoader {
+    const DO_NOT_ALTER_FILE_COORDINATES: boolean;
+}
+import { AssetContainer } from "@babylonjs/core/assetContainer.js";

package/dist/types/node_modules/@babylonjs/loaders/glTF/1.0/glTFBinaryExtension.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @internal
+ * @deprecated
+ */
+export class GLTFBinaryExtension extends GLTFLoaderExtension {
+    constructor();
+    loadRuntimeAsync(scene: any, data: any, rootUrl: any, onSuccess: any): boolean;
+    _bin: any;
+    loadBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): boolean;
+    loadTextureBufferAsync(gltfRuntime: any, id: any, onSuccess: any): boolean;
+    loadShaderStringAsync(gltfRuntime: any, id: any, onSuccess: any): boolean;
+}
+import { GLTFLoaderExtension } from "./glTFLoader.js";

package/dist/types/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoader.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Implementation of the base glTF spec
+ * @internal
+ */
+export class GLTFLoaderBase {
+    static CreateRuntime(parsedData: any, scene: any, rootUrl: any): {
+        extensions: {};
+        accessors: {};
+        buffers: {};
+        bufferViews: {};
+        meshes: {};
+        lights: {};
+        cameras: {};
+        nodes: {};
+        images: {};
+        textures: {};
+        shaders: {};
+        programs: {};
+        samplers: {};
+        techniques: {};
+        materials: {};
+        animations: {};
+        skins: {};
+        extensionsUsed: never[];
+        scenes: {};
+        buffersCount: number;
+        shaderscount: number;
+        scene: any;
+        rootUrl: any;
+        loadedBufferCount: number;
+        loadedBufferViews: {};
+        loadedShaderCount: number;
+        importOnlyMeshes: boolean;
+        dummyNodes: never[];
+        assetContainer: null;
+    };
+    static LoadBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any, onProgress: any): void;
+    static LoadTextureBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+    static CreateTextureAsync(gltfRuntime: any, id: any, buffer: any, onSuccess: any): void;
+    static LoadShaderStringAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+    static LoadMaterialAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+}
+/**
+ * glTF V1 Loader
+ * @internal
+ * @deprecated
+ */
+export class GLTFLoader {
+    static RegisterExtension(extension: any): void;
+    dispose(): void;
+    _importMeshAsync(meshesNames: any, scene: any, data: any, rootUrl: any, assetContainer: any, onSuccess: any, onProgress: any, onError: any): boolean;
+    /**
+     * 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 assetContainer defines the asset container to use (can be null)
+     * @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: any, assetContainer: any, data: any, rootUrl: any, onProgress: any): Promise<any>;
+    _loadAsync(scene: any, data: any, rootUrl: any, onSuccess: any, onProgress: any, onError: any): void;
+    /**
+     * 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: any, data: any, rootUrl: any, onProgress: any): Promise<any>;
+    _loadShadersAsync(gltfRuntime: any, onload: any): void;
+    _loadBuffersAsync(gltfRuntime: any, onLoad: any): void;
+    _createNodes(gltfRuntime: any): void;
+}
+export namespace GLTFLoader {
+    const Extensions: {};
+}
+/** @internal */
+export class GLTFLoaderExtension {
+    static LoadRuntimeAsync(scene: any, data: any, rootUrl: any, onSuccess: any, onError: any): void;
+    static LoadRuntimeExtensionsAsync(gltfRuntime: any, onSuccess: any, onError: any): void;
+    static LoadBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any, onProgress: any): void;
+    static LoadTextureAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+    static LoadShaderStringAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+    static LoadMaterialAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+    static _LoadTextureBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): void;
+    static _CreateTextureAsync(gltfRuntime: any, id: any, buffer: any, onSuccess: any, onError: any): void;
+    static _ApplyExtensions(func: any, defaultFunc: any): void;
+    constructor(name: any);
+    _name: any;
+    get name(): any;
+    /**
+     * Defines an override for loading the runtime
+     * Return true to stop further extensions from loading the runtime
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onSuccess
+     * @param onError
+     */
+    loadRuntimeAsync(scene: any, data: any, rootUrl: any, onSuccess: any, onError: any): boolean;
+    /**
+     * Defines an onverride for creating gltf runtime
+     * Return true to stop further extensions from creating the runtime
+     * @param gltfRuntime
+     * @param onSuccess
+     * @param onError
+     */
+    loadRuntimeExtensionsAsync(gltfRuntime: any, onSuccess: any, onError: any): boolean;
+    /**
+     * Defines an override for loading buffers
+     * Return true to stop further extensions from loading this buffer
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     * @param onProgress
+     */
+    loadBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any, onProgress: any): boolean;
+    /**
+     * Defines an override for loading texture buffers
+     * Return true to stop further extensions from loading this texture data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    loadTextureBufferAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): boolean;
+    /**
+     * Defines an override for creating textures
+     * Return true to stop further extensions from loading this texture
+     * @param gltfRuntime
+     * @param id
+     * @param buffer
+     * @param onSuccess
+     * @param onError
+     */
+    createTextureAsync(gltfRuntime: any, id: any, buffer: any, onSuccess: any, onError: any): boolean;
+    /**
+     * Defines an override for loading shader strings
+     * Return true to stop further extensions from loading this shader data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    loadShaderStringAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): boolean;
+    /**
+     * Defines an override for loading materials
+     * Return true to stop further extensions from loading this material
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    loadMaterialAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): boolean;
+}

package/dist/types/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderInterfaces.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enums
+ * @internal
+ */
+export const EComponentType: any;
+/** @internal */
+export const EShaderType: any;
+/** @internal */
+export const EParameterType: any;
+/** @internal */
+export const ETextureWrapMode: any;
+/** @internal */
+export const ETextureFilterType: any;
+/** @internal */
+export const ETextureFormat: any;
+/** @internal */
+export const ECullingType: any;
+/** @internal */
+export const EBlendingFunction: any;

package/dist/types/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderUtils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Utils functions for GLTF
+ * @internal
+ * @deprecated
+ */
+export 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: any, source: any, parameter: any, uniformName: any, shaderMaterial: any): 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: any, uniform: any, value: any, type: any): boolean;
+    /**
+     * Returns the wrap mode of the texture
+     * @param mode the mode value
+     */
+    static GetWrapMode(mode: any): 1 | 0 | 2;
+    /**
+     * Returns the byte stride giving an accessor
+     * @param accessor the GLTF accessor objet
+     */
+    static GetByteStrideFromType(accessor: any): 1 | 4 | 2 | 16 | 3 | 9;
+    /**
+     * Returns the texture filter mode giving a mode value
+     * @param mode the filter mode value
+     */
+    static GetTextureFilterMode(mode: any): 1 | 2 | 3;
+    static GetBufferFromBufferView(gltfRuntime: any, bufferView: any, byteOffset: any, byteLength: any, componentType: any): Uint16Array | Float32Array | Uint8Array | Int8Array | Int16Array;
+    /**
+     * Returns a buffer from its accessor
+     * @param gltfRuntime the GLTF runtime
+     * @param accessor the GLTF accessor
+     */
+    static GetBufferFromAccessor(gltfRuntime: any, accessor: any): Uint16Array | Float32Array | Uint8Array | Int8Array | Int16Array;
+    /**
+     * Decodes a buffer view into a string
+     * @param view the buffer view
+     */
+    static DecodeBufferToText(view: any): 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: any): any;
+}
+export namespace GLTFUtils {
+    const _DefaultMaterial: any;
+}

package/dist/types/node_modules/@babylonjs/loaders/glTF/1.0/glTFMaterialsCommonExtension.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ * @deprecated
+ */
+export class GLTFMaterialsCommonExtension extends GLTFLoaderExtension {
+    constructor();
+    loadRuntimeExtensionsAsync(gltfRuntime: any): boolean;
+    loadMaterialAsync(gltfRuntime: any, id: any, onSuccess: any, onError: any): boolean;
+    _loadTexture(gltfRuntime: any, id: any, material: any, propertyPath: any, onError: any): void;
+}
+import { GLTFLoaderExtension } from "./glTFLoader.js";

package/dist/types/node_modules/@babylonjs/loaders/glTF/1.0/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./glTFBinaryExtension.js";
+export * from "./glTFLoader.js";
+export * from "./glTFLoaderInterfaces.js";
+export * from "./glTFLoaderUtils.js";
+export * from "./glTFMaterialsCommonExtension.js";