C++ ofMesh::addColor方法代码示例

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();
//.........这里部分代码省略.........