ofMesh

ofDocsdocumentation 3d ofMesh

An ofMesh represents a set of vertices in 3D spaces, and normals at those points, colors at those points, and texture coordinates at those points. Each of these different properties is stored in a vector. Vertices are passed to your graphics card and your graphics card fill in the spaces in between them in a processing usually called the rendering pipeline. The rendering pipeline goes more or less like this:

Say how you're going to connect all the points.
Make some points.
Say that you're done making points.

You may be thinking: I'll just make eight vertices and voila: a cube. Not so quick. There's a hitch and that hitch is that the OpenGL renderer has different ways of connecting the vertices that you pass to it and none are as efficient as to only need eight vertices to create a cube.

You've probably seen a version of the following image somewhere before. PRIMATIVES

Generally you have to create your points to fit the drawing mode that you've selected because of whats called winding. A vertex gets connected to another vertex in the order that the mode does its winding and this means that you might need multiple vertices in a given location to create the shape you want. The cube, for example, requires eighteen vertices, not the eight that you would expect. If you note the order of vertices in the GL chart above you'll see that all of them use their vertices slightly differently (in particular you should make note of the GL_TRIANGLE_STRIP example). Drawing a shape requires that you keep track of which drawing mode is being used and which order your vertices are declared in.

If you're thinking: it would be nice if there were an abstraction layer for this you're thinking right. Enter the mesh, which is really just an abstraction of the vertex and drawing mode that we started with but which has the added bonus of managing the draw order for you. That may seem insignificant at first, but it provides some real benefits when working with complex geometry.

A very typical usage is something like the following:

ofMesh mesh;
for (int y = 0; y < height; y++){
	for (int x = 0; x<width; x++){
		mesh.addVertex(ofPoint(x,y,0)); // make a new vertex
		mesh.addColor(ofFloatColor(0,0,0));  // add a color at that vertex
	}
}

// now it's important to make sure that each vertex is correctly connected with the
// other vertices around it. This is done using indices, which you can set up like so:
for (int y = 0; y<height-1; y++){
	for (int x=0; x<width-1; x++){
		mesh.addIndex(x+y*width);				// 0
		mesh.addIndex((x+1)+y*width);			// 1
		mesh.addIndex(x+(y+1)*width);			// 10

		mesh.addIndex((x+1)+y*width);			// 1
		mesh.addIndex((x+1)+(y+1)*width);		// 11
		mesh.addIndex(x+(y+1)*width);			// 10
	}
}

addColor( `...` )

void addColor(const C &c)

This adds a color to the mesh, the color will be associated with the vertex in the same position.

addColors( `...` )

void addColors(const C *cols, size_t amt)

This adds a pointer of colors to the ofMesh instance with the amount passed as the second parameter.

addIndex( `...` )

void addIndex(ofIndexType i)

Will give you this shape: image of basic use of indices

    ofMesh mesh;
    mesh.setMode(OF_PRIMITIVE_TRIANGLES);
    mesh.addVertex(ofPoint(0,-200,0));
    mesh.addVertex(ofPoint(200, 0, 0 ));
    mesh.addVertex(ofPoint(-200, 0, 0 ));
    mesh.addVertex(ofPoint(0, 200, 0 ));
    mesh.addIndex(0); //connect the first vertex we made, v0
    mesh.addIndex(1); //to v1
    mesh.addIndex(2); //to v2 to complete the face
    mesh.addIndex(1); //now start a new face beginning with v1
    mesh.addIndex(2); //that is connected to v2
    mesh.addIndex(3); //and we complete the face with v3

Will give you this shape: image of basic use of indices

addIndices( `...` )

void addIndices(const ofIndexType *inds, size_t amt)

This adds indices to the ofMesh by pointing to an array of indices. The "amt" defines the length of the array.

addNormal( `...` )

void addNormal(const N &n)

Add a normal to the mesh as a 3D vector, typically perpendicular to the plane of the face. A normal is a vector that defines how a surface responds to lighting, i.e. how it is lit. The amount of light reflected by a surface is proportional to the angle between the light's direction and the normal. The smaller the angle the brighter the surface will look. See the normalsExample for advice on computing the normals. addNormal adds the 3D vector to the end of the list, so you need to make sure you add normals at the same index of the matching vertex.

addNormals( `...` )

void addNormals(const N *norms, size_t amt)

Add an array of normals to the mesh. Because you are using a pointer to the array you also have to define the length of the array as an std::size_t (amt). The normals are added at the end of the current normals list.

Add an array of normals to the mesh. Because you are using a pointer to the array you also have to define the length of the array as an int (amt). The normals are added at the end of the current normals list.

addTexCoord( `...` )

void addTexCoord(const T &t)

Add a Vec2f representing the texture coordinate. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.

addTexCoords( `...` )

void addTexCoords(const T *tCoords, size_t amt)

Add an array of texture coordinates to the mesh. Because you are using a pointer to the array you also have to define the length of the array as an std::size_t (amt). The texture coordinates are added at the end of the current texture coordinates list.

Add an array of texture coordinates to the mesh. Because you are using a pointer to the array you also have to define the length of the array as an int (amt). The texture coordinates are added at the end of the current texture coordinates list.

addTriangle( `...` )

void addTriangle(ofIndexType index1, ofIndexType index2, ofIndexType index3)

Adding a triangle means using three of the vertices that have already been added to create a triangle. This is an easy way to create triangles in the mesh. The indices refer to the index of the vertex in the vector of vertices.

addVertex( `...` )

void addVertex(const V &v)

Add a new vertex at the end of the current list of vertices. It is important to remember that the order the vertices are added to the list determines how they link they form the polygons and strips (assuming you do not change their indeces). See the ofMesh class description for details.

addVertices( `...` )

void addVertices(const V *verts, size_t amt)

Add an array of vertices to the mesh. Because you are using a pointer to the array you also have to define the length of the array as an int (amt). The vertices are added at the end of the current vertices list.

clear( )

void clear()

Removes all the vertices, colors, and indices from the mesh.

This removes all the vertices, colors, and indices from the mesh.

clearColors( )

void clearColors()

Clear all the colors.

clearIndices( )

void clearIndices()

Remove all the indices of the mesh. This means that your mesh will be a point cloud.

clearNormals( )

void clearNormals()

Remove all the normals.

clearTexCoords( )

void clearTexCoords()

Clear all the texture coordinates.

clearVertices( )

void clearVertices()

Removes all the vertices.

disableColors( )

void disableColors()

Disable mesh colors. Use enableColors() to turn colors back on.

disableIndices( )

void disableIndices()

Disable mesh indices. Use enableIndices() to turn indices back on.

disableNormals( )

void disableNormals()

Disable mesh normals. Use enableNormals() to turn normals back on.

disableTextures( )

void disableTextures()

Disable mesh textures. Use enableTextures() to turn textures back on.

draw( )

void draw()

This draws the mesh using its primitive type, meaning that if you set them up to be triangles, this will draw the triangles.

