DrawParam Class Reference

#include <draw.h>

Public Member Functions
	DrawParam ()
	constructeur par defaut.
DrawParam &	model (const Transform &m)
	modifie la transformation model utilisee pour afficher l'objet.
DrawParam &	view (const Transform &m)
	modifie la transformation view utilisee pour afficher l'objet.
DrawParam &	projection (const Transform &m)
	modifie la transformation projection utilisee pour afficher l'objet.
DrawParam &	camera (Orbiter &o)
	utilise les transformations view et projection definies par une camera.
DrawParam &	camera (Orbiter &o, const int width, const int height, const float fov)
	utilise les transformations view et projection definies par une camera. parametres explicites de la projection.
DrawParam &	light (const Point &p, const Color &c=White())
	eclaire l'objet avec une source ponctuelle, de position p et de couleur c.
DrawParam &	light (const bool flag=true)
	active / desactive la source ponctuelle.
DrawParam &	sun (const Vector &d, const Color &c)
	eclaire l'objet avec une source directionnelle, de direction d et de couleur c.
DrawParam &	sun (const bool flag=true)
	active / desactive le soleil.
DrawParam &	sky (const Vector &d, const Color &c)
	eclaire l'objet avec une source hemispherique de couleur c. le zenith se trouve dans la direction d.
DrawParam &	sky (const bool flag=true)
	active / desactive le ciel
DrawParam &	texture (const GLuint t)
	plaque une texture opaque a la surface de l'objet.
DrawParam &	alpha_texture (const GLuint t, const float a=0.5)
	utilise une texture semi transparente, si l'alpha du texel est plus petit que a, le pixel est transparent. desactive aussi les calculs d'eclairage.
DrawParam &	shading (const bool flag=true)
	utilise une source de lumire pour eclairer l'objet, ou pas si flag= false.
DrawParam &	material (const Material &material)
	utilise une matiere pour dessiner un objet.
DrawParam &	material (const bool flag=true)
	active / desactive la matiere pour dessiner un objet.
DrawParam &	debug_normals (const float s=0.2)
	visualise les normales des sommets des triangles et les normales geometrique des triangles
DrawParam &	wireframe (const bool flag=true)
	visualise les aretes des triangles.
DrawParam &	debug_texcoords (const bool flag=true)
	visualise les coordonnees de textures des sommets des triangles.
void	draw (Mesh &mesh)
	dessine l'objet avec l'ensemble des parametres definis.
void	draw (Mesh &mesh, const Transform &model)
void	draw (const TriangleGroup &group, Mesh &mesh)

Protected Types
enum	: unsigned {   USE_TEXCOORD = 1 , USE_NORMAL = 2 , USE_COLOR = 4 , USE_TEXTURE = 8 ,   USE_ALPHATEST = 16 , USE_SHADING = 32 , USE_LIGHT = 64 , USE_SUN = 128 ,   USE_SKY = 256 , USE_ENVMAP = 512 , USE_MATERIAL = 1024 , DEBUG_NORMALS = 1u << 20 ,   DEBUG_TEXCOORDS = 1u << 21 }
	flags pour identifier les parametres actifs du draw / generer le shader More...

Protected Member Functions
void	draw (const unsigned first, const unsigned count, Mesh &mesh)
unsigned	create_flags (const bool use_texcoord, const bool use_normal, const bool use_color)
unsigned	update (unsigned &flags, const unsigned option, const bool use=true)
bool	flag (const unsigned option)
GLuint	create_program (const GLenum primitives, const unsigned flags)
	construit un shader program configure pour l'ensemble d'options.
GLuint	create_debug_normals_program (const GLenum primitives, const unsigned flags)
	construit un shader program / debug des normales.
GLuint	create_debug_texcoords_program (const GLenum primitives, const unsigned flags)
	construit un shader program / debug des coordonnees de texture.

Protected Attributes
unsigned	flags
Transform	m_model
Transform	m_view
Transform	m_projection
Point	m_light
Color	m_light_color
Vector	m_sun
Color	m_sun_color
Vector	m_sky
Color	m_sky_color
GLuint	m_texture
GLuint	m_envmap
float	m_alpha_min
float	m_normals_scale
Material	m_material

Detailed Description

representation des options / parametres d'un draw. permet de donner tous les parametres d'un draw de maniere flexible.

exemple :

Mesh objet= { ... };
 
DrawParam param;
param.light(Point(0, 20, 0), Red());
param.camera(orbiter);
param.draw(objet);

ou de maniere encore plus compacte :

