tuto_cubemap.cpp

Go to the documentation of this file.

 
#include <memory>
#include <random>
#include <chrono>
 
#include "wavefront.h"
#include "texture.h"
 
#include "orbiter.h"
#include "program.h"
#include "uniforms.h"
#include "draw.h"
 
#include "app_camera.h"        // classe Application a deriver
 
 
// creation d'une grille + axes du repere
Mesh make_grid( const int n= 10 )
{
    Mesh grid= Mesh(GL_LINES);
    
    // grille
    grid.color(White());
    float w= float(n-1) / 2;
    for(int x= 0; x < n; x++)
    {
        grid.vertex(x -w, 0, -w); 
        grid.vertex(x -w, 0,  w);
    }
    for(int z= 0; z < n; z++)
    {
        grid.vertex(-w, 0, z -w); 
        grid.vertex( w, 0, z -w); 
    }
    
    // axes XYZ
    grid.color(Red());
    grid.vertex(Point(0, .1, 0));
    grid.vertex(Point(1, .1, 0));
    
    grid.color(Green());
    grid.vertex(Point(0, .1, 0));
    grid.vertex(Point(0, 1, 0));
    
    grid.color(Blue());
    grid.vertex(Point(0, .1, 0));
    grid.vertex(Point(0, .1, 1));
    
    glLineWidth(2);
    
    return grid;
}

GLuint read_cubemap( const int unit, const char *filename,  const GLenum texel_type = GL_RGBA )
{
    ImageData image= read_image_data(filename);
    if(image.pixels.empty()) 
        return 0;
 
    // les 6 faces sur une colonne
    //~ int w= image.width;
    //~ int h= image.height / 6;
    // les 6 faces sur une croix
    int w= image.width / 4;
    int h= image.height / 3;
    assert(w == h);
    
    GLenum data_format;
    GLenum data_type= GL_UNSIGNED_BYTE;
    if(image.channels == 3)
        data_format= GL_RGB;
    else // par defaut
        data_format= GL_RGBA;
    
    // creer la texture
    GLuint texture= 0;
    glGenTextures(1, &texture);
    glActiveTexture(GL_TEXTURE0 + unit);
    glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
 
    // creer les 6 faces
    // chaque face de la cubemap est un rectangle [image.width/4 x image.height/3] dans l'image originale 
    struct { int x, y; } faces[]= {
        {0, 1}, // X+
        {2, 1}, // X-
        {1, 2}, // Y+
        {1, 0}, // Y- 
        {1, 1}, // Z+
        {3, 1}, // Z-
    };
    //~ struct { int x, y; } faces[]= {
        //~ {0, 4}, // Z+
        //~ {0, 5}, // Z-
        //~ {0, 3}, // Y-
        //~ {0, 2}, // Y+ 
        //~ {0, 0}, // X+
        //~ {0, 1}, // X-
    //~ };
    
    // face de test / rouge
    ImageData red(w, h, image.channels);
    for(unsigned y= 0; y < red.height; y++)
    for(unsigned x= 0; x < red.width; x++)
    {
        unsigned char *pixel= red.pixels.data() + red.offset(x, y);
        pixel[0]= 255;
        pixel[1]= 0;
        pixel[2]= 0;
        if(red.channels > 3)
            pixel[3]= 255;
    }
    
    for(int i= 0; i < 6; i++)
    {
        ImageData face= flipX(flipY(copy(image, faces[i].x*w, faces[i].y*h, w, h)));
        
        //~ if(i == 5)  // remplace par la face test...
            //~ face= red;
        
        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X +i, 0,
            texel_type, w, h, 0,
            data_format, data_type, face.data());
    }
    
    // parametres de filtrage
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);    
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);    
    
    glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
    
    // filtrage "correct" sur les bords du cube...
    glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
    //~ glDisable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
    
    printf("  cubemap faces %dx%d\n", w, h);
    
    return texture;
}
 
 
GLuint make_cubemap( const unsigned unit, const std::vector<Image>& faces, GLenum texel_type= GL_RGBA )
{
    if(faces.empty())
        return 0;
    
    for(unsigned i= 1; i < faces.size(); i++)
        if( faces[i].width() != faces[0].width()
        || faces[i].height() != faces[0].height() )
            return 0;
    
    // creer la texture
    GLuint texture= 0;
    glGenTextures(1, &texture);
    glActiveTexture(GL_TEXTURE0 + unit);
    glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
    
    Image red( faces[0].width(), faces[0].height(), Red() );
    
    // cree les 6 faces
    for(unsigned i= 0; i < 6; i++)
    {
        //~ if(i == 5)  // remplace par la face test...
            //~ face= red;
        
        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X +i, 0,
            texel_type, faces[i].width(), faces[i].height(), 0,
            GL_RGBA, GL_FLOAT, faces[i].data());
    }
    
    // parametres de filtrage
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);    
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);    
    
    glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
    
    // filtrage "correct" sur les bords du cube...
    glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
    //~ glDisable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
    
    printf("  cubemap faces %dx%d\n", faces[0].width(), faces[0].height());
    return texture;
}
    