draw( `...` )

void draw(ofPolyRenderMode renderType)

This draws the mesh using a defined renderType, overriding the renderType defined with setMode().

drawFaces( )

void drawFaces()

This draws the mesh as faces, meaning that you'll have a collection of faces.

drawVertices( )

void drawVertices()

This allows you draw just the vertices, meaning that you'll have a point cloud.

drawWireframe( )

void drawWireframe()

This draws the mesh as GL_LINES, meaning that you'll have a wireframe.

enableColors( )

void enableColors()

Enable mesh colors. Use disableColors() to turn colors off. Colors are enabled by default when they are added to the mesh.

enableIndices( )

void enableIndices()

Enable mesh indices. Use disableIndices() to turn indices off. Indices are enabled by default when they are added to the mesh.

enableNormals( )

void enableNormals()

Enable mesh normals. Use disableNormals() to turn normals off. Normals are enabled by default when they are added to the mesh.

enableTextures( )

void enableTextures()

Enable mesh textures. Use disableTextures() to turn textures off. Textures are enabled by default when they are added to the mesh.

flatNormals( )

void flatNormals()

Duplicates vertices and updates normals to get a low-poly look.

getCentroid( )

V getCentroid()

Returns: a ofVec3f defining the centroid of all the vetices in the mesh.

Returns a ofVec3f defining the centroid of all the vetices in the mesh.

getColor( `...` )

C getColor(ofIndexType i)

Get the color at the index in the colors vector.

Returns: the color at the index in the colors vector.

Returns the color at the index in the colors vector.

getColorsPointer( )

C * getColorsPointer()

Use this if you plan to change the colors as part of this call as it will force a reset of the cache.

Returns: a pointer that contains all of the colors of the mesh, if it has any.

Returns a pointer that contains all of the colors of the mesh, if it has any. Use this if you plan to change the colors as part of this call as it will force a reset of the cache.

getColorsPointer( )

const C * getColorsPointer()

Returns: a pointer that contains all of the colors of the mesh, if it has any. (read only)

Returns a pointer that contains all of the colors of the mesh, if it has any. (read only)

getIndex( `...` )

ofIndexType getIndex(ofIndexType i)

Returns: the index from the index vector. Each index represents the index of the vertex in the vertices vector. This determines the way that the vertices are connected into the polgoynon type set in the primitiveMode.

Returns the index from the index vector. Each index represents the index of the vertex in the vertices vector. This determines the way that the vertices are connected into the polgoynon type set in the primitiveMode.

getIndexPointer( )

ofIndexType * getIndexPointer()

Returns: a pointer to the indices that the mesh contains.

Returns a pointer to the indices that the mesh contains.

getIndexPointer( )

const ofIndexType * getIndexPointer()

Returns: a pointer to the indices that the mesh contains.

Returns a pointer to the indices that the mesh contains.

getMode( )

ofPrimitiveMode getMode()

Returns: the primitive mode that the mesh is using.

Returns the primitive mode that the mesh is using.

getNormal( `...` )

N getNormal(ofIndexType i)

Returns: the normal at the index in the normals vector.

Returns the normal at the index in the normals vector.

getNormalsPointer( )

N * getNormalsPointer()

Returns: a pointer to the normals that the mesh contains.

Returns a pointer to the normals that the mesh contains.

getNormalsPointer( )

const N * getNormalsPointer()

Returns: a pointer to the normals that the mesh contains.

Returns a pointer to the normals that the mesh contains.

getNumColors( )

size_t getNumColors()

Returns: the size of the colors vector for the mesh. This will tell you how many colors are contained in the mesh.

Returns the size of the colors vector for the mesh. This will tell you how many colors are contained in the mesh.

getNumIndices( )

size_t getNumIndices()

This will tell you how many indices are contained in the mesh.

Returns: the size of the indices vector for the mesh.

Returns the size of the indices vector for the mesh. This will tell you how many indices are contained in the mesh.

getNumNormals( )

size_t getNumNormals()

This will tell you how many normals are contained in the mesh.

Returns: the size of the normals vector for the mesh.

Returns the size of the normals vector for the mesh. This will tell you how many normals are contained in the mesh.

getNumTexCoords( )

size_t getNumTexCoords()

This will tell you how many texture coordinates are contained in the mesh.

Returns: the size of the texture coordinates vector for the mesh.

Returns the size of the texture coordinates vector for the mesh. This will tell you how many texture coordinates are contained in the mesh.

getNumVertices( )

size_t getNumVertices()

Returns: the size of the vertices vector for the mesh. This will tell you how many vertices are contained in the mesh.

Returns the size of the vertices vector for the mesh. This will tell you how many vertices are contained in the mesh.

getTexCoord( `...` )

T getTexCoord(ofIndexType i)

Returns: the Vec2f representing the texture coordinate. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.

Returns the Vec2f representing the texture coordinate. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.

getTexCoordsPointer( )

T * getTexCoordsPointer()

Returns: a pointer to the texture coords that the mesh contains.

Returns a pointer to the texture coords that the mesh contains.

getTexCoordsPointer( )

const T * getTexCoordsPointer()

Get a pointer to the ofVec2f texture coordinates that the mesh contains.

getVertex( `...` )

V getVertex(ofIndexType i)

Returns: the vertex at the index.

Returns the vertex at the index.

getVerticesPointer( )

V * getVerticesPointer()

Returns: a pointer to the vertices that the mesh contains.

Returns a pointer to the vertices that the mesh contains.

getVerticesPointer( )

const V * getVerticesPointer()

Returns: a pointer to the vertices that the mesh contains.

Returns a pointer to the vertices that the mesh contains.

hasColors( )

bool hasColors()

/returns Whether the mesh has any colors.

Whether the mesh has any colors.

hasIndices( )

bool hasIndices()

/returns Whether the mesh has any indices assigned to it.

Whether the mesh has any indices assigned to it.

hasNormals( )

bool hasNormals()

/returnsWhether the mesh has any normals.

Whether the mesh has any normals.

hasTexCoords( )

bool hasTexCoords()

/returns Whether the mesh has any textures assigned to it.

Whether the mesh has any textures assigned to it.

hasVertices( )

bool hasVertices()

Returns: Whether the mesh has any vertices.

Whether the mesh has any vertices.

haveColorsChanged( )

bool haveColorsChanged()

Returns: If the colors of the mesh have changed, been added or removed.

If the colors of the mesh have changed, been added or removed.

haveIndicesChanged( )

bool haveIndicesChanged()

Returns: If the indices of the mesh have changed, been added or removed.

If the indices of the mesh have changed, been added or removed.

haveNormalsChanged( )

bool haveNormalsChanged()

Returns: If the normals of the mesh have changed, been added or removed.

If the normals of the mesh have changed, been added or removed.

haveTexCoordsChanged( )

bool haveTexCoordsChanged()

Returns: If the texture coords of the mesh have changed, been added or removed.

If the texture coords of the mesh have changed, been added or removed.

