Mesh

Create an empty mesh

Bounding box, for picking, measured with the radius

GPU vertex buffer, created by upload

Indices in the GPU index buffer, three per triangle

Vertex colors

The mesh changed and needs uploading again, set it yourself if you edit the arrays

Draw both sides, each lit as the side that is seen; off skips the faces pointing away, which is faster and right for closed shapes, the open builders like buildGrid and buildRibbon turn it on

The values change often but the shape never does, for a water surface or a cloth: set once, the mesh keeps its GPU layout and a dirty upload only rewrites the vertices into the buffer it has; the strip must keep the same points in the same order, a new point count asserts; the layout is decided by the first upload, so strip entries equal then stay one vertex and triangles with no area then stay dropped, set vertexKeys or give it distinct values at the start, not a flat grid of one color or points all in one place

GPU index buffer, the triangles, created by upload

The mesh as an indexed triangle list instead of a strip: the arrays hold each vertex once and this says how they join, three vertex numbers per triangle, counter clockwise seen from the front like a strip's first triangle; addTriangles and the loaders fill it, toIndexed turns a strip mesh into this form

Draw every use of this mesh in the opaque stage as one instanced call, undefined follows render3D.instancing

Vertex normals

Vertex positions, in strip order or one per vertex of an indexed mesh

Bounding sphere radius around the origin, for culling and picking, computed by upload

Vertex texture coords, 0-1 across the tile

Number of vertices in the mesh

The vertices in the GPU layout, given to setVertexData, read only; a mesh given them has no points

The triangles given to setVertexData, read only

Which strip entries are one vertex, set by a builder that knows, one whole number per entry with equal numbers meaning the same vertex; upload skips its search for them, then drops the keys, since an edit after that may tell the entries apart; adding geometry or recomputing normals drops them too

Add a flat quad from four corners in loop order, counter clockwise seen from the front, a is the top left of the texture

Add a triangle strip, joined to the previous one by invisible flat triangles so one mesh holds many strips

• Strip order: the first three points make a triangle, then each point makes another with the two before it
• List the first three points counter clockwise as seen from the front, or the face points away and may vanish when back faces are culled

Add triangles over their own vertices, the indexed form a model file comes in

• The mesh becomes indexed: a strip mesh is turned into triangles first, and strips added later join as triangles
• List each triangle counter clockwise as seen from the front, like a strip's first triangle

Move the mesh so the center of its bounds is on the origin

Append another mesh transformed by a matrix, for building one shape out of several

Derive normals from the triangles, of the strip or of the index list

Measure the bounding sphere around the origin into radius; upload measures it as it packs, and calls this only with no WebGL

Delete the GPU buffer now, the CPU arrays stay so the mesh can be rendered again

• Optional, the buffer is freed anyway once the mesh is garbage collected, this frees it right away

Scale the mesh evenly so its largest extent is a size, for loaded models of unknown units

Turn the mesh inside out so it is lit and drawn from within, for rooms and domes

Measure the axis aligned box around the vertices

The mesh as an indexed triangle list, what upload sends to the GPU: the strip's real triangles over its distinct vertices, the joins between its pieces dropped and every triangle facing the way it did in the strip

• Vertices are compared to a millionth, so two at one place with the same normal, uv and color are one

Returns a new mesh of only what is in both this mesh and the other, see subtract

Returns a new mesh: this one and its mirror image across the plane through the origin facing axis

• For modeling half a shape against that plane, a part that crosses it overlaps its image

Draw the mesh with the current draw state, batched with its other uses in the opaque stage

Scale every uv, so a whole texture repeats across the mesh when its TextureInfo wraps

Set every vertex color

Make the mesh from vertices already in the GPU layout, for a big mesh a game generates, like terrain: they go to the GPU as they are, with no points made and packed again

• Each vertex is RENDER3D_VERTEX_FLOATS floats, written by meshWriteVertex: its place, its normal, its uv and its color as RGBA bytes through a Uint32Array view of the same buffer
• The triangles are listed counter clockwise seen from the front, as addTriangles takes them
• The arrays are kept, not copied, and never changed, so a lost context uploads them again; call this again after changing them
• The mesh's points, normals, uvs, colors and indices are emptied, and what edits or reads those, like transform, combine and computeNormals, does not take a mesh made this way; it draws, casts shadows, is instanced and is picked like any other

Returns a new mesh of count copies of this one, each turned further around an axis through the origin

Returns a new mesh of this one with the other cut out of it, CSG with BSP trees

• Both must be closed, every edge shared by two triangles, as the builders make them apart from the open ones like buildGrid and buildRibbon; the result is closed and indexed, and neither mesh changes
• The faces a cut makes come from the other mesh's surface, turned to face out, with its normals, uvs and colors, so a smooth cylinder drills a round hole
• Parts that overlap must be joined with union to be one solid, not with combine, mirror or spin, which leave them overlapping, and CSG then gives a wrong shape
• Cuts split the triangles near them, so the result has more: a few thousand triangles take tens to a few hundred milliseconds, so build shapes this way at load time, not every frame; joining several cutters with union and cutting once is quicker than cutting with each in turn
• Details closer than about 1e-4 are made one, so build a very small part larger and scale it after

Turn a strip mesh into the indexed form, each distinct vertex once and the real triangles over them, in place

• An indexed mesh is left as it is; the builders make strips and a loader makes this, and either draws the same

Move, turn or scale every vertex in place, normals follow along

Returns a new mesh of everything in this mesh or the other, see subtract

Pack the vertices and create the GPU buffer, called automatically by render