//----------------------------------------------------------
void ofEndShape(bool bClose){
// (close -> add the first point to the end)
// -----------------------------------------------
if ((bClose == true)){
//---------------------------
if (polyVertices.size() > currentStartVertex){
double* point = new double[3];
point[0] = polyVertices[currentStartVertex][0];
point[1] = polyVertices[currentStartVertex][1];
point[2] = 0;
polyVertices.push_back(point);
}
}
//------------------------------------------------
if ((polyMode == OF_POLY_WINDING_ODD) && (drawMode == OF_OUTLINE)){
// let's just draw via another method, like glLineLoop
// much, much faster, and *no* tess / computation necessary
glBegin(GL_LINE_STRIP);
for (int i=currentStartVertex; i< polyVertices.size(); i++) {
float x = polyVertices[i][0];
float y = polyVertices[i][1];
glVertex2f(x,y);
}
glEnd();
} else {
if ( tobj != NULL){
gluTessBeginContour( tobj);
for (int i=currentStartVertex; i<polyVertices.size(); i++) {
gluTessVertex( tobj, polyVertices[i],polyVertices[i]);
}
gluTessEndContour( tobj);
}
}
if ( tobj != NULL){
// no matter what we did / do, we need to delete the tesselator object
gluTessEndPolygon( tobj);
gluDeleteTess( tobj);
tobj = NULL;
}
// now clear the vertices on the dynamically allocated data
clearTessVertices();
if (bSmoothHinted && drawMode == OF_OUTLINE) endSmoothing();
}
//----------------------------------------------------------
void ofGLRenderer::draw(ofMesh & vertexData, ofPolyRenderMode renderType, bool useColors, bool useTextures, bool useNormals){
if (bSmoothHinted) startSmoothing();
#ifndef TARGET_OPENGLES
glPushAttrib(GL_POLYGON_BIT);
glPolygonMode(GL_FRONT_AND_BACK, ofGetGLPolyMode(renderType));
draw(vertexData,useColors,useTextures,useNormals);
glPopAttrib(); //TODO: GLES doesnt support polygon mode, add renderType to gl renderer?
#else
if(vertexData.getNumVertices()){
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(ofVec3f), vertexData.getVerticesPointer());
}
if(vertexData.getNumNormals() && useNormals){
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, vertexData.getNormalsPointer());
}
if(vertexData.getNumColors() && useColors){
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4,GL_FLOAT, sizeof(ofFloatColor), vertexData.getColorsPointer());
}
if(vertexData.getNumTexCoords() && useTextures){
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, vertexData.getTexCoordsPointer());
}
GLenum drawMode;
switch(renderType){
case OF_MESH_POINTS:
drawMode = GL_POINTS;
break;
case OF_MESH_WIREFRAME:
drawMode = GL_LINES;
break;
case OF_MESH_FILL:
drawMode = ofGetGLPrimitiveMode(vertexData.getMode());
break;
default:
drawMode = ofGetGLPrimitiveMode(vertexData.getMode());
break;
}
if(vertexData.getNumIndices()){
glDrawElements(drawMode, vertexData.getNumIndices(),GL_UNSIGNED_SHORT,vertexData.getIndexPointer());
}else{
glDrawArrays(drawMode, 0, vertexData.getNumVertices());
}
if(vertexData.getNumColors() && useColors){
glDisableClientState(GL_COLOR_ARRAY);
}
if(vertexData.getNumNormals() && useNormals){
glDisableClientState(GL_NORMAL_ARRAY);
}
if(vertexData.getNumTexCoords() && useTextures){
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
#endif
if (bSmoothHinted) endSmoothing();
}
//----------------------------------------------------------
void ofGLRenderer::draw(vector<ofPoint> & vertexData, ofPrimitiveMode drawMode){
if(!vertexData.empty()) {
if (bSmoothHinted) startSmoothing();
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(ofVec3f), &vertexData[0].x);
glDrawArrays(ofGetGLPrimitiveMode(drawMode), 0, vertexData.size());
if (bSmoothHinted) endSmoothing();
}
}
//----------------------------------------------------------
void ofGLRenderer::draw(ofPolyline & poly){
// use smoothness, if requested:
if (bSmoothHinted) startSmoothing();
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(ofVec3f), &poly.getVertices()[0].x);
glDrawArrays(poly.isClosed()?GL_LINE_LOOP:GL_LINE_STRIP, 0, poly.size());
// use smoothness, if requested:
if (bSmoothHinted) endSmoothing();
}
//----------------------------------------------------------
void ofLine(float x1,float y1,float x2,float y2){
// use smoothness, if requested:
if (bSmoothHinted) startSmoothing();
// draw:
glBegin( GL_LINES );
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glEnd();
// back to normal, if smoothness is on
if (bSmoothHinted) endSmoothing();
}
//----------------------------------------------------------
void ofTriangle(float x1,float y1,float x2,float y2,float x3, float y3){
// use smoothness, if requested:
if (bSmoothHinted && drawMode == OF_OUTLINE) startSmoothing();
// draw:
glBegin( (drawMode == OF_FILLED) ? GL_TRIANGLES : GL_LINE_LOOP);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glVertex2f(x3,y3);
glEnd();
// back to normal, if smoothness is on
if (bSmoothHinted && drawMode == OF_OUTLINE) endSmoothing();
}
//----------------------------------------------------------
void ofEllipse(float x, float y, float width, float height){
if (!bSetupCircle) setupCircle();
// use smoothness, if requested:
if (bSmoothHinted && drawMode == OF_OUTLINE) startSmoothing();
// draw:
glPushMatrix();
glTranslatef(x, y, 0);
glScalef(width, height, 1);
glBegin( (drawMode == OF_FILLED) ? GL_POLYGON : GL_LINE_LOOP);
glCallList(precachedCircle);
glEnd();
glPopMatrix();
// back to normal, if smoothness is on
if (bSmoothHinted && drawMode == OF_OUTLINE) endSmoothing();
}
void ofCircleSlice(float x,float y, float radius, float lowAngle, float highAngle, bool closed, bool radians) {
if (!bSetupCircle) setupCircle();
// use smoothness, if requested:
if (bSmoothHinted && drawMode == OF_OUTLINE) startSmoothing();
bool angleWrap = (lowAngle > highAngle); // are we doing the 0/360 wrap?
if(!radians) {
lowAngle = ofDegToRad(lowAngle);
highAngle = ofDegToRad(highAngle);
}
int res = numCirclePts;
float angle = lowAngle;
float angleRange = ((!angleWrap)?(highAngle - lowAngle):(M_TWO_PI - lowAngle + highAngle));
float angleAdder = angleRange / (float)res;
int k = 0;
for (int i = 0; i < numCirclePts; i++) {
circlePtsScaled[k] = x + cos(angle) * radius;
circlePtsScaled[k+1] = y - sin(angle) * radius;
angle += angleAdder;
k+=2;
}
// we draw the circle points ourself (vs. glDrawArrays) because it allows us to draw the center point, and have the triangles fan around it
k = 0;
glBegin((drawMode == OF_FILLED) ? GL_TRIANGLE_FAN : (closed?GL_LINE_LOOP:GL_LINE_STRIP));
glVertex2f(x, y); // center vertex
// now all the points around the circumference
for (int i = 0; i < numCirclePts; i++) {
glVertex2f(circlePtsScaled[k], circlePtsScaled[k+1]);
k+=2;
}
glEnd();
// back to normal, if smoothness is on
if (bSmoothHinted && drawMode == OF_OUTLINE) endSmoothing();
};
//----------------------------------------------------------
void ofRect(float x,float y,float w,float h){
// use smoothness, if requested:
if (bSmoothHinted && drawMode == OF_OUTLINE) startSmoothing();
if (cornerMode == OF_RECTMODE_CENTER){
glBegin( (drawMode == OF_FILLED) ? GL_QUADS : GL_LINE_LOOP);
glVertex2f(x-w/2,y-h/2);
glVertex2f(x+w/2,y-h/2);
glVertex2f(x+w/2,y+h/2);
glVertex2f(x-w/2,y+h/2);
glEnd();
} else {
glBegin( (drawMode == OF_FILLED) ? GL_QUADS : GL_LINE_LOOP);
glVertex2f(x,y);
glVertex2f(x+w,y);
glVertex2f(x+w,y+h);
glVertex2f(x,y+h);
glEnd();
}
// use smoothness, if requested:
if (bSmoothHinted && drawMode == OF_OUTLINE) endSmoothing();
}
