Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 9 of 9

Thread: Omnidirectional shadow mapping and wrong space?

Threaded View

  1. #1
    Intern Newbie
    Join Date
    Jan 2014
    Posts
    33

    Omnidirectional shadow mapping and wrong space?

    I've been banging my head against the wall when dealing with point light shadow mapping, and a recent idea is that I might've been comparing two depth values from different spaces and I'd like some confirmation if thats the case.

    The shadow pass draws all the geometry from the 6 different angles originating from the point light using its own view and projection matrices, while the directional vector ("positionDiff") used in sampling the shadowmap and which is also converted to the comparison depth value (func "VectorToDepthValue") is in world space. Is this a potential error?

    Code :
    const std::string gShadingFragmentShader = 
        "#version 420                                                                                                                            
     
        layout(std140) uniform UnifPointLight                                                                                                    
        {                                                                                                                                        
            mat4 mWVPMatrix;                                                                                                                     
            vec4 mLightColor;                                                                                                                    
            vec4 mLightPos;                                                                                                                      
            vec4 mGamma;                                                                                                                         
            vec2 mScreenSize;                                                                                                                    
     
            float mLightIntensity;                                                                                                               
            float mMaxDistance;                                                                                                                  
        } UnifPointLightPass;                                                                                                                    
     
        layout (binding = 2) uniform sampler2D unifPositionTexture;                                                                              
        layout (binding = 3) uniform sampler2D unifNormalTexture;                                                                                
        layout (binding = 4) uniform sampler2D unifDiffuseTexture;                                                                               
        layout (binding = 7) uniform samplerCube unifShadowmap;                                                                                  
     
        out vec4 fragColor;                                                                                                                      
     
        float VectorToDepthValue(vec3 Vec)                                                                                                       
        {                                                                                                                                        
            vec3 AbsVec = abs(Vec);                                                                                                              
            float LocalZcomp = max(AbsVec.x, max(AbsVec.y, AbsVec.z));                                                                           
     
            const float f = 100.0;                                                                                                               
            const float n = 0.1;                                                                                                                 
            float NormZComp = (f + n) / (f - n) - (2 * f * n) / (f - n) / LocalZcomp;                                                            
     
            return (NormZComp + 1.0) * 0.5;                                                                                                      
        }                                                                                                                                        
     
        void main()                                                                                                                              
        {                                                                                                                                        
            vec2 texcoord = gl_FragCoord.xy / UnifPointLightPass.mScreenSize;                                                                    
     
            vec3 worldPos = texture(unifPositionTexture, texcoord).xyz;                                                                          
            vec3 normal   = texture(unifNormalTexture, texcoord).xyz;                                                                            
            vec3 diffuse  = texture(unifDiffuseTexture, texcoord).xyz;                                                                           
            normal        = normalize(normal);                                                                                                   
     
            vec3 positionDiff = (UnifPointLightPass.mLightPos.xyz - worldPos);                                                                   
     
            float storedDepth = texture(unifShadowmap, positionDiff);                                                                            
            float visibility = 0.0;                                                                                                              
            if (storedDepth + 0.0001 > VectorToDepthValue(positionDiff))                                                                         
                visibility = 1.0;                                                                                                                
     
            float dist = length(positionDiff);                                                                                                   
            float attenuation = clamp(1.0 - dist*dist * (1 / (UnifPointLightPass.mMaxDistance * UnifPointLightPass.mMaxDistance)), 0.0, 1.0);    
            attenuation *= attenuation;                                                                                                          
     
            vec3 lightDir = normalize(positionDiff);                                                                                             
            float angleNormal = clamp(dot(normalize(normal), lightDir), 0, 1);                                                                   
     
            fragColor = vec4(diffuse, 1.0) * visibility * (angleNormal * attenuation *                                                           
                        UnifPointLightPass.mLightIntensity * UnifPointLightPass.mLightColor);                                                    
        }


    EDIT: also, is it "Lightposition - worldPosition" or is it "worldPosition - LightPosition"? The more I think about it, it feels like the latter.
    Last edited by TheKaiser; 06-08-2014 at 08:19 AM.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •