tuto_cubemap.cpp File Reference

reflets miroirs cubemap / envmap. More...

#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"

Go to the source code of this file.

Classes
struct	World
struct	splitsum
class	TP

Functions
Mesh	make_grid (const int n=10)
GLuint	read_cubemap (const int unit, const char *filename, const GLenum texel_type=GL_RGBA)
	charge une image, decoupe les 6 faces et renvoie une texture cubemap.
GLuint	make_cubemap (const unsigned unit, const std::vector< Image > &faces, GLenum texel_type=GL_RGBA)
std::vector< Image >	read_envmap (const char *filename)
vec3	envmap_texel (const Vector &d)
vec3	envmap_direction (const int face, const float s, const float t)
float	frsplit (const Vector &v, const float ns)
splitsum	splitsum_cubemap (const int unit, const char *filename, const GLenum texel_type=GL_RGBA)
int	main (int argc, char **argv)

Detailed Description

reflets miroirs cubemap / envmap.

Definition in file tuto_cubemap.cpp.

---

Class Documentation

splitsum

struct splitsum

Definition at line 368 of file tuto_cubemap.cpp.

Class Members
GLuint	diffuse_texture
GLuint	glossy_texture

Function Documentation

make_grid()

Mesh make_grid

(

const int

n = 10

)

Definition at line 20 of file tuto_cubemap.cpp.

{
    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;
}

read_cubemap()

GLuint read_cubemap	(	const int	unit,
		const char *	filename,
		const GLenum	texel_type = GL_RGBA )

charge une image, decoupe les 6 faces et renvoie une texture cubemap.

Definition at line 57 of file tuto_cubemap.cpp.

{
    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;
}

make_cubemap()

GLuint make_cubemap	(	const unsigned	unit,
		const std::vector< Image > &	faces,
		GLenum	texel_type = GL_RGBA )

Definition at line 147 of file tuto_cubemap.cpp.

{
    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;
}

read_envmap()

std::vector< Image > read_envmap

(

const char *

filename

)

Definition at line 193 of file tuto_cubemap.cpp.

{
    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;
}

envmap_texel()

vec3 envmap_texel

(

const Vector &

d

)

Definition at line 223 of file tuto_cubemap.cpp.

{
    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 };
}

envmap_direction()

vec3 envmap_direction	(	const int	face,
		const float	s,
		const float	t )

Definition at line 284 of file tuto_cubemap.cpp.

{
    // 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 };
    }
}

frsplit()

float frsplit	(	const Vector &	v,
		const float	ns )

Definition at line 357 of file tuto_cubemap.cpp.

{
    // 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 );
}

splitsum_cubemap()

splitsum splitsum_cubemap	(	const int	unit,
		const char *	filename,
		const GLenum	texel_type = GL_RGBA )

Definition at line 374 of file tuto_cubemap.cpp.

{
    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) };
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 657 of file tuto_cubemap.cpp.

{
    // il ne reste plus qu'a creer un objet application et la lancer 
    TP tp;
    tp.run();
    
    return 0;
}