
## Lines

Lines are created as a contiguous series of attached line segments from a list of points. You must set at least the _points_ option. On update, you must set the _points_ and _instance_ options. You can also update the _colors_ option if previously set at construction time.

## MeshBuilder

Usage:

```javascript
const options = {
  points: myPoints, //vec3 array,
  updatable: true,
};

let lines = BABYLON.MeshBuilder.CreateLines("lines", options, scene); //scene is optional and defaults to the current scene

// Update
options.points[0].x += 6;
options.instance = lines;
lines = BABYLON.MeshBuilder.CreateLines("lines", options); //No scene parameter when using instance
```

| option         | value                                                             | default value |
| -------------- | ----------------------------------------------------------------- | ------------- |
| points         | _(Vector3[])_ array of Vector3, the path of the line **REQUIRED** |
| updatable      | _(boolean)_ true if the mesh is updatable                         | false         |
| instance       | _(LineMesh)_ an instance of a line mesh to be updated             | null          |
| colors         | _(Color4[])_ array of Color4, each point color                    | null          |
| useVertexAlpha | _(boolean)_ false if the alpha blending is not required (faster)  | true          |

Unlike a mesh, lines are colored after creation with a color property rather than a material.

```javascript
lines.color = new BABYLON.Color3(1, 0, 0);
```

### Examples

non updatable lines: <Playground id="#MZ7QRG#6" title="Create Non Updatable Lines" description="Simple example of creating non updatable lines."/>
non updatable closed lines: <Playground id="#MZ7QRG#8" title="Create Non Updatable Closed Lines" description="Simple example of creating non updatable closed lines."/>
updatable example: <Playground id="#MZ7QRG#9" title="Create Updatable Closed Lines" description="Simple example of creating updatable closed lines."/>
updatable spiral: <Playground id="#MZ7QRG#10" title="Create Updatable Spiral Lines" description="Simple example of creating updatable spiral lines."/>

Multi-colored lines have to be set at creation. <Playground id="#MZ7QRG#11" title="Create Multi Colored Lines" description="Simple example of creating multi colored lines."/>

## Mesh

usage:

```javascript
let lines = BABYLON.MeshBuilder.CreateLines("lines", { points }, scene);
let lines = BABYLON.MeshBuilder.CreateLines("lines", { points, updatable, instance }, scene);
```



## Dashed Lines
Creates a contiguous series of dashed line segments from a list of points. You must set at least the _points_ option. On update, you must set the _points_ and _instance_ option properties, and you should not change them. Any other options will not be changed.
## MeshBuilder
Usage:
```javascript
const options = {
    points: myPoints, //vec3 array,
    updatable: true
}

let dashedlines = BABYLON.MeshBuilder.CreateDashedLines("dashedlines", options, scene);  //scene is optional and defaults to the current scene

// Update
options.points[0].x +=6; 
options.instance = lines;
lines = BABYLON.MeshBuilder.CreateDashedLines("dashedlines", options); //No scene parameter when using instance
```

option|value|default value
--------|-----|-------------
points|_(Vector3[])_  array of Vector3, the path of the line **REQUIRED** |
dashSize|_(number)_  size of the dashes|3
gapSize|_(number)_  size of the gaps|1
dashNb|_(number)_  intended number of dashes|200
updatable|_(boolean)_ true if the mesh is updatable|false
instance|_(LineMesh)_ an instance of a line mesh to be updated|null

The actual length of the dashes and gaps is determined by how many are set by *dashNb* and then by the ratio of *dashSize* and *gapSize*, rather than by their literal values.
All of the following will produce equally sized dashes and gaps.
```javascript
dashSize = 1;
gapSize = 1;

dashSize = 1000;
gapSize = 1000;

dashSize = 876;
gapSize = dashSize;
```
### Examples
non updatable default dashed lines: <Playground id="#TYF5GH#1" title="Create Non Updatable Default Dashed Lines" description="Simple example of creating non updatable default dashed lines."/> 
non updatable dashed lines set options: <Playground id="#TYF5GH#2" title="Create Non Updatable Dashed Lines With Options" description="Simple example of creating non updatable dashed lines with options."/>
non updatable 'closed' dashed lines: <Playground id="#TYF5GH#3" title="Create Non Updatable Closed Dashed Lines" description="Simple example of creating non updatable closed dashed lines."/>
updatable example: <Playground id="#TYF5GH#4" title="Create Updatable Closed Dashed Lines" description="Simple example of creating updatable closed dashed lines."/>

Dashed lines are colored with a color property rather than a material.

```javascript
dashedlines.color = new BABYLON.Color3(1, 0, 0);
```

Colored Dashed Lines: <Playground id="#TYF5GH#5" title="Create Colored Dashed Lines" description="Simple example of creating colored dashed lines."/>

## Mesh
Usage:
```javascript
const dashedlines = BABYLON.Mesh.CreateDashedLines("dashedLines", vector3 array, dashSize, gapSize, dashNb, scene);
const dashedlines = BABYLON.Mesh.CreateDashedLines("dashedLines", vector3 array, dashSize, gapSize, dashNb, scene, updatable, instance); //optional parameters after scene
```



## Parametric Shapes
These meshes are so-called because their shape is defined by an array of Vector3 parameters and can be irregular in nature. You can produce a series of broken or unbroken lines across 3D space. In 2D, you can produce a horizontal irregular convex or concave polygon, which may be extruded vertically into 3D. It is also possible to extrude the 2D outline along a path that travels in 3D space and vary its rotation and scale as it travels the path. You can also 'lathe' an outline to give a shape with rotational symmetry.

To create these meshes you use one of
```javascript
const mesh = BABYLON.MeshBuilder.Create<MeshType>(name, options, scene);
const mesh = BABYLON.MeshBuilder.Extrude<MeshType>(name, options, scene);
```
where the *options* object properties vary according to the type of mesh. The scene parameter is optional and defaults to the current scene. One or more of the *options* properties will be used to set the Vector3 data that defines paths and outlines, and you must set these.

All the parametric shapes, except for CreateLathe, CreatePolygon, and ExtrudePolygon, have an *instance* property in the options. This is used to update the shape after creation, provided its *updatable* option property was set to *true*. You can change only the values in the shape-defining data arrays, not the size of the arrays.

Where possible, playgrounds will give two examples: the first creates a mesh, and the second updates it with the instance option. Comment out the latter to see the original mesh.

It is still possible to use the *Mesh* method to create these shapes. This has the forms

```javascript
const mesh = BABYLON.Mesh.Create<MeshType>(name, required_param1, required_param2, ..., scene, optional_parameter1, ........);
const mesh = BABYLON.Mesh.Extrude<MeshType>(name, required_param1, required_param2, ..., scene, optional_parameter1, ........);
```
The scene parameter is compulsory when used with optional parameters. You will still find this method in playgrounds.



option	value	default value
points	(Vector3[]) array of Vector3, the path of the line REQUIRED
updatable	(boolean) true if the mesh is updatable	false
instance	(LineMesh) an instance of a line mesh to be updated	null
colors	(Color4[]) array of Color4, each point color	null
useVertexAlpha	(boolean) false if the alpha blending is not required (faster)	true

Creating Lines

Lines

MeshBuilder

Examples

Mesh