//-------------------------------------------------------------- void Leaf::draw(){ ofPushMatrix(); ofTranslate(xPos,yPos); ofRotate(90); ofRotate(rotation); //leaf left side ofSetColor(leafColor); ofBeginShape(); ofVertex(x1,y1); ofBezierVertex(x2, y2, x3, y3, x4, y4); ofEndShape(); //right side ofBeginShape(); ofVertex(x1,y1); ofBezierVertex(-x2, y2, -x3, y3, -x4, y4); ofEndShape(); //leaf line ofSetColor(stemColor); ofTriangle(0-stemWidth/2, y1, 0+stemWidth/2, y1, 0, leafLength ); ofPopMatrix(); }
//-------------------------------------------------------------- void testApp::draw(){ ofEnableAlphaBlending(); float bez1X1 = 350+50 * cos(ofGetElapsedTimef()*2.0f); float bez1Y1 = 200+100 * sin(ofGetElapsedTimef()/3.5f); float bez1X2 = 400+30 * cos(ofGetElapsedTimef()*5.0f); float bez1Y2 = 300+100 * sin(ofGetElapsedTimef()); float bez2X1 = 350+50 * cos(ofGetElapsedTimef()*2.0f); float bez2Y1 = 200-100 * sin(ofGetElapsedTimef()/3.5f); float bez2X2 = 400+30 * cos(ofGetElapsedTimef()*5.0f); float bez2Y2 = 300-100 * sin(ofGetElapsedTimef()); ofFill(); ofSetColor(255, 0, 0, 127); ofBeginShape(); // first we create the point from which to begin drawing ofVertex(100,300); // then create the Bezier vertex ofBezierVertex(100,300,bez1X2,bez1Y2,650,300); ofBezierVertex(650,300,bez2X2,bez2Y2,100,300); // finish the shape ofVertex(650,300); ofEndShape(); ofFill(); ofSetColor(255, 0, 0, 127); ofBeginShape(); ofVertex(100,300); ofBezierVertex(bez1X1,bez1Y1,bez1X2,bez1Y2,650,300); ofBezierVertex(bez2X1,bez2Y1,bez2X2,bez2Y2,100,300); ofVertex(650,300); ofEndShape(); }
//-------------------------------------------------------------- void testApp::heart(float x2, float y2, float scale, float color) { float myLenght = sin(myRotation/6.5) *20; //LINES BG ofPushMatrix(); ofRotate(myRotation * 1.5); ofFill(); ofSetColor(0, 180, 180); float myPulse = 130 + myLenght; ofLine(0, 0, 0, myPulse); ofLine(0, -myPulse, 0, 0); ofSetColor(110, 0, 150, 100 ); ofCircle(myPulse+10, 0, 1); ofPopMatrix(); //HEART ofPushMatrix(); ofSetColor(250, 0, 0); ofTranslate(0, -25); ofBeginShape(); ofVertex(0, 20); ofBezierVertex(0, -35, 80, 10, 0, 60); ofVertex(0, 20); ofBezierVertex(0, -35, -80, 10, 0, 60); ofEndShape(); ofPopMatrix(); }
void ArrowShape::draw(float scale = 1, bool fill = false){ ofSetColor(colour); ofPushMatrix(); ofPushStyle(); ofTranslate(pos); ofScale(size*scale, size*scale); ofRotate(rotation); if (!fill) { ofNoFill(); ofSetLineWidth(2); } //ofCircle(0, 0, 1); ofBeginShape(); ofVertex(-25,7); ofBezierVertex(-25,11,-18,17,-18,17); ofVertex(-13,23); ofBezierVertex(-8,18,0,10,0,10); ofVertex(13,23); ofVertex(17,18); ofBezierVertex(17,18,24,13,25,8); ofBezierVertex(25,3,21,0,21,0); ofVertex(0,-23); ofVertex(-22,-2); ofBezierVertex(-22,-2,-26,2,-25,7); ofEndShape(); ofPopStyle(); ofPopMatrix(); }
void CurveSquare::draw(float scale = 1, bool fill=false){ ofSetColor(colour); ofPushMatrix(); ofPushStyle(); ofTranslate(pos); ofScale(size*scale, size*scale); ofRotate(rotation); if (!fill) { ofNoFill(); ofSetLineWidth(2); } //ofCircle(0, 0, 1); ofBeginShape(); ofVertex(-9,-21); ofBezierVertex(-9,-21,-15,-21,-18,-17); ofBezierVertex(-21,-13,-21,-5,-21,-5); ofVertex(-21,21); ofVertex(4,21); ofBezierVertex(4,21,12,22,16,19); ofBezierVertex(20,16,21,10,21,10); ofVertex(21,-21); ofVertex(-9,-21); ofEndShape(); ofPopStyle(); ofPopMatrix(); }
//-------------------------------------------------------------- void Leaf::draw(){ // ofRect(xPos, yPos, 20,20); //test if code is working - white rect cout << stemWidth << endl; //this is println - displays values ofPushMatrix(); ofTranslate(xPos, yPos); ofScale(scaleFactor, scaleFactor); ofRotateZ(rotation); //1 //left leaf // ofSetColor (myColor); ofBeginShape(); float x0 = 0; float x1 = x0 - leafWidth/2; float x2 = x0 - leafWidth/4; // or leafCurvature float x3 = x0; float y0 = 0 - stemLength; float y1 = y0 - leafLength/3; float y2 = y1 - leafLength/3; float y3 = y0 - leafLength; ofVertex (x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); //right leaf ofBeginShape(); x0 = 0; x1 = x0 + leafWidth/2; x2 = x0 + leafWidth/leafCurvature; x3 = x0; y0 = 0 - stemLength; y1 = y0 - leafLength/3; y2 = y1 - leafLength/3; y3 = y0 - leafLength; ofVertex (x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); //draw stem // ofSetColor (stemColor); // ofRect (0,0 - (stemLength/2), stemWidth, stemLength); // ofTriangle (0 - stemWidth/2, 0 - stemLength, 0 + stemWidth/2, 0 - stemLength, 0, 0 - stemLength - 3*(leafLength/4)); ofPopMatrix(); }
void testApp::myShape1(int _x, int _y, int _rot) { //HEART ofPushMatrix(); ofSetColor(250, 0, 0, 10); ofTranslate(_x, _y); ofRotate(_rot); ofBeginShape(); ofVertex(0, 20); ofBezierVertex(0, -35, 80, 10, 0, 60); ofVertex(0, 20); ofBezierVertex(0, -35, -80, 10, 0, 60); ofEndShape(); ofPopMatrix(); }
void GReaf::draw(){ ofRotateZ(rotZ); ofSetPolyMode(OF_POLY_WINDING_NONZERO); glPushMatrix(); ofSetColor(255, 255, 255); ofRotateZ(180); myImage.draw(0, 0, 100, reafTopMov); glImage.draw(0, 105, 50, reafTopMov+100); glPopMatrix(); // ofSetColor(213, 255, 155, 70); ofFill(); //ofSetLineWidth(1); //ofSetColor(0, 123, 80, 70); //ofNoFill(); ofSetLineWidth(6); ofBeginShape(); ofVertex(0, -105); ofBezierVertex(0, -105, reafLeftMov, -105, reafTopRLMov, reafTopMov); ofVertex(reafTopRLMov, reafTopMov); ofBezierVertex(reafTopRLMov, reafTopMov, reafRightMov, -105, 0, -105); ofEndShape(); // /* ofBeginShape(); ofVertex(0, -135); ofBezierVertex(0, -135, reafLeftMov, -135, reafTopRLMov, reafTopMov); ofVertex(reafTopRLMov, reafTopMov); ofBezierVertex(reafTopRLMov, reafTopMov, reafRightMov, -135, 0, -135); ofEndShape(); //ofNextContour();// ofBeginShape(); ofVertex(0, -135); ofBezierVertex(0, -135, (reafLeftMov+reafRightMov)/2, -135, reafTopRLMov, reafTopMov); ofVertex(reafTopRLMov, reafTopMov); ofBezierVertex(reafTopRLMov, reafTopMov, (reafLeftMov+reafRightMov)/2, -135, 0, -135); ofEndShape(); */ }
void Weirdo::draw(){ ofPushMatrix(); ofPushStyle(); ofTranslate(posEnd.x, posEnd.y); ofRotate(rotation); ofScale(scaleAmount, scaleAmount); ofFill(); ofBeginShape(); ofVertex(0,0); ofBezierVertex(-5,-2,-13,0,-20,7); ofBezierVertex(-22,-7,-27,-18,-35,-18); ofBezierVertex(-45,-19,-55,0,-57,26); ofBezierVertex(-60,51,-54,72,-44,74); ofBezierVertex(-43,76,-42,77,-40,78); ofBezierVertex(-30,83,-14,70,-2,48); ofBezierVertex(8,26,9,4,0,0); ofEndShape(); ofPopMatrix(); ofPopStyle(); }
void TextImageContent::quadraticBezierVertex(float cpx, float cpy, float x, float y, float prevX, float prevY ) { float cp1x = prevX + 2.0/3.0*(cpx - prevX) ; float cp1y = prevY + 2.0/3.0*(cpy - prevY) ; float cp2x = cp1x + ( x-prevX )/3.0 ; float cp2y = cp1y + ( y-prevY )/3.0 ; ofBezierVertex( cp1x , cp1y , cp2x , cp2y , x , y ) ; }
void simpleToggle::quadraticBezierVertex(float cpx, float cpy, float x, float y, float prevX, float prevY) { float cp1x = prevX + 2.0/3.0*(cpx - prevX); float cp1y = prevY + 2.0/3.0*(cpy - prevY); float cp2x = cp1x + (x - prevX)/3.0; float cp2y = cp1y + (y - prevY)/3.0; // finally call cubic Bezier curve function ofBezierVertex(cp1x, cp1y, cp2x, cp2y, x, y); };
void wave::draw(){ ofSetColor(r,g,b,alpha); ofBeginShape(); ofVertex(0,600); ofBezierVertex(50+ySin*0.5,50 +xSin*0.5,100+xSin,100+ySin,150+ySin*0.5,180+xSin*0.5); ofBezierVertex(150+ySin*0.5,180 +xSin*0.5,300+xSin,550+ySin,400+ySin*0.5,400+xSin*0.5); ofBezierVertex(400+ySin*0.5,400+xSin*0.5,600+xSin,50+ySin,650+ySin*0.5,600+xSin*0.5); ofBezierVertex(650+ySin*0.5,600+xSin*0.5,700+xSin,700+ySin,850+ySin*0.5,400+xSin*0.5); ofBezierVertex(850+ySin*0.5,400+xSin*0.5,950+xSin,300+ySin,1200+ySin*0.5,150+xSin*0.5); ofVertex(1200,800); ofVertex(0,800); ofEndShape(true); };
void mui::Helpers::quadraticBezierVertex(float cpx, float cpy, float x, float y, float prevX, float prevY) { float cp1x = prevX + 2.0f/3.0f*(cpx - prevX); float cp1y = prevY + 2.0f/3.0f*(cpy - prevY); float cp2x = cp1x + (x - prevX)/3.0f; float cp2y = cp1y + (y - prevY)/3.0f; // finally call cubic Bezier curve function ofBezierVertex(cp1x, cp1y, cp2x, cp2y, x, y); };
//------------------------------------------------------------------ void creature::draw() { ofFill(); ofPushMatrix(); ofTranslate(pos.x, pos.y, 0); ofRotateZ(angle * RAD_TO_DEG); // creature body color ofSetColor(255,240,230); // ofSetColor(198,246,55); ofBeginShape(); ofVertex(0,0); for(int i =0; i< 3; i++){ ofBezierVertex(vertices[i][0].x, vertices[i][0].y, vertices[i][1].x, vertices[i][1].y, vertices[i][2].x, vertices[i][2].y); ofVertex(vertices[i][2].x, vertices[i][2].y); } ofEndShape(); ofPopMatrix(); //draw tentacles ofNoFill(); ofBeginShape(); for (int i = 0; i < points.size(); i++){ ofVertex(points[i].x + cos(ofGetElapsedTimef()*10+1*i)*10, points[i].y ); } ofEndShape(); ofBeginShape(); for (int i = 0; i < points.size(); i++){ ofVertex(points[i].x, points[i].y ); } ofEndShape(); }
void SpikeGraph::drawSpike(spike s) { float ybase = 0; if (s.direction == 1) ybase = h / 2; else ybase = h / 2; float c1y = ybase + s.height*0.1*s.direction; float c2y = ybase + s.height*0.3*s.direction; float c1x = spikeWidth*0.1; float c2x = spikeWidth*0.05; ofVertex(s.x, ybase); ofBezierVertex(ofPoint(s.x + spikeWidth - c1x, c1y), ofPoint(s.x + spikeWidth - c2x, c2y), ofPoint(s.x + spikeWidth, ybase + s.height*s.direction)); ofBezierVertex(ofPoint(s.x + spikeWidth + c2x, c2y), ofPoint(s.x + spikeWidth + c1x, c1y), ofPoint(s.x + spikeWidth * 2, ybase)); }
void Radar::debug_draw_bezier_segments() { ofNoFill(); ofBeginShape(); { for (int i = 0; i < bezier_segments.size(); i++) { bezier b = bezier_segments[i]; if (i == 0) ofVertex(b.start); ofBezierVertex(b.c1, b.c2, b.end); } } ofEndShape(); }
//---------------------------------------------------------- //this takes three arguments as it is based off the idea that at least one //inital polyVertex has already been set. void ofxVectorGraphics::bezierVertex(float x1, float y1, float x2, float y2, float x3, float y3){ if(bDraw){ ofBezierVertex(x1, y1, x2, y2, x3, y3); } if(bRecord){ //clear curve vertices if(whichShapeMode == 1){ clearAllVertices(); } whichShapeMode = 2; //we can only add a bezier curve if the curve //has started with a polyVertex //so as long as this is not the first point we add it if(!bFirstPoint){ creeps.addCurve(x1, y1, x2, y2, x3, y3); } } }
void Leaf::draw(float _xPos, float _yPos){ ofPushMatrix(); ofSetLineWidth(1); ofTranslate(_xPos, _yPos); ofScale(scaleFactor, scaleFactor); ofRotateZ(rotation); //draw leaf ofSetColor(leafColor); //draw left half of leaf ofBeginShape(); float x0 = 0; float x1 = x0 - leafWidth; float x2 = x0 - leafWidth/leafCurvature; float x3 = x0; float y0 = 0 - stemLength; float y1 = y0 - leafLength/3; float y2 = y1 - leafLength/3; float y3 = y0 - leafLength; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //draw middle part of leaf ofBeginShape(); x0 = 0; x1 = x0 - leafWidth; x2 = x0 - leafWidth/leafCurvature; x3 = x0; y0 = 0 - stemLength; y1 = y0 - leafLength/3; y2 = y1 - leafLength/2; y3 = y0 - leafLength/2; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //draw right half of leaf ofBeginShape(); x0 = 0; //don't need to redefine as float, because we are just reusing the variables created above x1 = x0 + leafWidth; x2 = x0 + leafWidth/leafCurvature; x3 = x0 + leafWidth/3; y0 = 0 - stemLength; y1 = y0 - leafLength/3; y2 = y1 - leafLength/3; y3 = y0 - leafLength; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //draw stem and veins of leaf ofSetColor(stemColor); ofRect(0,0 - (stemLength/2), stemWidth, stemLength); //MATH! ofTriangle(0 - stemWidth/2, 0 - stemLength, 0 + stemWidth/2, 0 - stemLength, 0, 0 - stemLength - 3*(leafLength/4)); cout << "x1 = "; cout << x1 << endl; cout << "x2 = "; cout << x2 << endl; ofPopMatrix(); }
//-------------------------------------------------------------- void testApp::draw(){ ofFill(); ofSetHexColor(0xe0be21); //------(a)-------------------------------------- // // draw a star // // use poly winding odd, the default rule // // info about the winding rules is here: // http://glprogramming.com/red/images/Image128.gif // ofSetPolyMode(OF_POLY_WINDING_ODD); // this is the normal mode ofBeginShape(); ofVertex(200,135); ofVertex(15,135); ofVertex(165,25); ofVertex(105,200); ofVertex(50,25); ofEndShape(); //------(b)-------------------------------------- // // draw a star // // use poly winding nonzero // // info about the winding rules is here: // http://glprogramming.com/red/images/Image128.gif // ofSetHexColor(0xb5de10); ofSetPolyMode(OF_POLY_WINDING_NONZERO); ofBeginShape(); ofVertex(400,135); ofVertex(215,135); ofVertex(365,25); ofVertex(305,200); ofVertex(250,25); ofEndShape(); //------------------------------------- //------(c)-------------------------------------- // // draw a star dynamically // // use the mouse position as a pct // to calc nPoints and internal point radius // float xPct = (float)(mouseX) / (float)(ofGetWidth()); float yPct = (float)(mouseY) / (float)(ofGetHeight()); int nTips = 5 + xPct * 60; int nStarPts = nTips * 2; float angleChangePerPt = TWO_PI / (float)nStarPts; float innerRadius = 0 + yPct*80; float outerRadius = 80; float origx = 525; float origy = 100; float angle = 0; ofSetHexColor(0xa16bca); ofBeginShape(); for (int i = 0; i < nStarPts; i++){ if (i % 2 == 0) { // inside point: float x = origx + innerRadius * cos(angle); float y = origy + innerRadius * sin(angle); ofVertex(x,y); } else { // outside point float x = origx + outerRadius * cos(angle); float y = origy + outerRadius * sin(angle); ofVertex(x,y); } angle += angleChangePerPt; } ofEndShape(); //------------------------------------- //------(d)-------------------------------------- // // poylgon of random points // // lots of self intersection, 500 pts is a good stress test // // ofSetHexColor(0x0cb0b6); ofSetPolyMode(OF_POLY_WINDING_ODD); ofBeginShape(); for (int i = 0; i < 10; i++){ ofVertex(ofRandom(650,850), ofRandom(20,200)); } ofEndShape(); //------------------------------------- //------(e)-------------------------------------- // // use sin cos and time to make some spirally shape // glPushMatrix(); glTranslatef(100,300,0); ofSetHexColor(0xff2220); ofFill(); ofSetPolyMode(OF_POLY_WINDING_ODD); ofBeginShape(); float angleStep = TWO_PI/(100.0f + sin(ofGetElapsedTimef()/5.0f) * 60); float radiusAdder = 0.5f; float radius = 0; for (int i = 0; i < 200; i++){ float anglef = (i) * angleStep; float x = radius * cos(anglef); float y = radius * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(OF_CLOSE); glPopMatrix(); //------------------------------------- //------(f)-------------------------------------- // // ofCurveVertex // // because it uses catmul rom splines, we need to repeat the first and last // items so the curve actually goes through those points // ofSetHexColor(0x2bdbe6); ofBeginShape(); for (int i = 0; i < nCurveVertexes; i++){ // sorry about all the if/states here, but to do catmull rom curves // we need to duplicate the start and end points so the curve acutally // goes through them. // for i == 0, we just call the vertex twice // for i == nCurveVertexes-1 (last point) we call vertex 0 twice // otherwise just normal ofCurveVertex call if (i == 0){ ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // we need to duplicate 0 for the curve to start at point 0 ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // we need to duplicate 0 for the curve to start at point 0 } else if (i == nCurveVertexes-1){ ofCurveVertex(curveVertices[i].x, curveVertices[i].y); ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // to draw a curve from pt 6 to pt 0 ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // we duplicate the first point twice } else { ofCurveVertex(curveVertices[i].x, curveVertices[i].y); } } ofEndShape(); // show a faint the non-curve version of the same polygon: ofEnableAlphaBlending(); ofNoFill(); ofSetColor(0,0,0,40); ofBeginShape(); for (int i = 0; i < nCurveVertexes; i++){ ofVertex(curveVertices[i].x, curveVertices[i].y); } ofEndShape(true); ofSetColor(0,0,0,80); for (int i = 0; i < nCurveVertexes; i++){ if (curveVertices[i].bOver == true) ofFill(); else ofNoFill(); ofCircle(curveVertices[i].x, curveVertices[i].y,4); } ofDisableAlphaBlending(); //------------------------------------- //------(g)-------------------------------------- // // ofBezierVertex // // with ofBezierVertex we can draw a curve from the current vertex // through the the next three vertexes we pass in. // (two control points and the final bezier point) // float x0 = 500; float y0 = 300; float x1 = 550+50*cos(ofGetElapsedTimef()*1.0f); float y1 = 300+100*sin(ofGetElapsedTimef()/3.5f); float x2 = 600+30*cos(ofGetElapsedTimef()*2.0f); float y2 = 300+100*sin(ofGetElapsedTimef()); float x3 = 650; float y3 = 300; ofFill(); ofSetHexColor(0xFF9933); ofBeginShape(); ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); ofEnableAlphaBlending(); ofFill(); ofSetColor(0,0,0,40); ofCircle(x0,y0,4); ofCircle(x1,y1,4); ofCircle(x2,y2,4); ofCircle(x3,y3,4); ofDisableAlphaBlending(); //------(h)-------------------------------------- // // holes / ofNextContour // // with ofNextContour we can create multi-contour shapes // this allows us to draw holes, for example... // ofFill(); ofSetHexColor(0xd3ffd3); ofRect(80,480,140,70); ofSetHexColor(0xff00ff); ofBeginShape(); ofVertex(100,500); ofVertex(180,550); ofVertex(100,600); ofNextContour(true); ofVertex(120,520); ofVertex(160,550); ofVertex(120,580); ofEndShape(true); //------------------------------------- //------(i)-------------------------------------- // // CSG / ofNextContour // // with different winding rules, you can even use ofNextContour to // perform constructive solid geometry // // be careful, the clockwiseness or counter clockwisenss of your multiple // contours matters with these winding rules. // // for csg ideas, see : http://glprogramming.com/red/chapter11.html // // info about the winding rules is here: // http://glprogramming.com/red/images/Image128.gif // ofNoFill(); glPushMatrix(); ofSetPolyMode(OF_POLY_WINDING_ODD); ofBeginShape(); ofVertex(300,500); ofVertex(380,550); ofVertex(300,600); ofNextContour(true); for (int i = 0; i < 20; i++){ float anglef = ((float)i / 19.0f) * TWO_PI; float x = 340 + 30 * cos(anglef); float y = 550 + 30 * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(true); glTranslatef(100,0,0); ofSetPolyMode(OF_POLY_WINDING_NONZERO); ofBeginShape(); ofVertex(300,500); ofVertex(380,550); ofVertex(300,600); ofNextContour(true); for (int i = 0; i < 20; i++){ float anglef = ((float)i / 19.0f) * TWO_PI; float x = 340 + 30 * cos(anglef); float y = 550 + 30 * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(true); glTranslatef(100,0,0); ofSetPolyMode(OF_POLY_WINDING_ABS_GEQ_TWO); ofBeginShape(); ofVertex(300,500); ofVertex(380,550); ofVertex(300,600); ofNextContour(true); for (int i = 0; i < 20; i++){ float anglef = ((float)i / 19.0f) * TWO_PI; float x = 340 + 30 * cos(anglef); float y = 550 + 30 * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(true); glPopMatrix(); //------------------------------------- ofSetHexColor(0x000000); ofDrawBitmapString("(a) star\nwinding rule odd", 20,210); ofSetHexColor(0x000000); ofDrawBitmapString("(b) star\nwinding rule nonzero", 220,210); ofSetHexColor(0x000000); ofDrawBitmapString("(c) dynamically\ncreated shape", 420,210); ofSetHexColor(0x000000); ofDrawBitmapString("(d) random points\npoly", 670,210); ofSetHexColor(0x000000); ofDrawBitmapString("(e) fun with sin/cos", 20,410); ofSetHexColor(0x000000); ofDrawBitmapString("(f) ofCurveVertex\nuses catmull rom\nto make curved shapes", 220,410); ofSetHexColor(0x000000); ofDrawBitmapString("(g) ofBezierVertex\nuses bezier to draw curves", 460,410); ofSetHexColor(0x000000); ofDrawBitmapString("(h) ofNextContour\nallows for holes", 20,610); ofSetHexColor(0x000000); ofDrawBitmapString("(i) ofNextContour\ncan even be used for CSG operations\nsuch as union and intersection", 260,620); }
void OctoplusShape::draw(float scale = 1, bool fill = false){ ofSetColor(colour); ofPushMatrix(); ofPushStyle(); ofTranslate(pos); ofScale(size*scale, size*scale); ofRotate(rotation); if (!fill) { ofNoFill(); ofSetLineWidth(2); } //ofCircle(0, 0, 1); ofBeginShape(); ofVertex(24,4); ofBezierVertex(21,8,21,17,21,17); ofVertex(21,22); ofVertex(17,22); ofBezierVertex(17,22,8,21,4,24); ofBezierVertex(0,27,0,33,0,33); ofBezierVertex(0,33,0,27,-3,24); ofBezierVertex(-7,21,-16,22,-16,22); ofVertex(-21,22); ofVertex(-21,17); ofBezierVertex(-21,17,-21,8,-24,4); ofBezierVertex(-27,0,-33,0,-33,0); ofBezierVertex(-33,0,-27,0,-24,-3); ofBezierVertex(-21,-7,-21,-16,-21,-16); ofVertex(-21,-22); ofBezierVertex(-18,-22,-16,-22,-16,-22); ofBezierVertex(-16,-22,-7,-21,-3,-24); ofBezierVertex(0,-27,0,-33,0,-33); ofBezierVertex(0,-33,0,-27,4,-24); ofBezierVertex(8,-21,17,-22,17,-22); ofVertex(21,-22); ofVertex(21,-16); ofBezierVertex(21,-16,21,-7,24,-3); ofBezierVertex(27,0,33,0,33,0); ofBezierVertex(33,0,27,0,24,4); ofEndShape(); ofPopStyle(); ofPopMatrix(); }
//------------------------------------------------------------ void particle::draw(){ // ofCircle(pos.x, pos.y, 3); ofFill(); ofPushMatrix(); ofTranslate(pos.x, pos.y, 0); ofRotateZ(angle * RAD_TO_DEG); // creature body color ofSetColor(230,80,0); // ofSetColor(198,246,55); ofBeginShape(); ofVertex(0,0); for(int i =0; i< 3; i++){ ofBezierVertex(vertices[i][0].x, vertices[i][0].y, vertices[i][1].x, vertices[i][1].y, vertices[i][2].x, vertices[i][2].y); ofVertex(vertices[i][2].x, vertices[i][2].y); } ofEndShape(); ofPopMatrix(); //draw tentacles ofNoFill(); ofBeginShape(); for (int i = 0; i < points.size(); i++){ ofVertex(points[i].x + cos(ofGetElapsedTimef()*10+1*i)*10, points[i].y ); } ofEndShape(); ofBeginShape(); for (int i = 0; i < points.size(); i++){ ofVertex(points[i].x, points[i].y ); } ofEndShape(); //only replace points if moving if(currVel > .01) { ofPoint tempPt; tempPt.x = pos.x; tempPt.y = pos.y; points.push_back(tempPt); // printf ("size of vector %i \n", points.size()); if (points.size() > 35){ points.erase(points.begin()); } } }
//-------------------------------------------------------------- void rm_assembly::draw(ofColor _collider){ if (currentLevel == thisLevel) { // Placeholder: draw the current level number onscreen: //ofDrawBitmapString(ofToString(thisLevel), ofGetWidth()/2, ofGetHeight()/2); collider = _collider; ofSetColor(collider); // Draw the boundary walls: ofRect(0, 0, ofGetWidth()/4, thickWall); // Top-left ofRect(ofGetWidth()/4+gap, 0, ofGetWidth()-(ofGetWidth()/4+gap), thickWall); // Top-right ofRect(0, 0, thickWall, ofGetHeight()); // Left ofRect(ofGetWidth()-thickWall, 0, thickWall, ofGetHeight()); // Right ofRect(0, ofGetHeight()-thickWall, ofGetWidth(), thickWall); // Bottom // Draw the room contents: // THE ARROWS: ofNoFill(); ofSetLineWidth(1); ofSetColor(66,108,255); ofBeginShape(); ofVertex(548,121); ofBezierVertex(548,139,549,157,548,174); ofBezierVertex(538,174,531,162,524,154); ofBezierVertex(533,165,552,177,563,163); ofEndShape(); ofNoFill(); ofSetLineWidth(1); ofSetColor(66,108,255); ofBeginShape(); ofVertex(756,280); ofBezierVertex(737,282,722,287,704,291); ofBezierVertex(706,283,709,275,712,267); ofBezierVertex(712,276,703,290,714,294); ofEndShape(); ofNoFill(); ofSetLineWidth(1); ofSetColor(66,108,255); ofBeginShape(); ofVertex(882,499); ofBezierVertex(864,499,840,485,825,475); ofBezierVertex(824,479,824,484,826,488); ofBezierVertex(829,469,834,467,854,462); ofEndShape(); ofNoFill(); ofSetLineWidth(1); ofSetColor(66,108,255); ofBeginShape(); ofVertex(600,494); ofBezierVertex(600,480,600,464,595,452); ofBezierVertex(583,457,574,466,562,471); ofBezierVertex(579,449,594,433,620,448); ofEndShape(); ofNoFill(); ofSetLineWidth(1); ofSetColor(66,108,255); ofBeginShape(); ofVertex(381,468); ofBezierVertex(399,468,421,450,436,440); ofBezierVertex(427,434,414,435,404,434); ofBezierVertex(430,436,429,443,429,466); ofEndShape(); ofNoFill(); ofSetLineWidth(1); ofSetColor(66,108,255); ofBeginShape(); ofVertex(304,126); ofBezierVertex(322,133,340,140,358,147); ofBezierVertex(367,150,376,150,381,157); ofBezierVertex(372,159,362,159,352,159); ofBezierVertex(362,160,384,164,392,157); ofBezierVertex(389,150,384,145,378,139); ofEndShape(); // THE HEXAGON: ofSetColor(collider); ofPushMatrix(); ofTranslate(0, -25); // Top: ofPushMatrix(); ofTranslate(0, -yPos); ofFill(); //ofSetColor(247,165,47); ofBeginShape(); ofVertex(658,186); ofVertex(458,186); ofVertex(458,164); ofVertex(658,164); ofVertex(658,186); ofEndShape(); ofPopMatrix(); // Top-left: ofPushMatrix(); ofTranslate(-xPos, -yPos); ofFill(); //ofSetColor(247,165,47); ofBeginShape(); ofVertex(370,355); ofVertex(350,345); ofVertex(445,169); ofVertex(465,179); ofVertex(370,355); ofEndShape(); ofPopMatrix(); // Bottom-left: ofPushMatrix(); ofTranslate(-xPos, yPos); ofFill(); //ofSetColor(247,165,47); ofBeginShape(); ofVertex(448,533); ofVertex(348,360); ofVertex(367,349); ofVertex(467,522); ofVertex(448,533); ofEndShape(); ofPopMatrix(); // Bottom: ofPushMatrix(); ofTranslate(0, yPos); ofFill(); //ofSetColor(247,165,47); ofBeginShape(); ofVertex(661,533); ofVertex(461,533); ofVertex(461,511); ofVertex(661,511); ofVertex(661,533); ofEndShape(); ofPopMatrix(); // Bottom-right: ofPushMatrix(); ofTranslate(xPos, yPos); ofFill(); //ofSetColor(247,165,47); ofBeginShape(); ofVertex(671,527); ofVertex(652,516); ofVertex(752,343); ofVertex(771,354); ofVertex(671,527); ofEndShape(); ofPopMatrix(); // Top-right: ofPushMatrix(); ofTranslate(xPos, -yPos); ofFill(); //ofSetColor(247,165,47); ofBeginShape(); ofVertex(752,354); ofVertex(652,181); ofVertex(671,170); ofVertex(771,343); ofVertex(752,354); ofEndShape(); ofPopMatrix(); ofPopMatrix(); ofFill(); ofSetColor(255); } }
//-------------------------------------------------------------- void rm_music::draw(ofColor _collider){ if (currentLevel == thisLevel) { // Placeholder: draw the current level number onscreen: //ofDrawBitmapString(ofToString(thisLevel), ofGetWidth()/2, ofGetHeight()/2); collider = _collider; ofSetColor(collider); // Draw the boundary walls: ofRect(0, 0, ofGetWidth(), thickWall); // Top ofRect(0, 0, thickWall, ofGetHeight()); // Left // Draw the room contents: ofPushMatrix(); ofTranslate(0, 10); // Bottom of gramophone: ofFill(); //ofSetColor(255,255,255); ofBeginShape(); ofVertex(449,449); ofVertex(50,449); ofVertex(50,388); ofVertex(449,388); ofVertex(449,449); ofEndShape(); // Top of gramophone: ofFill(); //ofSetColor(255,255,255); ofBeginShape(); ofVertex(634,286); ofBezierVertex(617,299,560,256,507,189); ofBezierVertex(454,122,425,56,442,43); ofBezierVertex(459,29,516,72,569,140); ofBezierVertex(622,207,652,272,634,286); ofEndShape(); // Left side: // The line generated from the original image is not sufficient to prevent movement. So we draw a rectangle and rotate it to fill in for the line: //ofNoFill(); //ofSetLineWidth(5); //ofSetColor(0,0,0); /*ofBeginShape(); ofVertex(442,43); ofVertex(232,354); ofEndShape();*/ ofPushMatrix(); ofTranslate(232, 354); ofRotate(-56); ofRect(0,0, ofDist(232, 354, 442, 43), 15); ofPopMatrix(); // Right side: // The line generated from the original image is not sufficient to prevent movement. So we draw a rectangle and rotate it to fill in for the line: //ofNoFill(); //ofSetLineWidth(5); //ofSetColor(0,0,0); /*ofBeginShape(); ofVertex(620,288); ofVertex(345,363); ofEndShape();*/ ofPushMatrix(); ofTranslate(345, 363); ofRotate(-18); ofRect(0,0, ofDist(345, 363, 620, 288), 15); ofPopMatrix(); //ofNoFill(); ofSetLineWidth(1); //ofSetColor(0,0,0); ofBeginShape(); ofVertex(232,354); ofBezierVertex(232,354,213,372,204,376); ofBezierVertex(195,380,158,388,158,388); ofEndShape(); //ofNoFill(); ofSetLineWidth(1); //ofSetColor(0,0,0); ofBeginShape(); ofVertex(345,363); ofBezierVertex(345,363,333,372,346,377); ofBezierVertex(358,381,402,388,402,388); ofEndShape(); ofColor buttonStatus; if (pressedButton) { buttonStatus.r = 0; buttonStatus.g = 0; buttonStatus.b = 255; } else { buttonStatus.r = 255; buttonStatus.g = 1; buttonStatus.b = 0; } ofFill(); ofSetColor(buttonStatus); ofBeginShape(); ofVertex(99,423); ofVertex(78,423); ofVertex(78,414); ofVertex(99,414); ofVertex(99,423); ofEndShape(); ofPopMatrix(); ofSetColor(255); } }
//-------------------------------------------------------------- void ofApp::draw(){ ofPushMatrix(); ofRotateZ(rotation); ofRotate(rotation, xPos, yPos, 0); ofTranslate(xPos, yPos); ofRotate(rotation); ofScale(scaleFactor, scaleFactor); //petal1 ofBeginShape(); float x0 = 0; float x1 = x0 - petalWidth/2; float x2 = x0 - petalWidth/4; float x3 = x0; float y0 = 0; float y1 = y0 + petalLength/3; float y2 = y1 + petalLength/3; float y3 = y0 + petalLength; ofRotate(0, x0, y0, 30); ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); ofBeginShape(); x0 = 0; x1 = x0 + petalWidth/2; x2 = x0 + petalWidth/petalCurvature; x3 = x0; y0 = 0; y1 = y0 + petalLength/3; y2 = y1 + petalLength/3; y3 = y0 + petalLength; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //stem rectangle ofBeginShape(); ofRect(x0, y0 - (stemLength/2), stemWidth, stemLength); ofEndShape(); //petal2 ofBeginShape(); ofRotate(70, x0, y0, 30); x0 = 0; x1 = x0 - petal2Width/2; x2 = x0 - petal2Width/4; x3 = 0; y0 = 0; y1 = y0 + petal2Length/3; y2 = y1 + petal2Length/3; y3 = y0 + petal2Length; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); ofBeginShape(); x0 = 0; x1 = x0 + petal2Width/2; x2 = x0 + petal2Width/petalCurvature; x3 = 0; y0 = 0; y1 = y0 + petal2Length/3; y2 = y1 + petal2Length/3; y3 = y0 + petal2Length; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //petal3 ofBeginShape() ; ofRotate(70, x0, y0, 30); x0 = 0; x1 = x0 - petal3Width/2; x2 = x0 - petal3Width/4; x3 = x0; y0 = 0; y1 = y0 + petal3Length/3; y2 = y0 + petal3Length/3; y3 = y0 + petal3Length; ofVertex(x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); ofBeginShape(); x0 = 0; x1 = x0 + petal3Width/2; x2 = x0 + petal3Width/petalCurvature; x3 = x0; y0 = 0; y1 = y0 + petal3Length/3; y2 = y0 + petal3Length/3; y3 = y0 + petal3Length; ofVertex(x0, y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //petal4 ofBeginShape() ; ofRotate(80, x0, y0, 30); x0 = 0; x1 = x0 - petalWidth/2; x2 = x0 - petalWidth/4; x3 = x0; y0 = 0; y1 = y0 + petalLength/3; y2 = y0 + petalLength/3; y3 = y0 + petalLength; ofVertex(x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); ofBeginShape(); x0 = 0; x1 = x0 + petalWidth/2; x2 = x0 + petalWidth/petalCurvature; x3 = x0; y0 = 0; y1 = y0 + petalLength/3; y2 = y0 + petalLength/3; y3 = y0 + petalLength; ofVertex(x0, y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //petal5 ofBeginShape() ; ofRotate(70, x0, y0, 20); x0 = 0; x1 = x0 - petal4Width/2; x2 = x0 - petal4Width/4; x3 = x0; y0 = 0; y1 = y0 + petal4Length/3; y2 = y0 + petal4Length/3; y3 = y0 + petal4Length; ofVertex(x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); ofBeginShape(); x0 = 0; x1 = x0 + petal4Width/2; x2 = x0 + petal4Width/petalCurvature; x3 = x0; y0 = 0; y1 = y0 + petal4Length/3; y2 = y0 + petal4Length/3; y3 = y0 + petal4Length; ofVertex(x0, y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); ofPopMatrix(); }
//-------------------------------------------------------------- void Leaf::draw(){ // DRAW LEAF / STEM / FRUIT ofPushMatrix(); ofTranslate(xPos, yPos); // Set Center Point to xPos and yPos. //------0. Do Rotation and Scale------// ofRotateZ(rotation); ofScale(scaleFactor, scaleFactor); //------1. Draw Left Leaf------// ofBeginShape(); ofSetColor(leafColorLeft); // Set Color Green to Leaf. // Set x Values of Bezier float x0 = 0; float x1 = x0-leafWidth/2; float x2 = x0-leafWidth/4; float x3 = x0; // Set y Values of Bezier float y0 = (2*stemHeight)/3; float y1 = y0+leafHeight/3; float y2 = y0+(2*leafHeight)/3; float y3 = y0+leafHeight; ofVertex(x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); //-----2. Draw Right Leaf-----// ofBeginShape(); ofSetColor(leafColorRight); // Set x Values of Bezier x0 = 0; x1 = x0+leafWidth/2; x2 = x0+leafWidth/4; x3 = x0; // Set y Values of Bezier y0 = (2*stemHeight)/3; y1 = y0+leafHeight/3; y2 = y0+(2*leafHeight)/3; y3 = y0+leafHeight; ofVertex(x0, y0); ofBezierVertex(x1, y1, x2, y2, x3, y3); ofEndShape(); //-----3. Draw Stem Body-----// ofSetColor(stemColor); //Set Color Brown to Stem. ofRect(0, 0+stemHeight/2, stemWidth, stemHeight); //-----4. Draw Stem Head-----// ofTriangle(0-stemWidth/2, 0+stemHeight, 0+stemWidth/2, 0+stemHeight, 0, 0+stemHeight+leafHeight/3); //-----5. Draw Fruits No.01-----// ofSetColor(fruitColorOne); ofCircle(fruitXPosOne, fruitYPosOne, fruitRadiusOne); //-----6. Draw Fruits No.02-----// ofSetColor(fruitColorTwo); ofCircle(fruitXPosTwo, fruitYPosTwo, fruitRadiusTwo); //-----7. Draw Root ofSetColor(stemColor); ofCircle(0, 0, stemWidth/2); ofPopMatrix(); }
void ofxSymbolInstance::drawLayer(layer *ly,float alpha) { if (!ly) { return; } ofPushMatrix(); glMultMatrixf(mat.getPtr()); frame &f = ly->frames[ly->currentFrame]; for (vector<ofxSymbolInstance>::iterator iter=f.instances.begin(); iter!=f.instances.end(); iter++) { if (iter->bVisible) { switch (iter->type) { case BITMAP_INSTANCE: { ofPushMatrix(); glMultMatrixf(iter->mat.getPtr()); ofSetColor(255, 255, 255,alpha*alphaMultiplier*255.0); iter->bitmapItem->draw(); ofSetColor(255, 255, 255,255); ofPopMatrix(); } break; case SHAPE: { ofxShape &shape = symbolItem->shapes[iter->shapeIndex]; if (!shape.curve.empty()) { vector<curvePath>::iterator citer=shape.curve.begin(); ofBeginShape(); ofVertex(citer->p0.x,citer->p0.y); for (vector<vector<ofVec2f> >::iterator iter=citer->segments.begin(); iter!=citer->segments.end(); iter++) { ofBezierVertex(iter->at(0).x,iter->at(0).y,iter->at(1).x,iter->at(1).y,iter->at(2).x,iter->at(2).y); } ofEndShape(); } if (!shape.line.empty()) { //linePath l = shape.line.front(); vector<linePath>::iterator liter = shape.line.begin(); if (liter->bClosed) { if (!shape.solidColorFill.empty()) { ofPushStyle(); ofSetHexColor(shape.solidColorFill.front()); ofFill(); ofBeginShape(); ofVertex(liter->p0.x,liter->p0.y); for (vector<ofVec2f>::iterator iter=liter->segments.begin(); iter!=liter->segments.end()-1; iter++) { // roikr: we don't need the end ofVertex(iter->x,iter->y); } ofEndShape(); ofPopStyle(); }; if (!shape.solidColorStroke.empty()) { ofPushStyle(); ofSetHexColor(shape.solidColorStroke.front()); ofNoFill(); ofBeginShape(); ofVertex(liter->p0.x,liter->p0.y); for (vector<ofVec2f>::iterator iter=liter->segments.begin(); iter!=liter->segments.end(); iter++) { ofVertex(iter->x,iter->y); } ofEndShape(); ofPopStyle(); }; if (!shape.bitmapFill.empty()) { ofxBitmapFill &bitmapFill = shape.bitmapFill.front(); // // glEnable(GL_SCISSOR_TEST); // ofRectangle &rect = bitmapFill.rect; // //#ifndef TARGET_OPENGLES // ofVec2f p = (ofVec2f(rect.x,rect.y+rect.height)+doc->offset)*doc->zoom+0.5*ofVec2f(ofGetWidth(),ofGetHeight()); // // glScissor(p.x, ofGetHeight()-p.y, rect.width*doc->zoom , rect.height*doc->zoom); // //#else // ofVec2f q = (ofVec2f(rect.x+rect.width,rect.y+rect.height)+offset)*zoom+0.5*ofVec2f(ofGetWidth(),ofGetHeight()); // ofVec2f p = ofVec2f(ofGetHeight(),ofGetWidth())-ofVec2f(q.y,q.x); // // glScissor(p.x, p.y, rect.height*zoom , rect.width*zoom); //#endif ofPushMatrix(); glMultMatrixf(bitmapFill.mat.getPtr()); bitmapFill.bitmapItem->draw(); ofPopMatrix(); // glDisable(GL_SCISSOR_TEST); } } else { if (!shape.solidColorStroke.empty()) { ofPushStyle(); ofSetHexColor(shape.solidColorStroke.front()); ofLine(liter->p0, liter->segments.front()); for (vector<ofVec2f>::iterator iter=liter->segments.begin(); iter!=liter->segments.end()-1; iter++) { ofLine(*iter, *(iter+1)); } ofPopStyle(); } } } } break; case SYMBOL_INSTANCE: iter->draw(alpha*alphaMultiplier); break; default: break; } } } ofPopMatrix(); /* ofPushStyle(); for (vector<tlfText>::iterator titer=ly.texts.begin();titer!=ly.texts.end();titer++) { float v = 0; for (vector<span>::iterator iter=titer->spans.begin(); iter!=titer->spans.end(); iter++) { ofPushMatrix(); // ofTranslate(titer->translation+ofVec2f(0,v+iter->fontSize)); ofTranslate(titer->translation+ofVec2f(0,v+(float)font.stringHeight(iter->text)*(float)iter->fontSize/(float)font.getSize())); float scale = (float)iter->fontSize/(float)font.getSize(); ofScale(scale, scale); ofSetHexColor(iter->color); font.drawString(iter->text, 0, 0); ofPopMatrix(); v+= (float)iter->fontSize*lineHeight; } } ofPopStyle(); */ }
//-------------------------------------------------------------- void Leaf::draw(){ //DRAW STUFF // ofRect(xPos, yPos, 20, 40); //Draw leave //draw leaf left ofPushMatrix(); ofTranslate(xPos, yPos); ofRotateZ(rotation); ofScale(scaleFactor, scaleFactor); ofSetColor(leafColor); ofBeginShape(); float x0 = 0; float x1 = x0 - leafWidth/2; float x2 = x0 - leafWidth/4; float x3 = 0; float y0 = 0 + stemLength; float y1 = y0 + leafLength/3; float y2 = y1 + leafLength/3; float y3 = y0 + leafLength; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //draw leaf right ofBeginShape(); x0 = 0; x1 = x0 + leafWidth/2; x2 = x0 + leafWidth/4; x3 = 0; y0 = 0 + stemLength; y1 = y0 + leafLength/3; y2 = y1 + leafLength/3; y3 = y0 + leafLength; ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); //draw stem ofSetColor(stemColor); ofRect(0, 0 + stemLength/2, stemWidth, stemLength); //triangular stem through leaf ofTriangle(0 - stemWidth/2, 0 + stemLength, 0 + stemWidth/2, 0 + stemLength, 0, 0 + stemLength + 2*(leafLength/3)); ofPopMatrix(); }
//-------------------------------------------------------------- void ofApp::draw(){ ofBackground(235, 180, 68); ofSetColor(255); background.draw(-165, -8); ofSetColor(255); orangeBackground.draw(273,221); for(int i=0; i<numLines; i++){ lines[i].draw(); } for(int i=0; i<numLittleSquares; i++){ dressSquares[i].draw(); } //image of green circle on dress ofSetColor(255); ofEnableAlphaBlending(); greenCircle.draw(376.496,333); for(int i=0; i<numSmallCircles; i++){ smallCircles[i].draw(); } for(int i=0; i<numBigCirclesDress; i++){ //check to see if they have overlapped bigCircles[i].draw(); } ofBeginShape(); ofVertex(132,213); ofBezierVertex(132,213,137,172,137,163); ofBezierVertex(136,154,124,87,133,73); ofBezierVertex(142,58,159,27,166,26); ofBezierVertex(174,24,180,22,183,20); ofBezierVertex(186,18,189,15,212,9); ofBezierVertex(236,3,261,-2,267,-3); ofBezierVertex(273,-3,294,-9,303,-9); ofBezierVertex(312,-9,364,-9,388,-8); ofBezierVertex(413,-7,450,0,462,5); ofBezierVertex(474,9,506,31,515,45); ofBezierVertex(524,58,534,67,536,75); ofBezierVertex(538,83,541,90,545,96); ofBezierVertex(549,102,555,133,555,133); ofBezierVertex(555,133,555,159,554,163); ofBezierVertex(554,167,544,195,540,207); ofBezierVertex(536,219,531,239,532,245); ofBezierVertex(534,251,543,295,550,311); ofBezierVertex(558,327,572,369,576,373); ofBezierVertex(580,378,582,397,584,401); ofBezierVertex(585,406,594,451,594,457); ofBezierVertex(594,464,592,488,592,495); ofBezierVertex(593,501,597,527,603,537); ofBezierVertex(609,546,616,564,616,568); ofBezierVertex(616,572,613,583,622,593); ofBezierVertex(632,602,624,615,624,619); ofBezierVertex(625,623,631,635,629,641); ofBezierVertex(627,648,618,662,618,668); ofBezierVertex(618,674,625,692,632,700); ofBezierVertex(638,708,637,739,637,739); ofBezierVertex(637,739,610,738,585,752); ofBezierVertex(559,765,531,789,516,794); ofBezierVertex(501,798,490,792,486,798); ofBezierVertex(481,804,462,824,451,830); ofBezierVertex(441,836,361,858,352,855); ofBezierVertex(343,852,321,860,306,861); ofBezierVertex(291,863,264,870,250,863); ofBezierVertex(237,855,229,849,220,849); ofBezierVertex(211,849,190,849,183,840); ofBezierVertex(175,831,168,797,166,788); ofBezierVertex(165,779,145,734,145,720); ofBezierVertex(145,707,138,687,138,677); ofBezierVertex(138,666,133,659,133,648); ofBezierVertex(133,638,130,620,130,620); ofBezierVertex(130,620,131,599,131,594); ofBezierVertex(130,589,126,571,126,565); ofBezierVertex(126,560,127,544,127,544); ofBezierVertex(127,544,123,528,123,523); ofBezierVertex(123,517,125,481,125,470); ofBezierVertex(125,459,118,406,119,386); ofBezierVertex(121,365,127,246,127,238); ofBezierVertex(128,230,132,213,132,213); ofNextContour(true); //beginning point ofFill(); ofVertex(471,309); ofBezierVertex(471,309,435,309,412,309); ofBezierVertex(389,309,334,298,334,298); ofBezierVertex(334,298,328,314,325,330); ofBezierVertex(322,346,333,372,333,387); ofBezierVertex(333,402,331,416,331,426); ofBezierVertex(331,436,350,493,358,510); ofBezierVertex(366,527,381,560,385,568); ofBezierVertex(389,576,381,613,381,627); ofBezierVertex(381,641,398,662,400,675); ofBezierVertex(402,688,386,739,382,753); ofBezierVertex(378,767,380,798,380,798); ofVertex(472,796); ofBezierVertex(472,796,472,752,473,740); ofBezierVertex(474,728,460,681,455,673); ofBezierVertex(450,665,446,652,446,644); ofBezierVertex(446,636,464,598,466,587); ofBezierVertex(468,576,463,548,459,536); ofBezierVertex(455,524,448,496,450,487); ofBezierVertex(452,478,472,382,475,366); ofBezierVertex(478,350,475,309,475,309); ofVertex(471,309); ofEndShape(); //image of arm ofSetColor(255); ofEnableAlphaBlending(); arm.draw(329, 274); //image of under spirals ofSetColor(255); ofEnableAlphaBlending(); spiralBackground.draw(424,203,291, 820); //heads image ofSetColor(255); heads.draw(210,-5); //spiral for(int i=0; i<numSpirals; i++){ spirals[i].draw(); } // ofPushMatrix(); // ofTranslate(100,300,0); // ofSetHexColor(0xff2220); // ofFill(); // ofSetPolyMode(OF_POLY_WINDING_ODD); // ofBeginShape(); // float angleStep = TWO_PI/(100.0f + sin(ofGetElapsedTimef()/5.0f) * 60); // float radiusAdder = 0.5f; // float radius = 0; // for (int i = 0; i < 200; i++){ // float anglef = (i) * angleStep; // float x = radius * cos(anglef); // float y = radius * sin(anglef); // ofVertex(x,y); // radius += radiusAdder; // } // ofEndShape(); // ofPopMatrix(); // guy image ofSetColor(255); ofEnableAlphaBlending(); man.draw(-165, -8); }