haveVertsChanged( )

bool haveVertsChanged()

Returns: If the vertices of the mesh have changed, been added or removed.

If the vertices of the mesh have changed, been added or removed.

load( `...` )

void load(const filesystem::path &path)

Loads a mesh from a file located at the provided path into the mesh. This will replace any existing data within the mesh.

It expects that the file will be in the PLY Format. It will only load meshes saved in the PLY ASCII format; the binary format is not supported.

Loads a mesh from a file located at the provided path into the mesh. This will replace any existing data within the mesh.

It expects that the file will be in the PLY Format. It will only load meshes saved in the PLY ASCII format; the binary format is not supported.

mergeDuplicateVertices( )

void mergeDuplicateVertices()

ofMesh_( )

ofMesh_()

This creates the mesh, using OF_PRIMITIVE_TRIANGLES without any initial vertices.

This creates the mesh, using OF_PRIMITIVE_TRIANGLES and without any initial vertices.

removeColor( `...` )

void removeColor(ofIndexType index)

Remove a color at the index in the colors vector.

removeIndex( `...` )

void removeIndex(ofIndexType index)

Removes an index.

removeNormal( `...` )

void removeNormal(ofIndexType index)

Remove a normal.

removeTexCoord( `...` )

void removeTexCoord(ofIndexType index)

Remove a Vec2f representing the texture coordinate.

removeVertex( `...` )

void removeVertex(ofIndexType index)

Removes the vertex at the index in the vector.

save( `...` )

void save(const filesystem::path &path, bool useBinary=false)

Saves the mesh at the passed path in the PLY Format.

There are two format options for PLY: a binary format and an ASCII format. By default, it will save using the ASCII format. Passing true into the useBinary parameter will save it in the binary format.

If you're planning on reloading the mesh into ofMesh, ofMesh currently only supports loading the ASCII format.

For more information, see the PLY format specification.

Saves the mesh at the passed path in the PLY Format.

If you're planning on reloading the mesh into ofMesh, ofMesh currently only supports loading the ASCII format.

For more information, see the PLY format specification.

setColor( `...` )

void setColor(ofIndexType index, const C &c)

Set the color at the index in the colors vector.

setColorForIndices( `...` )

void setColorForIndices(ofIndexType startIndex, ofIndexType endIndex, C color)

setIndex( `...` )

void setIndex(ofIndexType index, ofIndexType val)

This sets the index at i.

setMode( `...` )

void setMode(ofPrimitiveMode mode)

Allows you to set the ofPrimitiveMode. The available modes are OF_PRIMITIVE_TRIANGLES, OF_PRIMITIVE_TRIANGLE_STRIP, OF_PRIMITIVE_TRIANGLE_FAN, OF_PRIMITIVE_LINES, OF_PRIMITIVE_LINE_STRIP, OF_PRIMITIVE_LINE_LOOP, OF_PRIMITIVE_POINTS

setNormal( `...` )

void setNormal(ofIndexType index, const N &n)

\todo Documentation.

setTexCoord( `...` )

void setTexCoord(ofIndexType index, const T &t)

setVertex( `...` )

void setVertex(ofIndexType index, const V &v)

setupIndicesAuto( )

void setupIndicesAuto()

Allow you to set up the indices automatically when you add a vertex.

smoothNormals( `...` )

void smoothNormals(float angle)

usingColors( )

bool usingColors()

usingIndices( )

bool usingIndices()

usingNormals( )

bool usingNormals()

usingTextures( )

bool usingTextures()

~ofMesh_( )

~ofMesh_()

#class ofMesh_

##InlineDescription

Represents a set of vertices in 3D spaces with normals, colors,
and texture coordinates at those points.

Each of these different properties is stored in a vector.
Vertices are passed to your graphics card and your graphics card fill in
the spaces in between them in a processing usually called the rendering
pipeline. The rendering pipeline goes more or less like this:

1. Say how you're going to connect all the points.
2. Make some points.
3. Say that you're done making points.

You may be thinking: I'll just make eight vertices and voila: a cube.
Not so quick. There's a hitch and that hitch is that the OpenGL renderer
has different ways of connecting the vertices that you pass to it and none
are as efficient as to only need eight vertices to create a cube.

You've probably seen a version of the following image somewhere before.
![PRIMATIVES](3d/primitives_new-640x269.gif)
Generally you have to create your points to fit the drawing mode that
you've selected because of whats called winding.
A vertex gets connected to another vertex in the order that the mode does
its winding and this means that you might need multiple vertices in a given
location to create the shape you want. The cube, for example, requires
eighteen vertices, not the eight that you would expect.
If you note the order of vertices in the GL chart above you'll see that all
of them use their vertices slightly differently (in particular you should
make note of the GL_TRIANGLE_STRIP example). Drawing a shape requires that
you keep track of which drawing mode is being used and which order
your vertices are declared in.

If you're thinking: it would be nice if there were an abstraction layer
for this you're thinking right. Enter the mesh, which is really just
an abstraction of the vertex and drawing mode that we started with
but which has the added bonus of managing the draw order for you.
That may seem insignificant at first, but it provides some real benefits
when working with complex geometry.

A very typical usage is something like the following:

~~~~{.cpp}
ofMesh mesh;
for (int y = 0; y < height; y++){
	for (int x = 0; x<width; x++){
		mesh.addVertex(glm::vec3(x,y,0)); // make a new vertex
		mesh.addColor(ofFloatColor(0,0,0));  // add a color at that vertex
	}
}
~~~~

Now it's important to make sure that each vertex is correctly connected
with the other vertices around it. This is done using indices, which you
can set up like so:
~~~~{.cpp}
for (int y = 0; y<height-1; y++){
	for (int x=0; x<width-1; x++){
		mesh.addIndex(x+y*width);				// 0
		mesh.addIndex((x+1)+y*width);			// 1
		mesh.addIndex(x+(y+1)*width);			// 10

mesh.addIndex((x+1)+y*width);			// 1
		mesh.addIndex((x+1)+(y+1)*width);		// 11
		mesh.addIndex(x+(y+1)*width);			// 10
	}
}
~~~~

##Description

An ofMesh represents a set of vertices in 3D spaces, and normals at those points, colors at those points, and texture coordinates at those points. Each of these different properties is stored in a vector.
Vertices are passed to your graphics card and your graphics card fill in the spaces in between them in a processing usually called the rendering pipeline. The rendering pipeline goes more or less like this:

1. Say how you're going to connect all the points.

2. Make some points.

3. Say that you're done making points.

You've probably seen a version of the following image somewhere before.
![PRIMATIVES](gl_primitives_640x269.png)

A very typical usage is something like the following:

~~~~{.cpp}
ofMesh mesh;
for (int y = 0; y < height; y++){
	for (int x = 0; x<width; x++){
		mesh.addVertex(ofPoint(x,y,0)); // make a new vertex
		mesh.addColor(ofFloatColor(0,0,0));  // add a color at that vertex
	}
}