DrawParam().light(Point(0, 20, 0), Red()).model(m).camera(orbiter).draw(objet);

les parametres peuvent etre decrits dans un ordre quelconque, mais DrawParam::draw() doit etre appele en dernier.

Definition at line 66 of file draw.h.

Member Enumeration Documentation

anonymous enum

anonymous enum : unsigned

protected

flags pour identifier les parametres actifs du draw / generer le shader

Definition at line 136 of file draw.h.

    {
        USE_TEXCOORD = 1,
        USE_NORMAL= 2,
        USE_COLOR= 4,
        USE_TEXTURE= 8,
        USE_ALPHATEST= 16,
        USE_SHADING= 32,
        USE_LIGHT= 64,
        USE_SUN= 128,
        USE_SKY= 256,
        USE_ENVMAP= 512,
        USE_MATERIAL= 1024,
        
        DEBUG_NORMALS= 1u << 20,
        DEBUG_TEXCOORDS= 1u << 21
    };

Constructor & Destructor Documentation

DrawParam()

DrawParam::DrawParam ( )

inline

constructeur par defaut.

Definition at line 70 of file draw.h.

                 :  flags( USE_SUN ),
        m_model(), m_view(), m_projection(),
        m_light( Point(1, 1, 1) ), m_light_color( White() ),
        m_sun( normalize( Vector(0.5, 0.25, 0.5) ) ), m_sun_color( Color(1) ),
        m_sky( normalize( Vector(0, 1, 0) ) ), m_sky_color( Color(0.2) ),
        m_texture(0),
        m_alpha_min(0.3),
        m_normals_scale(0.2),
        m_material( Color(0.7) )
    {}

Member Function Documentation

model()

DrawParam & DrawParam::model ( const Transform & m )

inline

modifie la transformation model utilisee pour afficher l'objet.

Definition at line 82 of file draw.h.

{ m_model= m; return *this; }

view()

DrawParam & DrawParam::view ( const Transform & m )

inline

modifie la transformation view utilisee pour afficher l'objet.

Definition at line 84 of file draw.h.

{ m_view= m; return *this; }

projection()

DrawParam & DrawParam::projection ( const Transform & m )

inline

modifie la transformation projection utilisee pour afficher l'objet.

Definition at line 86 of file draw.h.

{ m_projection= m; return *this; }

camera() [1/2]

DrawParam & DrawParam::camera ( Orbiter & o )

inline

utilise les transformations view et projection definies par une camera.

Definition at line 89 of file draw.h.

{ m_view= o.view(); m_projection= o.projection(); return *this; }

camera() [2/2]

DrawParam & DrawParam::camera ( Orbiter & o, const int width, const int height, const float fov )

inline

utilise les transformations view et projection definies par une camera. parametres explicites de la projection.

Definition at line 91 of file draw.h.

{ m_view= o.view(); m_projection= o.projection(width, height, fov); return *this; }

light() [1/2]

DrawParam & DrawParam::light ( const Point & p, const Color & c = White() )

inline

eclaire l'objet avec une source ponctuelle, de position p et de couleur c.

Definition at line 93 of file draw.h.

{ update(flags, USE_LIGHT); m_light= p; m_light_color=c; return *this; }

light() [2/2]

DrawParam & DrawParam::light ( const bool flag = true )

inline

active / desactive la source ponctuelle.

Definition at line 95 of file draw.h.

{ update(flags, USE_LIGHT, flag); return *this; }

sun() [1/2]

DrawParam & DrawParam::sun ( const Vector & d, const Color & c )

inline

eclaire l'objet avec une source directionnelle, de direction d et de couleur c.

Definition at line 97 of file draw.h.

{ update(flags, USE_SUN); m_sun= d; m_sun_color=c; return *this; }

sun() [2/2]

DrawParam & DrawParam::sun ( const bool flag = true )

inline

active / desactive le soleil.

Definition at line 99 of file draw.h.

{ update(flags, USE_SUN, flag); return *this; }

sky() [1/2]

DrawParam & DrawParam::sky ( const Vector & d, const Color & c )

inline

eclaire l'objet avec une source hemispherique de couleur c. le zenith se trouve dans la direction d.

Definition at line 102 of file draw.h.

{ update(flags, USE_SKY); m_sky= d; m_sky_color=c; return *this; }

sky() [2/2]

DrawParam & DrawParam::sky ( const bool flag = true )

inline

active / desactive le ciel

Definition at line 104 of file draw.h.

{ update(flags, USE_SKY, flag); return *this; }

texture()

