OpenGL Texturas

[caza]

Buenas!

Tengo que aplicar una textura de ladrillos a un cubo pero la verdad es que la explicacion que me dan de como se aplican las texturas en los vertex no es muy buena y me gustaria basicamente eso, que a ver si me lo podeis explicar mejor este punto:

glTexCoord2f(1.0f, 1.0f); glVertex3f(0,1,1);

Y de paso os dejo el codigo.

Código (cpp) [Seleccionar] Expand

#include <Windows.h>
#include <GL\GL.h>
#include <GL\GLU.h>
#include <GL\glut.h>
#include <iostream>
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;
#include <conio.h>
#define BITMAP_ID 0x4D42
GLuint nombres_texturas;
int angulo;

void init(void);
void redraw(void);
void reshape(int, int);

BITMAPINFOHEADER bitmapInfoHeader;
unsigned char* bitmapData;

unsigned char* LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{
   FILE *filePtr;                       // Puntero a programa
   BITMAPFILEHEADER bitmapFileHeader;   // Bitmap file header
   unsigned char *bitmapImage;          // Bitmap image data
   int imageIdx = 0;             // Index de la imagen
   unsigned char tempRGB;

   // Abrimos el archivo en binary mode
   filePtr = fopen(filename,"rb");
   if(filePtr == NULL)
      return NULL;

   // Leemos el bitmap file header
   fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER),1,filePtr);

   // Verificamos que sea un BItmap
   if(bitmapFileHeader.bfType != BITMAP_ID)
   {
      fclose(filePtr);
      return NULL;
   }

   // Leemos la información del bitmap header
   fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER),1,filePtr);

   // Movemos el puntero al principio del bitmap
   fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);

   // Guardamos suficiente memoria para el archivo
   bitmapImage=(unsigned char*) malloc(bitmapInfoHeader->biSizeImage);

   // Verificamos la memoria
   if(!bitmapImage)
   {
      free(bitmapImage);
      fclose(filePtr);
      return NULL;
   }
   fread(bitmapImage,1,bitmapInfoHeader->biSizeImage,filePtr);
   if(bitmapImage == NULL)
   {
      fclose(filePtr);
      return NULL;
   }

   // Cambiamos la imagen a RGB
   for(imageIdx = 0; imageIdx<(int)bitmapInfoHeader->biSizeImage; imageIdx+=3)
   {
      tempRGB = bitmapImage[imageIdx];
      bitmapImage[imageIdx]=bitmapImage[imageIdx+2];
      bitmapImage[imageIdx + 2] = tempRGB;
   }

   // Cerramos el archivo y devolvemos la imagen
   fclose(filePtr);
   return bitmapImage;
}

void init(void)
{
   glClearColor(1.0,1.0,1.0,0.0); // Color fondo pantalla
   glEnable(GL_CULL_FACE);
   glEnable(GL_DEPTH_TEST); // Test de profundidad !IMPORTANTE
   glShadeModel(GL_SMOOTH); // Modo sombreado de poligonos
   glMatrixMode(GL_MODELVIEW);
   gluLookAt(3,-3,3,0,0,0,0,1,0);

   glEnable(GL_TEXTURE_2D);
   glGenTextures(1,&nombres_texturas); // Genero el nombre de la textura

   glBindTexture(GL_TEXTURE_2D, nombres_texturas); // Activamos la textura
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   bitmapData = LoadBitmapFile("agua.bmp", &bitmapInfoHeader);
   gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, bitmapInfoHeader.biWidth,
      bitmapInfoHeader.biHeight, GL_RGB, GL_UNSIGNED_BYTE, bitmapData);

}

void animacion(void)
{
   angulo = (angulo+1)%360;
   Sleep(50);
   glutPostRedisplay();
}

