ofVboMeshfile

ofVboMeshclass

Construction

setFromTriangles ()

void setFromTriangles(const vector< ofMeshFace > &tris, bool bUseFaceNormal=false)

Mesh Mode

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.

getMode ()

ofPrimitiveMode getMode() const

\returns the primitive mode that the mesh is using.

Primitive constructor helper methods

plane ()

ofMesh plane(float width, float height, int columns=2, int rows=2, ofPrimitiveMode mode=OF_PRIMITIVE_TRIANGLE_STRIP)

sphere ()

ofMesh sphere(float radius, int res=12, ofPrimitiveMode mode=OF_PRIMITIVE_TRIANGLE_STRIP)

icosahedron ()

ofMesh icosahedron(float radius)

Step 1 : Generate icosahedron

icosphere ()

ofMesh icosphere(float radius, int iterations=2)

Step 2 : tessellate

Step 3 : generate texcoords

Step 4 : fix texcoords

cylinder ()

ofMesh cylinder(float radius, float height, int radiusSegments=12, int heightSegments=6, int numCapSegments=2, bool bCapped=true, ofPrimitiveMode mode=OF_PRIMITIVE_TRIANGLE_STRIP)

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.

ofMesh mesh;

mesh = ofMesh::cylinder(100.0, 200.0);

cone ()

ofMesh cone(float radius, float height, int radiusSegments=12, int heightSegments=6, int capSegments=2, ofPrimitiveMode mode=OF_PRIMITIVE_TRIANGLE_STRIP)

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.

ofMesh mesh;

mesh = ofMesh::cone(100.0, 200.0);

box ()

ofMesh box(float width, float height, float depth, int resX=2, int resY=2, int resZ=2)

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).

ofMesh mesh;

mesh = ofMesh::box(200.0, 200.0, 200.0);

axis ()

ofMesh axis(float size=1.0)

Returns an ofMesh representing an XYZ coordinate system.

Returns: an ofMesh representing an XYZ coordinate system.

Vertices

addVertex ()