DrawParam & DrawParam::texture ( const GLuint t )

inline

plaque une texture opaque a la surface de l'objet.

Definition at line 107 of file draw.h.

{ update(flags, USE_TEXTURE, (t > 0)); m_texture= t; return *this; }

alpha_texture()

DrawParam & DrawParam::alpha_texture ( const GLuint t, const float a = 0.5 )

inline

utilise une texture semi transparente, si l'alpha du texel est plus petit que a, le pixel est transparent. desactive aussi les calculs d'eclairage.

Definition at line 110 of file draw.h.

{ update(flags, USE_ALPHATEST, (a > 0)); m_alpha_min= a; m_texture= t; return *this; }

shading()

DrawParam & DrawParam::shading ( const bool flag = true )

inline

utilise une source de lumire pour eclairer l'objet, ou pas si flag= false.

Definition at line 113 of file draw.h.

{ update(flags, USE_SHADING, flag);  return *this; }

material() [1/2]

DrawParam & DrawParam::material ( const Material & material )

inline

utilise une matiere pour dessiner un objet.

Definition at line 116 of file draw.h.

{ update(flags, USE_SHADING | USE_MATERIAL); m_material= material; return *this; }

material() [2/2]

DrawParam & DrawParam::material ( const bool flag = true )

inline

active / desactive la matiere pour dessiner un objet.

Definition at line 118 of file draw.h.

{ update(flags, USE_MATERIAL, flag); return *this; }

debug_normals()

DrawParam & DrawParam::debug_normals ( const float s = 0.2 )

inline

visualise les normales des sommets des triangles et les normales geometrique des triangles

Definition at line 121 of file draw.h.

{ update(flags, DEBUG_NORMALS, (s > 0)); m_normals_scale= s; return *this;}

wireframe()

DrawParam & DrawParam::wireframe ( const bool flag = true )

inline

visualise les aretes des triangles.

Definition at line 123 of file draw.h.

{ update(flags, DEBUG_NORMALS,  flag); m_normals_scale= 0; return *this;}

debug_texcoords()

DrawParam & DrawParam::debug_texcoords ( const bool flag = true )

inline

visualise les coordonnees de textures des sommets des triangles.

Definition at line 125 of file draw.h.

{ update(flags, DEBUG_TEXCOORDS, flag); return *this;}

draw() [1/4]

void DrawParam::draw

(

Mesh &

mesh

)

dessine l'objet avec l'ensemble des parametres definis.

Definition at line 196 of file draw.cpp.

{
    if(mesh.index_count())
        draw(0, mesh.index_count(), mesh);
    else
        draw(0, mesh.vertex_count(), mesh);
}

draw() [2/4]

void DrawParam::draw	(	Mesh &	mesh,
		const Transform &	model )

Definition at line 204 of file draw.cpp.

{
    m_model= model;
    draw(mesh);
}

draw() [3/4]

void DrawParam::draw	(	const TriangleGroup &	group,
		Mesh &	mesh )

Definition at line 210 of file draw.cpp.

{
    draw(group.first, group.n, mesh);
}

draw() [4/4]

void DrawParam::draw ( const unsigned first, const unsigned count, Mesh & mesh )

protected

Definition at line 215 of file draw.cpp.

