C++ TriMesh::appendNormal方法代码示例

void TerrainApp::addQuad( int x, int y )
{
	Vec2f p00( x, y );
	Vec2f p10( x + 1, y );
	Vec2f p11( x + 1, y + 1 );
	Vec2f p01( x, y + 1 );

	float zScale = mHeight;
	float noiseScale = mNoiseScale;
	float z00 = zScale * mPerlin.fBm( p00 * noiseScale );
	float z10 = zScale * mPerlin.fBm( p10 * noiseScale );
	float z11 = zScale * mPerlin.fBm( p11 * noiseScale );
	float z01 = zScale * mPerlin.fBm( p01 * noiseScale );

	size_t idx = mTriMesh.getNumVertices();

	// positions
	Vec3f t00( p00.x - xSize / 2., z00, p00.y - ySize / 2. );
	Vec3f t10( p10.x - xSize / 2., z10, p10.y - ySize / 2. );
	Vec3f t11( p11.x - xSize / 2., z11, p11.y - ySize / 2. );
	Vec3f t01( p01.x - xSize / 2., z01, p01.y - ySize / 2. );

	mTriMesh.appendVertex( t00 );
	mTriMesh.appendVertex( t10 );
	mTriMesh.appendVertex( t01 );

	mTriMesh.appendVertex( t10 );
	mTriMesh.appendVertex( t11 );
	mTriMesh.appendVertex( t01 );

	// normals
	Vec3f n0 = ( t10 - t00 ).cross( t10 - t01 ).normalized();
	Vec3f n1 = ( t11 - t10 ).cross( t11 - t01 ).normalized();
	mTriMesh.appendNormal( n0 );
	mTriMesh.appendNormal( n0 );
	mTriMesh.appendNormal( n0 );
	mTriMesh.appendNormal( n1 );
	mTriMesh.appendNormal( n1 );
	mTriMesh.appendNormal( n1 );

	mTriMesh.appendTriangle( idx, idx + 1, idx + 2 );
	mTriMesh.appendTriangle( idx + 3, idx + 4, idx + 5 );
}

void SmoothDisplacementMappingApp::createMesh()
{
	// use the TriMesh class to easily construct the vertex buffer object
	TriMesh mesh;

	// create vertex, normal and texcoord buffers
	const int RES_X = 400;
	const int RES_Z = 100;
	const Vec3f size(200.0f, 1.0f, 50.0f);

	for(int x=0;x<RES_X;++x) {
		for(int z=0;z<RES_Z;++z) {
			float u = float(x) / RES_X;
			float v = float(z) / RES_Z;
			mesh.appendVertex( size * Vec3f( u - 0.5f , 0.0f, v - 0.5f ) );
			mesh.appendNormal( Vec3f::yAxis() );
			mesh.appendTexCoord( Vec2f( u, v ) );
		}
	}

	// create index buffer
	vector< uint32_t > indices;
	for(int x=0;x<RES_X-1;++x) {
		for(int z=0;z<RES_Z-1;++z) {
			uint32_t i = x * RES_Z + z;

			indices.push_back( i ); indices.push_back( i + 1 ); indices.push_back( i + RES_Z );
			indices.push_back( i + RES_Z );  indices.push_back( i + 1 ); indices.push_back( i + RES_Z + 1 );
		}
	}
	mesh.appendIndices( &indices.front(), indices.size() );

	// construct vertex buffer object
	gl::VboMesh::Layout layout;
	layout.setStaticPositions();
	layout.setStaticTexCoords2d();
	layout.setStaticIndices();
	layout.setStaticNormals();

	mVboMesh = gl::VboMesh( mesh, layout );
}

TriMesh MeshHelper::createTriMesh( vector<uint32_t> &indices, const vector<Vec3f> &positions, 
	const vector<Vec3f> &normals, const vector<Vec2f> &texCoords )
{
	TriMesh mesh;
	if ( indices.size() > 0 ) {
		mesh.appendIndices( &indices[ 0 ], indices.size() );
	}
	if ( normals.size() > 0 ) {
		for ( vector<Vec3f>::const_iterator iter = normals.begin(); iter != normals.end(); ++iter ) {
			mesh.appendNormal( *iter );
		}
	}
	if ( positions.size() > 0 ) {
		mesh.appendVertices( &positions[ 0 ], positions.size() );
	}
	if ( texCoords.size() > 0 ) {
		for ( vector<Vec2f>::const_iterator iter = texCoords.begin(); iter != texCoords.end(); ++iter ) {
			mesh.appendTexCoord( *iter );
		}
	}
	return mesh;
}

