Dudas con iluminacion en OpenGL

[kokorico]

Hola a todos, me estoy iniciando en el tema de la programacion grafica y tengo bastantes dudas sobre la iluminacion.
Cargo un modelo 3D desde un archivo (uso Assimp, para importar archivos 3D). He comprobado que  los poligonos se pintan en sentido contrario a las agujas del reloj, y tambien he comprobado que las normales se calculan bien:
http://picasaweb.google.com/lh/photo/WIwiaasKZkHLHVvn20Afaw?feat=directlink

Este es el codigo de init()

Código [Seleccionar] Expand


int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
glClearDepth(1.0);
glClearColor(0.1f, 0.3f, 0.3f, 0.0f);

glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);

glEnable(GL_LIGHTING);
GLfloat ambientLight[] = {.30f,.30f,.30f,1.0f};
GLfloat difusseLigth[] = {.70f,.70f,0.70f,1.0f};
GLfloat specularLight[] = {1.0f,1.0f,1.0f,1.0f};


glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambientLight);
GLfloat lightPos[] = {4,-6,-4};
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,difusseLigth);
glEnable(GL_LIGHT0);

glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glFrontFace(GL_CCW);

std::cout << gluErrorString(glGetError());
return TRUE;
}


Y este el de dibujado (que no me parece que tenga nada de especial)

Código [Seleccionar] Expand


glBegin(GL_TRIANGLES);
for(unsigned int j=0; j < mesh->mNumFaces; j++)
{
int vert1 = mesh->mFaces[j].mIndices[0];
int vert2 = mesh->mFaces[j].mIndices[1];
int vert3 = mesh->mFaces[j].mIndices[2];

glNormal3f(mesh->mNormals[vert1].x,mesh->mNormals[vert1].y,mesh->mNormals[vert1].z);
glVertex3f(mesh->mVertices[vert1].x,mesh->mVertices[vert1].y,mesh->mVertices[vert1].z);
glNormal3f(mesh->mNormals[vert2].x,mesh->mNormals[vert2].y,mesh->mNormals[vert2].z);
glVertex3f(mesh->mVertices[vert2].x,mesh->mVertices[vert2].y,mesh->mVertices[vert2].z);
glNormal3f(mesh->mNormals[vert3].x,mesh->mNormals[vert3].y,mesh->mNormals[vert3].z);
glVertex3f(mesh->mVertices[vert3].x,mesh->mVertices[vert3].y,mesh->mVertices[vert3].z);
}
glEnd();

               //dibujar normales
glColor3f(1,1,1);
glBegin(GL_LINES);
for(unsigned int j=0; j < mesh->mNumFaces; j++)
{
int vert1 = mesh->mFaces[j].mIndices[0];
int vert2 = mesh->mFaces[j].mIndices[1];
int vert3 = mesh->mFaces[j].mIndices[2];

glVertex3f(mesh->mVertices[vert1].x,mesh->mVertices[vert1].y,mesh->mVertices[vert1].z);
glVertex3f( mesh->mVertices[vert1].x +mesh->mNormals[vert1].x
,mesh->mVertices[vert1].y + mesh->mNormals[vert1].y
,mesh->mVertices[vert1].z + mesh->mNormals[vert1].z);


glVertex3f(mesh->mVertices[vert2].x,mesh->mVertices[vert2].y,mesh->mVertices[vert2].z);
glVertex3f( mesh->mNormals[vert2].x + mesh->mVertices[vert2].x
,mesh->mNormals[vert2].y + mesh->mVertices[vert2].y
,mesh->mNormals[vert2].z + mesh->mVertices[vert2].z);

glVertex3f(mesh->mVertices[vert3].x,mesh->mVertices[vert3].y,mesh->mVertices[vert3].z);
glVertex3f( mesh->mNormals[vert3].x + mesh->mVertices[vert3].x
,mesh->mNormals[vert3].y + mesh->mVertices[vert3].y
,mesh->mNormals[vert3].z + mesh->mVertices[vert3].z);
}
glEnd();


Lo que me resulta mas raro de todo es que cuando cambio la posicion de la luz, y en vez de

Código [Seleccionar] Expand


GLfloat lightPos[] = {4,-6,-4};

Le pongo

Código [Seleccionar] Expand


GLfloat lightPos[] = {4,-7,-4};

O mas de -7, entonces me hace esto (desactivo el pintado de normales para que se vea mejor:

http://picasaweb.google.com/lh/photo/XPBMFshWCaeOOSBTuofNAw?feat=directlink

Aunque no se ve mucho, se ve que es el interior del cubo lo que esta mostrando y no es exterior. No entiendo por que, puesto que eso seria un problema de test de profundidad pero me aparece cuando vario la luz.

Por favor, si pudierais darme una pista os lo agradeceria :)

[tamat]

haces cull del front face, es decir, le dices que no muestre las caras que apuntan a la cámara. No pongas esa linea, por defecto ya lo hace culleando el back face. Para comprobarlo puedes desactivar el culling.

luego en el caso de la luz el vector tiene que ser de cuatro si no recuerdo mal, siendo la cuarta componente 0 o 1 en función de si el vector determina una posicion o una dirección.

[kokorico]

Muchas gracias, funciona perfectamente.

Una ultima pregunta. Leyendo algunos tutoriales sobre materiales e iluminacion me encuentro que muchos de ellos hacen un glenable(GL_TEXTURE_2D). Afecta en algo los materiales con las texturas?

[tamat]

por defecto las texturas se modulan por el color resultante, es decir, si el objeto es rojo y la textura es blanca y negra, el resultado será el objeto texturizado en rojo y negro.

entiendo que es temprano pero tal vez te interesaría empezar a mirar el tema de shaders ya que los temas que estas tratando (materiales e iluminacion) son cosas que ya estan deprecadas y han sido reemplazadas por shaders, incluso en dispositivos portatiles.

[kokorico]

Shaders en dispositivos portatiles? ¿Que me estas contando?  8o

La verdad es que es algo que tengo que hacer. He empezado por "opengl Programming" y después me liaré con el "more openGL programming" (viva amazon :) ). El tema de materiales me interesaba porque de momento no se usar programas de diseño 3D mas allá de materiales, así que es la única forma de dar algo de presencia a los modelos, pero estoy viendo por  ahí que los tutoriales son bastante antiguos. Mi idea era usar materiales + texturas para dar apariencia a los objetos, y después shaders, pero todavia me queda algo de camino

Muchisimas gracias por la ayuda.

[tamat]

el problema es que aprenderas muchas cosas que ya no se usan porque fueron reemplazadas por los shaders, puede ir bien para aprender los conceptos pero no pierdas tiempo en la sintaxis.

Antiguamente como las tarjetas no eran programables tenias que usar un sin fin de flags para definir cómo querias que se renderizase. Eso a dia de hoy se considera obsoleto, directamente programas tú el algoritmo que define cómo se pinta un pixel con la información que tienes, si necesitas más informacion se la pasas al shader.

en el standar de opengl ES (que es el que usan muchos dispositivos portatiles) los shaders estan soportados, y en las ultimas versiones directamente no puedes usar la fixed pipeline, eso incluye (glBegin/glEnd, glTranslate/Rotate/Scale, glMatrixMode, glLoadMatrix, incluso glColor o glNormal).

[kokorico]

Mmmm, entonces, sin perder de vista el GL clasico, que lenguage deberia aprender? CG, HLSL, GLSL?

Gracias

[tamat]

GLSL, para no salir del estandar de openGL

[kokorico]

Pues muchas gracias. Voy a ver si me documento un poco sobre el tema.