source/materials/rendermethod.h

   1 #ifndef MSP_GL_RENDERPASS_H_
   2 #define MSP_GL_RENDERPASS_H_
   3
   4 #include <msp/core/refptr.h>
   5 #include <msp/datafile/objectloader.h>
   6 #include "cullface.h"
   7 #include "material.h"
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 class Program;
  13 class ProgramData;
  14 class Renderer;
  15 class Sampler;
  16 class Texture;
  17
  18 /**
  19 Encapsulates the data that determines the appearance of a rendered surface.
  20 This includes shader and data for it, material and texturing.
  21 */
  22 class RenderMethod
  23 {
  24 public:
  25         class Loader: public DataFile::CollectionObjectLoader<RenderMethod>
  26         {
  27         private:
  28                 std::string inline_base_name;
  29
  30                 static ActionMap shared_actions;
  31
  32         public:
  33                 Loader(RenderMethod &, Collection &);
  34         private:
  35                 virtual void init_actions();
  36
  37         public:
  38                 void set_inline_base_name(const std::string &);
  39
  40         private:
  41                 virtual void finish();
  42
  43                 void material_inline();
  44                 void material(const std::string &);
  45                 void shader(const std::string &);
  46                 void texture(const std::string &);
  47                 void uniforms();
  48                 void uniform_slot(const std::string &);
  49                 void uniform_slot2(const std::string &, const std::string &);
  50         };
  51
  52 private:
  53         struct TextureSlot
  54         {
  55                 class Loader: public DataFile::CollectionObjectLoader<TextureSlot>
  56                 {
  57                 private:
  58                         std::string auto_slot_name;
  59
  60                 public:
  61                         Loader(TextureSlot &, const std::string &, Collection *);
  62
  63                 private:
  64                         void slot_auto();
  65                 };
  66
  67                 Tag tag;
  68                 std::string slot_name;
  69                 const Texture *texture;
  70                 const Sampler *sampler;
  71
  72                 TextureSlot(Tag t): tag(t), texture(0), sampler(0) { }
  73         };
  74
  75         const Program *shprog;
  76         bool shprog_from_material;
  77         RefPtr<ProgramData> shdata;
  78         std::map<Tag, Tag> uniform_slots;
  79         const Material *material;
  80         std::string material_slot;
  81         std::vector<TextureSlot> textures;
  82         CullMode face_cull;
  83         bool receive_shadows;
  84         bool image_based_lighting;
  85
  86 public:
  87         RenderMethod();
  88
  89 private:
  90         void maybe_create_material_shader();
  91         void set_material_textures();
  92
  93 public:
  94         void set_shader_program(const Program *, const ProgramData *);
  95         const Program *get_shader_program() const { return shprog; }
  96         const ProgramData *get_shader_data() const { return shdata.get(); }
  97         Tag get_slotted_uniform_tag(Tag) const;
  98         void set_material(const Material *);
  99         const Material *get_material() const { return material; }
 100         const std::string &get_material_slot_name() const { return material_slot; }
 101         void set_texture(Tag, const Texture *, const Sampler * = 0);
 102         Tag get_texture_tag(const std::string &) const;
 103         void set_face_cull(CullMode);
 104         CullMode get_face_cull() const { return face_cull; }
 105         void set_receive_shadows(bool);
 106         bool get_receive_shadows() const { return receive_shadows; }
 107         void set_image_based_lighting(bool);
 108         bool get_image_based_lighting() const { return image_based_lighting; }
 109
 110         void apply(Renderer &) const;
 111
 112         void set_debug_name(const std::string &);
 113 };
 114
 115 } // namespace GL
 116 } // namespace Msp
 117
 118 #endif