draw.h

Go to the documentation of this file.

 
#ifndef _DRAW_H
#define _DRAW_H
 
#include "mesh.h"
#include "orbiter.h"
#include "window.h"
#include "program.h"
 



void draw( Mesh& m, const Transform& model, const Transform& view, const Transform& projection );
void draw( Mesh& m, const Transform& model, const Transform& view, const Transform& projection, const GLuint texture );

void draw( Mesh& m, Orbiter& camera );
void draw( Mesh& m, const Transform& model, Orbiter& camera );

void draw( Mesh& m, Orbiter& camera, const GLuint texture );
void draw( Mesh& m, const Transform& model, Orbiter& camera, const GLuint texture );



void draw( const TriangleGroup& group, Mesh& mesh, Orbiter& camera );
void draw( const TriangleGroup& group, Mesh& mesh, const Transform& model, Orbiter& camera );
void draw( const TriangleGroup& group, Mesh& mesh, const Transform& model, const Transform& view, const Transform& projection );

void draw( const TriangleGroup& group, Mesh& mesh, Orbiter& camera, const GLuint texture );
void draw( const TriangleGroup& group, Mesh& mesh, const Transform& model, Orbiter& camera, const GLuint texture );
void draw( const TriangleGroup& group, Mesh& mesh, const Transform& model, const Transform& view, const Transform& projection, const GLuint texture );

class DrawParam
{
public:
    DrawParam( ) :  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) )
    {}

    DrawParam& model( const Transform& m ) { m_model= m; return *this; }
    DrawParam& view( const Transform& m ) { m_view= m; return *this; }
    DrawParam& projection( const Transform& m ) { m_projection= m; return *this; }

    DrawParam& camera( Orbiter& o ) { m_view= o.view(); m_projection= o.projection(); return *this; }
    DrawParam& camera( Orbiter& o, const int width, const int height, const float fov ) { m_view= o.view(); m_projection= o.projection(width, height, fov); return *this; }
    DrawParam& light( const Point& p, const Color& c= White() ) { update(flags, USE_LIGHT); m_light= p; m_light_color=c; return *this; }
    DrawParam& light( const bool flag= true ) { update(flags, USE_LIGHT, flag); return *this; }
    DrawParam& sun( const Vector& d, const Color& c ) { update(flags, USE_SUN); m_sun= d; m_sun_color=c; return *this; }
    DrawParam& sun( const bool flag= true ) { update(flags, USE_SUN, flag); return *this; }
    
    DrawParam& sky( const Vector& d, const Color& c ) { update(flags, USE_SKY); m_sky= d; m_sky_color=c; return *this; }
    DrawParam& sky( const bool flag= true ) { update(flags, USE_SKY, flag); return *this; }
    
    DrawParam& texture( const GLuint t ) { update(flags, USE_TEXTURE, (t > 0)); m_texture= t; return *this; }
    
    DrawParam& alpha_texture( const GLuint t, const float a= 0.5 ) { update(flags, USE_ALPHATEST, (a > 0)); m_alpha_min= a; m_texture= t; return *this; }
    
    DrawParam& shading( const bool flag= true ) { update(flags, USE_SHADING, flag);  return *this; }
    
    DrawParam& material( const Material& material ) { update(flags, USE_SHADING | USE_MATERIAL); m_material= material; return *this; }
    DrawParam& material( const bool flag= true ) { update(flags, USE_MATERIAL, flag); return *this; }
    
    DrawParam& debug_normals( const float s= 0.2 ) { update(flags, DEBUG_NORMALS, (s > 0)); m_normals_scale= s; return *this;}
    DrawParam& wireframe( const bool flag= true ) { update(flags, DEBUG_NORMALS,  flag); m_normals_scale= 0; return *this;}
    DrawParam& debug_texcoords( const bool flag= true ) { update(flags, DEBUG_TEXCOORDS, flag); return *this;}
    
    void draw( Mesh& mesh );
    void draw( Mesh& mesh, const Transform& model );
    void draw( const TriangleGroup& group, Mesh& mesh );
    
protected:
    void draw( const unsigned first, const unsigned count, Mesh& mesh );

    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
    };
    
    unsigned flags;
    
    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 );
    GLuint create_debug_normals_program( const GLenum primitives, const unsigned flags );
    GLuint create_debug_texcoords_program( const GLenum primitives, const 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;
};
 
 
void draw( Mesh& m, DrawParam& param );
 
#endif