// now it's important to make sure that each vertex is correctly connected with the
// other vertices around it. This is done using indices, which you can set up like so:
for (int y = 0; y<height-1; y++){
	for (int x=0; x<width-1; x++){
		mesh.addIndex(x+y*width);				// 0
		mesh.addIndex((x+1)+y*width);			// 1
		mesh.addIndex(x+(y+1)*width);			// 10

mesh.addIndex((x+1)+y*width);			// 1
		mesh.addIndex((x+1)+(y+1)*width);		// 11
		mesh.addIndex(x+(y+1)*width);			// 10
	}
}
~~~~

##Methods

###void addColor(&c)

_inlined_description: _

This adds a color to the mesh,
the color will be associated with the vertex in the same position.

_description: _

This adds a color to the mesh, the color will be associated with the vertex in the same position.

###void addColors(&cols)

_inlined_description: _

This adds colors using a reference to a vector of ofColors.
For each color in the vector, this will put the colors at the corresponding vertex.

_description: _

This adds colors using a reference to a vector of ofColors. For each color in the vector, this will put the colors at the corresponding vertex.

###void addColors(*cols, amt)

_inlined_description: _

This adds a pointer of colors to the ofMesh instance with the amount passed as the second parameter.

_description: _

This adds a pointer of colors to the ofMesh instance with the amount passed as the second parameter.

###void addIndex(i)

_inlined_description: _

Will give you this shape:
![image of basic use of indices](../index.jpg)

_description: _

Add an index to the index vector. Each index represents the order of connection for  vertices. This determines the way that the vertices are connected according to the polygon type set in the primitiveMode. It important to note that a particular vertex might be used for several faces and so would be referenced several times in the index vector.
~~~~{.cpp}
    ofMesh mesh;
    mesh.setMode(OF_PRIMITIVE_TRIANGLES);
    mesh.addVertex(ofPoint(0,-200,0));
    mesh.addVertex(ofPoint(200, 0, 0 ));
    mesh.addVertex(ofPoint(-200, 0, 0 ));
    mesh.addVertex(ofPoint(0, 200, 0 ));
    mesh.addIndex(0); //connect the first vertex we made, v0
    mesh.addIndex(1); //to v1
    mesh.addIndex(2); //to v2 to complete the face
    mesh.addIndex(1); //now start a new face beginning with v1
    mesh.addIndex(2); //that is connected to v2
    mesh.addIndex(3); //and we complete the face with v3
~~~~

Will give you this shape:
![image of basic use of indices](index.jpg)

###void addIndices(&inds)

_inlined_description: _

This adds a vector of indices.

_description: _

This adds a vector of indices.

###void addIndices(*inds, amt)

_inlined_description: _

This adds indices to the ofMesh by pointing to an array of indices.
The "amt" defines the length of the array.

_description: _

This adds indices to the ofMesh by pointing to an array of indices. The "amt" defines the length of the array.

###void addNormal(&n)

_inlined_description: _

Add a normal to the mesh as a 3D vector,
typically perpendicular to the plane of the face. A normal is a vector
that defines how a surface responds to lighting, i.e. how it is lit.
The amount of light reflected by a surface is proportional to the angle
between the light's direction and the normal. The smaller the angle the
brighter the surface will look. See the normalsExample for advice on
computing the normals.
addNormal adds the 3D vector to the end of the list, so you need to
make sure you add normals at the same index of the matching vertex.

_description: _

Add a normal to the mesh as a 3D vector, typically perpendicular to the plane of the face. A normal is a vector that defines how a surface responds to lighting, i.e. how it is lit. The amount of light reflected by a surface is proportional to the angle between the light's direction and the normal. The smaller the angle the brighter the surface will look. See the normalsExample for advice on computing the normals.
addNormal adds the 3D vector to the end of the list, so you need to make sure you add normals at the same index of the matching face.

###void addNormals(&norms)

_inlined_description: _

Add a vector of normals to a mesh,
allowing you to push out many normals at once rather than
adding one at a time. The vector of normals is added after the end of
the current normals list.

_description: _

Add a vector of normals to a mesh, allowing you to push out many normals at once rather than adding one at a time. The vector of normals is added after the end of the current normals list.

###void addNormals(*norms, amt)

_inlined_description: _

Add an array of normals to the mesh.
Because you are using a pointer to the array you also have to define
the length of the array as an std::size_t (amt). The normals are added at the
end of the current normals list.

_description: _

###void addTexCoord(&t)

_inlined_description: _

Add a Vec2f representing the texture coordinate.
Because OF uses ARB textures these are in pixels rather than
0-1 normalized coordinates.

_description: _

Add a Vec2f representing the texture coordinate. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.

###void addTexCoords(&tCoords)

_inlined_description: _

Add a vector of texture coordinates to a mesh,
allowing you to push out many at once rather than adding one at a time.
The vector of texture coordinates is added after the end of the current
texture coordinates list.

_description: _

Add a vector of texture coordinates to a mesh, allowing you to push out many at once rather than adding one at a time. The vector of texture coordinates is added after the end of the current texture coordinates list.

###void addTexCoords(*tCoords, amt)

_inlined_description: _

Add an array of texture coordinates to the mesh.
Because you are using a pointer to the array you also have to define
the length of the array as an std::size_t (amt).
The texture coordinates are added at the end of the current texture
coordinates list.

_description: _

###void addTriangle(index1, index2, index3)

_inlined_description: _

Adding a triangle means using three of the vertices that have already been added to create a triangle.
This is an easy way to create triangles in the mesh. The indices refer to the index of the vertex in the vector of vertices.

_description: _

###void addVertex(&v)

_inlined_description: _

Add a new vertex at the end of the current list of vertices.
It is important to remember that the order the vertices are added to
the list determines how they link they form the polygons and strips
(assuming you do not change their indeces). See the ofMesh class
description for details.

_description: _

###void addVertices(&verts)

_inlined_description: _

Add a vector of vertices to a mesh, allowing you to push out
many at once rather than adding one at a time. The vector of vertices
is added after the end of the current vertices list.

_description: _

Add a vector of vertices to a mesh, allowing you to push out many at once rather than adding one at a time. The vector of vertices is added after the end of the current vertices list.

###void addVertices(*verts, amt)

_inlined_description: _

Add an array of vertices to the mesh.
Because you are using a pointer to the array you also have to define
the length of the array as an int (amt). The vertices are added at the
end of the current vertices list.

_description: _

###void append(V, N, C, &mesh)

_inlined_description: _

Add the vertices, normals, texture coordinates and indices of one mesh onto another mesh.
Everything from the referenced mesh is simply added at the end
of the current mesh's lists.

_description: _

Add the vertices, normals, texture coordinates and indices of one mesh onto another mesh. Everything from the referenced mesh is simply added at the end of the current mesh's lists.

###ofMesh_< V, N, C, T > axis(size)

_inlined_description: _

**Returns**: an ofMesh representing an XYZ coordinate system.

_description: _