{
    bool use_texture= m_texture;
    if(flag(USE_MATERIAL))
        use_texture= use_texture || m_material.diffuse_texture || m_material.specular_texture  || m_material.ns_texture;
    bool use_texcoord= use_texture && mesh.has_texcoord();
    bool use_normal= mesh.has_normal();
    bool use_color= mesh.has_color();
    
    Transform mv= m_view * m_model;
    Transform mvp= m_projection * mv;
    
    GLuint program= 0;
    if(flag(DEBUG_TEXCOORDS))
    {
        program= create_debug_texcoords_program( mesh.primitives(), create_flags(use_texcoord, use_normal, use_color) );
        if(program > 0)
        {
            use_color= false;
            use_normal= false;
            use_texcoord= true;
            update(flags, USE_LIGHT | USE_TEXTURE | USE_ALPHATEST, false);
            
            glUseProgram(program);
            //~ program_use_texture(program, "diffuse_color", 0, m_debug_texture);
            program_uniform(program, "mvpMatrix", mvp);
            program_uniform(program, "mvMatrix", mv);
            
            mesh.draw(first, count, program);
            return;
        }
    }
    
    //
    program= create_program( mesh.primitives(), create_flags(use_texcoord, use_normal, use_color) );
    assert(program > 0);
    
    glUseProgram(program);
    if(!use_color)
        program_uniform(program, "mesh_color", mesh.default_color());
    
    program_uniform(program, "mvpMatrix", mvp);
    
    // utiliser une texture, elle ne sera visible que si le mesh a des texcoords...
    if(use_texcoord && m_texture > 0)
        program_use_texture(program, "diffuse_texture", 0, m_texture);
    
    if(flag(USE_ALPHATEST))
        program_uniform(program, "alpha_min", m_alpha_min);
    
    if(flag(USE_SHADING))
    {
        if(use_normal)
            program_uniform(program, "normalMatrix", mv.normal()); // transforme les normales dans le repere camera.
        if(!use_normal || flag(USE_LIGHT | USE_MATERIAL))
        program_uniform(program, "mvMatrix", mv);
        
        if(flag(USE_MATERIAL))
        {
            program_uniform(program, "diffuse_color", m_material.diffuse);
            program_uniform(program, "specular_color", m_material.specular);
            program_uniform(program, "ns", m_material.ns);
            
            if(use_texcoord)
            {
                // texture blanche uniforme par defaut
                static GLuint white_texture= 0;
                if(white_texture == 0)
                {
                    ImageData data(16, 16, 4);
                    for(unsigned y= 0; y < data.height; y++)
                    for(unsigned x= 0; x < data.width; x++)
                    {
                        unsigned char *pixel= data.pixels.data() + data.offset(x, y);
                        for(unsigned i= 0; i < data.channels; i++)
                            pixel[i]= 255;
                    }
                    
                    white_texture= make_texture(0, data);
                }
                
                if(m_material.diffuse_texture > 0)
                    program_use_texture(program, "diffuse_texture", 0, m_material.diffuse_texture);
                else
                    program_use_texture(program, "diffuse_texture", 0, white_texture);
                
                if(m_material.specular_texture > 0)
                    program_use_texture(program, "specular_texture", 1, m_material.specular_texture);
                else
                    program_use_texture(program, "specular_texture", 1, white_texture);
                
                if(m_material.specular_texture > 0)
                    program_use_texture(program, "ns_texture", 2, m_material.specular_texture);
                else
                    program_use_texture(program, "ns_texture", 2, white_texture);
            }
        }
        
        if(flag(USE_LIGHT))
        {
            program_uniform(program, "light", m_view(m_light));       // transforme la position de la source dans le repere camera, comme les normales
            program_uniform(program, "light_color", m_light_color);
        }
        if(flag(USE_SUN))
        {
            program_uniform(program, "sun", m_view(m_sun));       // transforme la direction de la source dans le repere camera, comme les normales
            program_uniform(program, "sun_color", m_sun_color);
        }
        if(flag(USE_SKY))
        {
            program_uniform(program, "sky", m_view(m_sky));       // transforme la direction de la source dans le repere camera, comme les normales
            program_uniform(program, "sky_color", m_sky_color);
        }
    }
    
    mesh.draw(first, count, program);
    
    // dessine les normales par dessus...
    if(flag(DEBUG_NORMALS))
    {
        program= create_debug_normals_program( mesh.primitives(), create_flags(use_texcoord, use_normal, use_color) );
        if(program > 0)
        {
            use_color= false;
            use_normal= true;
            use_texcoord= false;
            update(flags, USE_SHADING | USE_LIGHT | USE_TEXTURE | USE_ALPHATEST, false);
            
            static float scale= 1;
            if(key_state('p') || key_state(SDLK_KP_PLUS))
                scale+= 0.005f;
            if(key_state('m') || key_state(SDLK_KP_MINUS))
                scale-= 0.005f;
            if(scale < 0.1f)
                scale= 0.1f;
            
            glUseProgram(program);
            program_uniform(program, "mvpMatrix", mvp);
            program_uniform(program, "normalMatrix", mv.normal()); // transforme les normales dans le repere camera.
            program_uniform(program, "scale", scale * m_normals_scale);
 
            mesh.draw(first, count, program);
        }
    }
}

create_flags()

unsigned DrawParam::create_flags ( const bool use_texcoord, const bool use_normal, const bool use_color )

protected

Definition at line 172 of file draw.cpp.

{
    unsigned options= flags;
    update(options, USE_TEXCOORD, use_texcoord);
    update(options, USE_NORMAL, use_normal);
    update(options, USE_COLOR, use_color);
    
    return options;
}

update()

unsigned DrawParam::update ( unsigned & flags, const unsigned option, const bool use = true )

protected

Definition at line 182 of file draw.cpp.