void RodSoundApp::setup()
{
//  std::cout << solveBEM(constants::radius) << "\n\n";
//  std::cout << "Expected:\n" << -constants::pi * constants::radius * constants::radius * Mat2e::Identity() << "\n\n";
  
  // Setup scene
  cam.setPerspective(40.0, getWindowAspectRatio(), 0.1, 1000.0);
  cam.lookAt(eyePos, targetPos, Vec3c(0.0, 1.0, 0.0));
  
  // Setup rendering stuff
  spheredl = new gl::DisplayList(GL_COMPILE);
  spheredl->newList();
  gl::drawSphere(Vec3c::zero(), constants::radius);
  spheredl->endList();
  
  cylinderdl = new gl::DisplayList(GL_COMPILE);
  cylinderdl->newList();
  gl::drawCylinder(constants::radius, constants::radius, 1.0);
  cylinderdl->endList();
  
  l = new gl::Light(gl::Light::POINT, 0);
  
  try {
    rodTex = loadImage(loadResource(RES_SIM_YARN_TEX));
  } catch (ImageIoException e) {
    std::cerr << "Error loading textures: " << e.what();
    exit(1);
  }
  
  // Load and compile shaders
  try {
    diffuseProg = gl::GlslProg(loadResource(RES_SIM_VERT_GLSL), loadResource(RES_SIM_FRAG_GLSL));
    rodProg = gl::GlslProg(loadResource(RES_SIM_VERT_TEX_GLSL), loadResource(RES_SIM_FRAG_TEX_GLSL));
  } catch (gl::GlslProgCompileExc e) {
    std::cerr << "Error compiling GLSL program: " << e.what();
    exit(1);
  } catch (ResourceLoadExc e) {
    std::cerr << "Error loading shaders: " << e.what();
    exit(1);
  }
  
  floor.appendVertex(Vec3c(-100.0, 0.0, -100.0));
  floor.appendNormal(Vec3c(0.0, 1.0, 0.0));
  floor.appendTexCoord(Vec2c(-12.0, -12.0));
  floor.appendVertex(Vec3c(100.0, 0.0, -100.0));
  floor.appendNormal(Vec3c(0.0, 1.0, 0.0));
  floor.appendTexCoord(Vec2c(12.0, -12.0));
  floor.appendVertex(Vec3c(100.0, 0.0, 100.0));
  floor.appendNormal(Vec3c(0.0, 1.0, 0.0));
  floor.appendTexCoord(Vec2c(12.0, 12.0));
  floor.appendVertex(Vec3c(-100.0, 0.0, 100.0));
  floor.appendNormal(Vec3c(0.0, 1.0, 0.0));
  floor.appendTexCoord(Vec2c(-12.0, 12.0));
  floor.appendTriangle(0, 1, 2);
  floor.appendTriangle(0, 3, 2);
  
  ci::Surface s(4, 4, false);
  auto iter = s.getIter();
  do {
    do {
      Vec2i pos = iter.getPos();
      unsigned char val = pos.x > 0 && pos.x < 3 && pos.y > 0 && pos.y < 3 ? 100 : 150;
      iter.r() = iter.g() = iter.b() = val;
    } while (iter.pixel());
  } while (iter.line());
  floorTex = gl::Texture(s);
  floorTex.setMagFilter(GL_NEAREST);
  floorTex.setWrap(GL_REPEAT, GL_REPEAT);
  
  // Load the rod
  loadDefaultRod(50);
  // loadRodFile("");
  loadStdEnergies();
  
  PROFILER_START("Total");
}