###ofMesh_< V, N, C, T > box(width, height, depth, resX = 2, resY = 2, resZ = 2)

_inlined_description: _

A helper method that returns a box made of triangles.
The resolution settings for the width and height are optional
(they are both set at a default of 2 triangles per side).
~~~~{.cpp}
ofMesh mesh;
mesh = ofMesh::box(200.0, 200.0, 200.0);
~~~~

![image of a simple box](3d/box.jpg)

_description: _

A helper method that returns a box made of triangles. The resolution settings for the width and height are optional (they are both set at a default of 2 triangles per side).
~~~~{.cpp}
ofMesh mesh;
mesh = ofMesh::box(200.0, 200.0, 200.0);
~~~~

![image of a simple box](box.jpg)

###void clear()

_inlined_description: _

Removes all the vertices, colors, and indices from the mesh.

_description: _

This removes all the vertices, colors, and indices from the mesh.

###void clearColors()

_inlined_description: _

Clear all the colors.

_description: _

Clear all the colors.

###void clearIndices()

_inlined_description: _

Remove all the indices of the mesh.
This means that your mesh will be a point cloud.

_description: _

Remove all the indices of the mesh. This means that your mesh will be a point cloud.

###void clearNormals()

_inlined_description: _

Remove all the normals.

_description: _

Remove all the normals.

###void clearTexCoords()

_inlined_description: _

Clear all the texture coordinates.

_description: _

Clear all the texture coordinates.

###void clearVertices()

_inlined_description: _

Removes all the vertices.

_description: _

Removes all the vertices.

###ofMesh_< V, N, C, T > cone(radius, height, radiusSegments = 12, heightSegments = 6, capSegments = 2, mode = OF_PRIMITIVE_TRIANGLE_STRIP)

_inlined_description: _

A helper method that returns a cone made of triangles.
The resolution settings for the radius, height, and cap are optional
(they are set at a default of 12 segments around the radius, 6 segments
in the height, and 2 on the cap). The only valid modes are the default
OF_PRIMITIVE_TRIANGLE_STRIP and OF_PRIMITIVE_TRIANGLES.
~~~~{.cpp}
ofMesh mesh;
mesh = ofMesh::cone(100.0, 200.0);
~~~~

![image of a simple cone](3d/cone.jpg)

_description: _

A helper method that returns a cone made of triangles. The resolution settings for the radius, height, and cap are optional (they are set at a default of 12 segments around the radius, 6 segments in the height, and 2 on the cap). The only valid modes are the default OF_PRIMITIVE_TRIANGLE_STRIP and OF_PRIMITIVE_TRIANGLES.
~~~~{.cpp}
ofMesh mesh;
mesh = ofMesh::cone(100.0, 200.0);
~~~~

![image of a simple cone](cone.jpg)

###ofMesh_< V, N, C, T > cylinder(radius, height, radiusSegments = 12, heightSegments = 6, numCapSegments = 2, bCapped = true, mode = OF_PRIMITIVE_TRIANGLE_STRIP)

_inlined_description: _

A helper method that returns a cylinder made of triangles.
The resolution settings for the radius, height, and cap are optional
(they are set at a default of 12 segments around the radius, 6 segments
in the height, and 2 on the cap). You have the option to cap the
cylinder or not. The only valid modes are the default
OF_PRIMITIVE_TRIANGLE_STRIP and OF_PRIMITIVE_TRIANGLES.
	~~~~{.cpp}
	ofMesh mesh;
	mesh = ofMesh::cylinder(100.0, 200.0);
	~~~~

![image of a simple cylinder](3d/cylinder.jpg)

_description: _

A helper method that returns a cylinder made of triangles. The resolution settings for the radius, height, and cap are optional (they are set at a default of 12 segments around the radius, 6 segments in the height, and 2 on the cap). You have the option to cap the cylinder or not. The only valid modes are the default OF_PRIMITIVE_TRIANGLE_STRIP and OF_PRIMITIVE_TRIANGLES.
~~~~{.cpp}
ofMesh mesh;
mesh = ofMesh::cylinder(100.0, 200.0);
~~~~

![image of a simple cylinder](cylinder.jpg)

###void disableColors()

_inlined_description: _

Disable mesh colors.
Use enableColors() to turn colors back on.

_description: _

Disable mesh colors. Use enableColors() to turn colors back on.

###void disableIndices()

_inlined_description: _

Disable mesh indices.
Use enableIndices() to turn indices back on.

_description: _

Disable mesh indices. Use enableIndices() to turn indices back on.

###void disableNormals()

_inlined_description: _

Disable mesh normals.
Use enableNormals() to turn normals back on.

_description: _

Disable mesh normals. Use enableNormals() to turn normals back on.

###void disableTextures()

_inlined_description: _

Disable mesh textures.
Use enableTextures() to turn textures back on.

_description: _

Disable mesh textures. Use enableTextures() to turn textures back on.

###void draw()

_inlined_description: _

This draws the mesh using its primitive type, meaning that if
you set them up to be triangles, this will draw the triangles.

_description: _

This draws the mesh using its primitive type, meaning that if you set them up to be triangles, this will draw the triangles.

###void draw(renderType)

_inlined_description: _

This draws the mesh using a defined renderType,
overriding the renderType defined with setMode().

_description: _

This draws the mesh using a defined renderType, overriding the renderType defined with setMode().

###void drawFaces()

_inlined_description: _

This draws the mesh as faces, meaning that you'll have a collection of faces.

_description: _

This draws the mesh as faces, meaning that you'll have a collection of faces.

###void drawVertices()

_inlined_description: _

This allows you draw just the vertices, meaning that you'll have a point cloud.

_description: _

This allows you draw just the vertices, meaning that you'll have a point cloud.

###void drawWireframe()

_inlined_description: _

This draws the mesh as GL_LINES, meaning that you'll have a wireframe.

_description: _

This draws the mesh as GL_LINES, meaning that you'll have a wireframe.

###void enableColors()

_inlined_description: _

Enable mesh colors.
Use disableColors() to turn colors off.
Colors are enabled by default when they are added to the mesh.

_description: _

Enable mesh colors. Use disableColors() to turn colors off. Colors are enabled by default when they are added to the mesh.

###void enableIndices()

_inlined_description: _

Enable mesh indices.
Use disableIndices() to turn indices off.
Indices are enabled by default when they are added to the mesh.

_description: _

Enable mesh indices. Use disableIndices() to turn indices off. Indices are enabled by default when they are added to the mesh.

###void enableNormals()

_inlined_description: _

Enable mesh normals.
Use disableNormals() to turn normals off.
Normals are enabled by default when they are added to the mesh.

_description: _

Enable mesh normals. Use disableNormals() to turn normals off. Normals are enabled by default when they are added to the mesh.

###void enableTextures()

_inlined_description: _

Enable mesh textures.
Use disableTextures() to turn textures off.
Textures are enabled by default when they are added to the mesh.

_description: _

