source/program.h

   1 #ifndef MSP_GL_PROGRAM_H_
   2 #define MSP_GL_PROGRAM_H_
   3
   4 #include <list>
   5 #include <string>
   6 #include <msp/datafile/objectloader.h>
   7 #include "bindable.h"
   8 #include "gl.h"
   9
  10 namespace Msp {
  11 namespace GL {
  12
  13 class Shader;
  14
  15 class Program: public Bindable<Program>
  16 {
  17 public:
  18         class Loader: public DataFile::ObjectLoader<Program>
  19         {
  20         public:
  21                 Loader(Program &);
  22
  23         private:
  24                 virtual void finish();
  25
  26                 void attribute(unsigned, const std::string &);
  27                 void fragment_shader(const std::string &);
  28                 void standard();
  29                 void vertex_shader(const std::string &);
  30         };
  31
  32         struct StandardFeatures
  33         {
  34                 class Loader: public DataFile::ObjectLoader<StandardFeatures>
  35                 {
  36                 public:
  37                         Loader(StandardFeatures &);
  38                 };
  39
  40                 bool texture;
  41                 bool material;
  42                 bool lighting;
  43                 bool specular;
  44                 bool normalmap;
  45                 bool shadow;
  46                 bool reflection;
  47                 bool transform;
  48
  49                 StandardFeatures();
  50
  51                 std::string create_flags() const;
  52         };
  53
  54         struct UniformBlockInfo;
  55
  56         struct UniformInfo
  57         {
  58                 std::string name;
  59                 const UniformBlockInfo *block;
  60                 unsigned location;
  61                 unsigned size;
  62                 unsigned array_stride;
  63                 unsigned matrix_stride;
  64                 GLenum type;
  65         };
  66
  67         struct UniformBlockInfo
  68         {
  69                 std::string name;
  70                 unsigned data_size;
  71                 unsigned bind_point;
  72                 std::vector<const UniformInfo *> uniforms;
  73                 unsigned layout_hash;
  74         };
  75
  76         typedef std::list<Shader *> ShaderList;
  77         typedef std::map<std::string, UniformInfo> UniformMap;
  78         typedef std::map<std::string, UniformBlockInfo> UniformBlockMap;
  79
  80 private:
  81         unsigned id;
  82         ShaderList shaders;
  83         ShaderList owned_data;
  84         bool linked;
  85         UniformBlockMap uniform_blocks;
  86         UniformMap uniforms;
  87         unsigned uniform_layout_hash;
  88
  89 public:
  90         Program();
  91         Program(const StandardFeatures &);
  92         Program(const std::string &, const std::string &);
  93 private:
  94         void init();
  95 public:
  96         virtual ~Program();
  97
  98         void attach_shader(Shader &shader);
  99         void attach_shader_owned(Shader *shader);
 100         void detach_shader(Shader &shader);
 101         void add_standard_shaders(const StandardFeatures &);
 102 private:
 103         static std::string process_standard_source(const char **, const std::string &);
 104 public:
 105         const ShaderList &get_shaders() const { return shaders; }
 106
 107         void bind_attribute(unsigned, const std::string &);
 108
 109         void link();
 110 private:
 111         static unsigned compute_layout_hash(const std::vector<const UniformInfo *> &);
 112 public:
 113         bool is_linked() const { return linked; }
 114         std::string get_info_log() const;
 115
 116         unsigned get_uniform_layout_hash() const { return uniform_layout_hash; }
 117         const UniformBlockMap &get_uniform_blocks() const { return uniform_blocks; }
 118         const UniformBlockInfo &get_uniform_block_info(const std::string &) const;
 119         const UniformMap &get_uniforms() const { return uniforms; }
 120         const UniformInfo &get_uniform_info(const std::string &) const;
 121         int get_uniform_location(const std::string &) const;
 122
 123         void bind() const;
 124         static void unbind();
 125 };
 126
 127 } // namespace GL
 128 } // namespace Msp
 129
 130 #endif