View difference between Paste ID: eVzsnPd4 and 4btAJXLi

 #include <iostream>
 #include<GL/gl.h>
 #include<GL/glut.h>
 #include<stdio.h>
 #include <vector>
 #include <fstream>
 
 using namespace std;
 
 GLfloat X = 0.0f; // Translate screen to x direction (left or right)
 GLfloat Y = 0.0f; // Translate screen to y direction (up or down)
 GLfloat Z = 0.0f; // Translate screen to z direction (zoom in or out)
 GLfloat rotX = 0.0f; // Rotate screen on x axis
 GLfloat rotY = 0.0f; // Rotate screen on y axis
 GLfloat rotZ = 0.0f; // Rotate screen on z axis
 GLfloat rotLx = 0.0f; // Translate screen by using the glulookAt function (left or right)
 GLfloat rotLy = 0.0f; // Translate screen by using the glulookAt function (up or down)
 GLfloat rotLz = 0.0f; // Translate screen by using the glulookAt function (zoom in or out)
 
 float deltaAngle = 0.0f;
 int xOrigin = -1;
 //globals
 
 
 GLuint car;
 float carrot;
 int nTriangles;
 
 //typedef struct Vertex
-class Vertex {
+
 //    double x; //num de vertices
-  public:
+
-    Vertex (int,int,int);
+
 //    double faces; //qtd faces
 //
 //}
 //Vertex;
 
 class Vertex
 {
-Vertex::Vertex(int nx, int ny, int nz) {
+
 public:
     Vertex (double,double,double);
     Vertex();
     ~Vertex();
     double getX(void);
     double getY(void);
     double getZ(void);
 };
 
 Vertex::Vertex(double nx, double ny, double nz)
-Vertex::Vertex(void){
+
     x = nx;
     y = ny;
     z = nz;
-double Vertex::getX(void){
+
 
 Vertex::~Vertex(void)
 {
-double Vertex::getY(void){
+
 }
 
 Vertex::Vertex(void)
-double Vertex::getZ(void){
+
 
 }
 
 double Vertex::getX(void)
 {
     return x;
 }
 
 double Vertex::getY(void)
 {
     return y;
 }
-int globalTriangles[680000][3];
+
 double Vertex::getZ(void)
 {
     return z;
 }
 
 
 vector <Vertex> globalVertices;
 
 typedef struct Triangle
 {
 
 
 } Triangle;
 
 int globalTriangles[680000][5];
 
 //other functions and main
 //.obj loader code
 
 
 void loadObj(char *fname)
 {
 //   FILE *fp;
     int read;
     GLfloat x, y, z;
     int vindex = 0,vtindex = 0,vnindex = 0;
     char ch;
     car=glGenLists(1);
     streampos Position;
     streamoff Offset=0;
     ifstream fp (fname);
 //   fstream InputFile(fname,ios::in);
 //   fp=f(fname,"r");
 //
 
     if (!fp)
     {
-        type = line.substr(0,2);
+
         exit(1);
     }
 //    filebuf * InputBuffer=InputFile.rdbuf();
     glPointSize(2.0);
 //    glPushMatrix();
 //    glBegin(GL_TRIANGLES);
     nTriangles = 0;
     while(!fp.eof())
     {
         string type;
         string line;
 
         while (getline(fp, line))
         {
             type = line.substr(0,2);
             //cout << "linha: " << line << endl;
 
             if (type != "")
             {
                 if(type.compare("v ") == 0)
                 {
                     sscanf (line.c_str(), "%c %f %f %f",&ch,&x,&y,&z);
                     Vertex v(x,y,z);
                     globalVertices.push_back(v);
                     //cout << "vertex" << " x: "<< x << "y: " << y << "z: " << z << endl;
                 }
-                    int temp, vnum, tnum, nnum, v2num, t2num, n2num, v3num, t3num, n3num;
+
                 {
-                    temp = sscanf (line.c_str(), "%c %i/%i/%i",&ch,&vnum,&tnum,&nnum);
+
-                    //cout << "LIDO F: " << temp << endl;
+
-                    if (temp == 4)
+
                 }
-                        temp = sscanf (line.c_str(), "%c %i/%i/%i %i/%i/%i %i/%i/%i",&ch,&vnum,&tnum,&nnum,&v2num,&t2num,&n2num, &v3num, &t3num, &n3num);
+
-                       // cout << "formato f v1/t1/n1" << endl;
+
-//                        Vertex v1 = globalVertices.at(vnum);
+
-//                        Vertex v2 = globalVertices.at(v2num);
+
-//                        Vertex v3 = globalVertices.at(v3num);
+
-//                        globalTriangles[nTriangles].push_back(v1);
+
-//                        globalTriangles[nTriangles].push_back(v2);
+
-//                        globalTriangles[nTriangles].push_back(v3);
+
-//                        nTriangles++;
+
-                          globalTriangles[nTriangles][0] = vnum;
+                    int temp, vnum, tnum, nnum, v2num, t2num, n2num, v3num, t3num, n3num, v4num, t4num;
-                          globalTriangles[nTriangles][1] = v2num;
+
-                          globalTriangles[nTriangles][2] = v3num;
+                    temp = sscanf (line.c_str(), "%c %i//%i %i//%i %i//%i",&ch,&vnum,&tnum, &v2num, &t2num, &v3num, &t3num);
-                          nTriangles++;
+                    if (temp == 7)
                     {
                         globalTriangles[nTriangles][0] = 3;
                         globalTriangles[nTriangles][1] = vnum-1;
-                        temp = sscanf (line.c_str(), "%c %i//%i",&ch,&vnum,&nnum);
+                        globalTriangles[nTriangles][2] = v2num-1;
-                        if (temp == 3)
+                        globalTriangles[nTriangles][3] = v3num-1;
-                        {
+                        nTriangles++;
-                            //cout << "formato f v1//n1" << endl;
+
-                             temp = sscanf (line.c_str(), "%c %i//%i %i//%i %i//%i",&ch,&vnum,&nnum,&v2num,&n2num, &v3num,&n3num);
+
-//                            Vertex v1 = globalVertices.at(vnum);
+
-//                            Vertex v2 = globalVertices.at(v2num);
+                        temp = sscanf (line.c_str(), "%c %i//%i %i//%i %i//%i",&ch,&vnum,&tnum, &v2num, &t2num, &v3num, &t3num, &v4num, &t3num);
-//                            Vertex v3 = globalVertices.at(v3num);
+                        globalTriangles[nTriangles][0] = 4;
-//                            globalTriangles[nTriangles].push_back(v1);
+                        globalTriangles[nTriangles][1] = vnum-1;
-//                            globalTriangles[nTriangles].push_back(v2);
+                        globalTriangles[nTriangles][2] = v2num-1;
-//                            globalTriangles[nTriangles].push_back(v3);
+                        globalTriangles[nTriangles][3] = v3num-1;
-//                            nTriangles++;
+                        globalTriangles[nTriangles][4] = v4num-1;
-                            globalTriangles[nTriangles][0] = vnum;
+                        nTriangles++;
-                            globalTriangles[nTriangles][1] = v2num;
+
-                            globalTriangles[nTriangles][2] = v3num;
+                    //cout << "LIDO F: " << temp << " " << ch << "v1: " << vnum << "/ " << tnum << "v2: "<< v2num  << "/ " << t2num << "v3: "<< v3num << "/ " << t3num << endl;
-                            nTriangles++;
+
-                        }
+
-                        else
+
-                        {
+
-                            temp = sscanf (line.c_str(), "%c %i/%i",&ch,&vnum,&tnum, &v2num, &t2num, &v3num, &t3num);
+
-                            if (temp == 3)
+
-                            {
+
-                                temp = sscanf (line.c_str(), "%c %i/%i/%i",&ch,&vnum,&tnum, &v2num, &t2num, &v3num, &t3num);
+
-//                                Vertex v1 = globalVertices.at(vnum);
+
-//                                Vertex v2 = globalVertices.at(v2num);
+
-//                                Vertex v3 = globalVertices.at(v3num);
+
-//                                globalTriangles[nTriangles].push_back(v1);
+
-//                                globalTriangles[nTriangles].push_back(v2);
+
-//                                globalTriangles[nTriangles].push_back(v3);
+
-//                                nTriangles++;
+
-                               // cout << "formato f v1/t1" << endl;
+
-                            globalTriangles[nTriangles][0] = vnum;
+
-                            globalTriangles[nTriangles][1] = v2num;
+
-                            globalTriangles[nTriangles][2] = v3num;
+
-                            nTriangles++;
+    gluPerspective (135, (GLfloat)w / (GLfloat)h, 0.1, 10000.0);
-                            }
+
-                        }
+
     glLoadIdentity();
     gluLookAt (1.0, 1000.0, 10.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0);
 }
 
 
 void drawCar()
 {
     glPointSize(2.0);
     glNewList(car, GL_COMPILE);
     {
         {
             glPushMatrix();
 //    cout << globalTriangles.size() << endl;
             glColor3f(1.0f, 0.0f, 0.0f);
             glBegin(GL_POINTS);
 //     Vertex v0 = globalVertices[globalTriangles[0][1]];
 //     Vertex v1 = globalVertices[globalTriangles[0][2]];
-    gluPerspective (60, (GLfloat)w / (GLfloat)h, 0.1, 1000.0);
+//     Vertex v2 = globalVertices[globalTriangles[0][3]];
 //     cout << v0.getX() << " " << " " << v0.getY() << " " << v0.getZ() << endl;
 //     cout << v1.getX() << " " << " " << v1.getY() << " " << v1.getZ() << endl;
 //     cout << v2.getX() << " " << " " << v2.getY() << " " << v2.getZ() << endl;
             for (int i = 0; i < globalVertices.size(); i++)
             {
 //    for (int i = 0; i < nTriangles; i++)
 //    {
-    glPushMatrix();
+
-    glTranslatef(0,-40.00,-105);
+//        if (globalTriangles[i][0]  == 3) {
-    glColor3f(1.0,0.23,0.27);
+//            glBegin(GL_TRIANGLES);
-    glScalef(0.1,0.1,0.1);
+//            Vertex v0 = globalVertices[globalTriangles[i][1]];
-    //glRotatef(carrot,0,1,0);
+//            Vertex v1 = globalVertices[globalTriangles[i][2]];
-    glCallList(car);
+//            Vertex v2 = globalVertices[globalTriangles[i][3]];
-    glPopMatrix();
+
-    carrot=carrot+0.6;
+//            glVertex3f(v0.getX(), v0.getY(), v0.getZ());
-    if(carrot>360)carrot=carrot-360;
+//            glVertex3f(v1.getX(), v1.getY(), v1.getZ());
 //            glVertex3f(v2.getX(), v2.getY(), v2.getZ());
 //            glEnd();
 //        }
 //            else if (globalTriangles[i][0] == 4) {
 //
 //            Vertex v0 = globalVertices[globalTriangles[i][1]];
 //            Vertex v1 = globalVertices[globalTriangles[i][2]];
 //            Vertex v2 = globalVertices[globalTriangles[i][3]];
-    glColor3f(1.0f, 0.0f, 0.0f);
+//            Vertex v3 = globalVertices[globalTriangles[i][4]];
 //            glBegin(GL_QUADS);
-    for (int i = 0; i < nTriangles; i++) {
+//            glVertex3f(v0.getX(), v0.getY(), v0.getZ());
 //            glVertex3f(v1.getX(), v1.getY(), v1.getZ());
-        Vertex v0 = globalVertices[globalTriangles[i][0]];
+//            glVertex3f(v2.getX(), v2.getY(), v2.getZ());
-        Vertex v1 = globalVertices[globalTriangles[i][1]];
+//            glVertex3f(v3.getX(), v3.getY(), v3.getZ());
-        Vertex v2 = globalVertices[globalTriangles[i][2]];
+//            glEnd();
-        glBegin(GL_TRIANGLES);
+//        }
-        glVertex3f(v0.getX(), v0.getY(), v0.getZ());
+
-        glVertex3f(v1.getX(), v1.getY(), v1.getZ());
+                Vertex v0 = globalVertices[i];
-        glVertex3f(v2.getX(), v2.getY(), v2.getZ());
+                Vertex v1 = globalVertices[i];
-        glEnd();
+                Vertex v2 = globalVertices[i];
 
                 glVertex3f(v0.getX(), v0.getY(), v0.getZ());
                 glVertex3f(v1.getX(), v1.getY(), v1.getZ());
                 glVertex3f(v2.getX(), v2.getY(), v2.getZ());
 
 
             }
             glEnd();
             glPopMatrix();
             glEndList();
             glPushMatrix();
-    glutInitWindowSize(800,600);
+            glTranslatef(0,-40.00,-105);
-    glutInitWindowPosition(20,20);
+            glColor3f(1.0,0.23,0.27);
             glScalef(0.1,0.1,0.1);
             //glRotatef(carrot,0,1,0);
             glCallList(car);
             glPopMatrix();
-    loadObj("./paredesSimples.obj");//replace porsche.obj with radar.obj or any other .obj to display it
+            carrot=carrot+0.6;
             if(carrot>360)carrot=carrot-360;
 
 
         }
     }
 }
 
 
 void display(void)
 {
     glClearColor (0.0,0.0,0.0,1.0);
     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
     drawCar();
     glutSwapBuffers(); //swap the buffers
 }
 
 
 int main(int argc,char **argv)
 {
     glutInit(&argc,argv);
 
     glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
     glutInitWindowSize(460,300);
     //glutInitWindowPosition(20,20);
     glutCreateWindow("ObjLoader");
     glutReshapeFunc(reshape);
     glutDisplayFunc(display);
     glutIdleFunc(display);
     loadObj("./casa/casa.obj");
     glutMainLoop();
     return 0;
 }