Enable mesh textures. Use disableTextures() to turn textures off. Textures are enabled by default when they are added to the mesh.

###void flatNormals()

_inlined_description: _

Duplicates vertices and updates normals to get a low-poly look.

_description: _

###V getCentroid()

_inlined_description: _

**Returns**: a ofVec3f defining the centroid of all the vetices in the mesh.

_description: _

Returns a ofVec3f defining the centroid of all the vetices in the mesh.

###C getColor(i)

_inlined_description: _

Get the color at the index in the colors vector.

**Returns**: the color at the index in the colors vector.

_description: _

Returns the color at the index in the colors vector.

###vector< C > & getColors()

_inlined_description: _

Use this if you plan to change the colors as part of this call as it will force a reset of the cache.

**Returns**: the vector that contains all of the colors of the mesh, if it has any.

_description: _

Returns the vector that contains all of the colors of the mesh, if it has any. (read only)

###const vector< C > & getColors()

_inlined_description: _

**Returns**: the vector that contains all of the colors of the mesh, if it has any. (read only)

_description: _

Returns the vector that contains all of the colors of the mesh, if it has any. Use this if you plan to change the colors as part of this call as it will force a reset of the cache.

###C * getColorsPointer()

_inlined_description: _

Use this if you plan to change the colors as part of this call as it will force a reset of the cache.

**Returns**: a pointer that contains all of the colors of the mesh, if it has any.

_description: _

Returns a pointer that contains all of the colors of the mesh, if it has any. Use this if you plan to change the colors as part of this call as it will force a reset of the cache.

###const C * getColorsPointer()

_inlined_description: _

**Returns**: a pointer that contains all of the colors of the mesh, if it has any. (read only)

_description: _

Returns a pointer that contains all of the colors of the mesh, if it has any. (read only)

###ofMeshFace_< V, N, C, T > getFace(faceId)

_inlined_description: _

**Returns**: the vector that contains all of the faces of the mesh. This isn't currently implemented.

_description: _

Returns the vector that contains all of the faces of the mesh. This isn't currently implemented.

###vector< N > getFaceNormals(perVetex = false)

_inlined_description: _

Get normals for each face
As a default it only calculates the normal for the face as a whole but
by setting (perVertex = true) it will return the same normal value for
each of the three vertices making up a face.

**Returns**: a vector containing the calculated normals of each face in the mesh.

_description: _

Returns a vector containing the calculated normals of each face in the mesh. As a default it only calculates the normal for the face as a whole but by setting (perVertex = true) it will return the same normal value for each of the three vertices making up a face.

###ofIndexType getIndex(i)

_inlined_description: _

**Returns**: the index from the index vector. Each index represents the index of the vertex in the vertices vector. This determines the way that the vertices are connected into the polgoynon type set in the primitiveMode.

_description: _

###ofIndexType * getIndexPointer()

_inlined_description: _

**Returns**: a pointer to the indices that the mesh contains.

_description: _

Returns a pointer to the indices that the mesh contains.

###const ofIndexType * getIndexPointer()

_inlined_description: _

**Returns**: a pointer to the indices that the mesh contains.

_description: _

Returns a pointer to the indices that the mesh contains.

###vector< ofIndexType > & getIndices()

_inlined_description: _

Use this if you plan to change the indices as part of this call as it
will force a reset of the cache.

**Returns**: the vector that contains all of the indices of the mesh, if it has any.

_description: _

Returns the vector that contains all of the indices of the mesh, if it has any. (read only)

###const vector< ofIndexType > & getIndices()

_inlined_description: _

**Returns**: the vector that contains all of the indices of the mesh, if it has any. (read only)

_description: _

Returns the vector that contains all of the indices of the mesh, if it has any. Use this if you plan to change the indices as part of this call as it will force a reset of the cache.

###ofMesh_< V, N, C, T > getMeshForIndices(startIndex, endIndex)

_inlined_description: _

The new mesh includes the mesh mode, colors, textures, and normals of the original mesh (assuming any were added).

**Returns**: a mesh made up of a range of indices from startIndex to the endIndex.

_description: _

Returns a mesh made up of a range of indices from startIndex to the endIndex. The new mesh includes the mesh mode, colors, textures, and normals of the original mesh (assuming any were added).

###ofMesh_< V, N, C, T > getMeshForIndices(startIndex, endIndex, startVertIndex, endVertIndex)

_inlined_description: _

_description: _

###ofPrimitiveMode getMode()

_inlined_description: _

\
**Returns**: the primitive mode that the mesh is using.

_description: _

Returns the primitive mode that the mesh is using.

###N getNormal(i)

_inlined_description: _

\
**Returns**: the normal at the index in the normals vector.

_description: _

Returns the normal at the index in the normals vector.

###vector< N > & getNormals()

_inlined_description: _

Use this if you plan to change the normals as part of this call as it
will force a reset of the cache.

**Returns**: the vector that contains all of the normals of the mesh,
if it has any.

_description: _

Returns the vector that contains all of the normals of the mesh, if it has any. (read only)

###const vector< N > & getNormals()

_inlined_description: _

**Returns**: the vector that contains all of the normals of the mesh, if
it has any. (read only)

_description: _

Returns the vector that contains all of the normals of the mesh, if it has any. Use this if you plan to change the normals as part of this call as it will force a reset of the cache.

###N * getNormalsPointer()

_inlined_description: _

**Returns**: a pointer to the normals that the mesh contains.

_description: _

Returns a pointer to the normals that the mesh contains.

###const N * getNormalsPointer()

_inlined_description: _

**Returns**: a pointer to the normals that the mesh contains.

_description: _

Returns a pointer to the normals that the mesh contains.

###size_t getNumColors()

_inlined_description: _

**Returns**: the size of the colors vector for the mesh.
This will tell you how many colors are contained in the mesh.

_description: _

Returns the size of the colors vector for the mesh. This will tell you how many colors are contained in the mesh.

###size_t getNumIndices()

_inlined_description: _

This will tell you how many indices are contained in the mesh.

**Returns**: the size of the indices vector for the mesh.

_description: _

Returns the size of the indices vector for the mesh. This will tell you how many indices are contained in the mesh.

###size_t getNumNormals()

_inlined_description: _

This will tell you how many normals are contained in the mesh.

**Returns**: the size of the normals vector for the mesh.

_description: _

Returns the size of the normals vector for the mesh. This will tell you how many normals are contained in the mesh.

###size_t getNumTexCoords()

_inlined_description: _

This will tell you how many texture coordinates are contained in the mesh.

**Returns**: the size of the texture coordinates vector for the mesh.

_description: _

Returns the size of the texture coordinates vector for the mesh. This will tell you how many texture coordinates are contained in the mesh.

###size_t getNumVertices()

_inlined_description: _

**Returns**: the size of the vertices vector for the mesh.
This will tell you how many vertices are contained in the mesh.

_description: _

Returns the size of the vertices vector for the mesh. This will tell you how many vertices are contained in the mesh.

###T getTexCoord(i)

