@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Meshes/mesh.d.ts

@@ -0,0 +1,882 @@
+/**
+ * @internal
+ **/
+export class _CreationDataStorage {
+}
+/**
+ * @internal
+ **/
+export class _InstancesBatch {
+    mustReturn: boolean;
+    visibleInstances: any[];
+    renderSelf: any[];
+    hardwareInstancedRendering: any[];
+}
+/**
+ * Class used to represent renderable models
+ */
+export class Mesh extends AbstractMesh {
+    /**
+     * Gets the default side orientation.
+     * @param orientation the orientation to value to attempt to get
+     * @returns the default orientation
+     * @internal
+     */
+    static _GetDefaultSideOrientation(orientation: any): any;
+    /**
+     * @internal
+     */
+    static _instancedMeshFactory(name: any, mesh: any): void;
+    /**
+     * @internal
+     */
+    static _PhysicsImpostorParser(scene: any, physicObject: any, jsonObject: any): void;
+    /**
+     * Returns a new Mesh object parsed from the source provided.
+     * @param parsedMesh is the source
+     * @param scene defines the hosting scene
+     * @param rootUrl is the root URL to prefix the `delayLoadingFile` property with
+     * @returns a new Mesh
+     */
+    static Parse(parsedMesh: any, scene: any, rootUrl: any): Mesh;
+    /**
+     * Returns an object containing a min and max Vector3 which are the minimum and maximum vectors of each mesh bounding box from the passed array, in the world coordinates
+     * @param meshes defines the list of meshes to scan
+     * @returns an object `{min:` Vector3`, max:` Vector3`}`
+     */
+    static MinMax(meshes: any): {
+        min: Vector3;
+        max: Vector3;
+    };
+    /**
+     * Returns the center of the `{min:` Vector3`, max:` Vector3`}` or the center of MinMax vector3 computed from a mesh array
+     * @param meshesOrMinMaxVector could be an array of meshes or a `{min:` Vector3`, max:` Vector3`}` object
+     * @returns a vector3
+     */
+    static Center(meshesOrMinMaxVector: any): Vector3;
+    /**
+     * Merge the array of meshes into a single mesh for performance reasons.
+     * @param meshes array of meshes with the vertices to merge. Entries cannot be empty meshes.
+     * @param disposeSource when true (default), dispose of the vertices from the source meshes.
+     * @param allow32BitsIndices when the sum of the vertices > 64k, this must be set to true.
+     * @param meshSubclass (optional) can be set to a Mesh where the merged vertices will be inserted.
+     * @param subdivideWithSubMeshes when true (false default), subdivide mesh into subMeshes.
+     * @param multiMultiMaterials when true (false default), subdivide mesh into subMeshes with multiple materials, ignores subdivideWithSubMeshes.
+     * @returns a new mesh
+     */
+    static MergeMeshes(meshes: any, disposeSource: boolean | undefined, allow32BitsIndices: any, meshSubclass: any, subdivideWithSubMeshes: any, multiMultiMaterials: any): any;
+    /**
+     * Merge the array of meshes into a single mesh for performance reasons.
+     * @param meshes array of meshes with the vertices to merge. Entries cannot be empty meshes.
+     * @param disposeSource when true (default), dispose of the vertices from the source meshes.
+     * @param allow32BitsIndices when the sum of the vertices > 64k, this must be set to true.
+     * @param meshSubclass (optional) can be set to a Mesh where the merged vertices will be inserted.
+     * @param subdivideWithSubMeshes when true (false default), subdivide mesh into subMeshes.
+     * @param multiMultiMaterials when true (false default), subdivide mesh into subMeshes with multiple materials, ignores subdivideWithSubMeshes.
+     * @returns a new mesh
+     */
+    static MergeMeshesAsync(meshes: any, disposeSource: boolean | undefined, allow32BitsIndices: any, meshSubclass: any, subdivideWithSubMeshes: any, multiMultiMaterials: any): Promise<any>;
+    static _MergeMeshesCoroutine(meshes: any, disposeSource: boolean | undefined, allow32BitsIndices: any, meshSubclass: any, subdivideWithSubMeshes: any, multiMultiMaterials: any, isAsync: any): Generator<undefined, any, unknown>;
+    /**
+     * @constructor
+     * @param name The value used by scene.getMeshByName() to do a lookup.
+     * @param scene The scene to add this mesh to.
+     * @param parent The parent of this mesh, if it has one
+     * @param source An optional Mesh from which geometry is shared, cloned.
+     * @param doNotCloneChildren When cloning, skip cloning child meshes of source, default False.
+     *                  When false, achieved by calling a clone(), also passing False.
+     *                  This will make creation of children, recursive.
+     * @param clonePhysicsImpostor When cloning, include cloning mesh physics impostor, default True.
+     */
+    constructor(name: any, scene: null | undefined, parent: null | undefined, source: null | undefined, doNotCloneChildren: any, clonePhysicsImpostor?: boolean);
+    _internalMeshDataInfo: _InternalMeshDataInfo;
+    /**
+     * Gets the delay loading state of the mesh (when delay loading is turned on)
+     * @see https://doc.babylonjs.com/how_to/using_the_incremental_loading_system
+     */
+    delayLoadState: number;
+    /**
+     * Gets the list of instances created from this mesh
+     * it is not supposed to be modified manually.
+     * Note also that the order of the InstancedMesh wihin the array is not significant and might change.
+     * @see https://doc.babylonjs.com/how_to/how_to_use_instances
+     */
+    instances: any[];
+    /** @internal */
+    _creationDataStorage: any;
+    /** @internal */
+    _geometry: any;
+    /** @internal */
+    _instanceDataStorage: _InstanceDataStorage;
+    /** @internal */
+    _thinInstanceDataStorage: _ThinInstanceDataStorage;
+    /** @internal */
+    _shouldGenerateFlatShading: boolean;
+    /** @internal */
+    _originalBuilderSideOrientation: any;
+    /**
+     * Use this property to change the original side orientation defined at construction time
+     */
+    overrideMaterialSideOrientation: any;
+    /**
+     * Gets or sets a boolean indicating whether to render ignoring the active camera's max z setting. (false by default)
+     * Note this will reduce performance when set to true.
+     */
+    ignoreCameraMaxZ: boolean;
+    _onBeforeDraw: (isInstance: any, world: any, effectiveMaterial: any) => void;
+    parent: any;
+    material: any;
+    morphTargetManager: any;
+    physicsImpostor: any;
+    skeleton: any;
+    onMeshReadyObservable: Observable<any>;
+    set useLODScreenCoverage(arg: boolean);
+    /**
+     * Determines if the LOD levels are intended to be calculated using screen coverage (surface area ratio) instead of distance
+     */
+    get useLODScreenCoverage(): boolean;
+    /**
+     * An event triggered before rendering the mesh
+     */
+    get onBeforeRenderObservable(): any;
+    /**
+     * An event triggered before binding the mesh
+     */
+    get onBeforeBindObservable(): any;
+    /**
+     * An event triggered after rendering the mesh
+     */
+    get onAfterRenderObservable(): any;
+    /**
+     * An event triggeredbetween rendering pass when using separateCullingPass = true
+     */
+    get onBetweenPassObservable(): any;
+    /**
+     * An event triggered before drawing the mesh
+     */
+    get onBeforeDrawObservable(): any;
+    /**
+     * Sets a callback to call before drawing the mesh. It is recommended to use onBeforeDrawObservable instead
+     */
+    set onBeforeDraw(arg: any);
+    _onBeforeDrawObserver: any;
+    set forcedInstanceCount(arg: number);
+    /**
+     * Gets or sets the forced number of instances to display.
+     * If 0 (default value), the number of instances is not forced and depends on the draw type
+     * (regular / instance / thin instances mesh)
+     */
+    get forcedInstanceCount(): number;
+    /**
+     * Gets the source mesh (the one used to clone this one from)
+     */
+    get source(): any;
+    /**
+     * Gets the list of clones of this mesh
+     * The scene must have been constructed with useClonedMeshMap=true for this to work!
+     * Note that useClonedMeshMap=true is the default setting
+     */
+    get cloneMeshMap(): any;
+    set isUnIndexed(arg: any);
+    /**
+     * Gets or sets a boolean indicating that this mesh does not use index buffer
+     */
+    get isUnIndexed(): any;
+    _unIndexed: any;
+    /** Gets the array buffer used to store the instanced buffer used for instances' world matrices */
+    get worldMatrixInstancedBuffer(): any;
+    /** Gets the array buffer used to store the instanced buffer used for instances' previous world matrices */
+    get previousWorldMatrixInstancedBuffer(): any;
+    set manualUpdateOfWorldMatrixInstancedBuffer(arg: any);
+    /** Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual */
+    get manualUpdateOfWorldMatrixInstancedBuffer(): any;
+    set manualUpdateOfPreviousWorldMatrixInstancedBuffer(arg: any);
+    /** Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual */
+    get manualUpdateOfPreviousWorldMatrixInstancedBuffer(): any;
+    instantiateHierarchy(newParent: null | undefined, options: any, onNewNodeCreated: any): void | Mesh;
+    /** @internal */
+    get _isMesh(): boolean;
+    /**
+     * Returns a description of this mesh
+     * @param fullDetails define if full details about this mesh must be used
+     * @returns a descriptive string representing this mesh
+     */
+    toString(fullDetails: any): string;
+    /**
+     * Gets a boolean indicating if this mesh has LOD
+     */
+    get hasLODLevels(): boolean;
+    /**
+     * Gets the list of MeshLODLevel associated with the current mesh
+     * @returns an array of MeshLODLevel
+     */
+    getLODLevels(): any[];
+    _sortLODLevels(): void;
+    /**
+     * Add a mesh as LOD level triggered at the given distance.
+     * @see https://doc.babylonjs.com/how_to/how_to_use_lod
+     * @param distanceOrScreenCoverage Either distance from the center of the object to show this level or the screen coverage if `useScreenCoverage` is set to `true`.
+     * If screen coverage, value is a fraction of the screen's total surface, between 0 and 1.
+     * @param mesh The mesh to be added as LOD level (can be null)
+     * @returns This mesh (for chaining)
+     */
+    addLODLevel(distanceOrScreenCoverage: any, mesh: any): Mesh;
+    /**
+     * Returns the LOD level mesh at the passed distance or null if not found.
+     * @see https://doc.babylonjs.com/how_to/how_to_use_lod
+     * @param distance The distance from the center of the object to show this level
+     * @returns a Mesh or `null`
+     */
+    getLODLevelAtDistance(distance: any): any;
+    /**
+     * Remove a mesh from the LOD array
+     * @see https://doc.babylonjs.com/how_to/how_to_use_lod
+     * @param mesh defines the mesh to be removed
+     * @returns This mesh (for chaining)
+     */
+    removeLODLevel(mesh: any): Mesh;
+    /**
+     * Returns the registered LOD mesh distant from the parameter `camera` position if any, else returns the current mesh.
+     * @see https://doc.babylonjs.com/how_to/how_to_use_lod
+     * @param camera defines the camera to use to compute distance
+     * @param boundingSphere defines a custom bounding sphere to use instead of the one from this mesh
+     * @returns This mesh (for chaining)
+     */
+    getLOD(camera: any, boundingSphere: any): any;
+    /**
+     * Gets the mesh internal Geometry object
+     */
+    get geometry(): any;
+    /**
+     * Returns the total number of vertices within the mesh geometry or zero if the mesh has no geometry.
+     * @returns the total number of vertices
+     */
+    getTotalVertices(): any;
+    /**
+     * Returns the content of an associated vertex buffer
+     * @param kind defines which buffer to read from (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @param copyWhenShared defines a boolean indicating that if the mesh geometry is shared among some other meshes, the returned array is a copy of the internal one
+     * @param forceCopy defines a boolean forcing the copy of the buffer no matter what the value of copyWhenShared is
+     * @returns a FloatArray or null if the mesh has no geometry or no vertex buffer for this kind.
+     */
+    getVerticesData(kind: any, copyWhenShared: any, forceCopy: any): any;
+    /**
+     * Returns the mesh VertexBuffer object from the requested `kind`
+     * @param kind defines which buffer to read from (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.NormalKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @returns a FloatArray or null if the mesh has no vertex buffer for this kind.
+     */
+    getVertexBuffer(kind: any): any;
+    /**
+     * Tests if a specific vertex buffer is associated with this mesh
+     * @param kind defines which buffer to check (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.NormalKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @returns a boolean
+     */
+    isVerticesDataPresent(kind: any): any;
+    /**
+     * Returns a boolean defining if the vertex data for the requested `kind` is updatable.
+     * @param kind defines which buffer to check (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @returns a boolean
+     */
+    isVertexBufferUpdatable(kind: any): any;
+    /**
+     * Returns a string which contains the list of existing `kinds` of Vertex Data associated with this mesh.
+     * @returns an array of strings
+     */
+    getVerticesDataKinds(): any;
+    /**
+     * Returns a positive integer : the total number of indices in this mesh geometry.
+     * @returns the numner of indices or zero if the mesh has no geometry.
+     */
+    getTotalIndices(): any;
+    /**
+     * Returns an array of integers or a typed array (Int32Array, Uint32Array, Uint16Array) populated with the mesh indices.
+     * @param copyWhenShared If true (default false) and and if the mesh geometry is shared among some other meshes, the returned array is a copy of the internal one.
+     * @param forceCopy defines a boolean indicating that the returned array must be cloned upon returning it
+     * @returns the indices array or an empty array if the mesh has no geometry
+     */
+    getIndices(copyWhenShared: any, forceCopy: any): any;
+    /**
+     * Determine if the current mesh is ready to be rendered
+     * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
+     * @param forceInstanceSupport will check if the mesh will be ready when used with instances (false by default)
+     * @returns true if all associated assets are ready (material, textures, shaders)
+     */
+    isReady(completeCheck?: boolean, forceInstanceSupport?: boolean): boolean;
+    /**
+     * Gets a boolean indicating if the normals aren't to be recomputed on next mesh `positions` array update. This property is pertinent only for updatable parametric shapes.
+     */
+    get areNormalsFrozen(): boolean;
+    /**
+     * This function affects parametric shapes on vertex position update only : ribbons, tubes, etc. It has no effect at all on other shapes. It prevents the mesh normals from being recomputed on next `positions` array update.
+     * @returns the current mesh
+     */
+    freezeNormals(): Mesh;
+    /**
+     * This function affects parametric shapes on vertex position update only : ribbons, tubes, etc. It has no effect at all on other shapes. It reactivates the mesh normals computation if it was previously frozen
+     * @returns the current mesh
+     */
+    unfreezeNormals(): Mesh;
+    /**
+     * Sets a value overriding the instance count. Only applicable when custom instanced InterleavedVertexBuffer are used rather than InstancedMeshs
+     */
+    set overridenInstanceCount(arg: any);
+    /** @internal */
+    _preActivate(): Mesh;
+    /**
+     * @internal
+     */
+    _preActivateForIntermediateRendering(renderId: any): Mesh;
+    /**
+     * @internal
+     */
+    _registerInstanceForRenderId(instance: any, renderId: any): Mesh;
+    /**
+     * This method recomputes and sets a new BoundingInfo to the mesh unless it is locked.
+     * This means the mesh underlying bounding box and sphere are recomputed.
+     * @param applySkeleton defines whether to apply the skeleton before computing the bounding info
+     * @param applyMorph  defines whether to apply the morph target before computing the bounding info
+     * @returns the current mesh
+     */
+    refreshBoundingInfo(applySkeleton?: boolean, applyMorph?: boolean): Mesh;
+    /**
+     * @internal
+     */
+    _createGlobalSubMesh(force: any): any;
+    /**
+     * This function will subdivide the mesh into multiple submeshes
+     * @param count defines the expected number of submeshes
+     */
+    subdivide(count: any): void;
+    /**
+     * Copy a FloatArray into a specific associated vertex buffer
+     * @param kind defines which buffer to write to (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @param data defines the data source
+     * @param updatable defines if the updated vertex buffer must be flagged as updatable
+     * @param stride defines the data stride size (can be null)
+     * @returns the current mesh
+     */
+    setVerticesData(kind: any, data: any, updatable: boolean | undefined, stride: any): Mesh;
+    /**
+     * Delete a vertex buffer associated with this mesh
+     * @param kind defines which buffer to delete (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     */
+    removeVerticesData(kind: any): void;
+    /**
+     * Flags an associated vertex buffer as updatable
+     * @param kind defines which buffer to use (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @param updatable defines if the updated vertex buffer must be flagged as updatable
+     */
+    markVerticesDataAsUpdatable(kind: any, updatable?: boolean): void;
+    /**
+     * Sets the mesh global Vertex Buffer
+     * @param buffer defines the buffer to use
+     * @param disposeExistingBuffer disposes the existing buffer, if any (default: true)
+     * @returns the current mesh
+     */
+    setVerticesBuffer(buffer: any, disposeExistingBuffer?: boolean): Mesh;
+    /**
+     * Update a specific associated vertex buffer
+     * @param kind defines which buffer to write to (positions, indices, normals, etc). Possible `kind` values :
+     * - VertexBuffer.PositionKind
+     * - VertexBuffer.UVKind
+     * - VertexBuffer.UV2Kind
+     * - VertexBuffer.UV3Kind
+     * - VertexBuffer.UV4Kind
+     * - VertexBuffer.UV5Kind
+     * - VertexBuffer.UV6Kind
+     * - VertexBuffer.ColorKind
+     * - VertexBuffer.MatricesIndicesKind
+     * - VertexBuffer.MatricesIndicesExtraKind
+     * - VertexBuffer.MatricesWeightsKind
+     * - VertexBuffer.MatricesWeightsExtraKind
+     * @param data defines the data source
+     * @param updateExtends defines if extends info of the mesh must be updated (can be null). This is mostly useful for "position" kind
+     * @param makeItUnique defines if the geometry associated with the mesh must be cloned to make the change only for this mesh (and not all meshes associated with the same geometry)
+     * @returns the current mesh
+     */
+    updateVerticesData(kind: any, data: any, updateExtends: any, makeItUnique: any): Mesh;
+    /**
+     * This method updates the vertex positions of an updatable mesh according to the `positionFunction` returned values.
+     * @see https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh#other-shapes-updatemeshpositions
+     * @param positionFunction is a simple JS function what is passed the mesh `positions` array. It doesn't need to return anything
+     * @param computeNormals is a boolean (default true) to enable/disable the mesh normal recomputation after the vertex position update
+     * @returns the current mesh
+     */
+    updateMeshPositions(positionFunction: any, computeNormals?: boolean): Mesh;
+    /**
+     * Creates a un-shared specific occurence of the geometry for the mesh.
+     * @returns the current mesh
+     */
+    makeGeometryUnique(): Mesh;
+    /**
+     * Set the index buffer of this mesh
+     * @param indices defines the source data
+     * @param totalVertices defines the total number of vertices referenced by this index data (can be null)
+     * @param updatable defines if the updated index buffer must be flagged as updatable (default is false)
+     * @returns the current mesh
+     */
+    setIndices(indices: any, totalVertices?: null, updatable?: boolean): Mesh;
+    /**
+     * Update the current index buffer
+     * @param indices defines the source data
+     * @param offset defines the offset in the index buffer where to store the new data (can be null)
+     * @param gpuMemoryOnly defines a boolean indicating that only the GPU memory must be updated leaving the CPU version of the indices unchanged (false by default)
+     * @returns the current mesh
+     */
+    updateIndices(indices: any, offset: any, gpuMemoryOnly?: boolean): Mesh;
+    /**
+     * Invert the geometry to move from a right handed system to a left handed one.
+     * @returns the current mesh
+     */
+    toLeftHanded(): Mesh;
+    /**
+     * @internal
+     */
+    _bind(subMesh: any, effect: any, fillMode: any): Mesh;
+    /**
+     * @internal
+     */
+    _draw(subMesh: any, fillMode: any, instancesCount: any): Mesh;
+    /**
+     * Registers for this mesh a javascript function called just before the rendering process
+     * @param func defines the function to call before rendering this mesh
+     * @returns the current mesh
+     */
+    registerBeforeRender(func: any): Mesh;
+    /**
+     * Disposes a previously registered javascript function called before the rendering
+     * @param func defines the function to remove
+     * @returns the current mesh
+     */
+    unregisterBeforeRender(func: any): Mesh;
+    /**
+     * Registers for this mesh a javascript function called just after the rendering is complete
+     * @param func defines the function to call after rendering this mesh
+     * @returns the current mesh
+     */
+    registerAfterRender(func: any): Mesh;
+    /**
+     * Disposes a previously registered javascript function called after the rendering.
+     * @param func defines the function to remove
+     * @returns the current mesh
+     */
+    unregisterAfterRender(func: any): Mesh;
+    /**
+     * @internal
+     */
+    _getInstancesRenderList(subMeshId: any, isReplacementMode?: boolean): any;
+    /**
+     * @internal
+     */
+    _renderWithInstances(subMesh: any, fillMode: any, batch: any, effect: any, engine: any): Mesh;
+    _userInstancedBuffersStorage: {
+        data: {};
+        vertexBuffers: {};
+        strides: {};
+        sizes: {};
+        vertexArrayObjects: {} | undefined;
+    } | undefined;
+    /**
+     * @internal
+     */
+    _renderWithThinInstances(subMesh: any, fillMode: any, effect: any, engine: any): void;
+    /**
+     * @internal
+     */
+    _processInstancedBuffers(visibleInstances: any, renderSelf: any): void;
+    /**
+     * @internal
+     */
+    _processRendering(renderingMesh: any, subMesh: any, effect: any, fillMode: any, batch: any, hardwareInstancedRendering: any, onBeforeDraw: any, effectiveMaterial: any): Mesh;
+    /**
+     * Triggers the draw call for the mesh. Usually, you don't need to call this method by your own because the mesh rendering is handled by the scene rendering manager
+     * @param subMesh defines the subMesh to render
+     * @param enableAlphaMode defines if alpha mode can be changed
+     * @param effectiveMeshReplacement defines an optional mesh used to provide info for the rendering
+     * @returns the current mesh
+     */
+    render(subMesh: any, enableAlphaMode: any, effectiveMeshReplacement: any): Mesh;
+    /**
+     *   Renormalize the mesh and patch it up if there are no weights
+     *   Similar to normalization by adding the weights compute the reciprocal and multiply all elements, this wil ensure that everything adds to 1.
+     *   However in the case of zero weights then we set just a single influence to 1.
+     *   We check in the function for extra's present and if so we use the normalizeSkinWeightsWithExtras rather than the FourWeights version.
+     */
+    cleanMatrixWeights(): void;
+    _normalizeSkinFourWeights(): void;
+    _normalizeSkinWeightsAndExtra(): void;
+    /**
+     * ValidateSkinning is used to determine that a mesh has valid skinning data along with skin metrics, if missing weights,
+     * or not normalized it is returned as invalid mesh the string can be used for console logs, or on screen messages to let
+     * the user know there was an issue with importing the mesh
+     * @returns a validation object with skinned, valid and report string
+     */
+    validateSkinning(): {
+        skinned: boolean;
+        valid: boolean;
+        report: string;
+    };
+    /** @internal */
+    _checkDelayState(): Mesh;
+    _queueLoad(scene: any): Mesh;
+    /**
+     * Returns `true` if the mesh is within the frustum defined by the passed array of planes.
+     * A mesh is in the frustum if its bounding box intersects the frustum
+     * @param frustumPlanes defines the frustum to test
+     * @returns true if the mesh is in the frustum planes
+     */
+    isInFrustum(frustumPlanes: any): boolean;
+    /**
+     * Sets the mesh material by the material or multiMaterial `id` property
+     * @param id is a string identifying the material or the multiMaterial
+     * @returns the current mesh
+     */
+    setMaterialById(id: any): Mesh;
+    /**
+     * Returns as a new array populated with the mesh material and/or skeleton, if any.
+     * @returns an array of IAnimatable
+     */
+    getAnimatables(): any[];
+    /**
+     * Modifies the mesh geometry according to the passed transformation matrix.
+     * This method returns nothing but it really modifies the mesh even if it's originally not set as updatable.
+     * The mesh normals are modified using the same transformation.
+     * Note that, under the hood, this method sets a new VertexBuffer each call.
+     * @param transform defines the transform matrix to use
+     * @see https://doc.babylonjs.com/resources/baking_transformations
+     * @returns the current mesh
+     */
+    bakeTransformIntoVertices(transform: any): Mesh;
+    subMeshes: any;
+    /**
+     * Modifies the mesh geometry according to its own current World Matrix.
+     * The mesh World Matrix is then reset.
+     * This method returns nothing but really modifies the mesh even if it's originally not set as updatable.
+     * Note that, under the hood, this method sets a new VertexBuffer each call.
+     * @see https://doc.babylonjs.com/resources/baking_transformations
+     * @param bakeIndependenlyOfChildren indicates whether to preserve all child nodes' World Matrix during baking
+     * @returns the current mesh
+     */
+    bakeCurrentTransformIntoVertices(bakeIndependenlyOfChildren?: boolean): Mesh;
+    /** @internal */
+    get _positions(): any;
+    /** @internal */
+    _resetPointsArrayCache(): Mesh;
+    /** @internal */
+    _generatePointsArray(): any;
+    /**
+     * Returns a new Mesh object generated from the current mesh properties.
+     * This method must not get confused with createInstance()
+     * @param name is a string, the name given to the new mesh
+     * @param newParent can be any Node object (default `null`)
+     * @param doNotCloneChildren allows/denies the recursive cloning of the original mesh children if any (default `false`)
+     * @param clonePhysicsImpostor allows/denies the cloning in the same time of the original mesh `body` used by the physics engine, if any (default `true`)
+     * @returns a new mesh
+     */
+    clone(name: string | undefined, newParent: null | undefined, doNotCloneChildren: any, clonePhysicsImpostor?: boolean): Mesh;
+    /**
+     * Releases resources associated with this mesh.
+     * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
+     * @param disposeMaterialAndTextures Set to true to also dispose referenced materials and textures (false by default)
+     */
+    dispose(doNotRecurse: any, disposeMaterialAndTextures?: boolean): void;
+    /** @internal */
+    _disposeInstanceSpecificData(): void;
+    /** @internal */
+    _disposeThinInstanceSpecificData(): void;
+    /** @internal */
+    _invalidateInstanceVertexArrayObject(): void;
+    /**
+     * Modifies the mesh geometry according to a displacement map.
+     * A displacement map is a colored image. Each pixel color value (actually a gradient computed from red, green, blue values) will give the displacement to apply to each mesh vertex.
+     * The mesh must be set as updatable. Its internal geometry is directly modified, no new buffer are allocated.
+     * @param url is a string, the URL from the image file is to be downloaded.
+     * @param minHeight is the lower limit of the displacement.
+     * @param maxHeight is the upper limit of the displacement.
+     * @param onSuccess is an optional Javascript function to be called just after the mesh is modified. It is passed the modified mesh and must return nothing.
+     * @param uvOffset is an optional vector2 used to offset UV.
+     * @param uvScale is an optional vector2 used to scale UV.
+     * @param forceUpdate defines whether or not to force an update of the generated buffers. This is useful to apply on a deserialized model for instance.
+     * @returns the Mesh.
+     */
+    applyDisplacementMap(url: any, minHeight: any, maxHeight: any, onSuccess: any, uvOffset: any, uvScale: any, forceUpdate?: boolean): Mesh;
+    /**
+     * Modifies the mesh geometry according to a displacementMap buffer.
+     * A displacement map is a colored image. Each pixel color value (actually a gradient computed from red, green, blue values) will give the displacement to apply to each mesh vertex.
+     * The mesh must be set as updatable. Its internal geometry is directly modified, no new buffer are allocated.
+     * @param buffer is a `Uint8Array` buffer containing series of `Uint8` lower than 255, the red, green, blue and alpha values of each successive pixel.
+     * @param heightMapWidth is the width of the buffer image.
+     * @param heightMapHeight is the height of the buffer image.
+     * @param minHeight is the lower limit of the displacement.
+     * @param maxHeight is the upper limit of the displacement.
+     * @param uvOffset is an optional vector2 used to offset UV.
+     * @param uvScale is an optional vector2 used to scale UV.
+     * @param forceUpdate defines whether or not to force an update of the generated buffers. This is useful to apply on a deserialized model for instance.
+     * @returns the Mesh.
+     */
+    applyDisplacementMapFromBuffer(buffer: any, heightMapWidth: any, heightMapHeight: any, minHeight: any, maxHeight: any, uvOffset: any, uvScale: any, forceUpdate?: boolean): Mesh;
+    /**
+     * Modify the mesh to get a flat shading rendering.
+     * This means each mesh facet will then have its own normals. Usually new vertices are added in the mesh geometry to get this result.
+     * Warning : the mesh is really modified even if not set originally as updatable and, under the hood, a new VertexBuffer is allocated.
+     * @returns current mesh
+     */
+    convertToFlatShadedMesh(): Mesh;
+    /**
+     * This method removes all the mesh indices and add new vertices (duplication) in order to unfold facets into buffers.
+     * In other words, more vertices, no more indices and a single bigger VBO.
+     * The mesh is really modified even if not set originally as updatable. Under the hood, a new VertexBuffer is allocated.
+     * @returns current mesh
+     */
+    convertToUnIndexedMesh(): Mesh;
+    /**
+     * Inverses facet orientations.
+     * Warning : the mesh is really modified even if not set originally as updatable. A new VertexBuffer is created under the hood each call.
+     * @param flipNormals will also inverts the normals
+     * @returns current mesh
+     */
+    flipFaces(flipNormals?: boolean): Mesh;
+    /**
+     * Increase the number of facets and hence vertices in a mesh
+     * Vertex normals are interpolated from existing vertex normals
+     * Warning : the mesh is really modified even if not set originally as updatable. A new VertexBuffer is created under the hood each call.
+     * @param numberPerEdge the number of new vertices to add to each edge of a facet, optional default 1
+     */
+    increaseVertices(numberPerEdge?: number): void;
+    /**
+     * Force adjacent facets to share vertices and remove any facets that have all vertices in a line
+     * This will undo any application of covertToFlatShadedMesh
+     * Warning : the mesh is really modified even if not set originally as updatable. A new VertexBuffer is created under the hood each call.
+     */
+    forceSharedVertices(): void;
+    /**
+     * Creates a new InstancedMesh object from the mesh model.
+     * @see https://doc.babylonjs.com/how_to/how_to_use_instances
+     * @param name defines the name of the new instance
+     * @returns a new InstancedMesh
+     */
+    createInstance(name: any): void;
+    /**
+     * Synchronises all the mesh instance submeshes to the current mesh submeshes, if any.
+     * After this call, all the mesh instances have the same submeshes than the current mesh.
+     * @returns the current mesh
+     */
+    synchronizeInstances(): Mesh;
+    /**
+     * Optimization of the mesh's indices, in case a mesh has duplicated vertices.
+     * The function will only reorder the indices and will not remove unused vertices to avoid problems with submeshes.
+     * This should be used together with the simplification to avoid disappearing triangles.
+     * @param successCallback an optional success callback to be called after the optimization finished.
+     * @returns the current mesh
+     */
+    optimizeIndices(successCallback: any): Mesh;
+    /**
+     * Serialize current mesh
+     * @param serializationObject defines the object which will receive the serialization data
+     */
+    serialize(serializationObject: any): void;
+    /**
+     * Prepare internal position array for software CPU skinning
+     * @returns original positions used for CPU skinning. Useful for integrating Morphing with skeletons in same mesh
+     */
+    setPositionsForCPUSkinning(): any;
+    /**
+     * Prepare internal normal array for software CPU skinning
+     * @returns original normals used for CPU skinning. Useful for integrating Morphing with skeletons in same mesh.
+     */
+    setNormalsForCPUSkinning(): any;
+    /**
+     * Updates the vertex buffer by applying transformation from the bones
+     * @param skeleton defines the skeleton to apply to current mesh
+     * @returns the current mesh
+     */
+    applySkeleton(skeleton: any): Mesh;
+    /**
+     * @internal
+     */
+    addInstance(instance: any): void;
+    /**
+     * @internal
+     */
+    removeInstance(instance: any): void;
+    /**
+     * @internal
+     */
+    setMaterialByID(id: any): Mesh;
+}
+export namespace Mesh {
+    const FRONTSIDE: number;
+    const BACKSIDE: number;
+    const DOUBLESIDE: number;
+    const DEFAULTSIDE: number;
+    const NO_CAP: number;
+    const CAP_START: number;
+    const CAP_END: number;
+    const CAP_ALL: number;
+    const NO_FLIP: number;
+    const FLIP_TILE: number;
+    const ROTATE_TILE: number;
+    const FLIP_ROW: number;
+    const ROTATE_ROW: number;
+    const FLIP_N_ROTATE_TILE: number;
+    const FLIP_N_ROTATE_ROW: number;
+    const CENTER: number;
+    const LEFT: number;
+    const RIGHT: number;
+    const TOP: number;
+    const BOTTOM: number;
+    const INSTANCEDMESH_SORT_TRANSPARENT: boolean;
+    /**
+     * @internal
+     */
+    function _GroundMeshParser(parsedMesh: any, scene: any): never;
+    /**
+     * @internal
+     */
+    function _GoldbergMeshParser(parsedMesh: any, scene: any): never;
+    /**
+     * @internal
+     */
+    function _LinesMeshParser(parsedMesh: any, scene: any): never;
+    const CreateDisc: any;
+    const CreateBox: any;
+    const CreateSphere: any;
+    const CreateCylinder: any;
+    const CreateTorusKnot: any;
+    const CreateTorus: any;
+    const CreatePlane: any;
+    const CreateGround: any;
+    const CreateTiledGround: any;
+    const CreateGroundFromHeightMap: any;
+    const CreateTube: any;
+    const CreatePolyhedron: any;
+    const CreateIcoSphere: any;
+    const CreateDecal: any;
+    const CreateCapsule: any;
+    const ExtendToGoldberg: any;
+}
+import { AbstractMesh } from "./abstractMesh.js";
+/**
+ * @internal
+ **/
+declare class _InternalMeshDataInfo {
+    _areNormalsFrozen: boolean;
+    _source: any;
+    meshMap: any;
+    _preActivateId: number;
+    _LODLevels: any[];
+    /** Alternative definition of LOD level, using screen coverage instead of distance */
+    _useLODScreenCoverage: boolean;
+    _effectiveMaterial: any;
+    _forcedInstanceCount: number;
+}
+/**
+ * @internal
+ **/
+declare class _InstanceDataStorage {
+    visibleInstances: {};
+    batchCache: _InstancesBatch;
+    batchCacheReplacementModeInFrozenMode: _InstancesBatch;
+    instancesBufferSize: number;
+}
+/**
+ * @internal
+ **/
+declare class _ThinInstanceDataStorage {
+    instancesCount: number;
+    matrixBuffer: any;
+    previousMatrixBuffer: any;
+    matrixBufferSize: number;
+    matrixData: any;
+    boundingVectors: any[];
+    worldMatrices: any;
+}
+import { Observable } from "../Misc/observable.js";
+import { Vector3 } from "../Maths/math.vector.js";
+export {};