@onerjs/core 8.41.4 → 8.41.6

package/Meshes/mesh.d.ts

@@ -33,16 +33,27 @@ import type { AbstractEngine } from "../Engines/abstractEngine.js";
  * @internal
  **/
 export declare class _CreationDataStorage {
+    /** @internal */
     closePath?: boolean;
+    /** @internal */
     closeArray?: boolean;
+    /** @internal */
     idx: number[];
+    /** @internal */
     dashSize: number;
+    /** @internal */
     gapSize: number;
+    /** @internal */
     path3D: Path3D;
+    /** @internal */
     pathArray: Vector3[][];
+    /** @internal */
     arc: number;
+    /** @internal */
     radius: number;
+    /** @internal */
     cap: number;
+    /** @internal */
     tessellation: number;
 }
 /**
@@ -58,31 +69,50 @@ interface IInstanceDataStorageRenderPassVisibleInstances {
  * @internal
  **/
 declare class _InstanceDataStorageRenderPass {
+    /** @internal */
     visibleInstances: Nullable<IInstanceDataStorageRenderPassVisibleInstances>;
+    /** @internal */
     batchCache: _InstancesBatch;
+    /** @internal */
     batchCacheReplacementModeInFrozenMode: _InstancesBatch;
+    /** @internal */
     instancesBufferSize: number;
+    /** @internal */
     instancesBuffer: Nullable<Buffer>;
+    /** @internal */
     instancesPreviousBuffer: Nullable<Buffer>;
+    /** @internal */
     instancesData: Float32Array;
+    /** @internal */
     instancesPreviousData: Float32Array;
+    /** @internal */
     previousBatch: Nullable<_InstancesBatch>;
+    /** @internal */
     previousRenderId: number;
 }
 /**
  * @internal
  **/
 declare class _InstanceDataStorage {
+    /** @internal */
     renderPasses: {
         [id: number]: _InstanceDataStorageRenderPass;
     };
+    /** @internal */
     overridenInstanceCount: number;
+    /** @internal */
     isFrozen: boolean;
+    /** @internal */
     forceMatrixUpdates: boolean;
+    /** @internal */
     hardwareInstancedRendering: boolean;
+    /** @internal */
     manualUpdate: boolean;
+    /** @internal */
     previousManualUpdate: boolean;
+    /** @internal */
     masterMeshPreviousWorldMatrix: Nullable<Matrix>;
+    /** @internal */
     engine: AbstractEngine;
 }
 /**
@@ -90,24 +120,38 @@ declare class _InstanceDataStorage {
  **/
 export declare class _InstancesBatch {
     parent: _InstanceDataStorageRenderPass;
+    /** @internal */
     mustReturn: boolean;
+    /** @internal */
     visibleInstances: Nullable<InstancedMesh[]>[];
+    /** @internal */
     renderSelf: boolean[];
+    /** @internal */
     hardwareInstancedRendering: boolean[];
+    /** @internal */
     constructor(parent: _InstanceDataStorageRenderPass);
 }
 /**
  * @internal
  **/
 declare class _ThinInstanceDataStorage {
+    /** @internal */
     instancesCount: number;
+    /** @internal */
     matrixBuffer: Nullable<Buffer>;
+    /** @internal */
     previousMatrixBuffer: Nullable<Buffer>;
+    /** @internal */
     matrixBufferSize: number;
+    /** @internal */
     matrixData: Nullable<Float32Array>;
+    /** @internal */
     previousMatrixData: Nullable<Float32Array>;
+    /** @internal */
     boundingVectors: Array<Vector3>;
+    /** @internal */
     worldMatrices: Nullable<Matrix[]>;
+    /** @internal */
     masterMeshPreviousWorldMatrix: Nullable<Matrix>;
 }
 /**
@@ -236,7 +280,9 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * Observers added to this observable will be removed once triggered
      */
     onMeshReadyObservable: Observable<Mesh>;
+    /** {@inheritDoc} */
     get computeBonesUsingShaders(): boolean;
+    /** {@inheritDoc} */
     set computeBonesUsingShaders(value: boolean);
     /**
      * An event triggered before rendering the mesh
@@ -263,7 +309,9 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * Sets a callback to call before drawing the mesh. It is recommended to use onBeforeDrawObservable instead
      */
     set onBeforeDraw(callback: () => void);