_inlined_description: _

**Returns**: the Vec2f representing the texture coordinate.
Because OF uses ARB textures these are in pixels rather than
0-1 normalized coordinates.

_description: _

Returns the Vec2f representing the texture coordinate. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.

###vector< T > & getTexCoords()

_inlined_description: _

Get a vector representing the texture coordinates of the mesh
Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.
Use this if you plan to change the texture coordinates as part of this
call as it will force a reset of the cache.

**Returns**: a vector of Vec2f representing the texture coordinates for the whole mesh.

_description: _

Returns a vector of Vec2f representing the texture coordinates for the whole mesh. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates. (read only)

###const vector< T > & getTexCoords()

_inlined_description: _

Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates.

**Returns**: a vector of Vec2f representing the texture coordinates for the whole mesh. (read only)

_description: _

Returns a vector of Vec2f representing the texture coordinates for the whole mesh. Because OF uses ARB textures these are in pixels rather than 0-1 normalized coordinates. Use this if you plan to change the texture coordinates as part of this call as it will force a reset of the cache.

###T * getTexCoordsPointer()

_inlined_description: _

**Returns**: a pointer to the texture coords that the mesh contains.

_description: _

Returns a pointer to the texture coords that the mesh contains.

###const T * getTexCoordsPointer()

_inlined_description: _

Get a pointer to the ofVec2f texture coordinates that the mesh contains.

_description: _

Get a pointer to the ofVec2f texture coordinates that the mesh contains.

###const vector<ofMeshFace_< V, N, C, T>  > & getUniqueFaces()

_inlined_description: _

**Returns**: the mesh as a vector of unique ofMeshFace_s
a list of triangles that do not share vertices or indices

_description: _

Returns the mesh as a vector of unique ofMeshFaces.

###V getVertex(i)

_inlined_description: _

**Returns**: the vertex at the index.

_description: _

Returns the vertex at the index.

###vector< V > & getVertices()

_inlined_description: _

**Returns**: the vector that contains all of the vertices of the mesh.

_description: _

Returns the vector that contains all of the vertices of the mesh.

###const vector< V > & getVertices()

_inlined_description: _

**Returns**: the vector that contains all of the vertices of the mesh.

_description: _

Returns the vector that contains all of the vertices of the mesh.

###V * getVerticesPointer()

_inlined_description: _

**Returns**: a pointer to the vertices that the mesh contains.

_description: _

Returns a pointer to the vertices that the mesh contains.

###const V * getVerticesPointer()

_inlined_description: _

**Returns**: a pointer to the vertices that the mesh contains.

_description: _

Returns a pointer to the vertices that the mesh contains.

###bool hasColors()

_inlined_description: _

/returns Whether the mesh has any colors.

_description: _

Whether the mesh has any colors.

###bool hasIndices()

_inlined_description: _

/returns Whether the mesh has any indices assigned to it.

_description: _

Whether the mesh has any indices assigned to it.

###bool hasNormals()

_inlined_description: _

/returnsWhether the mesh has any normals.

_description: _

Whether the mesh has any normals.

###bool hasTexCoords()

_inlined_description: _

/returns Whether the mesh has any textures assigned to it.

_description: _

Whether the mesh has any textures assigned to it.

###bool hasVertices()

_inlined_description: _

**Returns**: Whether the mesh has any vertices.

_description: _

Whether the mesh has any vertices.

###bool haveColorsChanged()

_inlined_description: _

**Returns**: If the colors of the mesh have changed, been added or removed.

_description: _

If the colors of the mesh have changed, been added or removed.

###bool haveIndicesChanged()

_inlined_description: _

**Returns**: If the indices of the mesh have changed, been added or removed.

_description: _

If the indices of the mesh have changed, been added or removed.

###bool haveNormalsChanged()

_inlined_description: _

**Returns**: If the normals of the mesh have changed, been added or removed.

_description: _

If the normals of the mesh have changed, been added or removed.

###bool haveTexCoordsChanged()

_inlined_description: _

**Returns**: If the texture coords of the mesh have changed, been added or removed.

_description: _

If the texture coords of the mesh have changed, been added or removed.

###bool haveVertsChanged()

_inlined_description: _

**Returns**: If the vertices of the mesh have changed, been added or removed.

_description: _

If the vertices of the mesh have changed, been added or removed.

###ofMesh_< V, N, C, T > icosahedron(radius)

_inlined_description: _

_description: _

###ofMesh_< V, N, C, T > icosphere(radius, iterations)

_inlined_description: _

_description: _

###void load(&path)

_inlined_description: _

Loads a mesh from a file located at the provided path into the mesh.
This will replace any existing data within the mesh.

