GLSL matrices

[misscelan]

Buenas,

Tengo dudas y problemillas.

Código [Seleccionar] Expand


varying vec4 lightproj;
varying vec4 lightpos;

uniform mat4 LPM;  //ProjModelView de la luz
uniform mat4 CPOV;
uniform mat4 NORM;

uniform vec3 lpos;  //posicion de la luz

void main(void)
{
  gl_TexCoord[0] = gl_MultiTexCoord0;
  gl_TexCoord[1] = gl_MultiTexCoord1;

  lightproj      = LPM * gl_Vertex; //convertir el vertice a LPOV

  lightpos       = (vec4(lpos, 1) - gl_Vertex);  //para luego sacar la longitud
  gl_Position    = ftransform();

}


Este el el código de mi vertex shader para una implementación de shadow mapping que estoy haciendo.

EL shadow mapping funciona para el escenario que se renderiza sin tocar nada de la ModelView. Para los modelos antes de pintarlos hago un glTranslatef y un glRotatef y ahí está el problema, los modelos no reciben el sombreado.

El shadow map lo almaceno en una textura en un fbo, ahí si se almacena todo correctamente ya que los modelos si generan sombras pero como dije no las reciben.

Un tío en gamedev me dijo que el problema es que no aplicaba las transformaciones que hacía a los modelos (gltranslatef, glRotatef) al vector lightproj y que para solucionarlo lo multiplicasa por la Projmv, no lo entendí porque lo que entiendo es que ese vertice tengo que convertirlo al punto de vista de la luz y esa matriz no cambia.

Ya puesto alguien me podría aclarar que información guarda gl_Vertex, es decir está pasado por alguna matriz?.

Muchas gracias y un saludo.

[tamat]

A ver, responderé como pueda porque creo que tu pregunta abarca bastante:

gl_Vertex es exactamente el vertice que le pasas con la llamada glVertex3f(...), o el stream.

Obviamente para que cada modelo se renderice en la posicion adecuada de la escena ese vertice debe multiplicarse por la model del objeto, luego ademas querras que la camara este posicionada en algun punto de la escena, con lo que tambien se debe multiplicar por la view de la camara, y finalmente querras controlar la proyeccion para temas de fov, aspect o ortogonal, con lo que tambien lo multiplicaras por la projection.

Normalmente al shader se le pasa la MVP que es la concatenacion de esas tres matrices, VP es constante para la escena mientras que la M varia por objeto con lo que la MVP varia por objeto.

ftransform multiplica el vertice por la MVP que tiene almacenada en la fixed pipeline de openGL, es decir, por la model * view * projection.

Si quieres hacer shadowmaps la model de cada objeto será la misma tanto cuando pintes en el shadowmap como cuando pintes la escena final, pero la view y la projection cambiaran en funcion de la posicion del foco y las propiedades de este (el cono de apertura).

Lo chungo es que para pintar la escena final necesitaras la matriz que convierte de espacio de objeto a espacio de luz, es decir, la M del objeto multiplicada por la VP de la luz.

Para ello tienes que calcularla antes y subirla como parametro al shader.
Se que hay maneras de hacerlo directo usando funciones de GLSL y de la fixed pipeline pero yo soy mas de subir las cosas a mano asi que no puedo ayudarte mucho mas.

Suerte

[misscelan]

Gracias por tu ayuda tamat, me has aclarado muchas cosas.

la ProjecView de la luz la genero así:

Código [Seleccionar] Expand


glLoadIdentity();
glTranslatef( 0.5f, 0.5f, 0.5f );                      // Offset
glScalef( 0.5f, 0.5f, 0.5f );
glMultMatrixf(&luces[i].matProj.m[0]);
glMultMatrixf(&luces[i].matView.m[0]);
glGetFloatv(GL_MODELVIEW_MATRIX, luces[i].matProjView.m);


Después matProjView es lo que paso al shader como LPM.

Para el escenario no modifico nada, ni haga translaciones  ni rotaciones, los vértices son los mismos que en el programa de diseño, supongo que por esto lightproj  = LPM * gl_Vertex; funciona para el escenario.

Para los modelos hago una traslación y rotación antes de pintarlos y supongo que al shader llegan los vertices tal y como salieron del programa de diseño, porque es lo que paso al glDrawArrays, entonces debería aplicar esas translaciones y rotaciones al shader para que estén el mismo sistema que el escenario no?.

Ahora, esas supuestas manipulaciones que hago antes de pintar el modelo, están en en gl_ModelViewMatrix que hay en shader en el momento que pinte los modelos? porque he probado ha multiplicar los vertex por la glModelView y nanai.

Muchas gracias por la ayuda!

[misscelan]

Conseguí algo que funciona pero es un poco cutre.

Lo que hago es cada vez que quiero pintar el modelo limpio una matriz, hago las movimientos y paso esa matriz al vertex shader. Cuando renderizo el escenario le paso la identidad.

El caso es que si en vez de pasarle la identidad (para el escenario) o la matriz limpia con las trasnformaciones y rotaciones (para los modelos) le paso simplemente gl_modelview o la projecmodelview no funciona. En la fixed pipeline cada vez que va a pintar esos vértices no los pasa por esas matrices???

Gracias y un saludo!!!!