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.
#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.
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!
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!
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!
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