@onerjs/core 8.41.5 → 8.41.7

package/Meshes/mesh.js

@@ -32,8 +32,11 @@ export class _CreationDataStorage {
  **/
 class _InstanceDataStorageRenderPass {
     constructor() {
+        /** @internal */
         this.batchCache = new _InstancesBatch(this);
+        /** @internal */
         this.batchCacheReplacementModeInFrozenMode = new _InstancesBatch(this);
+        /** @internal */
         this.instancesBufferSize = 32 * 16 * 4; // let's start with a maximum of 32 instances
     }
 }
@@ -42,6 +45,7 @@ class _InstanceDataStorageRenderPass {
  **/
 class _InstanceDataStorage {
     constructor() {
+        /** @internal */
         this.renderPasses = {};
     }
 }
@@ -49,11 +53,16 @@ class _InstanceDataStorage {
  * @internal
  **/
 export class _InstancesBatch {
+    /** @internal */
     constructor(parent) {
         this.parent = parent;
+        /** @internal */
         this.mustReturn = false;
+        /** @internal */
         this.visibleInstances = new Array();
+        /** @internal */
         this.renderSelf = [];
+        /** @internal */
         this.hardwareInstancedRendering = [];
     }
 }
@@ -62,12 +71,19 @@ export class _InstancesBatch {
  **/
 class _ThinInstanceDataStorage {
     constructor() {
+        /** @internal */
         this.instancesCount = 0;
+        /** @internal */
         this.matrixBuffer = null;
+        /** @internal */
         this.previousMatrixBuffer = null;
+        /** @internal */
         this.matrixBufferSize = 32 * 16; // let's start with a maximum of 32 thin instances
+        /** @internal */
         this.matrixData = null;
+        /** @internal */
         this.boundingVectors = [];
+        /** @internal */
         this.worldMatrices = null;
     }
 }
@@ -121,9 +137,11 @@ export class Mesh extends AbstractMesh {
         this._internalMeshDataInfo._useLODScreenCoverage = value;
         this._sortLODLevels();
     }
+    /** {@inheritDoc} */
     get computeBonesUsingShaders() {
         return this._internalAbstractMeshDataInfo._computeBonesUsingShaders;
     }
+    /** {@inheritDoc} */
     set computeBonesUsingShaders(value) {
         if (this._internalAbstractMeshDataInfo._computeBonesUsingShaders === value) {
             return;
@@ -194,9 +212,11 @@ export class Mesh extends AbstractMesh {
         }
         this._onBeforeDrawObserver = this.onBeforeDrawObservable.add(callback);
     }
+    /** {@inheritDoc} */
     get hasInstances() {
         return this.instances.length > 0;
     }
+    /** {@inheritDoc} */
     get hasThinInstances() {
         return (this.forcedInstanceCount || this._thinInstanceDataStorage.instancesCount || 0) > 0;
     }
@@ -251,9 +271,11 @@ export class Mesh extends AbstractMesh {
     set overrideRenderingFillMode(fillMode) {
         this._internalMeshDataInfo._overrideRenderingFillMode = fillMode;
     }
+    /** {@inheritDoc} */
     get material() {
         return this._internalAbstractMeshDataInfo._material;
     }
+    /** {@inheritDoc} */
     set material(value) {
         if (value && ((this.material && this.material.sideOrientation === null) || this._internalAbstractMeshDataInfo._sideOrientationHint)) {
             value.sideOrientation = null;
@@ -288,12 +310,16 @@ export class Mesh extends AbstractMesh {
     }
     /** Gets the array buffer used to store the instanced buffer used for instances' world matrices */
     get worldMatrixInstancedBuffer() {
-        const instanceDataStorage = this._instanceDataStorage.renderPasses[this._instanceDataStorage.engine.isWebGPU ? this._instanceDataStorage.engine.currentRenderPassId : 0];
+        const instanceDataStorage = this._instanceDataStorage.useMonoDataStorageRenderPass
+            ? this._instanceDataStorage.dataStorageRenderPass
+            : this._instanceDataStorage.renderPasses[this._instanceDataStorage.engine.currentRenderPassId];
         return instanceDataStorage ? instanceDataStorage.instancesData : undefined;
     }
     /** Gets the array buffer used to store the instanced buffer used for instances' previous world matrices */
     get previousWorldMatrixInstancedBuffer() {
-        const instanceDataStorage = this._instanceDataStorage.renderPasses[this._instanceDataStorage.engine.isWebGPU ? this._instanceDataStorage.engine.currentRenderPassId : 0];
+        const instanceDataStorage = this._instanceDataStorage.useMonoDataStorageRenderPass
+            ? this._instanceDataStorage.dataStorageRenderPass
+            : this._instanceDataStorage.renderPasses[this._instanceDataStorage.engine.currentRenderPassId];
         return instanceDataStorage ? instanceDataStorage.instancesPreviousData : undefined;
     }
     /** Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual */
@@ -520,6 +546,10 @@ export class Mesh extends AbstractMesh {
         scene = this.getScene();
         this._instanceDataStorage = new _InstanceDataStorage();
         this._instanceDataStorage.engine = scene.getEngine();
+        this._instanceDataStorage.useMonoDataStorageRenderPass = !this._instanceDataStorage.engine.isWebGPU;
+        if (this._instanceDataStorage.useMonoDataStorageRenderPass) {
+            this._instanceDataStorage.dataStorageRenderPass = new _InstanceDataStorageRenderPass();
+        }
         if (this._scene.useRightHandedSystem) {
             this.sideOrientation = 0;
         }
@@ -581,6 +611,13 @@ export class Mesh extends AbstractMesh {
             source.onClonedObservable.notifyObservers(this);
         }
     }
+    /**
+     * 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 = null, options, onNewNodeCreated) {
         const instance = this.getTotalVertices() === 0 || (options && options.doNotInstantiate && (options.doNotInstantiate === true || options.doNotInstantiate(this)))
             ? this.clone("Clone of " + (this.name || this.id), newParent || this.parent, true)
@@ -843,11 +880,35 @@ export class Mesh extends AbstractMesh {
         }
         return data;
     }
+    /**
+     * 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, vertexData) {
         if (this._geometry) {
             this._geometry.copyVerticesData(kind, vertexData);
         }
     }
+    /**
+     * 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, bypassInstanceData) {
         if (!this._geometry) {
             return null;
@@ -962,6 +1023,7 @@ export class Mesh extends AbstractMesh {
         }
         return this._geometry.getIndices(copyWhenShared, forceCopy);
     }
+    /** {@inheritDoc} */
     get isBlocked() {
         return this._masterMesh !== null && this._masterMesh !== undefined;
     }
@@ -1077,7 +1139,10 @@ export class Mesh extends AbstractMesh {
     }
     /** @internal */
     _getInstanceDataStorage() {
-        const renderPassId = this._instanceDataStorage.engine.isWebGPU ? this._instanceDataStorage.engine.currentRenderPassId : 0;
+        if (this._instanceDataStorage.useMonoDataStorageRenderPass) {
+            return this._instanceDataStorage.dataStorageRenderPass;
+        }
+        const renderPassId = this._instanceDataStorage.engine.currentRenderPassId;
         let instanceDataStorage = this._instanceDataStorage.renderPasses[renderPassId];
         if (!instanceDataStorage) {
             instanceDataStorage = new _InstanceDataStorageRenderPass();
@@ -1094,14 +1159,19 @@ export class Mesh extends AbstractMesh {
             return this;
         }
         internalDataInfo._preActivateId = sceneRenderId;
-        this._getInstanceDataStorage().visibleInstances = null;
+        if (this._instanceDataStorage.useMonoDataStorageRenderPass) {
+            this._instanceDataStorage.dataStorageRenderPass.visibleInstances = null;
+        }
+        else {
+            this._getInstanceDataStorage().visibleInstances = null;
+        }
         return this;
     }
     /**
      * @internal
      */
     _preActivateForIntermediateRendering(renderId) {
-        const instanceDataStorage = this._getInstanceDataStorage();
+        const instanceDataStorage = this._instanceDataStorage.useMonoDataStorageRenderPass ? this._instanceDataStorage.dataStorageRenderPass : this._getInstanceDataStorage();
         if (instanceDataStorage.visibleInstances) {
             instanceDataStorage.visibleInstances.intermediateDefaultRenderId = renderId;
         }
@@ -1111,7 +1181,7 @@ export class Mesh extends AbstractMesh {
      * @internal
      */
     _registerInstanceForRenderId(instance, renderId) {
-        const instanceDataStorage = this._getInstanceDataStorage();
+        const instanceDataStorage = this._instanceDataStorage.useMonoDataStorageRenderPass ? this._instanceDataStorage.dataStorageRenderPass : this._getInstanceDataStorage();
         if (!instanceDataStorage.visibleInstances) {
             instanceDataStorage.visibleInstances = {
                 defaultRenderId: renderId,
@@ -1512,7 +1582,7 @@ export class Mesh extends AbstractMesh {
             this._geometry._bind(effect, indexToBind);
         }
         else {
-            if (this._instanceDataStorage.engine.isWebGPU &&
+            if (!this._instanceDataStorage.useMonoDataStorageRenderPass &&
                 this._userInstancedBuffersStorage.renderPasses &&
                 this._userInstancedBuffersStorage.renderPasses[this._instanceDataStorage.engine.currentRenderPassId]) {
                 const vertexBuffers = this._userInstancedBuffersStorage.renderPasses[this._instanceDataStorage.engine.currentRenderPassId];
@@ -1595,7 +1665,7 @@ export class Mesh extends AbstractMesh {
      * @internal
      */
     _getInstancesRenderList(subMeshId, isReplacementMode = false) {
-        const instanceDataStorage = this._getInstanceDataStorage();
+        const instanceDataStorage = this._instanceDataStorage.useMonoDataStorageRenderPass ? this._instanceDataStorage.dataStorageRenderPass : this._getInstanceDataStorage();
         if (this._instanceDataStorage.isFrozen) {
             if (isReplacementMode) {
                 instanceDataStorage.batchCacheReplacementModeInFrozenMode.hardwareInstancedRendering[subMeshId] = false;
@@ -1727,7 +1797,7 @@ export class Mesh extends AbstractMesh {
                 };
             }
             let vertexAndArrayObjectBuffers;
-            if (this._instanceDataStorage.engine.isWebGPU) {
+            if (!this._instanceDataStorage.useMonoDataStorageRenderPass) {
                 if (!this._userInstancedBuffersStorage.renderPasses) {
                     this._userInstancedBuffersStorage.renderPasses = {};
                 }
@@ -1888,20 +1958,24 @@ export class Mesh extends AbstractMesh {
         }
         return this;
     }
+    _disposeInstanceDataStorageRenderPass(dataStorage, dispose = false) {
+        if (dataStorage?.instancesBuffer) {
+            // Dispose instance buffer to be recreated in _renderWithInstances when rendered
+            if (dispose) {
+                dataStorage.instancesBuffer.dispose();
+            }
+            dataStorage.instancesBuffer = null;
+        }
+    }
     /**
      * @internal
      */
     _rebuild(dispose = false) {
         for (const renderPassId in this._instanceDataStorage.renderPasses) {
             const instanceDataStorage = this._instanceDataStorage.renderPasses[renderPassId];
-            if (instanceDataStorage.instancesBuffer) {
-                // Dispose instance buffer to be recreated in _renderWithInstances when rendered
-                if (dispose) {
-                    instanceDataStorage.instancesBuffer.dispose();
-                }
-                instanceDataStorage.instancesBuffer = null;
-            }
+            this._disposeInstanceDataStorageRenderPass(instanceDataStorage, dispose);
         }
+        this._disposeInstanceDataStorageRenderPass(this._instanceDataStorage.dataStorageRenderPass, dispose);
         if (this._userInstancedBuffersStorage) {
             for (const kind in this._userInstancedBuffersStorage.vertexBuffers) {
                 const buffer = this._userInstancedBuffersStorage.vertexBuffers[kind];
@@ -1939,6 +2013,9 @@ export class Mesh extends AbstractMesh {
             const instanceDataStorage = this._instanceDataStorage.renderPasses[renderPassId];
             instanceDataStorage.previousBatch = null;
         }
+        if (this._instanceDataStorage.dataStorageRenderPass) {
+            this._instanceDataStorage.dataStorageRenderPass.previousBatch = null;
+        }
     }
     /**
      * Triggers the draw call for the mesh (or a submesh), for a specific render pass id
@@ -3954,7 +4031,7 @@ export class Mesh extends AbstractMesh {
      * 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.
@@ -3967,7 +4044,7 @@ export class Mesh extends AbstractMesh {
      * 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.
@@ -4178,152 +4255,152 @@ export class Mesh extends AbstractMesh {
     /**
      * 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, pathArray, closeArray, closePath, offset, scene, updatable, sideOrientation, instance) {
+    static CreateRibbon(_name, _pathArray, _closeArray, _closePath, _offset, _scene, _updatable, _sideOrientation, _instance) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, radius, tessellation, scene, updatable, sideOrientation) {
+    static CreateDisc(_name, _radius, _tessellation, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, size, scene, updatable, sideOrientation) {
+    static CreateBox(_name, _size, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, segments, diameter, scene, updatable, sideOrientation) {
+    static CreateSphere(_name, _segments, _diameter, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, segments, diameter, scene) {
+    static CreateHemisphere(_name, _segments, _diameter, _scene) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, height, diameterTop, diameterBottom, tessellation, subdivisions, scene, updatable, sideOrientation) {
+    static CreateCylinder(_name, _height, _diameterTop, _diameterBottom, _tessellation, _subdivisions, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     // Torus  (Code from SharpDX.org)
     /**
      * 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, diameter, thickness, tessellation, scene, updatable, sideOrientation) {
+    static CreateTorus(_name, _diameter, _thickness, _tessellation, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, radius, tube, radialSegments, tubularSegments, p, q, scene, updatable, sideOrientation) {
+    static CreateTorusKnot(_name, _radius, _tube, _radialSegments, _tubularSegments, _p, _q, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, points, scene, updatable, instance) {
+    static CreateLines(_name, _points, _scene, _updatable, _instance) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, points, dashSize, gapSize, dashNb, scene, updatable, instance) {
+    static CreateDashedLines(_name, _points, _dashSize, _gapSize, _dashNb, _scene, _updatable, _instance) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
@@ -4334,34 +4411,34 @@ export class Mesh extends AbstractMesh {
      * 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, shape, scene, holes, updatable, sideOrientation, earcutInjection) {
+    static CreatePolygon(_name, _shape, _scene, _holes, _updatable, _sideOrientation, _earcutInjection) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, shape, depth, scene, holes, updatable, sideOrientation, earcutInjection) {
+    static ExtrudePolygon(_name, _shape, _depth, _scene, _holes, _updatable, _sideOrientation, _earcutInjection) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
@@ -4369,20 +4446,20 @@ export class Mesh extends AbstractMesh {
      * 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, shape, path, scale, rotation, cap, scene, updatable, sideOrientation, instance) {
+    static ExtrudeShape(_name, _shape, _path, _scale, _rotation, _cap, _scene, _updatable, _sideOrientation, _instance) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
@@ -4391,102 +4468,102 @@ export class Mesh extends AbstractMesh {
      * 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, shape, path, scaleFunction, rotationFunction, ribbonCloseArray, ribbonClosePath, cap, scene, updatable, sideOrientation, instance) {
+    static ExtrudeShapeCustom(_name, _shape, _path, _scaleFunction, _rotationFunction, _ribbonCloseArray, _ribbonClosePath, _cap, _scene, _updatable, _sideOrientation, _instance) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, shape, radius, tessellation, scene, updatable, sideOrientation) {
+    static CreateLathe(_name, _shape, _radius, _tessellation, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, size, scene, updatable, sideOrientation) {
+    static CreatePlane(_name, _size, _scene, _updatable, _sideOrientation) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, width, height, subdivisions, scene, updatable) {
+    static CreateGround(_name, _width, _height, _subdivisions, _scene, _updatable) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, xmin, zmin, xmax, zmax, subdivisions, precision, scene, updatable) {
+    static CreateTiledGround(_name, _xmin, _zmin, _xmax, _zmax, _subdivisions, _precision, _scene, _updatable) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, url, width, height, subdivisions, minHeight, maxHeight, scene, updatable, onReady, alphaFilter) {
+    static CreateGroundFromHeightMap(_name, _url, _width, _height, _subdivisions, _minHeight, _maxHeight, _scene, _updatable, _onReady, _alphaFilter) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
@@ -4495,20 +4572,20 @@ export class Mesh extends AbstractMesh {
      * 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, path, radius, tessellation, radiusFunction, cap, scene, updatable, sideOrientation, instance) {
+    static CreateTube(_name, _path, _radius, _tessellation, _radiusFunction, _cap, _scene, _updatable, _sideOrientation, _instance) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
@@ -4525,13 +4602,13 @@ export class Mesh extends AbstractMesh {
      * * 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, options, scene) {
+    static CreatePolyhedron(_name, _options, _scene) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
@@ -4544,50 +4621,50 @@ export class Mesh extends AbstractMesh {
      * * 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, options, scene) {
+    static CreateIcoSphere(_name, _options, _scene) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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, sourceMesh, position, normal, size, angle) {
+    static CreateDecal(_name, _sourceMesh, _position, _normal, _size, _angle) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /** 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, options, scene) {
+    static CreateCapsule(_name, _options, _scene) {
         throw new Error("Import MeshBuilder to populate this function");
     }
     /**
      * 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) {
+    static ExtendToGoldberg(_mesh) {
         throw new Error("Import MeshBuilder to populate this function");
     }
 }