
## Lathe
A lathed shape is created by defining a shape profile using Vector3 coordinates in the xy plane. The shape profile is rotated around the y axis to form the lathed shape. It is recommended that all x values are positive. You must set at least the _shape_ option.

On creation, the local origin of a lathed shape is coincident with the world origin. It is not possible to give a position relative to the constructed shape, as this depends on the data sets used.

There is no _instance_ option for lathed shapes.

## MeshBuilder
Usage :
```javascript
const lathe = BABYLON.MeshBuilder.CreateLathe("lathe", options, scene); //scene is optional and defaults to the current scene
```

option|value|default value
--------|-----|-------------
shape|_(Vector3[])_  array of Vector3, the shape you want to turn **REQUIRED** |
radius|_(number)_  the radius value of the lathe|1
tessellation|_(number)_  the number of iterations around the lathe|64
arc|_(number)_ ratio of the circumference between 0 and 1|1
cap|_(number)_ tube cap : NO_CAP, CAP_START, CAP_END, CAP_ALL|NO_CAP
closed|_(boolean)_ to open/close the lathe circumference, should be set to `false` when used with `arc`|true
updatable|_(boolean)_ true if the mesh is updatable|false
sideOrientation|_(number)_ side orientation|DEFAULTSIDE
frontUVs|_(Vector4)_  **ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option** | Vector4(0,0, 1,1) 
backUVs|_(Vector4)_  **ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option** | Vector4(0,0, 1,1) 
invertUV|_(boolean)_ to swap the U and V coordinates at geometry construction time (texture rotation of 90°)|false

The radius value is a multiplier for the x values in the profile shape Vector3s.

### Examples
Lathed shape: <Playground id="#PQ0GIE" title="Lathed Shape Example" description="Simple example of a lathed shape."/>
Hexagonal nut: <Playground id="#PQ0GIE#1" title="Lathed Hexagonal Nut" description="Simple example of a lathed hexagonal nut."/>  
Arc: <Playground id="#PQ0GIE#2" title="Lathed Arc" description="Simple example of a lathed arc."/>


## Mesh
Usage:
```javascript
let lathe = BABYLON.Mesh.CreateLathe("lathe", shape, radius, tessellation, scene);
let lathe = BABYLON.Mesh.CreateLathe("lathe", shape, radius, tessellation, scene, updatable, sideOrientation); //optional parameters after scene
```
Note the limited parameters for this method.


