Пример #1
0
void Matrix4x4::Transformation(vector<Vertex> &vertex, int index)
{
	Vertex tempVertex(vertex[index]._color, vertex[index]._x, vertex[index]._y, vertex[index]._z);

	vertex[index]._x = (_11 * tempVertex._x) + (_21 * tempVertex._y) + (_31 * tempVertex._z) + _41;
	vertex[index]._y = (_12 * tempVertex._x) + (_22 * tempVertex._y) + (_32 * tempVertex._z) + _42; 
	vertex[index]._z = (_13 * tempVertex._x) + (_23 * tempVertex._y) + (_33 * tempVertex._z) + _43;
	vertex[index]._w = (_14 * tempVertex._x) + (_24 * tempVertex._y) + (_34 * tempVertex._z) + (tempVertex._w *_44);
}
Пример #2
0
void Matrix4x4::Transformation(Vertex &vector)
{
	Vertex tempVertex(vector._color, vector._x, vector._y, vector._z, vector._w);

	vector._x = (_11 * tempVertex._x) + (_21 * tempVertex._y) + (_31 * tempVertex._z) + _41;
	vector._y = (_12 * tempVertex._x) + (_22 * tempVertex._y) + (_32 * tempVertex._z) + _42; 
	vector._z = (_13 * tempVertex._x) + (_23 * tempVertex._y) + (_33 * tempVertex._z) + _43;
	vector._w = (_14 * tempVertex._x) + (_24 * tempVertex._y) + (_34 * tempVertex._z) + (tempVertex._w * _44);
}
Пример #3
0
void Mesh::loadFile( char* fileName)
{
	ifstream input(fileName);
	string line;
	vector<string> temp;
	if(input.is_open())
	{
		cout<<"file opens successfully"<<endl;


		while(getline(input,line))
		{
			temp.clear();
			StringSplit(line," ",&temp);
			if(temp[0]=="#")
				continue;
			if(temp[0]=="v")
			{
				if(temp.size()==4)
				{
					Vertex tempVertex(atof(temp[1].c_str()),atof(temp[2].c_str()),atof(temp[3].c_str()),vertices.size());
					vertices.push_back(tempVertex);
				}
				else
				{
					cout<<"file format error: v size"<<endl;
				}

			}
			if(temp[0]=="f")
			{
				if(temp.size()==4)
				{
					Triangle tempTriangle(atoi(temp[1].c_str())-1,atoi(temp[2].c_str())-1,atoi(temp[3].c_str())-1,triangles.size());
					for(int i=1; i<4;++i)
						vertices[atoi(temp[i].c_str())-1].tri_id=triangles.size();
					triangles.push_back(tempTriangle);
				}
				else
				{
					cout<<"file format error: face size"<<endl;
				}

			}

		}
		cout<<"succefully load "<<vertices.size()<<" vertices and "<<triangles.size()<<" triangles"<<endl;
	}
	else
	{
		cout<<"file open error"<<endl;
	}
}
void PLYParser::importFile(std::string sFilePath)
{
    std::cout << "Parsing started" << std::endl ;

    fileImported = sFilePath ;

    char str1[SIZE], str2[SIZE] ;
    unsigned int iTemp = 0;
    char buffer[SIZE];

    FILE * fileReadPointer  = fopen ( sFilePath.c_str(), "r" );
    if( NULL == fileReadPointer )
    {
        puts("Error : File not opened for reading.");
        return;
    }

    while ( NULL != fgets( buffer , SIZE , fileReadPointer) )
    {
        if( EOF == buffer[0] )
        {
            break;
        }

        else
        {
            sscanf( buffer, "%s %s %d", &str1 , &str2, &iTemp );

            if( 0 == strcmp( "end_header", str1 ) )
                break;
            else if( 0 == strcmp( "element", str1 ) && 0 == strcmp( "vertex", str2 ) )
                objMesh.setNumberOfVertices(iTemp);
            else if( 0 == strcmp( "element", str1 ) && 0 == strcmp( "face", str2 ) )
                objMesh.setNumberOfFaces(iTemp);
        }
    }

    unsigned int count = 0;
    double x=0, y=0, z=0 ;
    for( ; count < objMesh.totalVertices() ; ++count )
    {
            fgets( buffer , SIZE , fileReadPointer);
            sscanf( buffer, "%lf %lf %lf", &x , &y, &z );

            Vertex tempVertex(x,y,z);
            objMesh.getVertexList().push_back(tempVertex);
    }

    count = 0;
    int  v1=0, v2=0, v3=0, v4=0, v5=0 ;


    for( count = 0 ; count < objMesh.totalFaces() ; ++count )
    {
        fgets( buffer , SIZE , fileReadPointer);
        sscanf( buffer, "%d %d %d %d %d %d", &iTemp, &v1 , &v2, &v3, &v4, &v5 );

        // Triangulate the quads

        if( 3 == iTemp )
        {
            Face objFace;
            objFace.getBoundingVerticesList().push_back( v1 );
            objFace.getBoundingVerticesList().push_back( v2 );
            objFace.getBoundingVerticesList().push_back( v3 );

            objMesh.getFaceList().push_back(objFace);

            if( !objMesh.getParsingStatus() )
            objMesh.getControlMeshFaceList().push_back(objFace);

            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v2);
            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v2].getNeighboringVerticesList().push_back(v1);
            objMesh.getVertexList()[v2].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v2);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v1);
        }

        else if( 4 == iTemp )
        {
            Face objFace1;
            objFace1.getBoundingVerticesList().push_back( v1 );
            objFace1.getBoundingVerticesList().push_back( v2 );
            objFace1.getBoundingVerticesList().push_back( v3 );

            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v2);
            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v2].getNeighboringVerticesList().push_back(v1);
            objMesh.getVertexList()[v2].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v2);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v1);

            Face objFace2;
            objFace2.getBoundingVerticesList().push_back( v3 );
            objFace2.getBoundingVerticesList().push_back( v4 );
            objFace2.getBoundingVerticesList().push_back( v1 );

            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v4);
            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v4].getNeighboringVerticesList().push_back(v1);
            objMesh.getVertexList()[v4].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v4);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v1);

            objMesh.getFaceList().push_back(objFace1);
            objMesh.getFaceList().push_back(objFace2);

            if( !objMesh.getParsingStatus() )
            {
                objMesh.getControlMeshFaceList().push_back(objFace1);
                objMesh.getControlMeshFaceList().push_back(objFace2);
            }
        }

        else if( 5 == iTemp )
        {
            Face objFace1;
            objFace1.getBoundingVerticesList().push_back( v1 );
            objFace1.getBoundingVerticesList().push_back( v2 );
            objFace1.getBoundingVerticesList().push_back( v3 );

            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v2);
            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v2].getNeighboringVerticesList().push_back(v1);
            objMesh.getVertexList()[v2].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v2);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v1);

            Face objFace2;
            objFace2.getBoundingVerticesList().push_back( v3 );
            objFace2.getBoundingVerticesList().push_back( v4 );
            objFace2.getBoundingVerticesList().push_back( v5 );

            objMesh.getVertexList()[v4].getNeighboringVerticesList().push_back(v5);
            objMesh.getVertexList()[v4].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v5].getNeighboringVerticesList().push_back(v4);
            objMesh.getVertexList()[v5].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v4);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v5);

            Face objFace3;
            objFace3.getBoundingVerticesList().push_back( v5 );
            objFace3.getBoundingVerticesList().push_back( v1 );
            objFace3.getBoundingVerticesList().push_back( v3 );

            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v5);
            objMesh.getVertexList()[v1].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v5].getNeighboringVerticesList().push_back(v1);
            objMesh.getVertexList()[v5].getNeighboringVerticesList().push_back(v3);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v5);
            objMesh.getVertexList()[v3].getNeighboringVerticesList().push_back(v1);

            objMesh.getFaceList().push_back(objFace1);
            objMesh.getFaceList().push_back(objFace2);
            objMesh.getFaceList().push_back(objFace3);

            if( !objMesh.getParsingStatus() )
            {
                objMesh.getControlMeshFaceList().push_back(objFace1);
                objMesh.getControlMeshFaceList().push_back(objFace2);
                objMesh.getControlMeshFaceList().push_back(objFace3);
            }
        }

        else
        {
            std::cerr << "Error: Found a face with for than 5 sides" << std::endl ;
        }
    }

    if( !objMesh.getParsingStatus() )
    for( unsigned int i =0 ; i < objMesh.getVertexList().size() ; ++ i )
        objMesh.getControlMeshVertexList().push_back(objMesh.getVertexList()[i]);

    updateMetaInformation();
}