+    /** {@inheritDoc} */
     get hasInstances(): boolean;
+    /** {@inheritDoc} */
     get hasThinInstances(): boolean;
     /**
      * Gets the delay loading state of the mesh (when delay loading is turned on)
@@ -331,7 +379,9 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      */
     get overrideRenderingFillMode(): Nullable<number>;
     set overrideRenderingFillMode(fillMode: Nullable<number>);
+    /** {@inheritDoc} */
     get material(): Nullable<Material>;
+    /** {@inheritDoc} */
     set material(value: Nullable<Material>);
     /**
      * Gets or sets a boolean indicating whether to render ignoring the active camera's max z setting. (false by default)
@@ -391,6 +441,13 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * @param clonePhysicsImpostor When cloning, include cloning mesh physics impostor, default True.
      */
     constructor(name: string, scene?: Nullable<Scene>, parent?: Nullable<Node>, source?: Nullable<Mesh>, doNotCloneChildren?: boolean, clonePhysicsImpostor?: boolean);
+    /**
+     * Instantiate (when possible) or clone that node with its hierarchy
+     * @param newParent defines the new parent to use for the instance (or clone)
+     * @param options defines options to configure how copy is done
+     * @param onNewNodeCreated defines an option callback to call when a clone or an instance is created
+     * @returns an instance (or a clone) of the current node with its hierarchy
+     */
     instantiateHierarchy(newParent?: Nullable<TransformNode>, options?: {
         doNotInstantiate: boolean | ((node: TransformNode) => boolean);
     }, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void): Nullable<TransformNode>;
@@ -482,9 +539,33 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * @returns a FloatArray or null if the mesh has no geometry or no vertex buffer for this kind.
      */
     getVerticesData(kind: string, copyWhenShared?: boolean, forceCopy?: boolean, bypassInstanceData?: boolean): Nullable<FloatArray>;
+    /**
+     * Copies the requested vertex data kind into the given vertex data map. Float data is constructed if the map doesn't have the data.
+     * @param kind defines the vertex data kind to use
+     * @param vertexData defines the map that stores the resulting data
+     */
     copyVerticesData(kind: string, vertexData: {
         [kind: string]: Float32Array;
     }): void;
+    /**
+     * 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
+     * @param bypassInstanceData defines a boolean indicating that the function should not take into account the instance data (applies only if the mesh has instances). Default: false
+     * @returns a FloatArray or null if the mesh has no vertex buffer for this kind.
+     */
     getVertexBuffer(kind: string, bypassInstanceData?: boolean): Nullable<VertexBuffer>;
     /**
      * Tests if a specific vertex buffer is associated with this mesh
@@ -543,6 +624,7 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * @returns the indices array or an empty array if the mesh has no geometry
      */
     getIndices(copyWhenShared?: boolean, forceCopy?: boolean): Nullable<IndicesArray>;