## Non Regular Polygon
A polygon of any type, regular or irregular, convex or concave, is created in the horizontal xz plane. Since it can be concave, it requires a procedure to fill the polygon with triangles, and an Earcut method is needed. While an Earcut script is pre-loaded in the Playground, you will have to add a reference to such a script in your own projects. One is available at [cdn](https://unpkg.com/earcut@2.1.1/dist/earcut.min.js) or via a [npm package](https://github.com/mapbox/earcut#install).

On creation, the local origin of the polygon is coincident with the world origin. It is not possible to give a position relative to the polygon, as this depends on the data sets used.

*CreatePolygon* calls [PolygonMeshBuilder](/features/featuresDeepDive/mesh/creation/param/polyMeshBuilder). There is no *instance* option. You must set at least the _shape_ option. 

## MeshBuilder
Usage :
```javascript
const polygon = BABYLON.MeshBuilder.CreatePolygon("polygon", options, scene); //scene is optional and defaults to the current scene
```

option|value|default value
--------|-----|-------------
shape|_(Vector3[])_  array of Vector3, the shape you want to build **REQUIRED** |
holes|_(Vector3[][])_  array of holes, each hole being an array of successive Vector3 | []
updatable|_(boolean)_ true if the mesh is updatable|false
sideOrientation|_(number)_ side orientation|DEFAULTSIDE
frontUVs|_(Vector4)_  **ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option** | Vector4(0,0, 1,1) 
backUVs|_(Vector4)_  **ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option** | Vector4(0,0, 1,1) 

All vectors for the shape and holes are Vector3s and should be in the xz plane, i.e. of the form BABYLON.Vector3(x, 0, z), and in **counter clockwise** order. You just list all the vertices of the polygon, and *CreatePolygon* closes the shape.

### Example
polygon with holes: <Playground id="#ZD60FU" title="Create a Polygon With Holes" description="Simple example of creating a polygon with holes."/>


## Mesh
```javascript
let polygon = BABYLON.Mesh.CreatePolygon("polygon", shape, scene);
let polygon = BABYLON.Mesh.CreatePolygon("polygon", shape, scene, holes, updatable, sideOrientation); //optional parameters after scene
```


## Custom Extruded Shapes

A custom extruded shape replaces the _rotation_ and _scale_ options with _rotationFunction_ or _scaleFunction_. These allow you to vary the rotation and scale of the mesh as it extrudes by defining them in terms of a path index or a distance along the path.

On creation, the local origin of a ribbon is coincident with the world origin. It is not possible to give a position relative to the constructed shape, as this depends on the data sets used.

## MeshBuilder

Usage :

```javascript
const options = {
  shape: myPoints, //vec3 array with z = 0,
  path: myPath, //vec3 array
  rotationFunction: rotFn,
  scaleFunction: scaleFn,
  updatable: true,
};

let extruded = BABYLON.MeshBuilder.ExtrudeShapeCustom("ext", options, scene); //scene is optional and defaults to the current scene

// Update
options.shape = newShape;
options.path = newPath;
options.instance = extruded;
options.rotationFunction = newRotFn;
options.scaleFunction = newScaleFn;
extruded = BABYLON.MeshBuilder.ExtrudeShapeCustom("ext", options); //No scene parameter when using instance
```

| option           | value                                                                                               | default value     |
| ---------------- | --------------------------------------------------------------------------------------------------- | ----------------- |
| shape            | _(Vector3[])_ array of Vector3, the shape you want to extrude **REQUIRED**                          |                   |
| path             | _(Vector3[])_ array of Vector3, the extrusion axis **REQUIRED**                                     |                   |
| scaleFunction    | _( function(i, distance) )_ a function returning a scale value from _(i, distance)_ parameters      | \{return 1;\}     |
| rotationFunction | _( function(i, distance) )_ a function returning a rotation value from _(i, distance)_ parameters   | \{return 0;\}     |
| closeShape       | _(boolean)_ closes the shape, replaces `ribbonClosePath`                                            | false             |
| closePath        | _(boolean)_ closes the path, replaces `ribbonCloseArray`                                            | false             |
| ribbonClosePath  | _(boolean)_ the underlying ribbon _closePath_ parameter value **deprecated**                        | false             |
| ribbonCloseArray | _(boolean)_ the underlying ribbon _closeArray_ parameter value **deprecated**                       | false             |
| cap              | _(number)_ extrusion cap : NO_CAP, CAP_START, CAP_END, CAP_ALL                                      | NO_CAP            |
| updatable        | _(boolean)_ true if the mesh is updatable                                                           | false             |
| sideOrientation  | _(number)_ side orientation                                                                         | DEFAULTSIDE       |
| frontUVs         | _(Vector4)_ **ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option**                      | Vector4(0,0, 1,1) |
| backUVs          | _(Vector4)_ **ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option**                      | Vector4(0,0, 1,1) |
| instance         | _(LineMesh)_ an instance of an extruded shape to be updated                                         | null              |
| invertUV         | _(boolean)_ to swap the U and V coordinates at geometry construction time (texture rotation of 90°) | false             |
| firstNormal      | _(Vector3)_ path normal of first point                                                              | null              |
| adjustFrame      | _(boolean)_ apply heuristic to adjust tangents of paths that reverse direction                      | false             |

You must set at least the _shape_ and _path_ options. On update, you must set the _shape_, _path_ and _instance_ options and you can set the _rotationFunction_ or _scaleFunction_ options.

The _scaleFunction_ and _rotationFunction_ are called on each path point and require two parameters: _index_ and _distance_.

- index refers to the path point position in the path array
- distance is the current point distance from the beginning of the path.

### Examples

<Playground id="#ZMKN5T#111" title="Closed Shape Extrusion" description="Closed shape extrusion."/>

closed shape extrusion

<Playground id="#ZMKN5T#112" title="Updatable Extrusion" description="Updatable extrusion."/>

update of extrusion scaleFunction and rotationFunction

 <Playground id="#ZMKN5T#3" title="Offset Using Trigonometry" description="Offset open profile shape path defined by trigonometry."/>

offset open profile shape path defined by trigonometry

<Playground id="#ZMKN5T#4" title="Sine Wave" description="Sine wave by alternately scaling positive/negative."/>

sine wave by alternately scaling positive/negative

<Playground id="#ZMKN5T#5" title="Rotation Evolving With The Distance" description="Rotation evolving with the distance."/>

scale constant and rotation changing with the distance

<Playground id="#ZMKN5T#6" title="Non-Linear Rotation Function" description="Non-linear rotation function."/>

non-linear rotation function

<Playground id="#RF9W9#20" title="Offset Open Profile Shape" description="Simple example of offset open profile shape."/>

offset open profile shape

<Playground id="#RF9W9#21" title="Open Extrusion path" description="Simple example of open extrusion path."/>

open extrusion path

<Playground id="#RF9W9#43" title="Extrusion With Constant Scale" description="Simple example of extrusion with constant scale 1 and no rotation."/>

Extrusion with constant scale 1 and no rotation

<Playground id="#ZMKN5T#113" title="Custom Extrusion With path closed" description="Simple example of custom extrusion with path closed."/>

`closePath` set to true

<Playground id="#ZMKN5T#114" title="Custom Extrusion With shape closed" description="Simple example of custom extrusion with shape closed."/>

`closeShape` set to true

<Playground id="#ZMKN5T#115" title="Closed Shape and Path" description="Closed shape and path."/>

closeShape and closePath both set to true

<Playground id="#5ICT41#5" title="Using firstNormal and adjustFrame" description="specifying first normal and adjusting tangents and normals."/>

using firstNormal and adjustFrame options

<Playground id="#ZMKN5T#116" title="Strange Shapes With Custom Extrusion" description="Generating some strange shapes with custom extrusion."/>

generate strange shapes

## Mesh

Usage:

```javascript
let extrusion = BABYLON.Mesh.ExtrudeShapeCustom("extrusion", shape, path, scaleFunction, rotateFunction, ribbonCloseArray, ribbonClosePath, cap, scene);
let extrusion = BABYLON.Mesh.ExtrudeShapeCustom("extrusion", shape, path, scaleFunction, rotateFunction, ribbonCloseArray, ribbonClosePath, cap, scene, updatable, sideOrientation, instance); //optional parameters after scene

// fixed unit scale and zero rotation
let extrusion = BABYLON.Mesh.ExtrudeShapeCustom(
  "extrusion",
  shape,
  path,
  () => {
    return 1;
  },
  () => {
    return 0;
  },
  ribbonCloseArray,
  ribbonClosePath,
  cap,
  scene,
);
```


option	value	default value
shape	(Vector3[]) array of Vector3, the shape you want to turn REQUIRED
radius	(number) the radius value of the lathe	1
tessellation	(number) the number of iterations around the lathe	64
arc	(number) ratio of the circumference between 0 and 1	1
cap	(number) tube cap : NO_CAP, CAP_START, CAP_END, CAP_ALL	NO_CAP
closed	(boolean) to open/close the lathe circumference, should be set to `false` when used with `arc`	true
updatable	(boolean) true if the mesh is updatable	false
sideOrientation	(number) side orientation	DEFAULTSIDE
frontUVs	(Vector4) ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option	Vector4(0,0, 1,1)
backUVs	(Vector4) ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option	Vector4(0,0, 1,1)
invertUV	(boolean) to swap the U and V coordinates at geometry construction time (texture rotation of 90°)	false