std::vector<Image> read_envmap( const char *filename )
{
    Image image= linear( read_image( filename ) );
    if(image.size() == 0)
        return {};
    
    int w= image.width() / 4;
    int h= image.height() / 3;
    assert(w == h);
    
    // creer les 6 faces
    // chaque face de la cubemap est un rectangle [image.width/4 x image.height/3] dans l'image originale 
    struct { int x, y; } cells[]= {
        {0, 1}, // X+
        {2, 1}, // X-
        {1, 2}, // Y+
        {1, 0}, // Y- 
        {1, 1}, // Z+
        {3, 1}, // Z-
    };
    
    std::vector<Image> faces;
    for(int i= 0; i < 6; i++)
        faces.emplace_back( flipX(flipY(copy(image, cells[i].x*w, cells[i].y*h, w, h))) );
    
    return faces;
}
 
// mapping direction vers texel [0 .. 1]x[0 .. 1]
// reproduit la convention openGL.
vec3 envmap_texel( const Vector& d )
{
    int face= -1;
    float sm, tm;
    
    const vec3 m= { std::abs(d.x), std::abs(d.y), std::abs(d.z) };
    if(m.x > m.y && m.x > m.z)
    {
        // X
        if(d.x > 0)
        {
            face= 0;
            sm= -d.z / m.x;
            tm= -d.y / m.x;
        }
        else
        {
            face= 1;
            sm= d.z / m.x;
            tm= -d.y / m.x;
        }
    }
    else if(m.y > m.z)
    {
        // Y
        if(d.y > 0)
        {
            face= 2;
            sm= d.x / m.y;
            tm= d.z / m.y;
        }
        else
        {
            face= 3;
            sm= d.x / m.y;
            tm= -d.z / m.y;
        }
    }
    else
    {
        // Z
        if(d.z > 0)
        {
            face= 4;
            sm= d.x / m.z;
            tm= -d.y / m.z;
        }
        else
        {
            face= 5;
            sm= -d.x / m.z;
            tm= -d.y / m.z;
        }
    }
    
    assert(face != -1);
    float s= (sm +1) / 2;
    float t= (tm +1) / 2;
    return { face, s, t };
}
 
vec3 envmap_direction( const int face, const float s, const float t )
{
    // retrouve le point sur le cube [-1 .. 1]
    float sm= 2 * s -1;
    float tm= 2 * t -1;
    if(face == 0)
    {
        // X+
        // sm= -d.z / m.x;
        // tm= -d.y / m.x;
        return { 1, -tm, -sm };
    }
    else if(face == 1)
    {
        // X-
        // sm= d.z / m.x;
        // tm= -d.y / m.x;
        return { -1, -tm, sm };
    }
    else if(face == 2)
    {
        // Y+
        // sm= d.x / m.y;
        // tm= d.z / m.y;
        return { sm, 1, tm };
    }
    else if(face == 3)
    {
        // Y-
        // sm= d.x / m.y;
        // tm= -d.z / m.y;
        return { sm, -1, -tm };
    }
    else if(face == 4)
    {
        // Z+
        // sm= d.x / m.z;
        // tm= -d.y / m.z;
        return { sm, -tm, 1 };
    }
    else // if(face == 5)
    {
        // Z-
        // sm= -d.x / m.z;
        // tm= -d.y / m.z;
        return { -sm, -tm, -1 };
    }
}
 
