
## Custom Meshes

Of course there will be times that the created meshes already available in Babylon.js do not serve your needs. In this case you can develop your own meshes from vertex data. Vertex data requires a list of vertices and indices to show how the vertices are formed into triangular facets to build the mesh. For lighting, material and texture you will need to provide vertex normals, colors and uv values. When the existing meshes partially meet your needs you can obtain their vertex data and update it, provided you create the mesh with the update option set to true in the first place.



## Parametric Shapes
These meshes are so called because their shape is defined by a 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 an 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 to define paths and outlines and you must set these.

All the parametric shapes, except for the CreateLathe, CreatePolygon and ExtrudePolygon have an *instance* property in the options. This is used to update the shape after creation provided its *updatable* options property was set to *true*. You can only change values in the shape defining data arrays not the size of the arrays.

Where possible playgrounds will give two examples; the first creating a mesh and the second updating 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.





## Polyhedra
There are a multitude of polyhedra, too many for all to be created by individual names. Often their names take too long anyway and Babylon.js provides 15 common ones via number. There are many beyond these 15 and those can be created from custom data sets provided in the form of Playground examples. 

The twenty sided icosahedron has the interesting property of approximating a sphere. By dividing each face into triangles and then mapping the resulting vertices onto a sphere it gives a better approximation of a sphere. The solids formed are called icospheres and provide a more regular distribution of triangles around a sphere then the *CreateSphere* method.

Other sphere approximations can be provided by geodesic and Goldberg polyhedra. Like the icosphere a geodesic polyhedron is based on an icosahedron and formed from equilateral triangles, in this case, however, their arrangement depends on two parameters, m and n, both integers. A Goldberg polyhedron is the dual of a geodesic one, and vice-versa. A dual of a polyhedron is formed by mapping its vertices to the faces of the dual and its faces to the dual's vertices. A Goldberg polyhedron is made up of 12 pentagonal and many hexagonal faces and has the advantage of a planet shaped hexagon-grid world.

![Geodesic Vertices](/img/snippets/geo30.png)  
The Arrangement of Vertices for a Geodesic Poly with m = 6 and n = 0, 1, 2 in order


## Common 3D Shapes
These common shapes cover 2D shapes such as horizontal planes (ground), vertical planes and regular polygons along with 3D shapes such as cuboids, spheres, ellipsoids and toruses. 

To create these meshes you use
```javascript
const mesh = BABYLON.MeshBuilder.Create<MeshType>(name, options, scene);
```
where the *options* object properties vary according to the type of mesh. Using an empty object, {}, the meshes will default to given sizes, usually unit ones. The scene parameter is optional and defaults to the current scene.

Two useful properties are *updatable* and *instance*. When a parametric mesh is created with its options property *updatable* set to true then you can change the values within the shape defining properties and re-render the mesh with these new values by using the *instance* property as the following line drawing example indicates.


```javascript
//creates lines using the vector3 myPoints array
const myLines = BABYLON.MeshBuilder.CreateLines("lines", {points: myPoints});
// update some or all values in myPoints array
myPoints[1] = new BABYLON.Vector3(1, 2, 3);
// updates the existing instance of myLines by pointing the instance property to it
myLines = BABYLON.MeshBuilder.CreateLines("lines", {points: myArray, instance: myLines});
```

Whilst you can change values within a property you cannot the number of elements of the property. All the parametric meshes, except for the Lathe,  CreatePolygon and ExtendPolygon can have their shape updated in this way.

It is still possible to use the form

```javascript
const mesh = BABYLON.Mesh.Create<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.
 



## The Creation of Different Types of Mesh
There is a large variety of meshes that you can create. The range falls into four broad categories, the first three of which requiring a single Babylon.js method to build.

1. Set Shapes - which usually have names in everyday use and their forms are well known and recognized. Examples include the box, sphere, cone and plane. These shapes are created with a method having the form *Create&lt;MeshType&gt*

2. Parametric Shapes - these have no everyday names and are formed through data sets and tend to have irregular shapes. Examples include ribbons, extrusions, and irregular convex or concave polygons. They are created mainly with *Create&lt;MeshType&gt* and also with *Extrude&lt;MeshType&gt*

3. Polyhedra - three dimensional regular solids including octahedron, dodecahedron, icosahedron and icosphere. The method of creating these is *createPolyhedron* along with a number for the basic shapes and an array of vertices for a wider range of shapes or *createIcoSphere*.

4. Custom - those you design yourself and build from your own set of vertices connected into triangular facets as you choose.


The current way to create a mesh is using *MeshBuilder*
```javascript
const mesh = BABYLON.MeshBuilder.Create<MeshType>(name, options, scene);
```
The *options* object will have different properties according to the type of mesh and can be empty {}. The scene parameter is optional and defaults to the current scene.

There is an older method, retained for backwards compatibility, which uses *Mesh* and a string of parameters

```javascript
const mesh = BABYLON.Mesh.Create<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.





## Meshes

In the 3D virtual world shapes are built from meshes, lots of triangular facets joined together, each facet made from three vertices.

![A mesh](/img/features/scene/custom1.jpg)

Babylon.js provides for the creation of predefined meshes, of your own custom meshes and for importing meshes created by 3D design software. For all meshes the underlying data structure is exposed and can be updated.

Creating Meshes

The Creation of Different Types of Mesh

Coming next

Creating Set Shapes

Learn how to create standard set shapes in Babylon.js.

Creating Parametric Meshes

Learn how to create parametric meshes in Babylon.js.

Creating Polyhedra Shapes

Learn how to create polyhedra shapes in Babylon.js.

Create Custom Meshes

Learn how to create custom meshes in Babylon.js.