void redraw()
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glPushMatrix();
   // Activo la textura

   glRotatef(angulo,0,1,0);
   glBindTexture(GL_TEXTURE_2D, nombres_texturas);

   // Primera cara
   glBegin(GL_POLYGON);
   glTexCoord2f(0.0f, 0.0f); glVertex3f(-1,0,1);
   glTexCoord2f(1.0f, 0.0f); glVertex3f(1,0,1);
   glTexCoord2f(0.5f, 1.0f); glVertex3f(0,2,0);
   glEnd();

    // Segunda cara
   glBegin(GL_POLYGON);
   glTexCoord2f(0.0f, 0.0f); glVertex3f(1,0,1);
   glTexCoord2f(1.0f, 0.0f); glVertex3f(1,0,-1);
   glTexCoord2f(0.5f, 1.0f); glVertex3f(0,2,0);
   glEnd();

   // Tercera cara
   glBegin(GL_POLYGON);
   glTexCoord2f(0.0f, 0.0f); glVertex3f(1,0,-1);
   glTexCoord2f(1.0f, 0.0f); glVertex3f(-1,0,-1);
   glTexCoord2f(0.5f, 1.0f); glVertex3f(0,2,0);
   glEnd();

   // Cuarta cara
   glBegin(GL_POLYGON);
   glTexCoord2f(0.0f, 0.0f); glVertex3f(-1,0,-1);
   glTexCoord2f(1.0f, 0.0f); glVertex3f(-1,0,1);
   glTexCoord2f(0.5f, 1.0f); glVertex3f(0,2,0);
   glEnd();

   // Quinta cara
   glBegin(GL_POLYGON);
   glTexCoord2f(0.0f, 0.0f); glVertex3f(-1,0,1);
   glTexCoord2f(1.0f, 0.0f); glVertex3f(-1,0,-1);
   glTexCoord2f(1.0f, 1.0f); glVertex3f(1,0,-1);
   glTexCoord2f(0.0f, 1.0f); glVertex3f(1,0,1);
   glEnd();
   glPopMatrix();
   glutSwapBuffers();
}

void reshape( int anchura, int altura)
{
   glViewport(0,0,(GLsizei) anchura, (GLsizei)altura);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(40.0, (GLfloat) anchura/(GLfloat) altura, 1.0, 20.0);
   glMatrixMode(GL_MODELVIEW);
}

   void keyboard(unsigned char tecla, int x, int y)
   {
      if(tecla==27) exit(0);
      if(tecla=='a') glutIdleFunc(animacion);
      if(tecla=='p') glutIdleFunc(NULL);
   }

   void main( int argc, char*argv[])
   {
      glutInit(&argc, argv);
      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
      glutInitWindowSize(320, 240);
      glutCreateWindow("Mapa de Bits");
      init();
      glutDisplayFunc(redraw);
      glutReshapeFunc(reshape);
      glutKeyboardFunc(keyboard);
      glutIdleFunc(animacion);
      glutMainLoop();
   }

Gracias.

[AgeR]

Hola,

Lo primero, ya que seguramente sea una práctica de universidad o similar... deberías decirle al profesor de turno que actualice sus conocimientos de OpenGL, que no basta con habérselos aprendido a duras penas hace más de 10 años y seguir dando el mismo material cada año, ya que OpenGL ha cambiado enormemente y prácticamente nadie usa glut, glVertex y similares, entre otras cosas porque en versiones posteriores están deprecados.

Pero bueno, en cualquier caso, sobre glTexCoord2f:
0,0 : Esquina superior izquierda de la TEXTURA
1,0: Esquina superior derecha
0,1 : Esquina inferior izquierda
1,1 : Esquina inferior derecha

Cada glTexCoord2f corresponde a un glVertex(x, y, z). De esta forma cada vértice tiene su coordenada de textura.

Un saludo!

[caza]

Muchas gracias por responder..

En teoria lo tenia bien pero cuando compilo me salen tres caras del cubo bien, dos a medio completar y una transparente.

A ver si me puedes decir por que es...

Gracias!

[AgeR]

No sabría decirte, pero mirando así rápidamente, veo que en el código comentas que se dibujan 5 caras, en vez de las 6 que tiene un cubo.

Luego usas GL_POLYGON, en las primeras caras lo usas con 3 vértices, con lo cual tienes un triángulo, en la última lo dibujas con 4 vértices. No he usado nunca GL_POLYGON así que solo te puedo decir que mires la documentación al respecto.

Después para las coordenadas de los vértices, ten en cuenta que siguen el formato X,Y,Z. Hazte un mapa mental (o en papel) para ver las coordenadas que debería tener cada vértice de cada cara para dibujarse correctamente.

Por último, y dado que activas el GL_CULL_FACE, ten en cuenta que los polígonos deberán dibujarse en sentido CCW o de lo contrario no se visualizarán.

Un saludo!

[caza]

Vaya fallo... XD copie el código de una pirámide que hice antes en vez de el código del cubo... Muchas gracias xD