program.h

Go to the documentation of this file.

 
#ifndef _PROGRAM_H
#define _PROGRAM_H
 
#include <vector>
#include <string>
 
#include "glcore.h"
 



GLuint read_program( const char *filename, const char *definitions= "" );

int release_program( const GLuint program );

int reload_program( const GLuint program, const char *filename, const char *definitions= "" );

int reload_program( const GLuint program );

int program_format_errors( const GLuint program, std::string& errors );

int program_print_errors( const GLuint program, const char *filename= "" );

bool program_ready( const GLuint program );

bool program_errors( const GLuint program );
 

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 appele... 
        // trop tard pour detruire les programs et les shaders...
    }
    
    PipelineProgram *find( const char *filename, const char *definitions= "" )
    {
        // todo unordered_map sans doute plus rapide ? mais il y a peu de shaders utilises... 
        for(auto cache : m_programs)
        {
            if(cache->filename == filename && cache->definitions == definitions)
                return cache;
        }
        
        return insert(filename, definitions);
    }
    
    PipelineProgram *insert( const char *filename, const char *definitions= "" )
    {
        int update_program( const GLuint program, const char *filename, const char *definitions );
        
        // cree le programme s'il n'existe pas deja...
        GLuint program= glCreateProgram();
        update_program(program, filename, definitions);
        program_print_errors(program);
        
        return insert(program, filename, definitions);
    }
    
    PipelineProgram *insert( const GLuint program, const char *filename, const char *definitions= "" )
    {
        PipelineProgram *cache= new PipelineProgram { filename, definitions, program };
        m_programs.push_back(cache);
        
        return cache;
    }
    
    PipelineProgram *reload( const GLuint program )
    {
        for(auto cache : m_programs)
        {
            if(cache->program == program)
            {
                reload_program(program, cache->filename.c_str(), cache->definitions.c_str());
                program_print_errors(program);
                return cache;
            }
        }
        
        return nullptr;
    }
    
    void reload( )
    {
        for(auto cache : m_programs)
        {
            reload_program(cache->program, cache->filename.c_str(), cache->definitions.c_str());
            program_print_errors(cache->program);
        }
    }
    
    static PipelineCache& manager( ) 
    {
        static PipelineCache cache;
        return cache;
    }
    
protected:
    PipelineCache( ) : m_programs() {}
    
    std::vector<PipelineProgram *> m_programs;
};
 

#endif