shadowmapping opengl glsl shader graphiques math

Question

J'ai des difficultés à comprendre les maths entre les différentes étapes du shader.

dans le fragment shader du point de vue des lumières j'écris essentiellement le fragDepth rgb couleur

#version 330 

out vec4 shader_fragmentColor; 

void main() 
{ 
    shader_fragmentColor = vec4(gl_FragCoord.z, gl_FragCoord.z, gl_FragCoord.z, 1); 
    //shader_fragmentColor = vec4(1, 0.5, 0.5, 1); 
} 

lors du rendu de la scène en utilisant le shader ci-dessus affiche la scène dans une toute couleur blanche. Je suppose que c'est parce que gl_FragCoord.z ​​est plus grand que 1. J'espère qu'il n'est pas au maximum à 1. Mais nous pouvons laisser cette question tout seul pour l'instant.

Dans le geometry shader du point de vue des caméras, je transforme fondamentalement tous les points en quads et j'écris la position de la texture probablement "incorrecte" pour la recherche dans lightTexture. le calcul ici est la question. Im également un peu incertain si la valeur d'interpolation sera correcte dans la prochaine étape de shader.

#version 330 
#extension GL_EXT_geometry_shader4 : enable 

uniform mat4 p1_modelM; 
uniform mat4 p1_cameraPV; 
uniform mat4 p1_lightPV; 

out vec4 shader_lightTexturePosition; 

void main() 
{ 
    float s = 10.00; 

    vec4 llCorner = vec4(-s, -s, 0.0, 0.0); 
    vec4 llWorldPosition = ((p1_modelM * llCorner) + gl_in[0].gl_Position); 
    gl_Position = p1_cameraPV * llWorldPosition; 
    shader_lightTexturePosition = p1_lightPV * llWorldPosition; 
    EmitVertex(); 

    vec4 rlCorner = vec4(+s, -s, 0.0, 0.0); 
    vec4 rlWorldPosition = ((p1_modelM * rlCorner) + gl_in[0].gl_Position); 
    gl_Position = p1_cameraPV * rlWorldPosition; 
    shader_lightTexturePosition = p1_lightPV * rlWorldPosition; 
    EmitVertex(); 

    vec4 luCorner = vec4(-s, +s, 0.0, 0.0); 
    vec4 luWorldPosition = ((p1_modelM * luCorner) + gl_in[0].gl_Position); 
    gl_Position = p1_cameraPV * luWorldPosition; 
    shader_lightTexturePosition = p1_lightPV * luWorldPosition; 
    EmitVertex(); 

    vec4 ruCorner = vec4(+s, +s, 0.0, 0.0); 
    vec4 ruWorldPosition = ((p1_modelM * ruCorner) + gl_in[0].gl_Position); 
    gl_Position = p1_cameraPV * ruWorldPosition; 
    shader_lightTexturePosition = p1_lightPV * ruWorldPosition; 
    EmitVertex(); 

    EndPrimitive(); 
} 

dans le fragment shader de la perspective des caméras i basiquement recherche dans la lightTexture quelle couleur serait démontré par les lumières perspecive et d'écrire la même couleur.

#version 330 

uniform sampler2D p1_lightTexture; 

in vec4 shader_lightTexturePosition; 

out vec4 shader_fragmentColor; 

void main() 
{ 
    vec4 lightTexel = texture2D(p1_lightTexture, shader_lightTexturePosition.xy); 
    shader_fragmentColor = lightTexel; 
    /* 
    if(lightTexel.x < shader_lightTexturePosition.z) 
     shader_fragmentColor = vec4(1, 0, 0, 1); 
    else 
     shader_fragmentColor = vec4(0, 1, 0, 1); 
    */ 
    //shader_fragmentColor = vec4(1, 1, 1, 1); 
} 

lors du rendu du point de vue des caméras que je vois la scène dessiné comme il se doit, mais avec la texture incorrecte des coordonnées appliquées sur ceux qui se répète. La texture répétitive est probablement due au fait que la coordonnée de texture est en dehors des limites de 0 à 1.

J'ai essayé plusieurs choses mais je n'arrive toujours pas à comprendre ce que les maths devraient être. certains de code et en a commenté un exemple im sûr de est:

shader_lightTexturePosition = normalize(p1_lightPV * llWorldPosition)/2 + vec4(0.5, 0.5, 0.5, 0.5); 

pour le coin inférieur gauche. le code de similair aux autres coins

de la solution je m'attends à ce que la scène soit rendue du point de vue de la caméra avec exactement la même couleur que du point de vue des lumières. avec peut-être une erreur de précision.

Answer 1

J'ai trouvé le bit de mappage de texture moi-même. le bit de profondeur est encore un peu étrange. convertir les screenProjectedCoords à normizedDeviceCoords puis ajouter 1 diviser par 2.

vec4 textureNormalizedCoords(vec4 screenProjected) 
{ 
    vec3 normalizedDeviceCoords = (screenProjected.xyz/screenProjected.w); 
    return vec4((normalizedDeviceCoords.xy + 1.0)/2.0, screenProjected.z * 0.005, 1/screenProjected.w); 
} 

void main() 
{ 
    float s = 10.00; 

    vec4 llCorner = vec4(-s, -s, 0.0, 0.0); 
    vec4 llWorldPosition = ((p1_modelM * llCorner) + gl_in[0].gl_Position); 
    gl_Position = p1_cameraPV * llWorldPosition; 
    shader_lightTextureCoords = textureNormalizedCoords(p1_lightPV * llWorldPosition); 
    EmitVertex();a