Using the ArrayMesh¶
This tutorial will present the basics of using an ArrayMesh.
To do so, we will use the function add_surface_from_arrays(), which takes up to five parameters. The first two are required, while the last three are optional.
The first parameter is the PrimitiveType
, an OpenGL concept that instructs the GPU
how to arrange the primitive based on the vertices given, i.e. whether they represent triangles,
lines, points, etc. See Mesh.PrimitiveType for the options available.
The second parameter, arrays
, is the actual Array that stores the mesh information. The array is a normal Godot array that
is constructed with empty brackets []
. It stores a Packed**Array
(e.g. PackedVector3Array,
PackedInt32Array, etc.) for each type of information that will be used to build the surface.
Common elements of arrays
are listed below, together with the position they must have within arrays
.
See Mesh.ArrayType for a full list.
Index |
Mesh.ArrayType Enum |
Array type |
---|---|---|
0 |
|
|
1 |
|
|
2 |
|
PackedFloat32Array or PackedFloat64Array of groups of 4 floats. The first 3 floats determine the tangent, and the last float the binormal direction as -1 or 1. |
3 |
|
|
4 |
|
|
5 |
|
|
10 |
|
PackedFloat32Array of groups of 4 floats or PackedInt32Array of groups of 4 ints. Each group lists indexes of 4 bones that affects a given vertex. |
11 |
|
PackedFloat32Array or PackedFloat64Array of groups of 4 floats. Each float lists the amount of weight the corresponding bone in |
12 |
|
In most cases when creating a mesh, we define it by its vertex positions. So usually, the array of vertices (at index 0) is required, while the index array (at index 12) is optional and will only be used if included. It is also possible to create a mesh with only the index array and no vertex array, but that's beyond the scope of this tutorial. In fact, we won't use the index array at all.
All the other arrays carry information about the vertices. They are optional and will only be used if included. Some of these arrays (e.g. ARRAY_COLOR
)
use one entry per vertex to provide extra information about vertices. They must have the same size as the vertex array. Other arrays (e.g. ARRAY_TANGENT
) use
four entries to describe a single vertex. These must be exactly four times larger than the vertex array.
For normal usage, the last three parameters in add_surface_from_arrays() are typically left empty.
Setting up the ArrayMesh¶
In the editor, create a MeshInstance3D and add an ArrayMesh to it in the Inspector. Normally, adding an ArrayMesh in the editor is not useful, but in this case it allows us to access the ArrayMesh from code without creating one.
Next, add a script to the MeshInstance3D.
Under _ready()
, create a new Array.
var surface_array = []
var surfaceArray = new Godot.Collections.Array();
This will be the array that we keep our surface information in - it will hold
all the arrays of data that the surface needs. Godot will expect it to be of
size Mesh.ARRAY_MAX
, so resize it accordingly.
var surface_array = []
surface_array.resize(Mesh.ARRAY_MAX)
var surfaceArray = new Godot.Collections.Array();
surfaceArray.Resize((int)Mesh.ArrayType.Max);
Next create the arrays for each data type you will use.
var verts = PackedVector3Array()
var uvs = PackedVector2Array()
var normals = PackedVector3Array()
var indices = PackedInt32Array()
var verts = new List<Vector3>();
var uvs = new List<Vector2>();
var normals = new List<Vector3>();
var indices = new List<int>();
Once you have filled your data arrays with your geometry you can create a mesh
by adding each array to surface_array
and then commit