✔ obj. Loader C++

Nabend,

hätte übers We ein wenig rumgebastelt.

Das eine leere Zeile zu einem Error führt, habe ich auch rausbekommen, und soweit, funktioniert das Aspeichern nun.

Ärgerlicher weiße, ist mir auch erst später aufgefallen, dass der einzulesende Blender File noch gar keine Normals ("vn") hatte, was natürlich auch wieder zu dem vorher beschriebenen Error fehlte.

Aber nun treten keine Errormeldungen mehr auf

Allerdings liefert nun die display()-Routine nur ein weißes Bild :/

Jetzt stellt sich natürlich die Frage, ob meine load-Object-Methode tatsächlich schrott ist (was ich bezweifle, da ich diese aus nem Toturial habe, wos anschließend funktioniert hat), oder ob in meiner Main/display noch etwas fehlt?

Weiter unten hatte ich mich mal SDL probiert, aber leider auch ohne Erfolg :/


Soweit der aktuelle Stand

Gruß Luq




Code: 
////////////////////////////////////////////////////////////////////////
// Projekt  : Aufgabe 2.1-2.5:  Datum: 16.04.2012  //
// Autor    : Lukas Sauer                                             //
//                                                                    //
////////////////////////////////////////////////////////////////////////



#include <windows.h>
#include <stdlib.h>
#include <glut.h>
#include <stdio.h>


#include <GL/gl.h>
#include <GL/glu.h>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
#include <fstream>
#include <cstdio>
#include <iostream>


struct coordinate{
	float x, y, z; 
	coordinate(float a, float b, float c) : x(a), y(b), z(c) {}; 
}; 


struct face{
	int facenum; 
	bool four; 
	int faces[4]; 
	face(int facen, int f1, int f2, int f3) : facenum(facen){
		faces[0]=f1; 
		faces[1]=f2; 
		faces[2]=f3;
		four=false; 		
	}
	face(int facen, int f1, int f2, int f3, int f4): facenum(facen) {
		faces[0]=f1; 
		faces[1]=f2; 
		faces[2]=f3;
		faces[3]=f4;
		four=true; 
		
	}
}; 



float angle = 0.0; 

int loadObject(const char* filename)
{
	std::vector<std::string*> coord; 
	std::vector<coordinate*> vertex; 
	std::vector<face*> faces; 
	std::vector<coordinate*> normals; 
	std::ifstream in(filename); 
	if(!in.is_open())
	{
		std::cout << "Not open" << std::endl; 
		return -1; 
	}


	char buf[256]; 
	while(!in.eof())
	{
		in.getline(buf, 256); 
		coord.push_back(new  std::string(buf));
	}
	for(int i = 0; i < coord.size(); i++)
	{
		if((*coord[i])[0]=='#')
			continue; 
		else if((*coord[i])[0] =='v' && (*coord[i])[1] == ' ' )
		{			
			float tmpx, tmpy, tmpz; 
			sscanf(coord[i]->c_str(), "v %f %f %f",&tmpx, &tmpy, &tmpz); 
			vertex.push_back(new coordinate(tmpx, tmpy, tmpz)); 
			
		}
		else if((*coord[i])[0] =='v' && (*coord[i])[1] =='n' )
		{
			float tmpx, tmpy, tmpz;
			sscanf(coord[i]->c_str(), "vn %f %f %f",&tmpx, &tmpy, &tmpz);
			normals.push_back(new coordinate(tmpx, tmpy, tmpz)); 
			
		}else if((*coord[i])[0]=='f')
		{
			int a, b, c, d, e; 				
		
			if(count(coord[i]->begin(),coord[i]->end(),' ')==3)     //if it is a triangle (it has 3 space in it)
			{
					sscanf(coord[i]->c_str(),"f %d//%d %d//%d %d//%d",&a,&b,&c,&b,&d,&b);
					faces.push_back(new face(b,a,c,d));     //read in, and add to the end of the face list
			}
			else
			{
					sscanf(coord[i]->c_str(),"f %d//%d %d//%d %d//%d %d//%d",&a,&b,&c,&b,&d,&b,&e,&b);
					faces.push_back(new face(b,a,c,d,e));   //do the same, except we call another constructor, and we use different pattern
			}
			
		}

	}

	//draw

	int num;        //the id for the list
        num=glGenLists(1);      //generate a uniqe
        glNewList(num,GL_COMPILE);      //and create it
        for(int i=0;i<faces.size();i++)
        {
                if(faces[i]->four)      //if it's a quad draw a quad
                {
                        glBegin(GL_QUADS);
                                //basically all I do here, is use the facenum (so the number of the face) as an index for the normal, so the 1st normal owe to the first face
                                //I subtract 1 because the index start from 0 in C++
                                glNormal3f(normals[faces[i]->facenum-1]->x,normals[faces[i]->facenum-1]->y,normals[faces[i]->facenum-1]->z);
                                //draw the faces
                                glVertex3f(vertex[faces[i]->faces[0]-1]->x,vertex[faces[i]->faces[0]-1]->y,vertex[faces[i]->faces[0]-1]->z);
                                glVertex3f(vertex[faces[i]->faces[1]-1]->x,vertex[faces[i]->faces[1]-1]->y,vertex[faces[i]->faces[1]-1]->z);
                                glVertex3f(vertex[faces[i]->faces[2]-1]->x,vertex[faces[i]->faces[2]-1]->y,vertex[faces[i]->faces[2]-1]->z);
                                glVertex3f(vertex[faces[i]->faces[3]-1]->x,vertex[faces[i]->faces[3]-1]->y,vertex[faces[i]->faces[3]-1]->z);
                        glEnd();
                }else{
                        glBegin(GL_TRIANGLES);
                                glNormal3f(normals[faces[i]->facenum-1]->x,normals[faces[i]->facenum-1]->y,normals[faces[i]->facenum-1]->z);
                                glVertex3f(vertex[faces[i]->faces[0]-1]->x,vertex[faces[i]->faces[0]-1]->y,vertex[faces[i]->faces[0]-1]->z);
                                glVertex3f(vertex[faces[i]->faces[1]-1]->x,vertex[faces[i]->faces[1]-1]->y,vertex[faces[i]->faces[1]-1]->z);
                                glVertex3f(vertex[faces[i]->faces[2]-1]->x,vertex[faces[i]->faces[2]-1]->y,vertex[faces[i]->faces[2]-1]->z);
                        glEnd();
                }
        }

	glEndList(); 

	for(int i=0; i<coord.size();i++)	
		delete coord[i];
	
	for(int i=0; i<faces.size(); i++)
		delete faces[i];

	for(int i=0; i<normals.size();i++)	
		delete normals[i];
	
	for(int i=0; i<vertex.size(); i++)
		delete vertex[i];

	return num; 
}




