cubemap.glsl

Go to the documentation of this file.

 
#version 430
 
#ifdef VERTEX_SHADER
uniform mat4 mvpMatrix;
uniform mat4 modelMatrix;
 
uniform samplerCube texture0;
 
layout(location= 0) in vec3 position;
layout(location= 2) in vec3 normal;
out vec3 vertex_position;
out vec3 vertex_normal;
out vec3 vertex_diffuse;
 
float sqr( in const float x ) { return x*x; }
 
void main( )
{
    gl_Position= mvpMatrix * vec4(position, 1);
    vertex_position= vec3(modelMatrix * vec4(position, 1));
    vertex_normal= mat3(modelMatrix) * normalize(normal);
    
    float size= textureSize(texture0, 0).x;
    float dlevel= floor(log2(size));
    
    //~ // mcguire 2103
    //~ vertex_diffuse= textureLod(texture0, n, dlevel).rgb;  
    
    // plus precis, cf croubois 2014
    // https://shared.hadriencroubois.com/publications/2014/MobileReality.pdf
    // pondere chaque face par son angle solide et en fonction de la normale
    // todo a deplacer dans le vertex shader et transmettre la couleur interpolee au fragment shader, ce sera bien plus rapide !
    vec3 diffuse= textureLod(texture0, vec3( 1, 0,  0), dlevel).rgb * sqr(max(0, .75 + vertex_normal.x)) / 1.75;
    diffuse+= textureLod(texture0, vec3(-1, 0,  0), dlevel).rgb * sqr(max(0, .75 - vertex_normal.x)) / 1.75;
    diffuse+= textureLod(texture0, vec3( 0, 1,  0), dlevel).rgb * sqr(max(0, .75 + vertex_normal.y)) / 1.75;
    diffuse+= textureLod(texture0, vec3( 0,-1,  0), dlevel).rgb * sqr(max(0, .75 - vertex_normal.y)) / 1.75;
    diffuse+= textureLod(texture0, vec3( 0, 0,  1), dlevel).rgb * sqr(max(0, .75 + vertex_normal.z)) / 1.75;
    diffuse+= textureLod(texture0, vec3( 0, 0, -1), dlevel).rgb * sqr(max(0, .75 - vertex_normal.z)) / 1.75;
    vertex_diffuse= diffuse / 3;
}
#endif
 
 
#ifdef FRAGMENT_SHADER
uniform vec3 camera_position;
uniform samplerCube texture0;
 
const float alpha= 20;
const float k= 0.9;
 
in vec3 vertex_position;
in vec3 vertex_normal;
in vec3 vertex_diffuse;
out vec4 fragment_color;
 
void main( )
{
    vec3 v= vertex_position - camera_position;
    vec3 n= normalize(vertex_normal);
    //~ vec3 color= texture(texture0, n).rgb;   // couleur dans la direction de la normale
    
    vec3 m= reflect(v, n);
    //~ vec3 color= texture(texture0, m).rgb;       // couleur dans la direction du reflet miroir
    
    // approximation pour un modele blinn - phong, cf mcguire 2103
    float size= textureSize(texture0, 0).x;
    float glevel= max(0, log2(size * sqrt(3)) - 0.5 * log2(alpha +1));
    vec3 glossy= textureLod(texture0, m, glevel).rgb;
    
    vec3 color= k * vertex_diffuse + (1 - k) * glossy;
    
    fragment_color= vec4(color, 1);
}
#endif