Hola a todos estoy empezando programar en openGL y ya lo llevo bastante adelantado la verdad estoy muy contento pensé que me costaría mas
.
he conseguido cargar el formato obj sin problemas y me manejo bien con las cámaras, iluminación y demás pero me a surgido un problema que no se como solucionar ???
Estoy cargando ahora modelos en el formato del quake II osea .MD2 y la lectura de los datos y la renderizacion sin animaciones y con animaciones muy bien el problema me a surgido al poner las texturas por que no me las coloca bien
y eso que descomprimo bien las coordenadas de texturas por que en todos los textos que he leído sobre el formato MD2 la forma de descodificar estas coordenadas es cogiendo S y dividiendo lo por el ancho de la imagen y cogiendo T y dividiéndolo por el alto de la imagen por cada vértice pero aun así las texturas se colocan mal mirar aquí os pongo el código que estoy usando haber si podéis echarme una mano yo creo que es por que la imagen era PNG y estas textura tiene un canal alpha y al trasformarla a BMP la he jodió pero es que no se como cargar imágenes png en C para usarlas de texturas.
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL\gl.h>
#include <GL\glaux.h>
typedef float vec3_t[3];
//CABECERA DEL MD2
struct md2_header_t
{
int ident;
int version;
int skinwidth;
int skinheight;
int framesize;
int num_skins;
int num_vertices;
int num_st;
int num_tris;
int num_glcmds;
int num_frames;
int offset_skins;
int offset_st;
int offset_tris;
int offset_frames;
int offset_glcmds;
int offset_end;
};
//NOMBRE DE LA TEXTURA
struct md2_skin_t
{
char name[64];
};
//CORDENADAS DE LA TEXTURA
struct md2_texCoord_t
{
short s;
short t;
};
// ESTRUCTURA DONDE VAMOS A GUARDAR LOS TRIANGULOS
struct md2_triangle_t
{
unsigned short vertex[3];
unsigned short st[3];
};
//COMPRESION DE VERTICES
struct md2_vertex_t
{
unsigned char v[3];
unsigned char normalIndex;
};
//FRAMES DEL MODELO
struct md2_frame_t
{
vec3_t scale;
vec3_t translate;
char name[16];
struct md2_vertex_t *verts;
};
/* GL command packet */
struct md2_glcmd_t
{
float s;
float t;
int index;
};
//ESTRUCTURA DEL MODELO MD2
struct md2_model_t
{
struct md2_header_t header;
struct md2_skin_t *skins;
struct md2_texCoord_t *texcoords;
struct md2_triangle_t *triangles;
struct md2_frame_t *frames;
int *glcmds;
GLuint tex_id;
};
//TABLA CON LAS NORMALES PRECALCULADAS
vec3_t anorms_table[162] = {
#include "anorms.h"
};
//MODELO MD2
struct md2_model_t md2file;
/* OpenGL texture info */
struct gl_texture_t
{
GLsizei width;
GLsizei height;
GLenum format;
GLint internalFormat;
GLuint id;
GLubyte *texels;
};
#pragma pack(1)
/* PCX header */
struct pcx_header_t
{
GLubyte manufacturer;
GLubyte version;
GLubyte encoding;
GLubyte bitsPerPixel;
GLushort xmin, ymin;
GLushort xmax, ymax;
GLushort horzRes, vertRes;
GLubyte palette[48];
GLubyte reserved;
GLubyte numColorPlanes;
GLushort bytesPerScanLine;
GLushort paletteType;
GLushort horzSize, vertSize;
GLubyte padding[54];
};
#pragma pack(4)
/* Texture id for the demo */
GLuint texId;
double PI = 3.14159265359;
GLfloat xRot = 0.0f;
GLfloat yRot = 0.0f;
GLfloat Rotacion = 0;
GLfloat shadowMat[4][4];
GLfloat lightPos[4] = { -50.0f, 150.0f, -200.0f, 1.0f };
GLint NumeroVertices = 0,NumeroNormales = 0,NumeroTexturas = 0,NumeroFacetas = 0;
GLint Vertical = 0,Horizontal = 0,PRotacion = 3,PrimeraVez = 1;
GLint PCuadroX = 0,PCuadroY = 0,PCuadroZ = 0;
GLfloat PPersonajeX = 0.0f,PPersonajeZ = 0.0f,Bandera = 1;
int ReadMD2Model (const char *filename, struct md2_model_t *mdl);//DEFINIMOS LA FUNCION ReadMD2Model
/*AQUI CREAMOS UNA FUNCION A LA QUE LE TENEMOS QUE PASAR PRIMERO
EL NOMBRE DEL ARCHIVO MD2 QUE QUEREMOS CARGAR Y LUEGO LA ESTRUCTURA
DEL MODELO MD2 COMPLETA OSEA MD2FILE.*/
int ReadMD2Model (const char *filename, struct md2_model_t *mdl)
{
FILE *fp,*FicheroE;
int i;
char Captura[255];
fp = fopen (filename, "rb"); //ABRIMOS EL FICHERO COMO LECTURA DE BITS
if (!fp)//COMPROBAMOS QUE EL FICHERO SE HALLA ABIERTO BIEN
{
fprintf (stderr, "Error: couldn't open \"%s\"!\n", filename);//SI NO MANDAMOS UN ERROR
return 0; //DEVOLVEMOS 0 POR QUE SE A PRODUCIDO UN ERROR
}
fread (&mdl->header, 1, sizeof (struct md2_header_t), fp);//LEEMOS LA CABECERA DESDE EL FICHERO
if ((mdl->header.ident != 844121161) ||
(mdl->header.version != 8))//COMPROBAMOS QUE SEA UN ARCHIVO MD2 VALIDO
{
/* Error! */
fprintf (stderr, "Error: bad version or identifier\n");//SI NO ES ASI MANDAMOS UN ERROR
fclose (fp);//CERRAMOS EL ARCHIVO
return 0;//DEVOLVEMOS 0 POR QUE SE A PRODUCIDO UN ERROR
}
mdl->skins = (struct md2_skin_t *)
malloc (sizeof (struct md2_skin_t) * mdl->header.num_skins);//RESERVAMOS ESPACIO PARA LOS NOMBRES DE TEXTURAS
mdl->texcoords = (struct md2_texCoord_t *)
malloc (sizeof (struct md2_texCoord_t) * mdl->header.num_st);//RESERVAMOS ESPACIO PARA LOS VERTICES DE TEXTURAS
mdl->triangles = (struct md2_triangle_t *)
malloc (sizeof (struct md2_triangle_t) * mdl->header.num_tris);//RESERVAMOS ESPACIO PARA LOS TRIANGULOS QUE FORMAN EL MODELO
mdl->frames = (struct md2_frame_t *)
malloc (sizeof (struct md2_frame_t) * mdl->header.num_frames);//RESERVAMOS ESPACIO PARA LOS FRAMES
mdl->glcmds = (int *)malloc (sizeof (int) * mdl->header.num_glcmds);//RESERVAMOS ESPACIO PARA LAS LISTAS DE COMANDOS GL
fseek (fp, mdl->header.offset_skins, SEEK_SET);//NOS MOVEMOS EN EL FICHERO A LA POSICION DENDE SE ESCUENTRAN LOS NOMBRES DE LAS TEXTURAS
fread (mdl->skins, sizeof (struct md2_skin_t),
mdl->header.num_skins, fp);//LEEMOS LOS NOMBRES DE LAS TEXTURAS Y LOS COLOCAMOS EN mdl->skins
fseek (fp, mdl->header.offset_st, SEEK_SET);//NOS MOVEMOS EN EL FICHERO A LA POSICION DENDE SE ESCUENTRAN LOS VERTICES DE LAS TEXTURAS
fread (mdl->texcoords, sizeof (struct md2_texCoord_t),
mdl->header.num_st, fp);//LEEMOS LOS VERTICES DE LAS TEXTURAS Y LOS COLOCAMOS EN mdl->texcoords
fseek (fp, mdl->header.offset_tris, SEEK_SET);//NOS MOVEMOS EN EL FICHERO A LA POSICION DENDE SE ESCUENTRAN LOS TRIANGULOS
fread (mdl->triangles, sizeof (struct md2_triangle_t),
mdl->header.num_tris, fp);//LEEMOS LOS TRIANGULOS Y LOS COLOCAMOS EN mdl->triangles
fseek (fp, mdl->header.offset_glcmds, SEEK_SET);//NOS MOVEMOS EN EL FICHERO A LA POSICION DENDE SE ESCUENTRAN LOS TRIANGULOS
fread (mdl->glcmds, sizeof (int), mdl->header.num_glcmds, fp);//LEEMOS LAS LISTAS DE COMANDOS GL Y LOS COLOCAMOS EN mdl->glcmds
fseek (fp, mdl->header.offset_frames, SEEK_SET);//NOS MOVEMOS EN EL FICHERO NUEVAMENTE A LA POSICION DENDE SE ESCUENTRAN LOS FRAMES
for (i = 0; i < mdl->header.num_frames; ++i)/*HACEMOS UN FOR PARA LEER TODOS LOS FRAMES CULLO NUMERO ESTA GUARDADO
DENTRO DE header.num_frames ESTO SE REPETIRA MIENTRAS I SEA MENOR AL
NUMERO DE FRAMES DE ESTE MODELO*/
{
mdl->frames[i].verts = (struct md2_vertex_t *)
malloc (sizeof (struct md2_vertex_t) * mdl->header.num_vertices);//RESERVAMOS MEMORIA PARA LOS VERTICES DE CADA FRAME
fread (mdl->frames[i].scale, sizeof (vec3_t), 1, fp);//LEMOS LOS DATOS ESCALA DE ESTE FRAME Y LA PONEMOS EN mdl->frames[i].scale
fread (mdl->frames[i].translate, sizeof (vec3_t), 1, fp);//LEMOS LOS DATOS DE TRASLACION DE ESTE FRAME Y LA PONEMOS EN mdl->frames[i].translate
fread (mdl->frames[i].name, sizeof (char), 16, fp);//LEMOS EL NOMBRE DE ESTE FRAME Y LA PONEMOS EN mdl->frames[i].name
fread (mdl->frames[i].verts, sizeof (struct md2_vertex_t),
mdl->header.num_vertices, fp);//LEMOS LOS VERTICES DE ESTE FRAME Y LA PONEMOS EN mdl->frames[i].verts
}
FicheroE = fopen("texturas.txt","wt");
sprintf(Captura, "Tamano Imagen : %dX%d\n",mdl->header.skinwidth,mdl->header.skinheight);
fputs(Captura,FicheroE);
fclose(FicheroE);
fclose (fp);//CERRAMOS EL ARCHIVO
return 1;//DEVOLVEMOS 1 COMO QUE LA LECTURA DE LOS DATOS DEL ARCHIVO A TENIDO EXITO
}
void CargarTexturas(const char *filename)
{
AUX_RGBImageRec *Imagen;
GLint tex_id;
glGenTextures(1,&tex_id);
glBindTexture(GL_TEXTURE_2D,tex_id);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
Imagen = auxDIBImageLoad(filename);
gluBuild2DMipmaps(GL_TEXTURE_2D,3,Imagen->sizeX,Imagen->sizeY,GL_RGB,GL_UNSIGNED_BYTE,Imagen->data);
}
/*AQUI CREAMOS UNA FUNCION PARA LIBERAR LA MEMORIA QUE TENIAMOS
RESERVADA PARA NUESTRO MODELO A LA QUE LE PASAMOS LA ESTRUCTURA DEL MODELO
MD2 COMPLETA OSEA MD2FILE precedido por &.*/
void FreeModel (struct md2_model_t *mdl)
{
int i;
if (mdl->skins)/*SI mdl->skins TIENE MEMORIA RESERVADA ENTRAMOS ESTO QUIERE DECIR
QUE SI mdl->skins ES DISTINTO DE CERO ES QUE TIENE MEMORIA RESERVADA
Y TENEMOS QUE LIBERARLA EN CASO CONTRARIO NO HARIA FALTA Y PASAMOS AL
SIGUIENTE if*/
{
free (mdl->skins);//LIBERAMOS LA MEMORIA RESERVADA PARA mdl->skins
mdl->skins = NULL;//PONEMOS EL VALOR DE mdl->skins A CERO PASANDOLE NULL
}
if (mdl->texcoords)/*SI mdl->texcoords TIENE MEMORIA RESERVADA ENTRAMOS ESTO QUIERE DECIR
QUE SI mdl->texcoords ES DISTINTO DE CERO ES QUE TIENE MEMORIA RESERVADA
Y TENEMOS QUE LIBERARLA EN CASO CONTRARIO NO HARIA FALTA Y PASAMOS AL
SIGUIENTE if*/
{
free (mdl->texcoords);//LIBERAMOS LA MEMORIA RESERVADA PARA mdl->texcoords
mdl->texcoords = NULL;//PONEMOS EL VALOR DE mdl->texcoords A CERO PASANDOLE NULL
}
if (mdl->triangles)/*SI mdl->triangles TIENE MEMORIA RESERVADA ENTRAMOS ESTO QUIERE DECIR
QUE SI mdl->triangles ES DISTINTO DE CERO ES QUE TIENE MEMORIA RESERVADA
Y TENEMOS QUE LIBERARLA EN CASO CONTRARIO NO HARIA FALTA Y PASAMOS AL
SIGUIENTE if*/
{
free (mdl->triangles);//LIBERAMOS LA MEMORIA RESERVADA PARA mdl->triangles
mdl->triangles = NULL;//PONEMOS EL VALOR DE mdl->triangles A CERO PASANDOLE NULL
}
if (mdl->glcmds)/*SI mdl->glcmds TIENE MEMORIA RESERVADA ENTRAMOS ESTO QUIERE DECIR
QUE SI mdl->glcmds ES DISTINTO DE CERO ES QUE TIENE MEMORIA RESERVADA
Y TENEMOS QUE LIBERARLA EN CASO CONTRARIO NO HARIA FALTA Y PASAMOS AL
SIGUIENTE if*/
{
free (mdl->glcmds);//LIBERAMOS LA MEMORIA RESERVADA PARA mdl->glcmds
mdl->glcmds = NULL;//PONEMOS EL VALOR DE mdl->glcmds A CERO PASANDOLE NULL
}
if (mdl->frames)/*SI mdl->frames TIENE MEMORIA RESERVADA ENTRAMOS ESTO QUIERE DECIR
QUE SI mdl->frames ES DISTINTO DE CERO ES QUE TIENE MEMORIA RESERVADA
Y TENEMOS QUE LIBERARLA EN CASO CONTRARIO NO HARIA FALTA Y PASAMOS AL
SIGUIENTE if*/
{
for (i = 0; i < mdl->header.num_frames; ++i)/*AQUI LA COSA SE COMPLICA UN POCO PERO NO
NEMASIADO OS ACORDAIS DE QUE RESERVAMOS
MEMORIA PARA LOS VERTICES DE CADA FRAME
PUES AHORA LA TENEMOS QUE LIBERAR TAMBIEN
SI NO SEGUIRIA EN MEMORIA ASI QUE VOLVEMOS
A INCLUIR UN FOR CON EL NUMERO DE FRAMES
Y VAMOS LIBERANDO LOS VERTICES DE LA MEMORIA
FRAME POR FRAME*/
{
free (mdl->frames[i].verts);//LIBERAMOS LA MEMORIA RESERVADA PARA mdl->frames[i].verts PARA ES TE FRAME
mdl->frames[i].verts = NULL;//PONEMOS EL VALOR DE mdl->frames[i].verts A CERO PASANDOLE NULL PARA ESTE FRAME
}
free (mdl->frames);/*Y AQUI FINALMENTE UNA VEZ HEMOS LIBERADO TODA LA MEMORIA DE LOS VERTICES DE LOS
DE LOS DISTINTOS FRAMES LIMERAMOS LA MEMORIA RESERVADA PARA mdl->frames*/
mdl->frames = NULL;//PONEMOS EL VALOR DE mdl->frames A CERO PASANDOLE NULL
}
}
/*AQUI CREAMOS UNA FUNCION PARA RENDERIZAR EL MODELO
EN EL FRAME QUE QUERAMOS A ESTA FINCION LE TEMEMOS QUE PASAR
PRIMERO EL NUEMRO DE FRAME QUE QUEREMOS RENDERIZAR Y LUEGO LA
ESTRUCTURA DEL MODELO MD2 COMPLETA OSEA MD2FILE precedido por &.*/
void RenderFrame (int n, const struct md2_model_t *mdl)
{
int i, j;
GLfloat s, t;
vec3_t v;
struct md2_frame_t *pframe;
struct md2_vertex_t *pvert;
if ((n < 0) || (n > mdl->header.num_frames - 1)) /*COMPROBAMOS QUE EL VALOR QUE LE HEMOS PASADO
A LA FUNCION COMO NUMERO DE FRAME NO SE MENOR
QUE 0 POR QUE NO PINTARIA NUNGUN FRAME Y
SEGURAMENTE TENDRIAMOS DESBORDAMIENTO DE BUFFER
NI QUE SEA MAYOR DEL NUMERO DE FRAMES DISPONIBLE
POR QUE NOS PASARIA LO MISMO JAJAJA*/
return;//EN CASO DE QUE EL VALOR SEA MENOR DE 0 O MAYOR DEL NUMERO DE FRAMES VOLVEMOS SIN HACER NADA
glEnable(GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, 1);
//glBindTexture (GL_TEXTURE_2D, mdl->tex_id);//ACTIVAMOS LA TEXTURA
glBegin (GL_TRIANGLES);//COMENZAMOS A PINTAR EL MODELO
for (i = 0; i < mdl->header.num_tris; ++i)/*HACEMOS UN FOR PARA LEER TODOS LOS TRIANGULOS
CULLO NUMERO ESTA GUARDADO DENTRO DE
mdl->header.num_tris ESTO SE REPETIRA MIENTRAS I
SEA MENOR AL NUMERO DE TRIANGULOS DE ESTE MODELO*/
{
for (j = 0; j < 3; ++j)/*HACEMOS UN FOR PARA PODER MODIFICAR LOS VERTICES DE CADA TRIANGULO
Y ASI PODER POSICIONARLOS BIEN EN PANTALLA COMO BIEN SABEIS
UN TRIANGULO CONSTA DE 3 VERTICES PARA PODER DIBUJARLO POR ESO
ESTE FOR SE REPETIRA MIENTRAS J SEA MENOR DE 3 QUE ES EL NUMERO
DE VERTICES POR CADA TRIANGULO*/
{
pframe = &mdl->frames[n];/*PONEMOS EN pframe EL FRAME DESIGNADO POR EL NUMERO QUE HEMOS
PASADO A LA FUNCION EN PRIMER LUGAR*/
pvert = &pframe->verts[mdl->triangles[i].vertex[j]];/*PONEMOS EN pvert LOS PUNTOS QUE
DENOMINAN CADA VERTIC CORESPONDIENTES
A CADA TRIANGULO DEL MODELO EN CADA
VUELTA DEL FOR*/
/* AQUI LO QUE HACEMOS ES DESIGNAL LOS PUNTOS DE CORDENADAS PAR LA TEXTURA
POR CADA VERTICE DEL TRIANGULO Y LOS PONEMOS EN s Y t RESPECTIVAMENTE */
s = (GLfloat)mdl->texcoords[mdl->triangles[i].st[j]].s / mdl->header.skinwidth;
t = (GLfloat)mdl->texcoords[mdl->triangles[i].st[j]].t / mdl->header.skinheight;
glTexCoord2f (s,t);//PONEMOS LAS CORDENADAS DE LA TEXTURA PARA ESTE VERTICE
glNormal3fv (anorms_table[pvert->normalIndex]);//PONEMOS LAS NORMALES PARA ESTE VERTICE
/* AQUI VAMOS A CALCULAR LA POSION REAL DE CADA VERTICE DEL MODELO PARA
PODER VISUALIZARLO EN PANTALLA */
v[0] = (pframe->scale[0] * pvert->v[0]) + pframe->translate[0];/*PONEMOS EN v[0] EL VALOR
"X" DEL VERTICE Y LO SACAMOS
MULTIPLICANDO LA ESCALA POR
LA POSICION "X" DEL VERTICE
Y LE SUMAMOS LA TRASLACION QUE
TIENE "X" Y LISTO FACIL VERDAD*/
v[1] = (pframe->scale[1] * pvert->v[1]) + pframe->translate[1];/*PONEMOS EN v[1] EL VALOR
"Y" DEL VERTICE Y LO SACAMOS
MULTIPLICANDO LA ESCALA POR
LA POSICION "Y" DEL VERTICE
Y LE SUMAMOS LA TRASLACION QUE
TIENE "Y" Y LISTO FACIL VERDAD*/
v[2] = (pframe->scale[2] * pvert->v[2]) + pframe->translate[2];/*PONEMOS EN v[1] EL VALOR
"Z" DEL VERTICE Y LO SACAMOS
MULTIPLICANDO LA ESCALA POR
LA POSICION "Z" DEL VERTICE
Y LE SUMAMOS LA TRASLACION QUE
TIENE "Z" Y LISTO FACIL VERDAD*/
glVertex3fv (v);//PINTAMOS EL VERTICE
}
}
glEnd ();//FINALIZAMOS DE PINTAR EL MODELO
}
void CALLBACK CambioDeTamano(GLsizei w,GLsizei h)
{
if(h == 0){h = 1;}
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,w/h,0.1f,1025.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void CALLBACK KeyLeft(void)
{
Rotacion += (3.1415/30.0f);
if(Rotacion > (2.0*PI)) // Keep in bounds
Rotacion = 0.0;
}
void CALLBACK KeyRight(void)
{
Rotacion -= (3.1415/30.0f);
if(Rotacion > (2.0*PI)) // Keep in bounds
Rotacion = 0.0;
}
void CALLBACK KeyUp(void)
{
GLfloat xDelta = 0.0f,zDelta = 0.0f;
xDelta = 10*cos(Rotacion);
zDelta = -10*sin(Rotacion);
PPersonajeX += (float)xDelta;
PPersonajeZ += (float)zDelta;
}
void CALLBACK KeyDown(void)
{
GLfloat xDelta = 0.0f,zDelta = 0.0f;
xDelta = (-10)*cos(Rotacion);
zDelta = -(-10)*sin(Rotacion);
PPersonajeX += (float)xDelta;
PPersonajeZ += (float)zDelta;
}
void Inicio(void)
{
GLfloat points[3][3] = {{ -120.0f, -99.0f, -20.0f },
{ -120.0f, -99.0f, 20.0f },
{ 60.0f, -99.0f, 120.0f }};
GLfloat ambientLight[] = { 0.3f, 0.3f, 0.3f, 1.0f };
GLfloat diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f };
GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f};
GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glClearColor(0.0f,0.0f,0.0f,1.0f);
//glColor3f(1.0f,1.0f,1.0f);
glShadeModel(GL_SMOOTH);
Rotacion = (PI/2.0);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
//glPolygonMode(GL_FRONT,GL_FILL);
// Setup and enable light 0
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
glMateriali(GL_FRONT,GL_SHININESS,128);
ReadMD2Model("play.md2",&md2file);
CargarTexturas("play.bmp");
//LeerObj();
//glFrontFace(GL_CCW);
}
void CALLBACK RenderizarEscena(void)
{
GLfloat x,y,angle;
GLint ipivot = 1;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glPushMatrix();
gluLookAt(PPersonajeX,5.0f,PPersonajeZ,((PPersonajeX)+(50*(float)(cos(Rotacion)))),1.0f,((PPersonajeZ)-(50*(float)(sin(Rotacion)))),0.0f,1.0f,0.0f);
glPushMatrix();
glTranslatef(-0.0f,-10.0f,-100.0f);
glRotatef (-90.0f, 1.0, 0.0, 0.0);
glRotatef (-90.0f, 0.0, 0.0, 1.0);
glColor3f(1.0f,1.0f,1.0f);
RenderFrame(1,&md2file);
glPopMatrix();
glPushAttrib(GL_LIGHTING_BIT);
glDisable(GL_LIGHTING);
glPushMatrix();
glTranslatef(lightPos[0],lightPos[1], lightPos[2]);
auxSolidSphere(5.0f);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0f,-100.0f, 0.0f);
glPolygonMode(GL_FRONT,GL_FILL);
glBegin(GL_QUADS);
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-4000.0f,-100.0f,-4000.0f);
glVertex3f(-4000.0f,-100.0f,4000.0f);
glVertex3f(8000.0f,-100.0f,4000.0f);
glVertex3f(8000.0f,-100.0f,-4000.0f);
glEnd();
glPopMatrix();
glPopAttrib();
glPopMatrix();
glFlush();
auxSwapBuffers();
}
int main(void)
{
auxInitDisplayMode(AUX_DOUBLE|AUX_RGBA|AUX_DEPTH);
auxInitPosition(100,50,640,480);
auxInitWindow("CARGAR MD2 DE SONIC EN OPENGL");
Inicio();
//LeerObj();
auxReshapeFunc(CambioDeTamano);
auxKeyFunc(AUX_LEFT,KeyLeft);
auxKeyFunc(AUX_RIGHT,KeyRight);
auxKeyFunc(AUX_UP,KeyUp);
auxKeyFunc(AUX_DOWN,KeyDown);
auxMainLoop(RenderizarEscena);
return 0;
}
ACTUALIZACIÓN:Pues después de tirarme toda la noche mirando código de otra gente e conseguido solucionar el problema del texturizado del modelo POR FIN!!! esta mal casi toda la documentación por no decir que toda jajaja en "glTexCoord2f (s,t);"
por que hay que ponerlo así "glTexCoord2f (s,1.0f- t);" y listo las texturas cargadas perfectamente madremia que comida de cabeza jajaja pero a veces esta es la parte divertida de programar y como se aprende jajaja.
Un saludo y gracias de antemano
Kaltorak.
