
## 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
```


## Line System
MeshBuilder only. A line system is a set of non-contiguous lines that are independent of each other and may exist in their own space. You must set at least the _lines_ option. On update, you must set the _lines_ and _instance_ options. You can also update the _colors_ option if it was previously set at construction time.

## MeshBuilder 
Usage :
```javascript
// creates an instance of a line system
let lineSystem = BABYLON.MeshBuilder.CreateLineSystem("lineSystem", {lines: myArray}, scene);

// updates the existing instance of lineSystem : no need for the parameter scene here
lineSystem = BABYLON.MeshBuilder.CreateLineSystem("lineSystem", {lines: myArray, instance: lineSystem});
```

option|value|default value
--------|-----|-------------
lines|_(Vector3[][])_  array of lines, each line being an array of successive Vector3 **REQUIRED**
updatable|_(boolean)_ true if the mesh is updatable|false
instance|_(LineMesh)_ an instance of a line system 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

### Examples
Example of a line system: <Playground id="#Y7CS4N" title="Line System Example" description="Simple example of a line system."/>
Update of the line system: <Playground id="#Y7CS4N#1" title="Updating Line System Example" description="Simple example of updating a line system."/>

Unlike a mesh, lines are colored after creation with a color property rather than a material.
```javascript
linesystem.color = new BABYLON.Color3(1, 0, 0);
```
Colored Line System: <Playground id="#Y7CS4N#2" title="Colored Line System Example 1" description="Simple example of a colored line system."/>

You can produce multi-colored lines by setting the colors for each point of each line before creation.

<Playground id="#Y7CS4N#3" title="Colored Line System Example 2" description="Simple example of a colored line system."/>


## 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);
```


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

Creating Dashed Lines

Dashed Lines

MeshBuilder

Examples

Mesh