int cube; 


void init()
{
        glClearColor(0.0,0.0,0.0,1.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45,640.0/480.0,1.0,500.0);
        glMatrixMode(GL_MODELVIEW);
        glEnable(GL_DEPTH_TEST);
        cube=loadObject("C:\\Users\\Luki89\\Desktop\\link.obj");    //load the test.obj file
        glEnable(GL_LIGHTING);  //we enable lighting, to make the 3D object to 3D
        glEnable(GL_LIGHT0);
        float col[]={1.0,1.0,1.0,1.0};  //light color is white
        glLightfv(GL_LIGHT0,GL_DIFFUSE,col);
}

void display()
{
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        float pos[]={-1.0,1.0,-2.0,1.0};        //set the position
        glLightfv(GL_LIGHT0,GL_POSITION,pos);
        glTranslatef(0.0,0.0,-5.0);
        glRotatef(angle,0.0,0.0,1.0);
        glCallList(cube);       //draw the 3D mesh
}


void reshape (int w, int h)
{
   
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
   glMatrixMode (GL_MODELVIEW);
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

void idle( void )
{
	glutPostRedisplay();
}



int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE GLUT_RGB | GLUT_DEPTH);  
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();   
   glutDisplayFunc(display); 
   glutIdleFunc( idle );
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}
/*

int main(int argc,char** argv)
{
		
        SDL_Init(SDL_INIT_EVERYTHING);
        SDL_Surface* screen=SDL_SetVideoMode(640,480,32,SDL_SWSURFACE|SDL_OPENGL);
        bool running=true;
        Uint32 start;
        SDL_Event event;
        init();
        while(running)
        {
                start=SDL_GetTicks();
                while(SDL_PollEvent(&event))
                {
                        switch(event.type)
                        {
                                case SDL_QUIT:
                                        running=false;
                                        break;
                        }
                }
                display();
                SDL_GL_SwapBuffers();
                angle+=0.5;
                if(angle>360)
                        angle-=360;
                if(1000/30>(SDL_GetTicks()-start))
                        SDL_Delay(1000/30-(SDL_GetTicks()-start));
        }
        SDL_Quit();
        return 0;      
}
*/
 
mir hat ein glFlush() gefehlt, läuft jetzt alles, wie es sollte :)

Nochmals vielen Dank für eure Hilfe.


Mit freundlichem Gruß

Luq
 
Moin,

also hab die oben angeführt Fehlermeldung beheben können, indem ich die beiden obj. Dateien einfach aus der Projektmappe gelöscht haben, allerdings löst das immer noch nicht all meine Probleme

Und zwar, springt er nun von vorneherein in die Zeile 63 und gibt folgendes aus:

std::cout << "Not open" << std::endl;

Heißt natürlich, dass er die Datei an der angegebenen Stelle nicht finden kann. Habs natürlcich sowohl mit dem relativen Pfad als auch mit dem absoluten versucht, leider ohne Erfolg.
Liegt das nun an der Datei selber? Weil dann müsste es ja, wenn ich die Informationen in einer Textdatei abspeicher funktionieren.

Vielen Dank für dem Link zu dem anderen Thread, allerdings ist CodeCrafterCpp schon einen Schritt weiter als ich.


Mit freundlichem Gruß
Luq
Zum Vergrößern anklicken....

Das würde ich nicht behaupten :D
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück