//---------------------------------------------------------- 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(); }