struct World
{
    World( ) : t(), b(), n() {}
 
    World( const Vector& _n ) : n(_n) 
    {
        float s= std::copysign(float(1), n.z);  // s= 1 ou -1
        float a= -1 / (s + n.z);
        float d= n.x * n.y * a;
        t= Vector(1 + s * n.x * n.x * a, s * d, -s * n.x);
        b= Vector(d, s + n.y * n.y * a, -n.y);        
    }
 
    // transforme le vecteur du repere local vers le repere du monde
    Vector operator( ) ( const Vector& local )  const { return local.x * t + local.y * b + local.z * n; }
 
    // transforme le vecteur du repere du monde vers le repere local
    Vector local( const Vector& global ) const { return Vector(dot(global, t), dot(global, b), dot(global, n)); }
 
    Vector t;   // x
    Vector b;   // y
    Vector n;   // z
};
 
float frsplit( const Vector& v, const float ns )
{
    // n= Z
    // o= Z
    assert(v.z >= 0);
    
    Vector h= normalize( Vector(0, 0, 1) + v );
    return (8 + ns) / float(8*M_PI) * std::pow( std::max(float(0), h.z), ns );
}
 
 
struct splitsum
{
    GLuint diffuse_texture;
    GLuint glossy_texture;
};
 
splitsum splitsum_cubemap( const int unit, const char *filename,  const GLenum texel_type = GL_RGBA )
{
    std::vector<Image> faces= read_envmap(filename);
    if(faces.size() == 0) 
        return {};
    
    const unsigned size= 16;
    const unsigned samples= 4096;
    std::vector<Image> diffuse;
    for(unsigned i= 0; i < 6; i++)
        diffuse.emplace_back( size, size, Black() );
    
    unsigned size0= std::max( faces[0].width(), faces[0].height() );
    unsigned levels= miplevels( faces[0].width(), faces[0].height() );
    std::vector< std::vector<Image> > glossy(6);
    for(unsigned i= 0; i < 6; i++)
    {
        for(unsigned k= 0; k < levels; k++)
        {
            unsigned ksize= std::max(unsigned(1), size0 >> k);
            glossy[i].emplace_back( ksize, ksize, Black() );
        }
    }
    printf("\n");
    
    std::chrono::high_resolution_clock::time_point start= std::chrono::high_resolution_clock::now();
    
    for(unsigned face= 0; face < diffuse.size(); face++)
    {
        #pragma omp parallel for schedule(dynamic, 1)
        for(unsigned y= 0; y < size; y++)
        {
            std::random_device hwseed;
            std::default_random_engine rng( hwseed() );
            std::uniform_real_distribution<float> uniform;
            
            for(unsigned x= 0; x < size; x++)
            {
                Vector n= envmap_direction( face, float(x) / float(size), float(y) / float(size) );
                World world( n );
                
                // diffuse
                Color color;
                for(unsigned i= 0; i < samples; i++)
                {
                    float cos_theta= std::sqrt( uniform( rng ) );
                    float sin_theta= std::sqrt(1 - cos_theta * cos_theta);
                    float phi= uniform( rng ) * float(2 * M_PI);
                    float pdf= cos_theta / float(M_PI);
                    
                    Vector v= world( { std::cos(phi) * sin_theta, std::sin(phi) * sin_theta, cos_theta} );
                    
                    vec3 fuv= envmap_texel(v);
                    color= color + faces[fuv.x].texture(fuv.y, fuv.z) / float(M_PI) * cos_theta / pdf;
                }
                
                diffuse[face](x, y)= Color(color / float(samples), 1);
            }
        }
    }
    
    std::chrono::high_resolution_clock::time_point stop= std::chrono::high_resolution_clock::now();
    printf("splitsum %dms\n", int( std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count() ));
    
    // glossy
    for(unsigned face= 0; face < glossy.size(); face++)
    {
        unsigned ksamples= 256;
        unsigned ksize= 256;
        //~ unsigned ksize= std::max( glossy[face][0].width(), glossy[face][0].height() );
        glossy[face][0]= Image(ksize, ksize);
        
        #pragma omp parallel for schedule(dynamic, 1)
        for(unsigned y= 0; y < ksize; y++)
        {
            std::random_device hwseed;
            std::default_random_engine rng( hwseed() );
            std::uniform_real_distribution<float> uniform;
            
            for(unsigned x= 0; x < ksize; x++)
            {
                Vector n= envmap_direction( face, float(x) / float(ksize), float(y) / float(ksize) );
                World world( n );
                
                float ns= 100;
                
                Color color;
                for(unsigned i= 0; i < ksamples; i++)
                {
                    // repere local, n= 0 0 1 et o= 0 0 1
                    float cos_theta_h= std::min( float(1), std::pow( uniform( rng ), float(1) / float(ns+1) ) );
                    float sin_theta_h= std::sqrt( 1 - cos_theta_h * cos_theta_h );
                    float phi_h= uniform( rng ) * float(2 * M_PI);
                    
                    Vector h= { std::cos(phi_h) * sin_theta_h, std::sin(phi_h) * sin_theta_h, cos_theta_h };
                    Vector v= 2*h.z * h - Vector(0, 0, 1);    // reflect(o, h) 
                    float pdf_h= float(ns +1) / float(2 * M_PI) * std::pow(cos_theta_h, ns);
                    float pdf= float(1) / float(4 * h.z) * pdf_h;
                    
                    float cos_theta= v.z;
                    if(cos_theta > 0)
                    {
                        vec3 fuv= envmap_texel( world(v) );
                        color= color + faces[fuv.x].texture(fuv.y, fuv.z) * frsplit(v, ns) * cos_theta / pdf;
                    }
                }
                
                glossy[face][0](x, y)= Color(color / float(samples), 1);
                
                if(face == 0 && y == 0)
                    printf("%u %f\n", x, color.max() / float(samples));
            }
        }
    }
    
    std::chrono::high_resolution_clock::time_point stop2= std::chrono::high_resolution_clock::now();
    printf("splitsum %dms\n", int( std::chrono::duration_cast<std::chrono::milliseconds>(stop2 - stop).count() ));
    
    std::vector<Image> tmp_glossy;
    for(unsigned i= 0; i < glossy.size(); i++)
        tmp_glossy.emplace_back( glossy[i][0] );
    
    Image band(tmp_glossy[0].width(), tmp_glossy[0].width()*6);
    for(unsigned i= 0; i < 6; i++)
        blit(band, 0, i * tmp_glossy[0].width(), tmp_glossy[i]);
    //~ Image band(diffuse[0].width(), diffuse[0].width()*6);
    //~ for(unsigned i= 0; i < 6; i++)
        //~ blit(band, 0, i * diffuse[0].width(), diffuse[i]);
    
    write_image(band, "env.png");
    
    return { make_cubemap(0, diffuse), make_cubemap(0, tmp_glossy) };
}
 
 
class TP : public AppCamera
{
public:
    // constructeur : donner les dimensions de l'image, et eventuellement la version d'openGL.
    TP( ) : AppCamera(1024, 640) {}
    
