//-----------------------------------------------------// // // Codigo del curso de programacion de videojuegos // // Clase para carga y manejo de modelos .COB de texto // (Caligari truSpace) // // UnSitioWeb.com para programar juegos // (cc) Reconocimiento-NoComercial-SinObrasDerivadas // // Codigo probado en: // VC++ 2005 Express con SDK Microsoft instalado // //-----------------------------------------------------// // Aclaramos las comparaciones de cadenas. #define Distintas(a,b) 0!=_stricmp(a,b) #define Iguales(a,b) 0==_stricmp(a,b) // Estructura de un triangulo (Cara) del modelo struct Triangulo { // Un indice de la posicion en el array // por cada vertice... GLuint vertices[3]; // ...por cada coordenada de textura.. GLuint texcor[3]; // ...por cadanormal... GLuint normales[3]; // ...indice de la normal por caras(facetado) GLuint normal; // Indice del material con que se pinta. GLuint material; }; // Estructura de un material struct Material { // Fichero de la textura char textura[100]; // Identificativo de la textura GLuint Tex; // Offset colocar la textura. GLfloat tOffset[2]; // Repeticion de la textura GLfloat tRepite[2]; // Componente difusa GLfloat difusa[4]; // Componente ambiente GLfloat ambiente[4]; // componente especular GLfloat especular[4]; // Componente emisiva GLfloat emisiva[4]; // Brillo GLfloat brillo; // Numero de caras (triangulos) con este // material en la malla de triangulos GLuint NCaras; }; // Estructura para los datos de los // bounding volumes. struct _bound { GLfloat maxX; GLfloat minX; GLfloat maxY; GLfloat minY; GLfloat maxZ; GLfloat minZ; GLfloat radio; }; //-------------------------------------------------------------- // Funcion para comparar triangulos que se pasa // como parametro a qsort(...), para ordenar los // triangulos por material. int comparar(const void *a, const void *b) { if( (*(Triangulo *)a).material < (*(Triangulo *)b).material ) return(-1); else if( (*(Triangulo *)a).material > (*(Triangulo *)b).material) return(1); else return(0); } //--------------------------------------------------------------------------- // Clase modeloCOB que encapsula la carga y // manejo de modelos truSpace de texto. class modeloCOB { private: // Variables auxiliares para // guardar vectores, puntos, vertices o // lo que se nos antoje de tres coordenadas float v[3],v2[3]; // Array para guardar la matriz que leeremos // del fichero y deberemos aplicar a los vertices // de cada malla de las que se componga el modelo. float trans[4][4]; // Numero de vertices GLuint NVertices; // Puntero para guardar vertices GLfloat (*Vertices)[3]; // Puntero para guardar los vertices // definitivos. GLfloat (*Puntos)[3]; // Numero de coordenadas de textura. GLuint NCorTex; // Puntero para guardar coordenadas // de textura GLfloat (*CorTex)[2]; // Puntero para guardar coordenadas // de textura definitivas. GLfloat (*uvTex)[2]; // Numero de normales. GLuint NNormales; // Puntero para normales por vertice. GLfloat (*Normales2)[3]; // Puntero para normales definitivas // por vertice. GLfloat (*Normales)[3]; // Numero de normales por cara. GLuint NFNormales; // Puntero para las normales // por cara. GLfloat (*FNormales)[3]; // Numero de caras (triangulos) // del modelo. GLuint NCaras; // Puntero para guardar las caras. Triangulo *Caras; // Numero de mateiales diferentes // en este objeto GLuint NMateriales; // Puntero para guardar los materiales. Material *Materiales; // Definimos tres variables para guardar el identificativo // de los VBOs que vamos a usar. GLuint vboVertices; GLuint vboNormales; // Funcion para separar datos de tipo "<5,45>" // de un fichero .cob. p=1 retorna el primer parametro, // p=2 el segundo. int IndiceCara(char *cad,int p=1); // Funcion para borrar el modelo void BorraModelo(); public: // Funcion para cargar modelo de fichero .COB (trueSpace) en // ASCII y triangulado. bool CargaModelo(char *fich); // Dibuja el modelo. void PintaModelo(); // Constructor modeloCOB(); // Constrructor con carga modeloCOB(char *fich); // Destructor ~modeloCOB(); // He dejado este VBO en la parte publica // para usarlo desde fuera de la clase en caso // de querer aplicar otra textura mas al modelo // con estas coordenadas. GLuint vboTextura; // Este estructura almacenara los datos // de los "bounding volumes" del modelo _bound bound; }; //-------------------------------------------------------------------- modeloCOB::modeloCOB() { NVertices=0; NCorTex=0; NNormales=0; NFNormales=0; NCaras=0; NMateriales=0; } //-------------------------------------------------------------------- modeloCOB::modeloCOB(char *fich) { NVertices=0; NCorTex=0; NNormales=0; NFNormales=0; NCaras=0; NMateriales=0; CargaModelo(fich); } //--------------------------------------------------------------------- modeloCOB::~modeloCOB() { if(NVertices!=0) BorraModelo(); } //--------------------------------------------------------------------- // Funcion para separar datos de tipo "<5,45>" // de un fichero .cob. p=1 retorna el primer parametro, // p=2 el segundo. int modeloCOB::IndiceCara(char *cad,int p) { char *prt; char aux[100]; strcpy(aux,cad); prt=strtok(aux+1,",><"); if(p==1) return atoi(prt); else return atoi(strtok(NULL,",><") ); } //----------------------------------------------------------------------- // Funcion para cargar modelo de fichero .COB (trueSpace) en // ASCII y triangulado. bool modeloCOB::CargaModelo(char *fich) { // Variable temporal para el calculo // del radio. GLfloat r_temp; // Variables para indices. int i,i2; // Puntero Puntos es NULL. Asi podre comprobar // si he cargado el modelo. Puntos=NULL; // Creo un objeto del tipo (clase) // fichero, de nombre cob. fichero cob(fich); // Si falla ¿para que seguir? if( cob.fallo ) return false; // Recorro lo primero el fichero para contar los // vertices, coordenadas de textura, // caras (triangulos) y materiales, y asi // luego reservar el espacio en memoria // necesario. //int mallas=0; // Mientras no termine el fichero. while(!cob.fin) { cob.leelinea(); //if(Iguales(cob.campo[0],"PolH")) mallas++; if(Iguales(cob.campo[0],"World")) NVertices+=atoi(cob.campo[2]); if(Iguales(cob.campo[0],"Texture")) NCorTex+=atoi(cob.campo[2]); if(Iguales(cob.campo[0],"Faces")) NCaras+=atoi(cob.campo[1]); if(Iguales(cob.campo[0],"mat#")) NMateriales++; } // Una vez visto, me pongo al principio para // la siguiente pasada. cob.principio(); // Reservo memoria para lo que necesito // por ahora. Vertices=new GLfloat[NVertices][3]; CorTex=new GLfloat[NCorTex][2]; Caras=new Triangulo[NCaras]; Materiales=new Material[NMateriales]; // Recorro el fichero cagando datos de cada cosa. // Variables para valores parciales de cada cosa. int V=0,V2=0,T=0,T2=0,F=0,M=0; // Variable auxiliar para el color. float rgb[3]; // Mientras no termine el fichero. // Recorro definitivamente el fichero. while(!cob.fin) { // Lee una linea. cob.leelinea(); // Si encuentra la palabra "PolH" al principio // de la linea es que hay una nueva malla. if(Iguales(cob.campo[0],"PolH") ) { // Lee 7 lineas. cob.leelinea(7); // Cargamos la matriz de transformacion // de los vertices para esta malla. for(i=0;i<4;i++) { for(i2=0;i2<4;i2++) trans[i][i2]=atof(cob.campo[i2]); cob.leelinea(); } } // Si encontramos en primer lugar de la linea // la palabra "World", hay que cargar vertices. if(Iguales(cob.campo[0],"World") ) { // Pongo indices parciales. V2=i=V; // Sumo el numero de vertices de esta malla al // de vertices que llevamos. V+=atoi(cob.campo[2]); // Del ultimo vertice de la vez anterior hasta // la suma total. for(;i bound.maxX ) bound.maxX=v2[1]; if( v2[2] > bound.maxY ) bound.maxY=v2[2]; if( v2[0] > bound.maxZ ) bound.maxZ=v2[0]; if( v2[1] < bound.minX ) bound.minX=v2[1]; if( v2[2] < bound.minY ) bound.minY=v2[2]; if( v2[0] < bound.minZ ) bound.minZ=v2[0]; } // Para la bounding sphere nos quedamos con // la mayor distancia de un vertice a la coordenada // 0,0,0. r_temp=(GLfloat)sqrt(v2[1]*v2[1] + v2[2]*v2[2] + v2[0]*v2[0]); if(bound.radio < r_temp) bound.radio = r_temp; } cob.leelinea(); } // Lo mismo que el apartado anterior, pero // con las coordenadas de textura. // Aqui no hay que convertir. if(Iguales(cob.campo[0],"Texture") ) { T2=i=T; T+=atoi(cob.campo[2]); for(;i". if(Iguales(cob.campo[0],"Faces") ) { i=F; F+=atoi(cob.campo[1]); for(;icos_angulo) { av[0]+=FNormales[Caras[c[k]].normal][0]; av[1]+=FNormales[Caras[c[k]].normal][1]; av[2]+=FNormales[Caras[c[k]].normal][2]; } } } // Normlizo el resultado. Normaliza(av); // Pongo los indices de las nuevas // normales en la cara. if(Caras[c[j]].vertices[0]==i) Caras[c[j]].normales[0]=indnor; if(Caras[c[j]].vertices[1]==i) Caras[c[j]].normales[1]=indnor; if(Caras[c[j]].vertices[2]==i) Caras[c[j]].normales[2]=indnor; // Y guardo la normal en el array Normales2[indnor][0]=av[0]; Normales2[indnor][1]=av[1]; Normales2[indnor][2]=av[2]; indnor++; } } // Reservo espacio para los bufferes // definitivos de vertices (puntos), // de coordenadas de textura (uv) y // normales suavizadas (las de cara ya estan // ordenadas. // Esto se hace por la forma de trabajar de // "glDrawArrays(...)". // Reservo espacio y declaro variables auxiliares. GLfloat *xv, *xuv, *xnor, ou, ov, ru, rv; Puntos=new GLfloat[NCaras*3][3]; uvTex=new GLfloat[NCaras*3][2]; Normales=new GLfloat[NCaras*3][3]; // Los punteros auxiliares iran recorriendo los // arrays (espacios reservados). xv=(GLfloat*)Puntos; xuv=(GLfloat*)uvTex; xnor=(GLfloat*)Normales; // Porque no sea como el primer material M=10000; // Recorro los triangulos. for(i2=0;i2