It expects that the file will be in the [PLY Format](http://en.wikipedia.org/wiki/PLY_(file_format)).
It will only load meshes saved in the PLY ASCII format; the binary format is not supported.

_description: _

Loads a mesh from a file located at the provided path into the mesh.
This will replace any existing data within the mesh.

It expects that the file will be in the [PLY Format](http://en.wikipedia.org/wiki/PLY_(file_format)).
It will only load meshes saved in the PLY ASCII format; the binary format is not supported.

###void mergeDuplicateVertices()

_inlined_description: _

_description: _

### ofMesh_()

_inlined_description: _

This creates the mesh,
using OF_PRIMITIVE_TRIANGLES without any initial vertices.

_description: _

This creates the mesh, using OF_PRIMITIVE_TRIANGLES and without any initial vertices.

### ofMesh_(mode, &verts)

_inlined_description: _

This allows to you to use one of the other ofPrimitiveModes:
OF_PRIMITIVE_TRIANGLES, OF_PRIMITIVE_TRIANGLE_STRIP,
OF_PRIMITIVE_TRIANGLE_FAN, OF_PRIMITIVE_LINES, OF_PRIMITIVE_LINE_STRIP,
OF_PRIMITIVE_LINE_LOOP, OF_PRIMITIVE_POINTS.
See [ofGLUtils](../gl/ofGLUtils) for more information on these types.

_description: _

This allows to you to use one of the other ofPrimitiveModes: OF_PRIMITIVE_TRIANGLES, OF_PRIMITIVE_TRIANGLE_STRIP, OF_PRIMITIVE_TRIANGLE_FAN, OF_PRIMITIVE_LINES, OF_PRIMITIVE_LINE_STRIP, OF_PRIMITIVE_LINE_LOOP, OF_PRIMITIVE_POINTS. See [ofGLUtils](../gl/ofGLUtils) for more information on these types.

###ofMesh_< V, N, C, T > plane(width, height, columns = 2, rows = 2, mode = OF_PRIMITIVE_TRIANGLE_STRIP)

_inlined_description: _

\}
\name Primitive constructor helper methods
\{

_description: _

###void removeColor(index)

_inlined_description: _

Remove a color at the index in the colors vector.

_description: _

Remove a color at the index in the colors vector.

###void removeIndex(index)

_inlined_description: _

Removes an index.

_description: _

Removes an index.

###void removeNormal(index)

_inlined_description: _

Remove a normal.

_description: _

Remove a normal.

###void removeTexCoord(index)

_inlined_description: _

Remove a Vec2f representing the texture coordinate.

_description: _

Remove a Vec2f representing the texture coordinate.

###void removeVertex(index)

_inlined_description: _

Removes the vertex at the index in the vector.

_description: _

Removes the vertex at the index in the vector.

###void save(&path, useBinary = false)

_inlined_description: _

Saves the mesh at the passed path in the [PLY Format](http://en.wikipedia.org/wiki/PLY_(file_format)).

There are two format options for PLY: a binary format and an ASCII format.
 By default, it will save using the ASCII format.
 Passing ``true`` into the ``useBinary`` parameter will save it in the binary format.

If you're planning on reloading the mesh into ofMesh, ofMesh currently only supports loading the ASCII format.

For more information, see the [PLY format specification](http://paulbourke.net/dataformats/ply/).

_description: _

Saves the mesh at the passed path in the [PLY Format](http://en.wikipedia.org/wiki/PLY_(file_format)).

There are two format options for PLY: a binary format and an ASCII format.
By default, it will save using the ASCII format.
Passing ``true`` into the ``useBinary`` parameter will save it in the binary format.

If you're planning on reloading the mesh into ofMesh, ofMesh currently only supports loading the ASCII format.

For more information, see the [PLY format specification](http://paulbourke.net/dataformats/ply/).

###void setColor(index, &c)

_inlined_description: _

Set the color at the index in the colors vector.

_description: _

Set the color at the index in the colors vector.

###void setColorForIndices(startIndex, endIndex, color)

_inlined_description: _

_description: _

###void setFromTriangles(V, N, C, &tris, bUseFaceNormal = false)

_inlined_description: _

_description: _

###void setIndex(index, val)

_inlined_description: _

This sets the index at i.

_description: _

This sets the index at i.

###void setMode(mode)

_inlined_description: _

Allows you to set the ofPrimitiveMode.
The available modes are OF_PRIMITIVE_TRIANGLES,
OF_PRIMITIVE_TRIANGLE_STRIP, OF_PRIMITIVE_TRIANGLE_FAN,
OF_PRIMITIVE_LINES, OF_PRIMITIVE_LINE_STRIP,
OF_PRIMITIVE_LINE_LOOP, OF_PRIMITIVE_POINTS

_description: _

###void setNormal(index, &n)

_inlined_description: _

\todo Documentation.

_description: _

###void setTexCoord(index, &t)

_inlined_description: _

_description: _

###void setVertex(index, &v)

_inlined_description: _

_description: _

###void setupIndicesAuto()

_inlined_description: _

Allow you to set up the indices automatically when you add a vertex.

_description: _

Allow you to set up the indices automatically when you add a vertex.

###void smoothNormals(angle)

_inlined_description: _

_description: _

###ofMesh_< V, N, C, T > sphere(radius, res = 12, mode = OF_PRIMITIVE_TRIANGLE_STRIP)

_inlined_description: _

_description: _

###bool usingColors()

_inlined_description: _

_description: _

###bool usingIndices()

_inlined_description: _

_description: _

###bool usingNormals()

_inlined_description: _

_description: _

###bool usingTextures()

_inlined_description: _

_description: _

### ~ofMesh_()

_inlined_description: _

_description: _

##Variables

###bool bColorsChanged

_inlined_description: _

_description: _

###bool bFacesDirty

_inlined_description: _

_description: _

###bool bIndicesChanged

_inlined_description: _

_description: _

###bool bNormalsChanged

_inlined_description: _

_description: _

###bool bTexCoordsChanged

_inlined_description: _

_description: _

###bool bVertsChanged

_inlined_description: _

_description: _

###int colors

_inlined_description: _

_description: _

###int faces

_inlined_description: _

_description: _

###int indices

_inlined_description: _

_description: _

###ofPrimitiveMode mode

_inlined_description: _

_description: _

###int normals

_inlined_description: _

_description: _

###int texCoords

_inlined_description: _

_description: _

###bool useColors

_inlined_description: _

_description: _

###bool useIndices

_inlined_description: _

_description: _

###bool useNormals

_inlined_description: _

_description: _

###bool useTextures

_inlined_description: _

_description: _

###int vertices

_inlined_description: _

_description: _

Docs 0.11.0

addColor( ... )

addColors( ... )

addIndex( ... )

addIndices( ... )

addNormal( ... )

addNormals( ... )

addTexCoord( ... )

addTexCoords( ... )

addTriangle( ... )

addVertex( ... )

addVertices( ... )

clear( )

clearColors( )

clearIndices( )

clearNormals( )

clearTexCoords( )

clearVertices( )

disableColors( )

disableIndices( )

disableNormals( )

disableTextures( )

draw( )

draw( ... )

drawFaces( )

drawVertices( )

drawWireframe( )

enableColors( )

enableIndices( )

enableNormals( )

enableTextures( )

flatNormals( )

getCentroid( )

getColor( ... )

getColorsPointer( )

getColorsPointer( )

getIndex( ... )

getIndexPointer( )

getIndexPointer( )

getMode( )

getNormal( ... )

getNormalsPointer( )

getNormalsPointer( )

getNumColors( )

getNumIndices( )

getNumNormals( )

getNumTexCoords( )

getNumVertices( )

getTexCoord( ... )

getTexCoordsPointer( )

getTexCoordsPointer( )

getVertex( ... )

getVerticesPointer( )

getVerticesPointer( )

hasColors( )

hasIndices( )

hasNormals( )

hasTexCoords( )

hasVertices( )

haveColorsChanged( )

haveIndicesChanged( )

haveNormalsChanged( )

haveTexCoordsChanged( )

haveVertsChanged( )

load( ... )

mergeDuplicateVertices( )

ofMesh_( )

removeColor( ... )

removeIndex( ... )

removeNormal( ... )

removeTexCoord( ... )

removeVertex( ... )

save( ... )

setColor( ... )

setColorForIndices( ... )

setIndex( ... )

setMode( ... )

setNormal( ... )

setTexCoord( ... )

addColor( `...` )

addColors( `...` )

addIndex( `...` )

addIndices( `...` )

addNormal( `...` )

addNormals( `...` )

addTexCoord( `...` )

addTexCoords( `...` )

addTriangle( `...` )

addVertex( `...` )

addVertices( `...` )

draw( `...` )

getColor( `...` )

getIndex( `...` )

getNormal( `...` )

getTexCoord( `...` )

getVertex( `...` )

load( `...` )

removeColor( `...` )

removeIndex( `...` )

removeNormal( `...` )

removeTexCoord( `...` )

removeVertex( `...` )

save( `...` )

setColor( `...` )

setColorForIndices( `...` )

setIndex( `...` )

setMode( `...` )

setNormal( `...` )

setTexCoord( `...` )

setVertex( `...` )

smoothNormals( `...` )