    // creation des objets de l'application
    int init( )
    {
        //~ m_objet= read_mesh("data/cube.obj");
        //~ m_objet= read_mesh("data/bigguy.obj");
        m_objet= read_mesh("data/ccbigguy.obj");
        //~ m_objet= make_grid(3);
        if(m_objet.vertex_count() == 0)
            return -1;
        
        //~ m_texture= read_cubemap(0, "gkit2_tutos/cubemap_debug_cross.png");
        splitsum textures= splitsum_cubemap(0, "canyon2.jpg");
        //~ m_texture= textures.diffuse_texture;
        m_texture= textures.glossy_texture;
        if(m_texture == 0)
            return -1;
        
        //~ m_texture= read_cubemap(0, "canyon2.jpg");
        //~ m_texture= read_cubemap(0, "faces.png");
        //~ m_texture= read_cubemap(0, "studio.png");
        //~ m_texture= read_texture(0, "studio_latlong.png");
        //~ m_texture= read_texture(0, "latlong.png");
        
        m_program_draw= read_program("gkit2_tutos/draw_cubemap.glsl");
        program_print_errors(m_program_draw);
        m_program= read_program("gkit2_tutos/cubemap.glsl");
        program_print_errors(m_program);
        
        // init camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // etat openGL par defaut
        glGenVertexArrays(1, &m_vao);
        
        glEnable(GL_FRAMEBUFFER_SRGB);
        glClearColor(0.1, 0.1, 0.1, 1);        // couleur par defaut de la fenetre
        
        glClearDepth(1);                          // profondeur par defaut
        glDepthFunc(GL_LEQUAL);                       // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        
        return 0;   // ras, pas d'erreur
    }
    
