
## Lathe
A lathed shape is created by defining a shape profile using vector3 coordinates in the xy plane. The shape profile will be rotated around the y axis to form the lather shape. It is recommended that all the 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 in 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 value to radius of the lathe|1
tessellation|_(number)_  the number of iteration 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. Whilst 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 shape and holes are Vector3 and should be in the xz plane, ie 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 **depreceated**                       | false             |
| ribbonCloseArray | _(boolean)_ the underlying ribbon _closeArray_ parameter value **depreceated**                      | 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 rotation Function

 <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="Rrotation 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
option shape	value (Vector3[]) array of Vector3, the shape you want to turn REQUIRED	default value
option radius	value (number) the value to radius of the lathe	default value 1
option tessellation	value (number) the number of iteration around the lathe	default value 64
option arc	value (number) ratio of the circumference between 0 and 1	default value 1
option cap	value (number) tube cap : NO_CAP, CAP_START, CAP_END, CAP_ALL	default value NO_CAP
option closed	value (boolean) to open/close the lathe circumference, should be set to `false` when used with `arc`	default value true
option updatable	value (boolean) true if the mesh is updatable	default value false
option sideOrientation	value (number) side orientation	default value DEFAULTSIDE
option frontUVs	value (Vector4) ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option	default value Vector4(0,0, 1,1)
option backUVs	value (Vector4) ONLY WHEN sideOrientation:BABYLON.Mesh.DOUBLESIDE is an option	default value Vector4(0,0, 1,1)
option invertUV	value (boolean) to swap the U and V coordinates at geometry construction time (texture rotation of 90°)	default value false