void ofxNDCircularGradient(float radius, const ofColor & start, const ofColor & end) { int n = 32; // circular gradient resolution static ofMesh _nd_cg_mesh; _nd_cg_mesh.clear(); _nd_cg_mesh.setMode(OF_PRIMITIVE_TRIANGLE_FAN); ofVec2f center(0,0); _nd_cg_mesh.addVertex(center); float angleBisector = TWO_PI / (n * 2); float smallRadius = radius; float bigRadius = smallRadius / cos(angleBisector); for(int i = 0; i <= n; i++) { float theta = i * TWO_PI / n; _nd_cg_mesh.addVertex(center + ofVec2f(sin(theta), cos(theta)) * bigRadius); } _nd_cg_mesh.clearColors(); _nd_cg_mesh.addColor(start); for(int i = 0; i <= n; i++) { _nd_cg_mesh.addColor(end); } _nd_cg_mesh.draw(); }
void update() { mesh.clear(); float t = ofGetElapsedTimef() * 0.3; float noise_scale = 0.05; float size = 300; float shape_size = 200; int num = 100; for (int i = 0; i < num; i++) { ofVec3f base(ofSignedNoise(10, 0, 0, i * noise_scale + t), ofSignedNoise(0, 10, 0, i * noise_scale + t), ofSignedNoise(0, 0, 10, i * noise_scale + t)); ofVec3f v0(ofSignedNoise(1, 0, 0, i * noise_scale + t), ofSignedNoise(0, 1, 0, i * noise_scale + t), ofSignedNoise(0, 0, 1, i * noise_scale + t)); ofVec3f v1(ofSignedNoise(2, 0, 0, i * noise_scale + t), ofSignedNoise(0, 2, 0, i * noise_scale + t), ofSignedNoise(0, 0, 2, i * noise_scale + t)); ofVec3f v2(ofSignedNoise(3, 0, 0, i * noise_scale + t), ofSignedNoise(0, 3, 0, i * noise_scale + t), ofSignedNoise(0, 0, 3, i * noise_scale + t)); float hue = ofMap(i, 0, num, 0, 1); ofFloatColor c = ofFloatColor::fromHsb(hue, 1, 1); float s = fabs(sin(i * 0.1 + t)) + 0.1; mesh.addColor(c); mesh.addColor(c); mesh.addColor(c); mesh.addVertex(base * size + v0 * shape_size * s); mesh.addVertex(base * size + v1 * shape_size * s); mesh.addVertex(base * size + v2 * shape_size * s); } IndexColor::convertColorToTexCoord(mesh); // export to abc abc_out.addPolyMesh("/mesh", mesh); }
//http://www.packtpub.com/sites/default/files/9781849518048_Chapter_07.pdf //knotExample void ofApp::addCircle( ofVec3f nextPoint, ofMesh &mesh ){ float time = ofGetElapsedTimef(); //Time //Parameters – twisting and rotating angles and color ofFloatColor color( ofNoise( time * 0.05 ), ofNoise( time * 0.1 ), ofNoise( time * 0.15 )); color.setSaturation( 1.0 ); //Make the color maximally //Add vertices for (int i=0; i<circleN; i++) { float angle = float(i) / circleN * TWO_PI+(PI*0.25); float x = Rad * cos( angle ); float y = Rad * sin( angle ); ofPoint p = nextPoint+ofVec3f(x ,y , 0); mesh.addVertex( p ); mesh.addColor( color ); } //Add the triangles int base = mesh.getNumVertices() - 2 * circleN; if ( base >= 0 ) { //Check if it is not the first step //and we really need to add the triangles for (int i=0; i<circleN; i++) { int a = base + i; int b = base + (i + 1) % circleN; int c = circleN + a; int d = circleN + b; mesh.addTriangle(a,b,d); mesh.addTriangle(a, d, c); } //Update the normals setNormals( mesh ); } }
//-------------------------------------------------------------- void ofApp::colorFaces(ofMesh & mesh){ for(int i = 0; i < mesh.getVertices().size(); i++){ const ofVec3f & v = mesh.getVertices()[i]; ofColor col; col.setHsb(ofMap(v.x + v.y, -1000, 1000, 0, 255), 255, 255); mesh.addColor(col); } }
//-------------------------------------------------------------- void testApp::draw(){ fbo.begin(); ofSetTextureWrap(GL_REPEAT,GL_REPEAT); fbfbo.draw(0,2); //cam.draw(0,0); fbfbo.getTextureReference().bind(); trik2.draw(); fbfbo.getTextureReference().unbind(); ofSetColor(255,255,255); if(tritimer>tritimerlimit){ float xpt, ypt,xtoff,ytoff; //draw gradient splashes ofMesh trik; for(int b = 0;b<5;b++){ xtoff = ofRandomf()*0.5; ytoff = ofRandomf()*0.5; for(int i=0;i<3;i++){ xpt = ofRandomuf()*2+xtoff; ypt = ofRandomuf()*2+ytoff; trik.addVertex(ofVec3f(xpt*w,ypt*h,0)); trik.addColor(ofFloatColor(float(ofRandomuf()>0.5)*0.6+0.4,float(ofRandomuf()>0.5)*0.5+0.5,float(ofRandomuf()>0.5)*0.7+0.3)); } } trik.draw(); tritimer = 0; tritimerlimit= ofRandom(20,200); } if(tritimer2>45){ //re-generate the feedback triangles float xpt, ypt,xoff,yoff,xtoff,ytoff; trik2.clear(); //ofEnableNormalizedTexCoords(); for(int b = 0;b<5;b++){ xoff = ofRandomf()*0.1; yoff = ofRandomf()*0.1; xtoff = ofRandomf()*0.5; ytoff = ofRandomf()*0.5; for(int i=0;i<3;i++){ xpt = ofRandomuf()+xtoff; ypt = ofRandomuf()+ytoff; trik2.addVertex(ofVec3f((xpt+xoff)*w,(ypt+yoff)*h,0)); trik2.addTexCoord(ofVec2f(xpt*w,ypt*h)); trik2.addColor(ofFloatColor(1,1,1)); } } tritimer2=0; tritimer2limit= ofRandom(20,200); //ofDisableNormalizedTexCoords(); } fbo.end(); fbfbo.begin(); fbo.draw(0,0); fbfbo.end(); fbo.draw(0,0); }
void Particle::addToMesh(ofMesh & mesh, unsigned long long systemTime) { float pct; switch(state) { case INACTIVE: break; case BORN: mesh.addColor(ofColor(baseColor)); mesh.addVertex(location); break; case FALLING: pct = 1 - ofMap(systemTime - bornTime, BORN_TIMEOUT_MS, FALL_TIMEOUT_MS, 0,1,true); curColor = baseColor * pct; mesh.addColor(curColor); mesh.addVertex(location); break; default: break; } }
//-------------------------------------------------------------- void addFace(ofMesh& mesh, ofVec3f a, ofFloatColor aC, ofVec3f b, ofFloatColor bC, ofVec3f c, ofFloatColor cC) { ofVec3f normal = ((b - a).cross(c - a)).normalize() * -1.0; mesh.addNormal(normal); mesh.addColor(aC); mesh.addVertex(a); mesh.addNormal(normal); mesh.addColor(bC); mesh.addVertex(b); mesh.addNormal(normal); mesh.addColor(cC); mesh.addVertex(c); }
OFX_OBJLOADER_BEGIN_NAMESPACE void load(string path, ofMesh& mesh, bool generateNormals, bool flipFace) { path = ofToDataPath(path); mesh.clear(); GLMmodel* m; m = glmReadOBJ((char*)path.c_str()); if (generateNormals) { glmFacetNormals(m); glmVertexNormals(m, 90); } if (flipFace) { glmReverseWinding(m); } for (int j = 0; j < m->numtriangles; j++) { const GLMtriangle &tri = m->triangles[j]; for (int k = 0; k < 3; k++) { GLfloat *v = m->vertices + (tri.vindices[k] * 3); mesh.addVertex(ofVec3f(v[0], v[1], v[2])); if (m->colors) { GLfloat *c = m->colors + (tri.vindices[k] * 3); mesh.addColor(ofFloatColor(c[0], c[1], c[2])); } if (m->normals && ofInRange(tri.nindices[k], 0, m->numnormals)) { GLfloat *n = m->normals + (tri.nindices[k] * 3); mesh.addNormal(ofVec3f(n[0], n[1], n[2])); } if (m->texcoords && ofInRange(tri.tindices[k], 0, m->numtexcoords)) { GLfloat *c = m->texcoords + (tri.tindices[k] * 2); mesh.addTexCoord(ofVec2f(c[0], c[1])); } } } glmDelete(m); }
//-------------------------------------------------------------- ofMesh testApp::pixelManipulate(ofImage imageA, ofMesh meshA, float intensityThreshold, float sketchDepth){ imageA.resize(200, 200); //create mesh with points as the primitive //meshA.setMode(OF_PRIMITIVE_POINTS); //create a mesh with lines meshA.setMode(OF_PRIMITIVE_LINE_LOOP); //meshA.setMode(OF_PRIMITIVE_LINE_STRIP); int w = imageA.getWidth(); int h = imageA.getHeight(); //loop through each pixel in the image using image width & height for (int x=0; x<w; x++){ for(int y=0; y<h; y++){ //create the color object at that pixel //ofColor c = imageA.getColor(x, y); ofColor c = imageA.getColor(x, y); //check the intensity of the pixel's color float intensity = c.getLightness(); //if the intensity exceeds the threshold, create a vertex at the location of the pixel //& color it with the pixel's color if (intensity >= intensityThreshold){ //pushes brighter colors in the positive z direction //pushes whiter colors in the negative z direction float saturation = c.getSaturation(); float z = ofMap(saturation, 0, 255, -sketchDepth, sketchDepth); //the image is now 1/4 the size of the OF window, so multiply //the pixel location by 4 so that the mesh covers the OF window ofVec3f pos(5*x, 4*y, z); meshA.addVertex(pos); meshA.addColor(c); } } } return meshA; }
void CloudsVisualSystemTunnelDrawing::drawRibbonTrail(const RibbonTrail& trail, ofMesh& geo){ for(int i = 1; i < trail.points.size(); i++){ //find this point and the next point ofVec3f thisPoint = trail.points[i-1]; ofVec3f nextPoint = trail.points[i]; //get the direction from one to the next. //the ribbon should fan out from this direction ofVec3f direction = (nextPoint - thisPoint); //direction.z = 0; //get the distance from one point to the next float distance = direction.length(); //get the normalized direction. normalized vectors always have a length of one //and are really useful for representing directions as opposed to something with length ofVec3f unitDirection = direction.normalized(); //find both directions to the left and to the right ofVec3f toTheLeft = unitDirection.getRotated(-90, ofVec3f(0,0,1)); ofVec3f toTheRight = unitDirection.getRotated(90, ofVec3f(0,0,1)); //use the map function to determine the distance. //the longer the distance, the narrower the line. //this makes it look a bit like brush strokes float thickness = ofMap(distance, distanceRange.min, distanceRange.max, thicknessRange.max, thicknessRange.min, true); //calculate the points to the left and to the right //by extending the current point in the direction of left/right by the length ofVec3f leftPoint = thisPoint + toTheLeft * thickness; ofVec3f rightPoint = thisPoint + toTheRight * thickness; if(i == 1){ geo.addColor(ofFloatColor(0,0,0,0)); geo.addVertex(ofVec3f(leftPoint.x, leftPoint.y, leftPoint.z)); geo.addColor(ofFloatColor(0,0,0,0)); geo.addVertex(ofVec3f(rightPoint.x, rightPoint.y, rightPoint.z)); } //add these points to the triangle strip geo.addColor(ofFloatColor::white); geo.addVertex(ofVec3f(leftPoint.x, leftPoint.y, leftPoint.z)); geo.addColor(ofFloatColor::white); geo.addVertex(ofVec3f(rightPoint.x, rightPoint.y, rightPoint.z)); if( i == trail.points.size()-1 ){ geo.addColor(ofFloatColor(0,0,0,0)); geo.addVertex(ofVec3f(leftPoint.x, leftPoint.y, leftPoint.z)); geo.addColor(ofFloatColor(0,0,0,0)); geo.addVertex(ofVec3f(rightPoint.x, rightPoint.y, rightPoint.z)); } } }
//-------------------------------------------------------------- static void aiMeshToOfMesh(const aiMesh* aim, ofMesh& ofm, ofxAssimpMeshHelper * helper = NULL){ // default to triangle mode ofm.setMode(OF_PRIMITIVE_TRIANGLES); // copy vertices for (int i=0; i < (int)aim->mNumVertices;i++){ ofm.addVertex(ofVec3f(aim->mVertices[i].x,aim->mVertices[i].y,aim->mVertices[i].z)); } if(aim->HasNormals()){ for (int i=0; i < (int)aim->mNumVertices;i++){ ofm.addNormal(ofVec3f(aim->mNormals[i].x,aim->mNormals[i].y,aim->mNormals[i].z)); } } // aiVector3D * mTextureCoords [AI_MAX_NUMBER_OF_TEXTURECOORDS] // just one for now if(aim->GetNumUVChannels()>0){ for (int i=0; i < (int)aim->mNumVertices;i++){ if( helper != NULL && helper->texture.getWidth() > 0.0 ){ ofVec2f texCoord = helper->texture.getCoordFromPercent(aim->mTextureCoords[0][i].x ,aim->mTextureCoords[0][i].y); ofm.addTexCoord(texCoord); }else{ ofm.addTexCoord(ofVec2f(aim->mTextureCoords[0][i].x ,aim->mTextureCoords[0][i].y)); } } } //aiColor4D * mColors [AI_MAX_NUMBER_OF_COLOR_SETS] // just one for now if(aim->GetNumColorChannels()>0){ for (int i=0; i < (int)aim->mNumVertices;i++){ ofm.addColor(aiColorToOfColor(aim->mColors[0][i])); } } for (int i=0; i <(int) aim->mNumFaces;i++){ if(aim->mFaces[i].mNumIndices>3){ ofLog(OF_LOG_WARNING,"non-triangular face found: model face # " + ofToString(i)); } for (int j=0; j<(int)aim->mFaces[i].mNumIndices; j++){ ofm.addIndex(aim->mFaces[i].mIndices[j]); } } ofm.setName(string(aim->mName.data)); // ofm.materialId = aim->mMaterialIndex; }
void TextWriter::addGlyphToMesh(Letter &letter, ofRectangle box, ofMesh& mesh) { //float randomness = 0.05; for( int i = 0; i < letter.points.size(); i++ ) { ofVec3f v; v.x = box.x + ofMap(letter.points[i].x + ofRandom(-lineRandomness, lineRandomness), 0, glyphWidth, 0, box.width); v.y = box.y + ofMap(letter.points[i].y + ofRandom(-lineRandomness, lineRandomness), 0, glyphHeight, 0, box.height); mesh.addVertex(v); ofColor vcolor(colour); vcolor.setBrightness(vcolor.getBrightness() * ofRandom(colourFlickerMin, 1)); mesh.addColor(vcolor); } }
void ofxAutoColorMesh(ofMesh &mesh) { for (int i=0; i<mesh.getNumVertices(); i++) { ofVec3f v = mesh.getVertex(i).normalized(); mesh.addColor(ofFloatColor(v.x,v.y,v.z)); } }
void ofxPolyvox::polyvoxToOfMesh(const PolyVox::SurfaceMesh<PositionMaterialNormal>& surfaceMesh, ofMesh& polyvxToOfMesh, bool setColor){ //Convienient access to the vertices and indices const vector<uint32_t>& vecIndices = surfaceMesh.getIndices(); const vector<PositionMaterialNormal>& vecVertices = surfaceMesh.getVertices();//surfaceMesh.getRawVertexData(); ofIndexType ofVecIndices; const void* pIndices = static_cast<const void*>(&(vecIndices[0])); int* indices = (int*)pIndices; vector<int> indx; for (int i = 0; i < surfaceMesh.getNoOfIndices(); i++ ){ indx.push_back(indices[i]); //cout << "indices:" << indices[i] << endl; polyvxToOfMesh.addIndex(indx[i]); } ofLog(OF_LOG_NOTICE, "ofMesh: number of indices is %d", polyvxToOfMesh.getNumIndices()); ofVec3f ofVecVertices; for (int i = 0; i < surfaceMesh.getNoOfVertices(); i++ ){ PositionMaterialNormal vert0 = vecVertices[i]; ofVecVertices = ofVec3f(vert0.getPosition().getX(),vert0.getPosition().getY(),vert0.getPosition().getZ()); polyvxToOfMesh.addVertex(ofVecVertices); } ofLog(OF_LOG_NOTICE, "ofMesh: number of vertices is %d", polyvxToOfMesh.getNumVertices()); ofVec3f ofVecNormals; for (int i = 0; i < surfaceMesh.getNoOfVertices(); i++ ){ PositionMaterialNormal vert0 = vecVertices[i]; ofVecNormals = ofVec3f(vert0.getNormal().getX(),vert0.getNormal().getY(),vert0.getNormal().getZ()); polyvxToOfMesh.addNormal(ofVecNormals); } ofLog(OF_LOG_NOTICE, "ofMesh: number of normals is %d", polyvxToOfMesh.getNumNormals()); if(setColor){ for (int i = 0; i < surfaceMesh.getNoOfVertices(); i++ ){ PositionMaterialNormal vert0 = vecVertices[i]; uint8_t material = static_cast<uint8_t>(vert0.getMaterial() + 0.5); //cout << "material:" << int(material) << endl; ofFloatColor colour = convertMaterialIDToColour(material); //cout << colour << endl; polyvxToOfMesh.addColor(colour); bool col = polyvxToOfMesh.hasColors(); //cout << "hasColors:" << col << endl; } } }
void FlockMember::draw(ofMesh & pointsMesh, ofMesh &forcesMesh){ if (!enabled) return; if (false){ //3d model orientation glPushMatrix(); glTranslatef( pos.x, pos.y, pos.z ); ofQuaternion rot; rot.makeRotate(vel.normalized(), ofVec3f(1,0,0) ); ofVec3f r = rot.getEuler(); glRotatef( -r.y, 0, 1, 0); glRotatef( -r.x, 0, 0, 1); //glRotatef( -r.z, 1, 0, 0); ofSetColor(c); //model->draw(); glPopMatrix(); }else{ ofSetColor(c); //ofSphere(pos, 0.1); pointsMesh.addColor(c); pointsMesh.addVertex(pos); } //ofSetColor(c); float gain = 30; if (params->debugShowDirection){ ofColor cc = ofColor::yellow; forcesMesh.addColor(cc); forcesMesh.addVertex(pos); cc.a = 0; forcesMesh.addColor(cc); forcesMesh.addVertex(pos + vel); } if (params->debugShowCollisions){ ofColor cc = ofColor::red; forcesMesh.addColor(cc); forcesMesh.addVertex(pos); cc.a = 0; forcesMesh.addColor(cc); forcesMesh.addVertex(pos + avoidNeigbhors * gain); } if (params->debugShowCohesion){ ofColor cc = ofColor::blue; forcesMesh.addColor(cc); forcesMesh.addVertex(pos); cc.a = 0; forcesMesh.addColor(cc); forcesMesh.addVertex(pos + groupCohesion * gain); } if (params->debugShowSchooling){ ofColor cc = ofColor::magenta; forcesMesh.addColor(cc); forcesMesh.addVertex(pos); cc.a = 0; forcesMesh.addColor(cc); forcesMesh.addVertex(pos + schoolSameColor * gain); cc = ofColor::cyan; forcesMesh.addColor(cc); forcesMesh.addVertex(pos); cc.a = 0; forcesMesh.addColor(cc); forcesMesh.addVertex(pos + schoolDifferentColor * gain); } float ballAlpha = 128; if (params->debugCohesionDist){ ofNoFill(); ofSetColor(0,0,255,ballAlpha ); ofSphere(pos, params->cohesionDist * 0.5f); ofFill(); } if (params->debugCollisionDist){ ofNoFill(); ofSetColor(255,0,0,ballAlpha ); ofSphere(pos, params->collisionDist * 0.5f); ofFill(); } if (params->debugSchoolingFriendsDist){ ofNoFill(); ofSetColor(255,0,255,ballAlpha ); ofSphere(pos, params->schoolFriendsDist * 0.5f); ofFill(); } if (params->debugSchoolingOthersDist){ ofNoFill(); ofSetColor(0,255,255,ballAlpha ); ofSphere(pos, params->schoolOthersDist * 0.5f); ofFill(); } // ofSetColor(255); // ofDrawBitmapString(ofToString(vel), pos); }
void BGGraphics::pushVertex(ofMesh & mesh, float x, float y, float z, float nx, float ny, float nz, float offsetX, float offsetY) { mesh.addVertex(ofVec3f(x, y, z)); mesh.addNormal(ofVec3f(nx, ny, nz)); mesh.addTexCoord(ofVec2f(offsetX, offsetY)); mesh.addColor(ofFloatColor(255, 255, 255)); }