{
    if(use)
        flags= flags | option;
    else
        flags= flags & ~option;
    return flags;
}

flag()

bool DrawParam::flag ( const unsigned option )

protected

Definition at line 191 of file draw.cpp.

{
    return flags & option;
}

create_program()

GLuint DrawParam::create_program ( const GLenum primitives, const unsigned flags )

protected

construit un shader program configure pour l'ensemble d'options.

Definition at line 115 of file draw.cpp.

{
    std::string definitions;
 
    if(flags & USE_TEXCOORD)
        definitions.append("#define USE_TEXCOORD\n");
    if(flags & USE_NORMAL)
        definitions.append("#define USE_NORMAL\n");
    if(flags & USE_COLOR)
        definitions.append("#define USE_COLOR\n");
    
    if((flags & USE_TEXCOORD) && (flags & USE_ALPHATEST))
        definitions.append("#define USE_ALPHATEST\n");
    
    if(flags & USE_SHADING)
    {
        definitions.append("#define USE_SHADING\n");
        
        if(flags & USE_MATERIAL)
            definitions.append("#define USE_MATERIAL\n");
        if((flags & USE_LIGHT))
            definitions.append("#define USE_LIGHT\n");
        if(flags & USE_SUN)
            definitions.append("#define USE_SUN\n");
        if(flags & USE_SKY)
            definitions.append("#define USE_SKY\n");
    }
 
    //~ printf("--\n%s", definitions.c_str());
    const char *filename= smart_path("data/shaders/mesh.glsl");
    bool use_mesh_color= (primitives == GL_POINTS || primitives == GL_LINES || primitives == GL_LINE_STRIP || primitives == GL_LINE_LOOP);
    if(use_mesh_color) 
        filename= smart_path("data/shaders/mesh_color.glsl");
    
    PipelineProgram *cache= PipelineCache::manager().find(filename, definitions.c_str());
    return cache->program;
}

create_debug_normals_program()

GLuint DrawParam::create_debug_normals_program ( const GLenum primitives, const unsigned flags )

protected

construit un shader program / debug des normales.

Definition at line 153 of file draw.cpp.

{
    const char *filename= smart_path("data/shaders/normals.glsl");
    bool use_mesh_color= (primitives == GL_POINTS || primitives == GL_LINES || primitives == GL_LINE_STRIP || primitives == GL_LINE_LOOP);
    if(use_mesh_color) 
        // pas la peine, les normales ne sont definies que pour les triangles...
        return 0;
    
    PipelineProgram *cache= PipelineCache::manager().find(filename);
    return cache->program;
}

create_debug_texcoords_program()

GLuint DrawParam::create_debug_texcoords_program ( const GLenum primitives, const unsigned flags )

protected

construit un shader program / debug des coordonnees de texture.

Definition at line 165 of file draw.cpp.

{
    const char *filename= smart_path("data/shaders/texcoords.glsl");
    PipelineProgram *cache= PipelineCache::manager().find(filename);
    return cache->program;
}

Member Data Documentation

flags

unsigned DrawParam::flags

protected

Definition at line 154 of file draw.h.

m_model

Transform DrawParam::m_model

protected

Definition at line 167 of file draw.h.

m_view

Transform DrawParam::m_view

protected

Definition at line 168 of file draw.h.

m_projection

Transform DrawParam::m_projection

protected

Definition at line 169 of file draw.h.

m_light

Point DrawParam::m_light

protected

Definition at line 171 of file draw.h.

m_light_color

Color DrawParam::m_light_color

protected

Definition at line 172 of file draw.h.

m_sun

Vector DrawParam::m_sun

protected

Definition at line 174 of file draw.h.

m_sun_color

Color DrawParam::m_sun_color

protected

Definition at line 175 of file draw.h.

m_sky

Vector DrawParam::m_sky

protected

Definition at line 176 of file draw.h.

m_sky_color

Color DrawParam::m_sky_color

protected

Definition at line 177 of file draw.h.

m_texture

GLuint DrawParam::m_texture

protected

Definition at line 179 of file draw.h.

m_envmap

GLuint DrawParam::m_envmap

protected

Definition at line 180 of file draw.h.

m_alpha_min

float DrawParam::m_alpha_min

protected

Definition at line 181 of file draw.h.

m_normals_scale

float DrawParam::m_normals_scale

protected

Definition at line 182 of file draw.h.

m_material

Material DrawParam::m_material

protected

Definition at line 184 of file draw.h.

---

The documentation for this class was generated from the following files:

• src/gKit/draw.h
• src/gKit/draw.cpp