void addVertex(const ofVec3f &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 vector< ofVec3f > &verts)

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(const ofVec3f *verts, int 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.

removeVertex ()

void removeVertex(ofIndexType index)

Removes the vertex at the index in the vector.

setVertex ()

void setVertex(ofIndexType index, const ofVec3f &v)

clearVertices ()

void clearVertices()

Removes all the vertices.

clear ()

void clear()

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

getNumVertices ()

int getNumVertices() const

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

getVerticesPointer ()

ofVec3f getVerticesPointer()

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

ofVec3f getVerticesPointer() const

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

getVertex ()

ofVec3f getVertex(ofIndexType i) const

Returns: the vertex at the index.

getVertices ()

ofVec3f getVertices()

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

ofVec3f getVertices() const

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

haveVertsChanged ()

bool haveVertsChanged()

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

hasVertices ()

bool hasVertices() const

Returns: Whether the mesh has any vertices.

append ()

void append(const ofMesh &mesh)

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.

mergeDuplicateVertices ()

void mergeDuplicateVertices()

getCentroid ()

ofVec3f getCentroid() const

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

Normals

getNormal ()

ofVec3f getNormal(ofIndexType i) const

\returns the normal at the index in the normals vector.

addNormal ()

void addNormal(const ofVec3f &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 face.

addNormals ()

void addNormals(const vector< ofVec3f > &norms)

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(const ofVec3f *norms, int 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 int (amt). The normals are added at the end of the current normals list.

removeNormal ()

void removeNormal(ofIndexType index)

Remove a normal.

setNormal ()

void setNormal(ofIndexType index, const ofVec3f &n)

clearNormals ()

void clearNormals()

Remove all the normals.

getNumNormals ()

int getNumNormals() const

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

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

getNormalsPointer ()

ofVec3f getNormalsPointer()

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

ofVec3f getNormalsPointer() const

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

getNormals ()

ofVec3f getNormals()

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.

ofVec3f getNormals() const

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

haveNormalsChanged ()

bool haveNormalsChanged()

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

hasNormals ()

bool hasNormals() const

/returnsWhether the mesh has any normals.

smoothNormals ()

void smoothNormals(float angle)

Faces

getFace ()

vector< int > & getFace(int faceId)

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

getFaceNormals ()

ofVec3f getFaceNormals(bool perVetex=false) const

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.

getUniqueFaces ()

ofMeshFace getUniqueFaces() const

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

Colors

getColor ()

ofFloatColor getColor(ofIndexType i) const

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

addColor ()

void addColor(const ofFloatColor &c)

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

addColors ()

void addColors(const vector< ofFloatColor > &cols)

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(const ofFloatColor *cols, int amt)

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

removeColor ()

void removeColor(ofIndexType index)

Remove a color at the index in the colors vector.

setColor ()

void setColor(ofIndexType index, const ofFloatColor &c)

Set the color at the index in the colors vector.

clearColors ()

void clearColors()

Clear all the colors.

getNumColors ()

int getNumColors() const

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

getColorsPointer ()

ofFloatColor 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.

ofFloatColor getColorsPointer() const

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

getColors ()

ofFloatColor getColors()

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.

ofFloatColor getColors() const

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

haveColorsChanged ()

bool haveColorsChanged()

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

hasColors ()

bool hasColors() const

/returns Whether the mesh has any colors.

Texture Coordinates

getTexCoord ()

ofVec2f getTexCoord(ofIndexType i) const

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

addTexCoord ()

void addTexCoord(const ofVec2f &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 vector< ofVec2f > &tCoords)

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(const ofVec2f *tCoords, int 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 int (amt). The texture coordinates are added at the end of the current texture coordinates list.

removeTexCoord ()

void removeTexCoord(ofIndexType index)

Remove a Vec2f representing the texture coordinate.

setTexCoord ()

void setTexCoord(ofIndexType index, const ofVec2f &t)

clearTexCoords ()

void clearTexCoords()

Clear all the texture coordinates.

getNumTexCoords ()

int getNumTexCoords() const

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

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

getTexCoordsPointer ()

ofVec2f getTexCoordsPointer()

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

ofVec2f getTexCoordsPointer() const

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

getTexCoords ()

ofVec2f getTexCoords()

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.

ofVec2f getTexCoords() const

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)

haveTexCoordsChanged ()

bool haveTexCoordsChanged()

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

hasTexCoords ()

bool hasTexCoords() const

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

Indices

setupIndicesAuto ()

void setupIndicesAuto()

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

getIndices ()

ofIndexType getIndices()

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.

ofIndexType getIndices() const

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

getIndex ()

ofIndexType getIndex(ofIndexType i) const

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.

addIndex ()

void addIndex(ofIndexType i)

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.

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:

addIndices ()

void addIndices(const vector< ofIndexType > &inds)

This adds a vector of indices.

void addIndices(const ofIndexType *inds, int amt)

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

removeIndex ()

void removeIndex(ofIndexType index)

Removes an index.

setIndex ()

void setIndex(ofIndexType index, ofIndexType val)

This sets the index at i.

clearIndices ()

void clearIndices()

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

getNumIndices ()

int getNumIndices() const

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

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

getIndexPointer ()

ofIndexType getIndexPointer()

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

ofIndexType getIndexPointer() const

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

haveIndicesChanged ()

bool haveIndicesChanged()

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

hasIndices ()

bool hasIndices() const

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

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.

setColorForIndices ()

void setColorForIndices(int startIndex, int endIndex, ofColor color)

getMeshForIndices ()

ofMesh getMeshForIndices(int startIndex, int endIndex) const

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.

ofMesh getMeshForIndices(int startIndex, int endIndex, int startVertIndex, int endVertIndex) const

Drawing

drawVertices ()

void drawVertices() const

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

drawWireframe ()

void drawWireframe() const

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

drawFaces ()

void drawFaces() const

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

draw ()

void draw() const

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

Saving and loading

load ()

void load(string 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.

save ()

void save(string path, bool useBinary=false) const

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.

Functions

ofVboMesh ()

ofVboMesh()

ofVboMesh(const ofMesh &mom)

operator= ()

void operator=(const ofMesh &mom)

setUsage ()

void setUsage(int usage)

enableColors ()

void enableColors()

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

Reimplemented from ofMesh.

enableTextures ()

void enableTextures()

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

Reimplemented from ofMesh.

enableNormals ()

void enableNormals()

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

Reimplemented from ofMesh.

enableIndices ()

void enableIndices()

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

Reimplemented from ofMesh.

disableColors ()

void disableColors()

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

Reimplemented from ofMesh.

disableTextures ()

void disableTextures()

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

Reimplemented from ofMesh.

disableNormals ()

void disableNormals()

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

Reimplemented from ofMesh.

disableIndices ()

void disableIndices()

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

Reimplemented from ofMesh.

usingColors ()

bool usingColors() const

Reimplemented from ofMesh.

usingTextures ()

bool usingTextures() const

Reimplemented from ofMesh.

usingNormals ()

bool usingNormals() const

Reimplemented from ofMesh.

usingIndices ()

bool usingIndices() const

Reimplemented from ofMesh.

draw ()

void draw(ofPolyRenderMode drawMode) const

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

Reimplemented from ofMesh.

drawInstanced ()

void drawInstanced(ofPolyRenderMode drawMode, int primCount) const

getVbo ()

ofVbo getVbo()

ofVbo getVbo() const