    // destruction des objets de l'application
    int quit( )
    {
        m_objet.release();
        release_program(m_program_draw);
        release_program(m_program);
        glDeleteVertexArrays(1, &m_vao);
        glDeleteTextures(1, &m_texture);
        return 0;
    }
    
    // dessiner une nouvelle image
    int render( )
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        static Transform model= Identity();
        if(key_state(SDLK_LEFT))
            model= model * RotationY(-2);
        if(key_state(SDLK_RIGHT))
            model= model * RotationY(2);
        
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform viewport= camera().viewport();
        Transform mvp= projection * view * model;
        
        Transform viewInv= Inverse(view);
        Point camera_position= viewInv(Point(0, 0, 0));  // coordonnees de la camera, dans le repere camera... c'est l'origine
        
        // etape 1 : affiche l'objet, utilise la cubemap pour calculer les reflets
        glUseProgram(m_program);
        program_uniform(m_program, "mvpMatrix", mvp);
        program_uniform(m_program, "modelMatrix", model);
        program_uniform(m_program, "camera_position", camera_position);
        
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
        
        //~ glBindTexture(GL_TEXTURE_2D, m_texture);
        program_uniform(m_program, "texture0", 0);
        
        // dessine l'objet.
        m_objet.draw(m_program);
        
        // etape 2 : affiche la cube map
        // inverse de la composition des transformations repere monde vers repere image
        Transform inv= Inverse(viewport * projection * view);
        
        glUseProgram(m_program_draw);
        glBindVertexArray(m_vao);
        program_uniform(m_program_draw, "invMatrix", inv);
        program_uniform(m_program_draw, "camera_position", camera_position);
        
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
        //~ glBindTexture(GL_TEXTURE_2D, m_texture);
        program_uniform(m_program_draw, "texture0", int(0));
        
        glDrawArrays(GL_TRIANGLES, 0, 3);
        
        // nettoyage
        glBindTexture(GL_TEXTURE_2D, 0);
        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
        glUseProgram(0);
        glBindVertexArray(0);
        
        if(key_state('r'))
        {
            clear_key_state('r');
            
            reload_program(m_program_draw, "gkit2_tutos/draw_cubemap.glsl");
            program_print_errors(m_program_draw);
            reload_program(m_program, "gkit2_tutos/cubemap.glsl");
            program_print_errors(m_program);
        }
        
        if(key_state('s'))
        {
            clear_key_state('s');
            static int calls= 0;
            screenshot("cubemap_brdf", ++calls);
            printf("screenshot %d\n", calls);
        }
        
        return 1;
    }
 
protected:
    Mesh m_objet;
    GLuint m_texture;
    GLuint m_program_draw;
    GLuint m_program;
    GLuint m_vao;
};
 
 
int main( int argc, char **argv )
{
    // il ne reste plus qu'a creer un objet application et la lancer 
    TP tp;
    tp.run();
    
    return 0;
}