void verticesApp::generateCapsule()
{
    
    vector<uint> indices;
    
    double fDeltaRingAngle = (M_PI_2 / mNumRings);
    double fDeltaSegAngle = ((M_PI * 2.0) / mNumSegments);
    
    double sphereRatio = mRadius / (2 * mRadius + mHeight);
    double cylinderRatio = mHeight / (2 * mRadius + mHeight);
    int offset = 0;
    // Top half sphere
    
    // Generate the group of rings for the sphere
    for(unsigned int ring = 0; ring <= mNumRings; ring++ )
    {
        double r0 = mRadius * sinf ( ring * fDeltaRingAngle);
        double y0 = mRadius * cosf (ring * fDeltaRingAngle);
        
        // Generate the group of segments for the current ring
        for(unsigned int seg = 0; seg <= mNumSegments; seg++)
        {
            double x0 = r0 * cosf(seg * fDeltaSegAngle);
            double z0 = r0 * sinf(seg * fDeltaSegAngle);
            
            Vec3f p(x0, 0.5f * mHeight + y0, z0);
            Vec3f n(x0, y0, z0);
            mesh.appendVertex(p);
            mesh.appendNormal(n.normalized());
            mesh.appendTexCoord(Vec2f((double) seg / (double) mNumSegments, (double) ring / (double) mNumRings * sphereRatio));
            mesh.appendColorRgb(Colorf(1.0, 0, 0));
            
            // each vertex (except the last) has six indices pointing to it
            indices.push_back(offset + mNumSegments + 1);
            indices.push_back(offset + mNumSegments);
            indices.push_back(offset);
            indices.push_back(offset + mNumSegments + 1);
            indices.push_back(offset);
            indices.push_back(offset + 1);
            
            offset ++;
        } // end for seg
    } // end for ring
    
    // Cylinder part
    double deltaAngle = ((M_PI * 2.0) / mNumSegments);
    double deltamHeight = mHeight/(double)mNumSegHeight;
    
    for (unsigned short i = 1; i < mNumSegHeight; i++) {
        for (unsigned short j = 0; j<=mNumSegments; j++)
        {
            double x0 = mRadius * cosf(j*deltaAngle);
            double z0 = mRadius * sinf(j*deltaAngle);
            
            Vec3f p(x0, 0.5f*mHeight-i*deltamHeight, z0);
            Vec3f n(x0, 0, z0);
            mesh.appendVertex(p);
            mesh.appendNormal(n.normalized());
            mesh.appendTexCoord(Vec2f(j/(double)mNumSegments, i/(double)mNumSegHeight * cylinderRatio + sphereRatio));
            mesh.appendColorRgb(Colorf(0, 1.0 - (float(j)/float(mNumSegments)), 0));

            
            indices.push_back(offset + mNumSegments + 1);
            indices.push_back(offset + mNumSegments);
            indices.push_back(offset);
            indices.push_back(offset + mNumSegments + 1);
            indices.push_back(offset);
            indices.push_back(offset + 1);
            
            offset ++;
        }
    }

    // Bottom half sphere
    
    // Generate the group of rings for the sphere
    for(unsigned int ring = 0; ring <= mNumRings; ring++)
    {
        double r0 = mRadius * sinf (M_PI_2 + ring * fDeltaRingAngle);
        double y0 =  mRadius * cosf (M_PI_2 + ring * fDeltaRingAngle);
        
        // Generate the group of segments for the current ring
        for(unsigned int seg = 0; seg <= mNumSegments; seg++)
        {
            double x0 = r0 * cosf(seg * fDeltaSegAngle);
            double z0 = r0 * sinf(seg * fDeltaSegAngle);
            
            Vec3f p(x0, -0.5f*mHeight + y0, z0);
            Vec3f n(x0, y0, z0);
            mesh.appendVertex(p);
            mesh.appendNormal(n.normalized());
            mesh.appendTexCoord(Vec2f((double) seg / (double) mNumSegments, (double) ring / (double) mNumRings*sphereRatio + cylinderRatio + sphereRatio));
            mesh.appendColorRgb(Colorf(0, 0, float(ring)/float(mNumRings)));

            
            if (ring != mNumRings) 
            {
                // each vertex (except the last) has six indices pointing to it
                indices.push_back(offset + mNumSegments + 1);
                indices.push_back(offset + mNumSegments);
//.........这里部分代码省略.........

void ssaoApp::setup()
{
    
    gl::disableVerticalSync();
    
    RENDER_MODE = DeferredRenderer::SHOW_FINAL_VIEW;
    
    //set up camera
    mCam.setPerspective( 45.0f, getWindowAspectRatio(), 0.1f, 10000.0f );
    Vec3f camPos( -14.0f, 7.0f, -14.0f );
    mCam.lookAt(camPos * 1.5f, Vec3f::zero(), Vec3f(0.0f, 1.0f, 0.0f) );
    mCam.setCenterOfInterestPoint(Vec3f::zero());
    mMayaCam.setCurrentCam(mCam);
    
    //create functions pointers to send to deferred renderer
    boost::function<void(gl::GlslProg*)> fRenderShadowCastersFunc = boost::bind( &ssaoApp::drawShadowCasters, this, boost::lambda::_1 );
    boost::function<void(gl::GlslProg*)> fRenderNotShadowCastersFunc = boost::bind( &ssaoApp::drawNonShadowCasters, this,  boost::lambda::_1 );
    boost::function<void(void)> fRenderOverlayFunc = boost::bind( &ssaoApp::drawOverlay, this );

    mDeferredRenderer.setup( fRenderShadowCastersFunc, fRenderNotShadowCastersFunc, NULL, NULL, &mCam, Vec2i(1024, 768), 1024, true, true ); //no overlay or "particles"
    
    //have these cast point light shadows
    mDeferredRenderer.addCubeLight(    Vec3f(-2.0f, 4.0f, 6.0f),      Color(0.10f, 0.69f, 0.93f) * LIGHT_BRIGHTNESS_DEFAULT, true);      //blue
    mDeferredRenderer.addCubeLight(    Vec3f(4.0f, 6.0f, -4.0f),      Color(0.94f, 0.15f, 0.23f) * LIGHT_BRIGHTNESS_DEFAULT, true);      //red
    
    //add a bunch of lights
    for(int i = 0; i < 10; i++) {
        for(int j = 0; j < 10; j++) {
        
            int randColIndex = Rand::randInt(5);
            Color randCol;
            switch( randColIndex ) {
                case 0:
                    randCol = Color(0.99f, 0.67f, 0.23f); //orange
                    break;
                case 1:
                    randCol = Color(0.97f, 0.24f, 0.85f); //pink
                    break;
                case 2:
                    randCol = Color(0.00f, 0.93f, 0.30f); //green
                    break;
                case 3:
                    randCol = Color(0.98f, 0.96f, 0.32f); //yellow
                    break;
                case 4:
                    randCol = Color(0.10f, 0.69f, 0.93f); //blue
                    break;
                case 5:
                    randCol = Color(0.94f, 0.15f, 0.23f); //red
                    break;
            };
            
            mDeferredRenderer.addCubeLight( Vec3f( i * 20, 30, j * 20), randCol * LIGHT_BRIGHTNESS_DEFAULT, false, true);
        }
    }
    
    mCurrLightIndex = 0;
    
    float size = 3000;
    
    plane.appendVertex(Vec3f(size, -1,-size));
    plane.appendColorRgba(ColorA(255,255,255,255));
    plane.appendNormal(Vec3f(.0f, 1.0f, 0.0f));
    plane.appendVertex(Vec3f(-size, -1,-size));
    plane.appendColorRgba(ColorA(255,255,255,255));
    plane.appendNormal(Vec3f(.0f, 1.0f, 0.0f));
    plane.appendVertex(Vec3f(-size, -1, size));
    plane.appendColorRgba(ColorA(255,255,255,255));
    plane.appendNormal(Vec3f(.0f, 1.0f, 0.0f));
    plane.appendVertex(Vec3f(size, -1, size));
    plane.appendColorRgba(ColorA(255,255,255,255));
    plane.appendNormal(Vec3f(.0f, 1.0f, 0.0f));
    
    uint indices[6] = {0,1,2,2,3,0};
    plane.appendIndices(&indices[0], 6);
    
    gl::VboMesh::Layout layout;
    shadowPlane = gl::VboMesh::create(plane);
    
    TriMesh bunnyMesh;
    ObjLoader loader( loadResource(RES_BUNNY) );
	loader.load( &bunnyMesh );
    
    bunny = gl::VboMesh(bunnyMesh);
    
}