int ConsistentOrientationBuilder::_findNextTriangle()
{
    int result = -1 ;

    /*
     * find an oriented triangle (reached) and not visited
     */
    for ( size_t i = 0; i < numTriangles(); i++ ) {
        if ( ! _oriented[i] || _visited[i] ) {
            continue ;
        }

        result = i ;
        break ;
    }

    //triangle found
    if ( result != -1 ) {
        return result ;
    }

    /*
     * here, a new connected part begins
     */
    for ( size_t i = 0; i < numTriangles(); i++ ) {
        if ( ! _oriented[i] ) {
            _oriented[i] = true ;
            return i ;
        }
    }

    BOOST_ASSERT( result == -1 );
    return result ;
}
Пример #2
0
void renderScene(void) {
	int i;

	glClear(GL_COLOR_BUFFER_BIT);
	
	for(i=0;i<numTriangles(shape);i++)
	{	
		glBegin(GL_TRIANGLES);
			glVertex3f(shape->vTable[shape->tTable[i*3]],
 				   shape->vTable[shape->tTable[i*3]+1],
				   shape->vTable[shape->tTable[i*3]+2]);
			glVertex3f(shape->vTable[shape->tTable[i*3+1]],
 				   shape->vTable[shape->tTable[i*3+1]+1],
				   shape->vTable[shape->tTable[i*3+1]+2]);
			glVertex3f(shape->vTable[shape->tTable[i*3+2]],
 				   shape->vTable[shape->tTable[i*3+2]+1],
				   shape->vTable[shape->tTable[i*3+2]+2]);
		glEnd();
	}

	glBegin(GL_TRIANGLES);
		glVertex3f(2.0,4.0,0.0);
		glVertex3f(2.1,4.1,0.1);
		glVertex3f(2.1,4.0,0.0);
	glEnd();
	glFlush();
}
Пример #3
0
void BvhTriangleMesh::formTriangleAabbs()
{
    void * cvs = verticesOnDevice();
    void * tri = triangleIndicesOnDevice();
    void * dst = bvh()->leafAabbs();
    bvhCalculateLeafAabbsTriangle((Aabb *)dst, (float3 *)cvs, (uint3 *)tri, numTriangles());
}
Пример #4
0
void BvhTriangleSystem::initOnDevice()
{
    std::cout<<"\n triangle system init on device";
    setNumPrimitives(numTriangles());
    CudaMassSystem::initOnDevice();
    CudaLinearBvh::initOnDevice();
}
void ConsistentOrientationBuilder::_computeNeighbors()
{
    _neighbors.clear() ;
    _neighbors.resize( numTriangles() );

    for ( size_t i = 0; i < _triangles.size(); i++ ) {
        const std::vector< edge_descriptor > & triangle = _triangles[i] ;

        for ( size_t j = 0; j < triangle.size(); j++ ) {
            vertex_descriptor source = _graph.source( triangle[j] ) ;
            vertex_descriptor target = _graph.target( triangle[j] ) ;

            //get neighbor edges
            std::vector< directed_edge_descriptor > neighborEdges = _graph.edges( source, target );

            //use marker to fill neighborGraph
            for ( size_t k = 0; k < neighborEdges.size(); k++ ) {
                size_t idOtherTriangle = ( size_t )_graph[ neighborEdges[k].first ].face;

                if ( idOtherTriangle == i ) {
                    continue ;
                }

                _neighbors[i].insert( idOtherTriangle );
            }
        }
    }
}
void ConstraintDelaunayTriangulation::getTriangles( TriangulatedSurface& triangulatedSurface, bool filterExteriorParts ) const
{
    triangulatedSurface.reserve( triangulatedSurface.numTriangles() + numTriangles() );

    for ( Finite_faces_iterator it = finite_faces_begin(); it != finite_faces_end(); ++it ) {
        if ( filterExteriorParts && ( it->info().nestingLevel % 2 == 0 ) ) {
            continue ;
        }

        const Coordinate& a = it->vertex( 0 )->info().original ;

        const Coordinate& b = it->vertex( 1 )->info().original ;

        const Coordinate& c = it->vertex( 2 )->info().original ;

        // check that vertex has an original vertex
        if ( a.isEmpty() || b.isEmpty() || c.isEmpty() ) {
            BOOST_THROW_EXCEPTION( Exception(
                                       ( boost::format( "Can't convert Triangulation to TriangulatedSurface (constraint intersection found)" ) ).str()
                                   ) ) ;
        }

        triangulatedSurface.addTriangle( new Triangle( Point( a ), Point( b ), Point( c ) ) );
    }
}
Пример #7
0
void BvhTriangleMesh::initOnDevice()
{
	m_verticesOnDevice = new CUDABuffer;
	m_verticesOnDevice->create(m_vertices->bufferSize());
	m_triangleIndicesOnDevice = new CUDABuffer;
	m_triangleIndicesOnDevice->create(m_triangleIndices->bufferSize());
	m_triangleIndicesOnDevice->hostToDevice(m_triangleIndices->data(), m_triangleIndices->bufferSize());
	
	bvh()->setNumLeafNodes(numTriangles());
	CollisionObject::initOnDevice();
}
TriangulatedSurface ConsistentOrientationBuilder::buildTriangulatedSurface()
{
    _makeOrientationConsistent() ;
    TriangulatedSurface triangulatedSurface ;

    for ( size_t i = 0; i < numTriangles(); i++ ) {
        triangulatedSurface.addTriangle( triangleN( i ) );
    }

    return triangulatedSurface ;
}
Пример #9
0
void Mesh::DrawMesh(triangleshashtype &triSet, GLuint VBO) {
  //assert ((int)mesh_tri_verts.size() == numTriangles()*3);

  glBindBuffer(GL_ARRAY_BUFFER, VBO);
  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(3, GL_FLOAT, sizeof(VBOPosNormal), BUFFER_OFFSET(0));
  glEnableClientState(GL_NORMAL_ARRAY);
  glNormalPointer(GL_FLOAT, sizeof(VBOPosNormal), BUFFER_OFFSET(12));
  glDrawArrays(GL_TRIANGLES,0,numTriangles(triSet)*3);
  
  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);

}
Пример #10
0
void Mesh::DrawMesh() {
    assert ((int)mesh_tri_verts.size() == numTriangles()*3);
  glBindBuffer(GL_ARRAY_BUFFER, mesh_tri_verts_VBO);
  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(3, GL_FLOAT, sizeof(VBOPosNormalColorTexture), BUFFER_OFFSET(0));
  glEnableClientState(GL_NORMAL_ARRAY);
  glNormalPointer(GL_FLOAT, sizeof(VBOPosNormalColorTexture), BUFFER_OFFSET(12));
  glEnableClientState(GL_COLOR_ARRAY);
  glColorPointer(3, GL_FLOAT, sizeof(VBOPosNormalColorTexture), BUFFER_OFFSET(24));

  // Texture
  glEnable(GL_TEXTURE_2D);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  glTexCoordPointer( 2, GL_FLOAT, sizeof(VBOPosNormalColorTexture), BUFFER_OFFSET(36));
  
  glDrawArrays(GL_TRIANGLES,0,numTriangles()*3);
  
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisable(GL_TEXTURE_2D);
  glDisableClientState(GL_COLOR_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);
}
Пример #11
0
void Mesh::SetupMesh() {
  ComputeGouraudNormals();
  for (triangleshashtype::iterator iter = triangles.begin();
       iter != triangles.end(); iter++) {
    Triangle *t = iter->second;
    Vec3f a = (*t)[0]->getPos();
    Vec3f b = (*t)[1]->getPos();
    Vec3f c = (*t)[2]->getPos();    
    Vec3f na = (*t)[0]->getGouraudNormal();
    Vec3f nb = (*t)[1]->getGouraudNormal();
    Vec3f nc = (*t)[2]->getGouraudNormal();
    Vec3f color = mesh_color;
    mesh_tri_verts.push_back(VBOPosNormalColorTexture(a,na,color,a.x()*1,a.z()*-1));
    mesh_tri_verts.push_back(VBOPosNormalColorTexture(b,nb,color,b.x()*1,b.z()*-1));
    mesh_tri_verts.push_back(VBOPosNormalColorTexture(c,nc,color,c.x()*1,c.z()*-1));
  }
  glBindBuffer(GL_ARRAY_BUFFER,mesh_tri_verts_VBO); 
  glBufferData(GL_ARRAY_BUFFER,
         sizeof(VBOPosNormalColorTexture) * numTriangles() * 3,
         &mesh_tri_verts[0],
         GL_STATIC_DRAW); 
}
Пример #12
0
void Mesh::SetupMesh(triangleshashtype &triSet, GLuint VBO, std::vector<VBOPosNormal> &VBO_verts_vector) {
  for (auto iter = triSet.begin(); iter != triSet.end(); iter++) {
    Triangle *t = iter->second;
    Vec3f a = (*t)[0]->getPos();
    Vec3f b = (*t)[1]->getPos();
    Vec3f c = (*t)[2]->getPos();
    Vec3f na = ComputeNormal(a,b,c);
    Vec3f nb = na;
    Vec3f nc = na;
    if (args->gouraud_normals) {
      na = (*t)[0]->getGouraudNormal();
      nb = (*t)[1]->getGouraudNormal();
      nc = (*t)[2]->getGouraudNormal();
    }
    VBO_verts_vector.push_back(VBOPosNormal(a,na));
    VBO_verts_vector.push_back(VBOPosNormal(b,nb));
    VBO_verts_vector.push_back(VBOPosNormal(c,nc));
  }
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
  glBufferData(GL_ARRAY_BUFFER,
         sizeof(VBOPosNormal) * numTriangles(triSet) * 3,
         &VBO_verts_vector[0],
         GL_STATIC_DRAW);
}
Пример #13
0
//----------------------------------------------------------------------------
std::vector<TriMesh*> Castle::LoadMeshPNT1Multi (const std::string& name)
{
    // Get the vertex format.
    VertexFormat* vformat = VertexFormat::Create(3,
        VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
        VertexFormat::AU_NORMAL, VertexFormat::AT_FLOAT3, 0,
        VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
    int vstride = vformat->GetStride();

    // Get the positions.
    std::string filename = Environment::GetPathR(name);
    std::ifstream inFile(filename.c_str());
    int numPositions;
    Float3* positions;
    GetFloat3(inFile, numPositions, positions);

    // Get the normals.
    int numNormals;
    Float3* normals;
    GetFloat3(inFile, numNormals, normals);

    // Get the texture coordinates.
    int numTCoords;
    Float2* tcoords;
    GetFloat2(inFile, numTCoords, tcoords);

    // Get the vertices and indices.
    int numMeshes;
    inFile >> numMeshes;
    std::vector<int> numTriangles(numMeshes);
    int numTotalTriangles = 0;
    int m;
    for (m = 0; m < numMeshes; ++m)
    {
        inFile >> numTriangles[m];
        numTotalTriangles += numTriangles[m];
    }

    std::vector<std::vector<int> >indices(numMeshes);
    VertexPNT1* vertices = new1<VertexPNT1>(3*numTotalTriangles);
    std::vector<VertexPNT1> PNT1Array;
    std::map<VertexPNT1,int> PNT1Map;
    for (m = 0; m < numMeshes; ++m)
    {
        for (int t = 0; t < numTriangles[m]; ++t)
        {
            for (int j = 0, k = 3*t; j < 3; ++j, ++k)
            {
                VertexPNT1& vertex = vertices[k];
                inFile >> vertex.PIndex;
                inFile >> vertex.NIndex;
                inFile >> vertex.TIndex;

                std::map<VertexPNT1,int>::iterator miter =
                    PNT1Map.find(vertex);
                int index;
                if (miter != PNT1Map.end())
                {
                    // Second or later time the vertex is encountered.
                    index = miter->second;
                }
                else
                {
                    // First time the vertex is encountered.
                    index = (int)PNT1Array.size();
                    PNT1Map.insert(std::make_pair(vertex, index));
                    PNT1Array.push_back(vertex);
                }
                indices[m].push_back(index);
            }
        }
    }
    inFile.close();

    // Build the meshes.
    int numVertices = (int)PNT1Array.size();
    VertexBuffer* vbuffer = new0 VertexBuffer(numVertices, vstride);
    VertexBufferAccessor vba(vformat, vbuffer);
    for (int i = 0; i < numVertices; ++i)
    {
        VertexPNT1& vertex = PNT1Array[i];
        vba.Position<Float3>(i) = positions[vertex.PIndex];
        vba.Normal<Float3>(i) = normals[vertex.NIndex];
        vba.TCoord<Float2>(0, i) = tcoords[vertex.TIndex];
    }

    std::vector<TriMesh*> meshes(numMeshes);
    for (m = 0; m < numMeshes; ++m)
    {
        int numIndices = (int)indices[m].size();
        IndexBuffer* ibuffer = new0 IndexBuffer(numIndices, sizeof(int));
        memcpy(ibuffer->GetData(), &indices[m][0], numIndices*sizeof(int));
        meshes[m] = new0 TriMesh(vformat, vbuffer, ibuffer);
    }

    delete1(vertices);
    delete1(tcoords);
    delete1(normals);
    delete1(positions);

    return meshes;
}
Пример #14
0
const unsigned ATriangleMesh::numComponents() const
{ return numTriangles(); }
Пример #15
0
const unsigned BvhTriangleMesh::numTriangleFaceVertices() const
{ return numTriangles() * 3; }
Пример #16
0
int main(int argc, char** argv)
{
   Shape inShape = NULL;
   Shape outShape= NULL;
   int i,c;
   int doVTable=0;

   int *oTable, *mTable;
   float *vTable;
   int counter;

   float tester;

   if(argc != 3)
   {
	fprintf(stderr,"Usage:\n\t%s inFile outFile.\n",argv[0]);
 	return 1;
   }

   inShape = readShapeFromFile(argv[1]);

   if(inShape == NULL)
	return 1;
 
/*   printf("Let's see what's in the inShape!\n");*/

#ifdef DEBUG
   printf("There are %d vertices.\n",inShape->numVertices);
#endif

   /*printf("The vTable contains:\n");*/
   for(c=0;c<inShape->numVertices*3;c+=3)
   {
/*	   printf("%d => %f %f %f\n",c,inShape->vTable[c],
			   inShape->vTable[c+1],
			   inShape->vTable[c+2]);*/
   }
   //printf("The tTable contains %d triangles\n\n",numTriangles(inShape));
 //  for(c=0;c<numTriangles(inShape)*3;c+=3)
  // {
//	   printf("%d => %d %d %d\n", c,inShape->tTable[c],
//			   inShape->tTable[c+1],
//			   inShape->tTable[c+2]);
  // }

   oTable = malloc(sizeof(int)*numTriangles(inShape)*3);
   /*oTable = malloc(sizeof(int)*99999);*/
  /* for(c=0;c<inShape->numVertices*3;c++)*/
   for(c=0;c<numTriangles(inShape)*3;c++)
   {
	   oTable[c] = -1;
   }


/*   for(c=0;c<numTriangles(inShape)*3;c++)
	   for(i=c+1;i<inShape->numVertices*3;i++)*/
   // printf("There are %d iterations of c and i\n",numTriangles(inShape)*3);
     for(c=0;c<numTriangles(inShape)*3;c++)
	     for(i=c+1;i<numTriangles(inShape)*3;i++)
	{
//		if(c<10)
//		printf("Trying to match %d and %d..V(N(c))=%d, V(P(i))=%d, V(P(c)=%d,v(N(i))=%d\n",c,i,V(inShape,N(c)),V(inShape,P(i)),V(inShape,P(c)),V(inShape,N(i)));
		   if((V(inShape,N(c)) == V(inShape,P(i)))
 		    &&(V(inShape,P(c)) == V(inShape,N(i))))
		   {
		//	   printf("Match found!\n");
			   oTable[c] = i;
			   oTable[i] = c;
		   }
	}

   printf("This is the oTable:\n");
   for(c=0;c<numTriangles(inShape)*3;c++)
   {
	   printf("%d => %d\n",c,oTable[c]);
   }
   
    for(c=0;c<numTriangles(inShape)*3;c++)
      if(oTable[c] == -1)
      {
	printf("MISALIGNMENT in corner %d!!!\n",c);
	printf("Cannot find a corner (opposite than at %d) with N(c)=%d and P(c)=%d\n",
		V(inShape,c),V(inShape,P(c)),V(inShape,N(c)));
        return 1;
      }
   /*mTable = malloc(sizeof(int)*inShape->numVertices*3);*/
   mTable = malloc(sizeof(int)*numTriangles(inShape)*3);
  /* for(c=0;c<inShape->numVertices*3;c++)*/
   for(c=0;c<numTriangles(inShape)*3;c++)
	   mTable[c] = -1;

   /*outShape = createShape(4*inShape->numVertices-6);*/
   outShape = createShape(4*inShape->numVertices,4*numTriangles(inShape));
   printf("outShape has %d vertices\n",outShape->numVertices);
   printf("outShape has %d Triangles\n",numTriangles(outShape));
   if(outShape == NULL)
	   return 5;



for(doVTable = 0;doVTable < inShape->numTables; doVTable++)
{
   outShape->vTable = outShape->vTables[doVTable];
   inShape->vTable = inShape->vTables[doVTable];

   for(c=0;c<inShape->numVertices*3;c++)
  /* for(c=0;c<numTriangles(inShape)*3;c++)*/
   {
	   outShape->vTable[c] = inShape->vTable[c];
   }
}

   counter = inShape->numVertices - 1;

   printf("Counter starts at: %d\n",counter);

   /*for(c=0;c<inShape->numVertices*3;c++)*/
   for(c=0;c<numTriangles(inShape)*3;c++)
   {
	if(mTable[c] == -1)
	{

		counter++;


		for(doVTable=0;doVTable<inShape->numTables;doVTable++)
		{
  		outShape->vTable = outShape->vTables[doVTable];
  		inShape->vTable = inShape->vTables[doVTable];


   		vTable = inShape->vTable;

		outShape->vTable[counter*3]=0;
		outShape->vTable[counter*3]=
			(vTable[3*V(inShape,N(c))]+
			vTable[3*V(inShape,P(c))])/2;
		outShape->vTable[counter*3]+=
			(
			 ( vTable[3*V(inShape,c)] +
			   vTable[3*V(inShape,oTable[c])]
			 )/2
			 - 
			 (
			  vTable[3*L(inShape,c,oTable)] + vTable[3*R(inShape,c,oTable)]
			 +vTable[3*L(inShape,oTable[c],oTable)] +
			  vTable[3*R(inShape,oTable[c],oTable)]
		         )/4	
			 
			 )/4;

		outShape->vTable[counter*3+1]=
			(vTable[3*(V(inShape,N(c)))+1]+
			 vTable[3*(V(inShape,P(c)))+1])/2
			+
			(
			 ( vTable[3*(V(inShape,c))+1] +
			   vTable[3*(V(inShape,oTable[c]))+1]
			 )/2
			 - 
			 (
			  vTable[3*(L(inShape,c,oTable))+1] + vTable[3*(R(inShape,c,oTable))+1]
			 +vTable[3*(L(inShape,oTable[c],oTable))+1] +
			  vTable[3*(R(inShape,oTable[c],oTable))+1]
		         )/4	
			 
			 )/4;
		outShape->vTable[counter*3+2]=
			(vTable[3*(V(inShape,N(c)))+2]+
			 vTable[3*(V(inShape,P(c)))+2])/2
			+
			(
			 ( vTable[3*(V(inShape,c))+2] +
			   vTable[3*(V(inShape,oTable[c]))+2]
			 )/2
			 - 
			 (
			  vTable[3*(L(inShape,c,oTable))+2] + vTable[3*(R(inShape,c,oTable))+2]
			 +vTable[3*(L(inShape,oTable[c],oTable))+2] +
			  vTable[3*(R(inShape,oTable[c],oTable))+2]
		         )/4	
			 
			 )/4;
		}

/*		outShape->vTable[counter*3] =
			(vTable[3*V(inShape,N(c))] + vTable[3*V(inShape,P(c))])/2;
		outShape->vTable[counter*3+1] =
			(vTable[3*(V(inShape,N(c)))+1] + vTable[3*(V(inShape,P(c)))+1])/2;
		outShape->vTable[counter*3+2] =
			(vTable[3*(V(inShape,N(c)))+2] + vTable[3*(V(inShape,P(c)))+2])/2;
*/
	printf("counter is %d\n",counter);
	printf("----\n");
		mTable[c] = counter;
		mTable[oTable[c]] = counter;
	}
   }

   outShape->numVertices = counter+1;
   printf("outShape has %d vertices\n",outShape->numVertices);
/*
   printf("mTable:\n");
   for(c=0;c<inShape->numVertices*3;c++)
	   printf("\t%d => %d\n",c,mTable[c]);*/

   /*printf("new vTable:\n");*/
/*   for(c=0;c<outShape->numVertices;c++)
   	  printf("\t%d => %f %f %f\n",c,outShape->vTable[c*3],
			  		outShape->vTable[c*3+1],
					outShape->vTable[c*3+2]);*/
  /* printf("Counter finishes at: %d\n",counter);*/
   
   printf("there are %d triangles\n",numTriangles(inShape));
   for(c=0;c<numTriangles(inShape)*3;c+=3)
   {
	printf("Triangle %d %d %d becomes: \n",V(inShape,c),V(inShape,c+1),
					       V(inShape,c+2));
	outShape->tTable[c*4] = V(inShape,c);
	outShape->tTable[c*4+1]=mTable[c+2];
	outShape->tTable[c*4+2]=mTable[c+1];
/*	printf("\tTriangle %d %d %d\n",
		outShape->tTable[c*4],
		outShape->tTable[c*4+1],
		outShape->tTable[c*4+2]);*/

	outShape->tTable[c*4+3]=mTable[c+1];
	outShape->tTable[c*4+4]=mTable[c];
	outShape->tTable[c*4+5]=V(inShape,c+2);
/*	printf("\tTriangle %d %d %d\n",
		outShape->tTable[c*4+3],
		outShape->tTable[c*4+4],
		outShape->tTable[c*4+5]);*/

	outShape->tTable[c*4+6]=mTable[c+2];
	outShape->tTable[c*4+7]=V(inShape,c+1);
	outShape->tTable[c*4+8]=mTable[c];
/*	printf("\tTriangle %d %d %d\n",
		outShape->tTable[c*4+6],
		outShape->tTable[c*4+7],
		outShape->tTable[c*4+8]);*/

	outShape->tTable[c*4+9]=mTable[c];
	outShape->tTable[c*4+10]=mTable[c+1];
	outShape->tTable[c*4+11]=mTable[c+2];
/*	printf("\tTriangle %d %d %d\n",
		outShape->tTable[c*4+9],
		outShape->tTable[c*4+10],
		outShape->tTable[c*4+11]);*/
  }
   
  printf("new tTable:\n");
  for(c=0;c<numTriangles(outShape);c++)
  {
	  printf("%d => %d %d %d\n",c,outShape->tTable[c*3],
			  	      outShape->tTable[c*3+1],
				      outShape->tTable[c*3+2]);
  }

  writeShapeToFile(outShape,argv[2]);

  printf("Hey there!!!!!\n\n\n");fflush(stdout);
  destroyShape(inShape);
  destroyShape(outShape);
  printf("Hey there!!!!!\n\n\n");fflush(stdout);
   return 0;
} 
Пример #17
0
void BvhTriangleSystem::formTetrahedronAabbs()
{
    void * cvs = deviceX();
    void * vsrc = deviceVa();
    void * idx = deviceTretradhedronIndices();
    void * dst = leafAabbs();
    trianglesys::formTetrahedronAabbs((Aabb *)dst, (float3 *)cvs, (float3 *)vsrc, 1.f/60.f, (uint4 *)idx, numTriangles());
    CudaBase::CheckCudaError("triangle system form aabb");
}
void ConsistentOrientationBuilder::_makeOrientationConsistent()
{
    if ( _triangles.empty() ) {
        return ;
    }

    /*
     * mark all triangles as not oriented and not visited
     */
    _visited.resize( numTriangles() ) ;
    _oriented.resize( numTriangles() ) ;

    for ( size_t i = 0; i < numTriangles(); i++ ) {
        _visited[i]  = false ;
        _oriented[i] = false ;
    }

    _computeNeighbors();

    // mark first one as oriented (reference)
    int currentTriangle = -1 ;

    while ( ( currentTriangle = _findNextTriangle() ) != -1 ) {
        //mark triangle as visited
        _visited[ currentTriangle ] = true ;

        //orient neighbors
        const std::set< size_t > & neighbors = _neighbors[ currentTriangle ] ;

        for ( std::set< size_t >::const_iterator it = neighbors.begin(); it != neighbors.end(); ++it ) {
            bool hasOppositeEdge, hasParallelEdge ;
            graph::algorithm::studyOrientation(
                _graph,
                _triangles[ currentTriangle ],
                _triangles[ ( *it ) ],
                hasOppositeEdge,
                hasParallelEdge
            );

            // orientation is consistent
            if ( ! hasParallelEdge ) {
                _oriented[ *it ] = true ;
                continue ;
            }

            // orientation can't be consistent
            if ( hasOppositeEdge && hasParallelEdge ) {
                BOOST_THROW_EXCEPTION( Exception(
                                           "can't build consistent orientation from triangle set"
                                       ) );
            }

            // orientation has already been fixed (moebius)
            if ( hasParallelEdge && _oriented[ *it ] ) {
                BOOST_THROW_EXCEPTION( Exception(
                                           "can't build consistent orientation from triangle set, inconsistent orientation for triangle"
                                       ) );
            }

            //here, neighbor triangle should be reversed
            _graph.reverse( _triangles[ ( *it ) ] );
            _oriented[ *it ] = true ;
        }
    }
}
Пример #19
0
const unsigned TriangleSystem::numElements() const
{ return numTriangles(); }
Пример #20
0
std::vector<std::shared_ptr<Visual>> CastleWindow::LoadMeshPNT1Multi(std::string const& name)
{
    // Get the positions, normals, and texture coordinates.
    std::string filename = mEnvironment.GetPath(name);
    std::ifstream inFile(filename);
    std::vector<Vector3<float>> positions, normals;
    std::vector<Vector2<float>> tcoords;
    GetTuple3(inFile, positions);
    GetTuple3(inFile, normals);
    GetTuple2(inFile, tcoords);

    // Get the vertices and indices.
    unsigned int numMeshes;
    inFile >> numMeshes;
    std::vector<unsigned int> numTriangles(numMeshes);
    unsigned int numTotalTriangles = 0;
    for (unsigned int m = 0; m < numMeshes; ++m)
    {
        inFile >> numTriangles[m];
        numTotalTriangles += numTriangles[m];
    }

    std::vector<std::vector<unsigned int>> indices(numMeshes);
    std::vector<LookupPNT1> lookups(3 * numTotalTriangles);
    std::vector<LookupPNT1> PNT1Array;
    std::map<LookupPNT1, unsigned int> PNT1Map;
    for (unsigned int m = 0; m < numMeshes; ++m)
    {
        for (unsigned int t = 0; t < numTriangles[m]; ++t)
        {
            for (unsigned int j = 0, k = 3 * t; j < 3; ++j, ++k)
            {
                LookupPNT1& lookup = lookups[k];
                inFile >> lookup.PIndex;
                inFile >> lookup.NIndex;
                inFile >> lookup.TIndex;

                auto iter = PNT1Map.find(lookup);
                unsigned int index;
                if (iter != PNT1Map.end())
                {
                    // Second or later time the vertex is encountered.
                    index = iter->second;
                }
                else
                {
                    // First time the vertex is encountered.
                    index = static_cast<unsigned int>(PNT1Array.size());
                    PNT1Map.insert(std::make_pair(lookup, index));
                    PNT1Array.push_back(lookup);
                }
                indices[m].push_back(index);
            }
        }
    }
    inFile.close();

    // Build the meshes.
    unsigned int numVertices = static_cast<unsigned int>(PNT1Array.size());
    std::shared_ptr<VertexBuffer> vbuffer =
        std::make_shared<VertexBuffer>(mPNT1Format, numVertices);
    VertexPNT1* vertex = vbuffer->Get<VertexPNT1>();
    for (unsigned int i = 0; i < numVertices; ++i)
    {
        LookupPNT1& lookup = PNT1Array[i];
        vertex[i].position = positions[lookup.PIndex];
        vertex[i].normal = normals[lookup.NIndex];
        vertex[i].tcoord = tcoords[lookup.TIndex];
    }

    std::vector<std::shared_ptr<Visual>> meshes(numMeshes);
    for (unsigned int m = 0; m < numMeshes; ++m)
    {
        unsigned int numIndices = static_cast<unsigned int>(indices[m].size());
        std::shared_ptr<IndexBuffer> ibuffer =
            std::make_shared<IndexBuffer>(IP_TRIMESH, numIndices, sizeof(unsigned int));
        memcpy(ibuffer->GetData(), &indices[m][0], numIndices * sizeof(unsigned int));
        meshes[m] = std::make_shared<Visual>(vbuffer, ibuffer);
    }

    return meshes;
}