+    /** {@inheritDoc} */
     get isBlocked(): boolean;
     /**
      * Determine if the current mesh is ready to be rendered
@@ -1085,7 +1167,7 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * 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 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.
@@ -1096,7 +1178,7 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * 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 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.
@@ -1126,133 +1208,133 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
     /**
      * Creates a ribbon mesh.
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param
-     * @param name defines the name of the mesh to create
-     * @param pathArray is a required array of paths, what are each an array of successive Vector3. The pathArray parameter depicts the ribbon geometry.
-     * @param closeArray creates a seam between the first and the last paths of the path array (default is false)
-     * @param closePath creates a seam between the first and the last points of each path of the path array
-     * @param offset is taken in account only if the `pathArray` is containing a single path
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
-     * @param instance defines an instance of an existing Ribbon object to be updated with the passed `pathArray` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#ribbon)
+     * @param _name defines the name of the mesh to create
+     * @param _pathArray is a required array of paths, what are each an array of successive Vector3. The pathArray parameter depicts the ribbon geometry.
+     * @param _closeArray creates a seam between the first and the last paths of the path array (default is false)
+     * @param _closePath creates a seam between the first and the last points of each path of the path array
+     * @param _offset is taken in account only if the `pathArray` is containing a single path
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _instance defines an instance of an existing Ribbon object to be updated with the passed `pathArray` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#ribbon)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateRibbon(name: string, pathArray: Vector3[][], closeArray: boolean, closePath: boolean, offset: number, scene?: Scene, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh;
+    static CreateRibbon(_name: string, _pathArray: Vector3[][], _closeArray: boolean, _closePath: boolean, _offset: number, _scene?: Scene, _updatable?: boolean, _sideOrientation?: number, _instance?: Mesh): Mesh;
     /**
      * Creates a plane polygonal mesh.  By default, this is a disc.
-     * @param name defines the name of the mesh to create
-     * @param radius sets the radius size (float) of the polygon (default 0.5)
-     * @param tessellation sets the number of polygon sides (positive integer, default 64). So a tessellation valued to 3 will build a triangle, to 4 a square, etc
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _radius sets the radius size (float) of the polygon (default 0.5)
+     * @param _tessellation sets the number of polygon sides (positive integer, default 64). So a tessellation valued to 3 will build a triangle, to 4 a square, etc
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateDisc(name: string, radius: number, tessellation: number, scene: Nullable<Scene>, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreateDisc(_name: string, _radius: number, _tessellation: number, _scene: Nullable<Scene>, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a box mesh.
-     * @param name defines the name of the mesh to create
-     * @param size sets the size (float) of each box side (default 1)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _size sets the size (float) of each box side (default 1)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateBox(name: string, size: number, scene: Nullable<Scene>, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreateBox(_name: string, _size: number, _scene: Nullable<Scene>, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a sphere mesh.
-     * @param name defines the name of the mesh to create
-     * @param segments sets the sphere number of horizontal stripes (positive integer, default 32)
-     * @param diameter sets the diameter size (float) of the sphere (default 1)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _segments sets the sphere number of horizontal stripes (positive integer, default 32)
+     * @param _diameter sets the diameter size (float) of the sphere (default 1)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateSphere(name: string, segments: number, diameter: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreateSphere(_name: string, _segments: number, _diameter: number, _scene?: Scene, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a hemisphere mesh.
-     * @param name defines the name of the mesh to create
-     * @param segments sets the sphere number of horizontal stripes (positive integer, default 32)
-     * @param diameter sets the diameter size (float) of the sphere (default 1)
-     * @param scene defines the hosting scene
+     * @param _name defines the name of the mesh to create
+     * @param _segments sets the sphere number of horizontal stripes (positive integer, default 32)
+     * @param _diameter sets the diameter size (float) of the sphere (default 1)
+     * @param _scene defines the hosting scene
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateHemisphere(name: string, segments: number, diameter: number, scene?: Scene): Mesh;
+    static CreateHemisphere(_name: string, _segments: number, _diameter: number, _scene?: Scene): Mesh;
     /**
      * Creates a cylinder or a cone mesh.
-     * @param name defines the name of the mesh to create
-     * @param height sets the height size (float) of the cylinder/cone (float, default 2)
-     * @param diameterTop set the top cap diameter (floats, default 1)
-     * @param diameterBottom set the bottom cap diameter (floats, default 1). This value can't be zero
-     * @param tessellation sets the number of cylinder sides (positive integer, default 24). Set it to 3 to get a prism for instance
-     * @param subdivisions sets the number of rings along the cylinder height (positive integer, default 1)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _height sets the height size (float) of the cylinder/cone (float, default 2)
+     * @param _diameterTop set the top cap diameter (floats, default 1)
+     * @param _diameterBottom set the bottom cap diameter (floats, default 1). This value can't be zero
+     * @param _tessellation sets the number of cylinder sides (positive integer, default 24). Set it to 3 to get a prism for instance
+     * @param _subdivisions sets the number of rings along the cylinder height (positive integer, default 1)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions: any, scene?: Scene, updatable?: any, sideOrientation?: number): Mesh;
+    static CreateCylinder(_name: string, _height: number, _diameterTop: number, _diameterBottom: number, _tessellation: number, _subdivisions: any, _scene?: Scene, _updatable?: any, _sideOrientation?: number): Mesh;
     /**
      * Creates a torus mesh.
-     * @param name defines the name of the mesh to create
-     * @param diameter sets the diameter size (float) of the torus (default 1)
-     * @param thickness sets the diameter size of the tube of the torus (float, default 0.5)
-     * @param tessellation sets the number of torus sides (positive integer, default 16)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _diameter sets the diameter size (float) of the torus (default 1)
+     * @param _thickness sets the diameter size of the tube of the torus (float, default 0.5)
+     * @param _tessellation sets the number of torus sides (positive integer, default 16)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreateTorus(_name: string, _diameter: number, _thickness: number, _tessellation: number, _scene?: Scene, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a torus knot mesh.
-     * @param name defines the name of the mesh to create
-     * @param radius sets the global radius size (float) of the torus knot (default 2)
-     * @param tube sets the diameter size of the tube of the torus (float, default 0.5)
-     * @param radialSegments sets the number of sides on each tube segments (positive integer, default 32)
-     * @param tubularSegments sets the number of tubes to decompose the knot into (positive integer, default 32)
-     * @param p the number of windings on X axis (positive integers, default 2)
-     * @param q the number of windings on Y axis (positive integers, default 3)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _radius sets the global radius size (float) of the torus knot (default 2)
+     * @param _tube sets the diameter size of the tube of the torus (float, default 0.5)
+     * @param _radialSegments sets the number of sides on each tube segments (positive integer, default 32)
+     * @param _tubularSegments sets the number of tubes to decompose the knot into (positive integer, default 32)
+     * @param _p the number of windings on X axis (positive integers, default 2)
+     * @param _q the number of windings on Y axis (positive integers, default 3)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateTorusKnot(name: string, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreateTorusKnot(_name: string, _radius: number, _tube: number, _radialSegments: number, _tubularSegments: number, _p: number, _q: number, _scene?: Scene, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a line mesh..
-     * @param name defines the name of the mesh to create
-     * @param points is an array successive Vector3
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param instance is an instance of an existing LineMesh object to be updated with the passed `points` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#lines-and-dashedlines).
+     * @param _name defines the name of the mesh to create
+     * @param _points is an array successive Vector3
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _instance is an instance of an existing LineMesh object to be updated with the passed `points` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#lines-and-dashedlines).
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateLines(name: string, points: Vector3[], scene: Nullable<Scene>, updatable: boolean, instance?: Nullable<LinesMesh>): LinesMesh;
+    static CreateLines(_name: string, _points: Vector3[], _scene: Nullable<Scene>, _updatable: boolean, _instance?: Nullable<LinesMesh>): LinesMesh;
     /**
      * Creates a dashed line mesh.
-     * @param name defines the name of the mesh to create
-     * @param points is an array successive Vector3
-     * @param dashSize is the size of the dashes relatively the dash number (positive float, default 3)
-     * @param gapSize is the size of the gap between two successive dashes relatively the dash number (positive float, default 1)
-     * @param dashNb is the intended total number of dashes (positive integer, default 200)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param instance is an instance of an existing LineMesh object to be updated with the passed `points` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#lines-and-dashedlines)
+     * @param _name defines the name of the mesh to create
+     * @param _points is an array successive Vector3
+     * @param _dashSize is the size of the dashes relatively the dash number (positive float, default 3)
+     * @param _gapSize is the size of the gap between two successive dashes relatively the dash number (positive float, default 1)
+     * @param _dashNb is the intended total number of dashes (positive integer, default 200)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _instance is an instance of an existing LineMesh object to be updated with the passed `points` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#lines-and-dashedlines)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateDashedLines(name: string, points: Vector3[], dashSize: number, gapSize: number, dashNb: number, scene: Nullable<Scene>, updatable?: boolean, instance?: LinesMesh): LinesMesh;
+    static CreateDashedLines(_name: string, _points: Vector3[], _dashSize: number, _gapSize: number, _dashNb: number, _scene: Nullable<Scene>, _updatable?: boolean, _instance?: LinesMesh): LinesMesh;
     /**
      * Creates a polygon mesh.Please consider using the same method from the MeshBuilder class instead
      * The polygon's shape will depend on the input parameters and is constructed parallel to a ground mesh.
@@ -1261,175 +1343,175 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created.
      * Remember you can only change the shape positions, not their number when updating a polygon.
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param#non-regular-polygon
-     * @param name defines the name of the mesh to create
-     * @param shape is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors
-     * @param scene defines the hosting scene
-     * @param holes is a required array of arrays of successive Vector3 used to defines holes in the polygon
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
-     * @param earcutInjection can be used to inject your own earcut reference
+     * @param _name defines the name of the mesh to create
+     * @param _shape is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors
+     * @param _scene defines the hosting scene
+     * @param _holes is a required array of arrays of successive Vector3 used to defines holes in the polygon
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _earcutInjection can be used to inject your own earcut reference
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreatePolygon(name: string, shape: Vector3[], scene: Scene, holes?: Vector3[][], updatable?: boolean, sideOrientation?: number, earcutInjection?: any): Mesh;
+    static CreatePolygon(_name: string, _shape: Vector3[], _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: any): Mesh;
     /**
      * Creates an extruded polygon mesh, with depth in the Y direction..
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param#extruded-non-regular-polygon
-     * @param name defines the name of the mesh to create
-     * @param shape is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors
-     * @param depth defines the height of extrusion
-     * @param scene defines the hosting scene
-     * @param holes is a required array of arrays of successive Vector3 used to defines holes in the polygon
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
-     * @param earcutInjection can be used to inject your own earcut reference
+     * @param _name defines the name of the mesh to create
+     * @param _shape is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors
+     * @param _depth defines the height of extrusion
+     * @param _scene defines the hosting scene
+     * @param _holes is a required array of arrays of successive Vector3 used to defines holes in the polygon
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _earcutInjection can be used to inject your own earcut reference
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static ExtrudePolygon(name: string, shape: Vector3[], depth: number, scene: Scene, holes?: Vector3[][], updatable?: boolean, sideOrientation?: number, earcutInjection?: any): Mesh;
+    static ExtrudePolygon(_name: string, _shape: Vector3[], _depth: number, _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: any): Mesh;
     /**
      * Creates an extruded shape mesh.
      * The extrusion is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param#extruded-shapes
-     * @param name defines the name of the mesh to create
-     * @param shape is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis
-     * @param path is a required array of successive Vector3. This is the axis curve the shape is extruded along
-     * @param scale is the value to scale the shape
-     * @param rotation is the angle value to rotate the shape each step (each path point), from the former step (so rotation added each step) along the curve
-     * @param cap sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
-     * @param instance is an instance of an existing ExtrudedShape object to be updated with the passed `shape`, `path`, `scale` or `rotation` parameters (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#extruded-shape)
+     * @param _name defines the name of the mesh to create
+     * @param _shape is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis
+     * @param _path is a required array of successive Vector3. This is the axis curve the shape is extruded along
+     * @param _scale is the value to scale the shape
+     * @param _rotation is the angle value to rotate the shape each step (each path point), from the former step (so rotation added each step) along the curve
+     * @param _cap sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _instance is an instance of an existing ExtrudedShape object to be updated with the passed `shape`, `path`, `scale` or `rotation` parameters (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#extruded-shape)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static ExtrudeShape(name: string, shape: Vector3[], path: Vector3[], scale: number, rotation: number, cap: number, scene: Nullable<Scene>, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh;
+    static ExtrudeShape(_name: string, _shape: Vector3[], _path: Vector3[], _scale: number, _rotation: number, _cap: number, _scene: Nullable<Scene>, _updatable?: boolean, _sideOrientation?: number, _instance?: Mesh): Mesh;
     /**
      * Creates an custom extruded shape mesh.
      * The custom extrusion is a parametric shape.
      * It has no predefined shape. Its final shape will depend on the input parameters.
      *
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param#extruded-shapes
-     * @param name defines the name of the mesh to create
-     * @param shape is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis
-     * @param path is a required array of successive Vector3. This is the axis curve the shape is extruded along
-     * @param scaleFunction is a custom Javascript function called on each path point
-     * @param rotationFunction is a custom Javascript function called on each path point
-     * @param ribbonCloseArray forces the extrusion underlying ribbon to close all the paths in its `pathArray`
-     * @param ribbonClosePath forces the extrusion underlying ribbon to close its `pathArray`
-     * @param cap sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
-     * @param instance is an instance of an existing ExtrudedShape object to be updated with the passed `shape`, `path`, `scale` or `rotation` parameters (https://doc.babylonjs.com/features/featuresDeepDive/mesh/dynamicMeshMorph#extruded-shape)
+     * @param _name defines the name of the mesh to create
+     * @param _shape is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis
+     * @param _path is a required array of successive Vector3. This is the axis curve the shape is extruded along
+     * @param _scaleFunction is a custom Javascript function called on each path point
+     * @param _rotationFunction is a custom Javascript function called on each path point
+     * @param _ribbonCloseArray forces the extrusion underlying ribbon to close all the paths in its `pathArray`
+     * @param _ribbonClosePath forces the extrusion underlying ribbon to close its `pathArray`
+     * @param _cap sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _instance is an instance of an existing ExtrudedShape object to be updated with the passed `shape`, `path`, `scale` or `rotation` parameters (https://doc.babylonjs.com/features/featuresDeepDive/mesh/dynamicMeshMorph#extruded-shape)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static ExtrudeShapeCustom(name: string, shape: Vector3[], path: Vector3[], scaleFunction: Nullable<{
+    static ExtrudeShapeCustom(_name: string, _shape: Vector3[], _path: Vector3[], _scaleFunction: Nullable<{
         (i: number, distance: number): number;
-    }>, rotationFunction: Nullable<{
+    }>, _rotationFunction: Nullable<{
         (i: number, distance: number): number;
-    }>, ribbonCloseArray: boolean, ribbonClosePath: boolean, cap: number, scene: Scene, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh;
+    }>, _ribbonCloseArray: boolean, _ribbonClosePath: boolean, _cap: number, _scene: Scene, _updatable?: boolean, _sideOrientation?: number, _instance?: Mesh): Mesh;
     /**
      * Creates lathe mesh.
      * The lathe is a shape with a symmetry axis : a 2D model shape is rotated around this axis to design the lathe.
-     * @param name defines the name of the mesh to create
-     * @param shape is a required array of successive Vector3. This array depicts the shape to be rotated in its local space : the shape must be designed in the xOy plane and will be rotated around the Y axis. It's usually a 2D shape, so the Vector3 z coordinates are often set to zero
-     * @param radius is the radius value of the lathe
-     * @param tessellation is the side number of the lathe.
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _shape is a required array of successive Vector3. This array depicts the shape to be rotated in its local space : the shape must be designed in the xOy plane and will be rotated around the Y axis. It's usually a 2D shape, so the Vector3 z coordinates are often set to zero
+     * @param _radius is the radius value of the lathe
+     * @param _tessellation is the side number of the lathe.
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateLathe(name: string, shape: Vector3[], radius: number, tessellation: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreateLathe(_name: string, _shape: Vector3[], _radius: number, _tessellation: number, _scene: Scene, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a plane mesh.
-     * @param name defines the name of the mesh to create
-     * @param size sets the size (float) of both sides of the plane at once (default 1)
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _name defines the name of the mesh to create
+     * @param _size sets the size (float) of both sides of the plane at once (default 1)
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreatePlane(name: string, size: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+    static CreatePlane(_name: string, _size: number, _scene: Scene, _updatable?: boolean, _sideOrientation?: number): Mesh;
     /**
      * Creates a ground mesh.
-     * @param name defines the name of the mesh to create
-     * @param width set the width of the ground
-     * @param height set the height of the ground
-     * @param subdivisions sets the number of subdivisions per side
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
+     * @param _name defines the name of the mesh to create
+     * @param _width set the width of the ground
+     * @param _height set the height of the ground
+     * @param _subdivisions sets the number of subdivisions per side
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateGround(name: string, width: number, height: number, subdivisions: number, scene?: Scene, updatable?: boolean): Mesh;
+    static CreateGround(_name: string, _width: number, _height: number, _subdivisions: number, _scene?: Scene, _updatable?: boolean): Mesh;
     /**
      * Creates a tiled ground mesh.
-     * @param name defines the name of the mesh to create
-     * @param xmin set the ground minimum X coordinate
-     * @param zmin set the ground minimum Y coordinate
-     * @param xmax set the ground maximum X coordinate
-     * @param zmax set the ground maximum Z coordinate
-     * @param subdivisions is an object `{w: positive integer, h: positive integer}` (default `{w: 6, h: 6}`). `w` and `h` are the numbers of subdivisions on the ground width and height. Each subdivision is called a tile
-     * @param precision is an object `{w: positive integer, h: positive integer}` (default `{w: 2, h: 2}`). `w` and `h` are the numbers of subdivisions on the ground width and height of each tile
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
+     * @param _name defines the name of the mesh to create
+     * @param _xmin set the ground minimum X coordinate
+     * @param _zmin set the ground minimum Y coordinate
+     * @param _xmax set the ground maximum X coordinate
+     * @param _zmax set the ground maximum Z coordinate
+     * @param _subdivisions is an object `{w: positive integer, h: positive integer}` (default `{w: 6, h: 6}`). `w` and `h` are the numbers of subdivisions on the ground width and height. Each subdivision is called a tile
+     * @param _precision is an object `{w: positive integer, h: positive integer}` (default `{w: 2, h: 2}`). `w` and `h` are the numbers of subdivisions on the ground width and height of each tile
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateTiledGround(name: string, xmin: number, zmin: number, xmax: number, zmax: number, subdivisions: {
+    static CreateTiledGround(_name: string, _xmin: number, _zmin: number, _xmax: number, _zmax: number, _subdivisions: {
         w: number;
         h: number;
-    }, precision: {
+    }, _precision: {
         w: number;
         h: number;
-    }, scene: Scene, updatable?: boolean): Mesh;
+    }, _scene: Scene, _updatable?: boolean): Mesh;
     /**
      * Creates a ground mesh from a height map.
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set/height_map
-     * @param name defines the name of the mesh to create
-     * @param url sets the URL of the height map image resource
-     * @param width set the ground width size
-     * @param height set the ground height size
-     * @param subdivisions sets the number of subdivision per side
-     * @param minHeight is the minimum altitude on the ground
-     * @param maxHeight is the maximum altitude on the ground
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param onReady  is a callback function that will be called  once the mesh is built (the height map download can last some time)
-     * @param alphaFilter will filter any data where the alpha channel is below this value, defaults 0 (all data visible)
+     * @param _name defines the name of the mesh to create
+     * @param _url sets the URL of the height map image resource
+     * @param _width set the ground width size
+     * @param _height set the ground height size
+     * @param _subdivisions sets the number of subdivision per side
+     * @param _minHeight is the minimum altitude on the ground
+     * @param _maxHeight is the maximum altitude on the ground
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _onReady  is a callback function that will be called  once the mesh is built (the height map download can last some time)
+     * @param _alphaFilter will filter any data where the alpha channel is below this value, defaults 0 (all data visible)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateGroundFromHeightMap(name: string, url: string, width: number, height: number, subdivisions: number, minHeight: number, maxHeight: number, scene: Scene, updatable?: boolean, onReady?: (mesh: GroundMesh) => void, alphaFilter?: number): GroundMesh;
+    static CreateGroundFromHeightMap(_name: string, _url: string, _width: number, _height: number, _subdivisions: number, _minHeight: number, _maxHeight: number, _scene: Scene, _updatable?: boolean, _onReady?: (mesh: GroundMesh) => void, _alphaFilter?: number): GroundMesh;
     /**
      * Creates a tube mesh.
      * The tube is a parametric shape.
      * It has no predefined shape. Its final shape will depend on the input parameters.
      *
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param
-     * @param name defines the name of the mesh to create
-     * @param path is a required array of successive Vector3. It is the curve used as the axis of the tube
-     * @param radius sets the tube radius size
-     * @param tessellation is the number of sides on the tubular surface
-     * @param radiusFunction is a custom function. If it is not null, it overrides the parameter `radius`. This function is called on each point of the tube path and is passed the index `i` of the i-th point and the distance of this point from the first point of the path
-     * @param cap sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
-     * @param scene defines the hosting scene
-     * @param updatable defines if the mesh must be flagged as updatable
-     * @param sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
-     * @param instance is an instance of an existing Tube object to be updated with the passed `pathArray` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#tube)
+     * @param _name defines the name of the mesh to create
+     * @param _path is a required array of successive Vector3. It is the curve used as the axis of the tube
+     * @param _radius sets the tube radius size
+     * @param _tessellation is the number of sides on the tubular surface
+     * @param _radiusFunction is a custom function. If it is not null, it overrides the parameter `radius`. This function is called on each point of the tube path and is passed the index `i` of the i-th point and the distance of this point from the first point of the path
+     * @param _cap sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
+     * @param _scene defines the hosting scene
+     * @param _updatable defines if the mesh must be flagged as updatable
+     * @param _sideOrientation defines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
+     * @param _instance is an instance of an existing Tube object to be updated with the passed `pathArray` parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#tube)
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateTube(name: string, path: Vector3[], radius: number, tessellation: number, radiusFunction: {
+    static CreateTube(_name: string, _path: Vector3[], _radius: number, _tessellation: number, _radiusFunction: {
         (i: number, distance: number): number;
-    }, cap: number, scene: Scene, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh;
+    }, _cap: number, _scene: Scene, _updatable?: boolean, _sideOrientation?: number, _instance?: Mesh): Mesh;
     /**
      * Creates a polyhedron mesh.
      *.
@@ -1444,13 +1526,13 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * * You can also set the mesh side orientation with the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
      * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation
      * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
-     * @param name defines the name of the mesh to create
-     * @param options defines the options used to create the mesh
-     * @param scene defines the hosting scene
+     * @param _name defines the name of the mesh to create
+     * @param _options defines the options used to create the mesh
+     * @param _scene defines the hosting scene
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreatePolyhedron(name: string, options: {
+    static CreatePolyhedron(_name: string, _options: {
         type?: number;
         size?: number;
         sizeX?: number;
@@ -1461,7 +1543,7 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
         faceColors?: Color4[];
         updatable?: boolean;
         sideOrientation?: number;
-    }, scene: Scene): Mesh;
+    }, _scene: Scene): Mesh;
     /**
      * Creates a sphere based upon an icosahedron with 20 triangular faces which can be subdivided
      * * The parameter `radius` sets the radius size (float) of the icosphere (default 1)
@@ -1472,49 +1554,49 @@ export declare class Mesh extends AbstractMesh implements IGetSetVerticesData {
      * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation
      * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/polyhedra#icosphere
-     * @param name defines the name of the mesh
-     * @param options defines the options used to create the mesh
-     * @param scene defines the hosting scene
+     * @param _name defines the name of the mesh
+     * @param _options defines the options used to create the mesh
+     * @param _scene defines the hosting scene
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateIcoSphere(name: string, options: {
+    static CreateIcoSphere(_name: string, _options: {
         radius?: number;
         flat?: boolean;
         subdivisions?: number;
         sideOrientation?: number;
         updatable?: boolean;
-    }, scene: Scene): Mesh;
+    }, _scene: Scene): Mesh;
     /**
      * Creates a decal mesh.
      *.
      * A decal is a mesh usually applied as a model onto the surface of another mesh
-     * @param name  defines the name of the mesh
-     * @param sourceMesh defines the mesh receiving the decal
-     * @param position sets the position of the decal in world coordinates
-     * @param normal sets the normal of the mesh where the decal is applied onto in world coordinates
-     * @param size sets the decal scaling
-     * @param angle sets the angle to rotate the decal
+     * @param _name  defines the name of the mesh
+     * @param _sourceMesh defines the mesh receiving the decal
+     * @param _position sets the position of the decal in world coordinates
+     * @param _normal sets the normal of the mesh where the decal is applied onto in world coordinates
+     * @param _size sets the decal scaling
+     * @param _angle sets the angle to rotate the decal
      * @returns a new Mesh
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateDecal(name: string, sourceMesh: AbstractMesh, position: Vector3, normal: Vector3, size: Vector3, angle: number): Mesh;
+    static CreateDecal(_name: string, _sourceMesh: AbstractMesh, _position: Vector3, _normal: Vector3, _size: Vector3, _angle: number): Mesh;
     /** Creates a Capsule Mesh
-     * @param name defines the name of the mesh.
-     * @param options the constructors options used to shape the mesh.
-     * @param scene defines the scene the mesh is scoped to.
+     * @param _name defines the name of the mesh.
+     * @param _options the constructors options used to shape the mesh.
+     * @param _scene defines the scene the mesh is scoped to.
      * @returns the capsule mesh
      * @see https://doc.babylonjs.com/how_to/capsule_shape
      * @deprecated Please use MeshBuilder instead
      */
-    static CreateCapsule(name: string, options: ICreateCapsuleOptions, scene: Scene): Mesh;
+    static CreateCapsule(_name: string, _options: ICreateCapsuleOptions, _scene: Scene): Mesh;
     /**
      * Extends a mesh to a Goldberg mesh
      * Warning  the mesh to convert MUST be an import of a perviously exported Goldberg mesh
-     * @param mesh the mesh to convert
+     * @param _mesh the mesh to convert
      * @returns the extended mesh
      * @deprecated Please use ExtendMeshToGoldberg instead
      */
-    static ExtendToGoldberg(mesh: Mesh): Mesh;
+    static ExtendToGoldberg(_mesh: Mesh): Mesh;
 }
 export {};