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( ) : m_model(), m_view(), m_projection(),
        m_use_light(false), m_light(), m_light_color(),
        m_use_texture(false), m_texture(0),
        m_use_alpha_test(false), m_alpha_min(0.3f),
        m_debug_normals(false), m_normals_scale(1),
        m_debug_texcoords(false)
    {}

    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() ) { m_use_light= true; m_light= p; m_light_color=c; return *this; }
    DrawParam& texture( const GLuint t ) { m_use_texture= true; m_texture= t; return *this; }
    
    DrawParam& alpha_texture( const GLuint t, const float a= 0.5f ) { m_use_alpha_test= (a > 0); m_alpha_min= a; m_use_texture= true; m_texture= t; return *this; }
 
// a virer     
    DrawParam& lighting( const bool use_light= true ) { m_use_light= use_light;  return *this; }
    const Point& light() const { return m_light; }
// les params sont configures une fois par groupe d'options, pas a chaque draw. l'idee est de dessiner tous les objets utilisant la meme config ensemble / en suivant, les uns apres les autres.
    
    DrawParam& debug_normals( const float s= 1 ) { m_debug_normals= true; m_normals_scale= s; return *this;}
    DrawParam& debug_texcoords( ) { m_debug_texcoords= true; return *this;}
    
    void draw( Mesh& mesh );
    void draw( const TriangleGroup& group, Mesh& mesh );
    
protected:
    GLuint create_program( const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test );
    GLuint create_debug_normals_program( const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test );
    GLuint create_debug_texcoords_program( const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test );
    
    Transform m_model;
    Transform m_view;
    Transform m_projection;
 
    bool m_use_light;
    Point m_light;
    Color m_light_color;
 
    bool m_use_texture;
    GLuint m_texture;
 
    bool m_use_alpha_test;
    float m_alpha_min;
    
    bool m_debug_normals;
    float m_normals_scale;
    bool m_debug_texcoords;
};
 
 
void draw( Mesh& m, DrawParam& param );
// \todo void draw( Mesh& m, const Transform& model, DrawParam& param );
// drawparams = parametres globaux, camera, light, texture, debug, etc...

struct PipelineProgram
{
    std::string filename;
    std::string definitions;
    GLuint program;
};

class PipelineCache
{
public:
    ~PipelineCache( ) 
    {
        printf("[pipeline cache] %d programs.\n", int(m_programs.size()));
        // le contexte est deja detruit lorsque ce destructeur est appelle... 
        // trop tard pour detruire les programs et les shaders...
    }
    
    PipelineProgram *find( const char *filename, const char *definitions= "" )
    {
        // todo peut etre remplacer par une unordered_map ? mais il y a peu de shaders utilise normalement...
        for(auto program : m_programs)
        {
            if(program->filename == filename && program->definitions == definitions)
                return program;
        }
        
        // cree le programme s'il n'existe pas deja...
        GLuint p= read_program(filename, definitions);
        program_print_errors(p);
        
        PipelineProgram *program= new PipelineProgram {filename, definitions, p};
        m_programs.push_back(program);
        return program;
    }
    
    static PipelineCache& manager( ) 
    {
        static PipelineCache cache;
        return cache;
    }
    
protected:
    PipelineCache( ) : m_programs() {}
    
    std::vector<PipelineProgram *> m_programs;
};
 
 
#endif