Problemas con texturas en OPENGL y C++

[Loopen]

                                Hola, estoy intentando hacer algo con C++ (orientado a objetos) y opengl, el caso es q las texturas se me atragantan.


Uso este codigo

bool Inicializa()
{
  bool PCompleta=true;
  // Pregunta al usuario si quiere ejecutar en modo pantalla completa
  if (MessageBox(NULL,"¿Ejecutar en modo pantalla completa?", "Tutoriales OpenGL",MB_YESNO|MB_ICONQUESTION)==IDNO)
  {    
      PCompleta=false;                     // Modo ventana
  }

  // Creamos nuestra ventana OpenGL
  ObjetoGL=new CGL;
 
  if (!ObjetoGL->CreaVentanaGL("Pruebas del motor 3D",640,480,16,PCompleta))
  {
      return 0;                           // Salir si la ventana no se ha creado
  }

  // Inicializamos la textura
  Textura= new CTextura;

 // !NUEVO!
  if (!Textura->CargarBMP("textura.bmp"))   // !NUEVO!
     
      return 0;                             // !NUEVO!

  // Inicializamos el Cuadrado
  // Triangulo 1
  Cuadrado[0].Vertices[0].Punto.Inicializa(-0.5f,-0.5f,0.0f);   
  Cuadrado[0].Vertices[0].PonCoordText(0.0f,0.0f);    // !NUEVO!
  Cuadrado[0].Vertices[1].Punto.Inicializa(-0.5f,0.5f,0.0f);   
  Cuadrado[0].Vertices[1].PonCoordText(0.0f,1.0f);    // !NUEVO!
  Cuadrado[0].Vertices[2].Punto.Inicializa(0.5f,0.5f,0.0f);   
  Cuadrado[0].Vertices[2].PonCoordText(1.0f,1.0f);    // !NUEVO!
   
  // Triangulo 2
  Cuadrado[1].Vertices[0].Punto.Inicializa(-0.5f,-0.5f,0.0f);   
  Cuadrado[1].Vertices[0].PonCoordText(0.0f,0.0f);    // !NUEVO!
  Cuadrado[1].Vertices[1].Punto.Inicializa(0.5f,0.5f,0.0f);   
  Cuadrado[1].Vertices[1].PonCoordText(1.0f,1.0f);    // !NUEVO!
  Cuadrado[1].Vertices[2].Punto.Inicializa(0.5f,-0.5f,0.0f);   
  Cuadrado[1].Vertices[2].PonCoordText(1.0f,0.0f);    // !NUEVO!
  return 1;
}







int Renderiza(GLvoid)                     
{
   int i,ntri;
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);   // Borramos la pantalla y el buffer de profundidad
   glLoadIdentity();                           // Inicializamos la matriz de modelado actual
   
   glTranslatef(0.0f,0.0f,fDesz);         // Trasladamos a lo largo del eje Z
   glRotatef(fRotx,1.0f,0.0f,0.0f);      // Rotamos alrededor del eje X
   glRotatef(fRoty,0.0f,1.0f,0.0f);      // Rotamos alrededor del eje Y
   
   Textura->Usa();
   for (ntri=0;ntri<=2;ntri++)
      
   {
      
   
      glBegin(GL_TRIANGLES);
      for (i=0;i<3;i++)
      {
           glTexCoord2f( Cuadrado[ntri].Vertices.U,Cuadrado[ntri].Vertices.V);
           glVertex3f(Cuadrado[ntri].Vertices.Punto.X,
                      Cuadrado[ntri].Vertices.Punto.Y,
                        Cuadrado[ntri].Vertices.Punto.Z);
       }
   
      glEnd(); // Terminamos de dibujar
   }
   return TRUE;                              // Todo ha ido bien
}


Inicializa evidentemente es lo primero que carga mi programa. el metodo CargaBMP de la clase textura es este:



bool CTextura::CargarBMP(char *NombreFichero)
{
  FILE *Fichero;
  AUX_RGBImageRec *Imagen;
  bool Resultado=false;


  if (NombreFichero)                               // Comprobamos que el nombre de fichero sea correcto
  {
      Fichero=fopen(NombreFichero,"r");           // Comprobamos si el fichero existe (Si podemos abrirlo)

      if (Fichero!=NULL)                                  // ¿Existe el fichero?
      {
          fclose(Fichero);                          // Cerramos el handle
                 
          Imagen=auxDIBImageLoad(NombreFichero);   // Cargamos el BMP
          glGenTextures(1, &ID);
         glBindTexture(GL_TEXTURE_2D, ID);
          glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
          glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
         Ancho=Imagen->sizeX;
          Alto=Imagen->sizeY;
      
          glTexImage2D(GL_TEXTURE_2D, 0, 3, Ancho, Alto, 0, GL_RGB, GL_UNSIGNED_BYTE, Imagen->data);
      
          Resultado=true;
      }
  }  
  delete Imagen->data;
  delete Imagen;        
 
  return Resultado;
}


El codigo del metodo usa es este:


void CTextura::Usa()
{
   glBindTexture(GL_TEXTURE_2D, ID);
}



Y yo creo que deberia funcionar, pero el cuadrado que me genera al ejecutar es perfectamente blanco, sin texturas, ya se que he metido mucho codigo para ser un post pero es q estoy muy desesperao y estoy bastante pez. A ver si me podeis ayudar.                                

[_Grey]

                                Paso de leer todo el codigo, y ademas hace tiempo que no toco OpenGL.............

Pero podria ser :

glEnable(GL_TEXTURE_2D);

o eso parece.                                

[Loopen]

                                Te entiendo totalmente :-) y no te culpo, pero no el el GLEnable, he comprobado que lo hago                                

[_Grey]

                                Pues ni idea............

pero esto:

delete Imagen->data;

No deberias de borrar la imagen si la quieres usar  :ojo:

Todo y que quizas no sea eso, pero no tendria que estar ahi.                                

[Loopen]

                                Tampoco es eso :-( , ademas segun tenia entendido una vez que registras la textura en opengl te puedes cargar la imagen para ahorrar memoria, corregirme si me equivoco. Estoy dandole vueltas al codigo y por mas que lo hago no encuentro el error.                                

[BeRSeRKeR]

                                Es un BMP válido?...en tu caso debería ser de 24 bits...

Saludos                                

[Loopen]

                                Si q lo es, :-( , la verdad es q cada vez le encuentro menos explicacion                                

[Mars Attacks]

                                http://www4.uji.es/~ribelles

Mira en la sección de prácticas si te has dejado alguna función por hacer. Ahí va paso por paso. Espero que te sirva de ayuda.                                

[Loopen]

                                Pues no, me parece que hago todo y me funciona mal igualmente                                

[ethernet]

La textura tiene tamaño 2^n ?
prueba a poner una texura cualquiera de tanaño 32 x 32 o 256 x 256 cualquiera.

El delete esta bien, una vez pasados los datos a opengl no es necesario tener la imagen en memoria :D

saludos

[Loopen]

                                ya he encontrado el error, me faltaba la llamada a la funcion gluBuild2DMipmaps , lo he copiado desde una web pero no se muy bien que hace ni porque no me funcionaba sin ella, si alguien es tan amable de explicarmelo. Gracias a todos por vuestro interes                                

[ethernet]

No tiene nada q ver, esa funcion sirve para calcular varias texturas y aplicar una u otra en funcion de la distancia para ganar asi velocidad. (no necesitamos ver una mosca a una distancia de 100 metros)

Lo q pasa es q en glTexParameter le has pasado GL_LINEAR_MIPMAP_LINEAR, prueba a quitar el gluBuild2dmipmap y poner GL_LINEAR donde tienes GL_LINEAR_MIPMAP_LINEAR.

saludos

[Ithaqua]

                                Si te funciona con gluBuild2DMipmaps() es porque estabas cargando un bitmap con tamaño inválido (algún lado no es potencia de 2). gluBuild2DMipmaps() reescala internamente la imágen si no cumple esta condición, glTexImage2D() no.
La diferencia entre una función y otra es que gluBuild2DMipmaps(), aparte de cargar la textura, te crea todos los niveles de mipmap para ella, tendrás que activar el filtrado adecuado, eso sí.
Si no sabes en qué consiste el mipmapping busca en google o en el red book de OpenGL.

Hay por ahí una función muy maja que es glGetError(), prueba a usarla cuando te encuentres con casos como ese.
Para algo están los códigos de error :)                                

[ethernet]

gluGetErrorString(); te puede ayudar tb, te da el error de forma legible

itha ;***

saludos

[Loopen]

                                La textura es 256 x 256, si q es tamaño de 2