source/materials/material.h

   1 #ifndef MSP_GL_MATERIAL_H_
   2 #define MSP_GL_MATERIAL_H_
   3
   4 #include <msp/datafile/collection.h>
   5 #include <msp/datafile/loadabletyperegistry.h>
   6 #include <msp/datafile/objectloader.h>
   7 #include "color.h"
   8 #include "programdata.h"
   9 #include "texture.h"
  10
  11 namespace Msp {
  12 namespace GL {
  13
  14 class Texturing;
  15
  16 class Material
  17 {
  18 private:
  19         class Loader: public DataFile::CollectionObjectLoader<Material>
  20         {
  21         protected:
  22                 Loader(Material &);
  23                 Loader(Material &, Collection &);
  24
  25                 virtual void init_actions();
  26
  27         private:
  28                 void sampler(const std::string &);
  29         };
  30
  31 protected:
  32         template<typename T>
  33         struct Property
  34         {
  35                 T value;
  36                 const Texture *texture;
  37
  38                 Property(): value(T()), texture(0) { }
  39         };
  40
  41         template<typename C>
  42         class PropertyLoader: public DataFile::DerivedObjectLoader<Material, Loader>
  43         {
  44         protected:
  45                 PropertyLoader(C &m): DerivedObjectLoader<Material, Loader>(m) { }
  46                 PropertyLoader(C &m, Collection &c): DerivedObjectLoader<Material, Loader>(m, c) { }
  47
  48                 void add_property(const std::string &, void (C::*)(float), void (C::*)(const Texture *));
  49                 void add_property(const std::string &, void (C::*)(const Color &), void (C::*)(const Texture *), bool);
  50                 void add_property(const std::string &, void (C::*)(const Texture *));
  51
  52                 void property_value_scalar(void (C::*)(float), float);
  53                 void property_value_rgb(void (C::*)(const Color &), float, float, float);
  54                 void property_value_rgba(void (C::*)(const Color &), float, float, float, float);
  55                 void property_value_srgb(void (C::*)(const Color &), float, float, float);
  56                 void property_value_srgb_alpha(void (C::*)(const Color &), float, float, float, float);
  57                 void property_texture(void (C::*)(const Texture *), const std::string &);
  58         };
  59
  60 public:
  61         class GenericLoader: public DataFile::Loader
  62         {
  63         private:
  64                 template<typename T>
  65                 struct AddType
  66                 {
  67                         static void add(GenericLoader &ldr, const std::string &kw) { ldr.add(kw, &GenericLoader::typed_material<T>); }
  68                 };
  69
  70                 DataFile::Collection *coll;
  71                 RefPtr<Material> material;
  72
  73                 static ActionMap shared_actions;
  74
  75         public:
  76                 GenericLoader(DataFile::Collection * = 0);
  77
  78                 Material *get_material() { return material.release(); }
  79         private:
  80                 virtual void init_actions();
  81
  82                 template<typename T>
  83                 void typed_material();
  84
  85                 friend class Material;
  86         };
  87
  88 private:
  89         typedef DataFile::LoadableTypeRegistry<GenericLoader, GenericLoader::AddType> MaterialRegistry;
  90
  91 protected:
  92         const Sampler *sampler;
  93         ProgramData shdata;
  94
  95         Material(): sampler(0) { }
  96 public:
  97         virtual ~Material() { }
  98
  99         virtual Program *create_compatible_shader() const;
 100         virtual const Program *create_compatible_shader(DataFile::Collection &) const;
 101 protected:
 102         virtual std::string create_program_source() const = 0;
 103
 104 public:
 105         /** Returns the uniforms for the material. */
 106         const ProgramData &get_shader_data() const { return shdata; }
 107
 108 protected:
 109         void attach_texture_to(const Texture *, Texturing &, ProgramData &, const std::string &) const;
 110 public:
 111         virtual void attach_textures_to(Texturing &, ProgramData &) const = 0;
 112
 113         template<typename T>
 114         static void register_type(const std::string &);
 115 private:
 116         static MaterialRegistry &get_material_registry();
 117 };
 118
 119 template<typename T>
 120 void Material::register_type(const std::string &kw)
 121 {
 122         get_material_registry().register_type<T>(kw);
 123 }
 124
 125
 126 template<typename C>
 127 void Material::PropertyLoader<C>::add_property(const std::string &kw, void (C::*set_value)(float), void (C::*set_texture)(const Texture *))
 128 {
 129         add(kw, &PropertyLoader<C>::property_value_scalar, set_value);
 130         if(set_texture)
 131                 add(kw+"_map", &PropertyLoader<C>::property_texture, set_texture);
 132 }
 133
 134 template<typename C>
 135 void Material::PropertyLoader<C>::add_property(const std::string &kw, void (C::*set_value)(const Color &), void (C::*set_texture)(const Texture *), bool allow_alpha)
 136 {
 137         add(kw, &PropertyLoader<C>::property_value_rgb, set_value);
 138         add(kw+"_srgb", &PropertyLoader<C>::property_value_srgb, set_value);
 139         if(allow_alpha)
 140         {
 141                 add(kw, &PropertyLoader<C>::property_value_rgba, set_value);
 142                 add(kw+"_srgb", &PropertyLoader<C>::property_value_srgb_alpha, set_value);
 143         }
 144         if(set_texture)
 145                 add(kw+"_map", &PropertyLoader<C>::property_texture, set_texture);
 146 }
 147
 148 template<typename C>
 149 void Material::PropertyLoader<C>::add_property(const std::string &kw, void (C::*set_texture)(const Texture *))
 150 {
 151         add(kw+"_map", &PropertyLoader<C>::property_texture, set_texture);
 152 }
 153
 154 template<typename C>
 155 void Material::PropertyLoader<C>::property_value_scalar(void (C::*set_value)(float), float value)
 156 {
 157         (static_cast<C &>(obj).*set_value)(value);
 158 }
 159
 160 template<typename C>
 161 void Material::PropertyLoader<C>::property_value_rgb(void (C::*set_value)(const Color &), float r, float g, float b)
 162 {
 163         (static_cast<C &>(obj).*set_value)(Color(r, g, b));
 164 }
 165
 166 template<typename C>
 167 void Material::PropertyLoader<C>::property_value_rgba(void (C::*set_value)(const Color &), float r, float g, float b, float a)
 168 {
 169         (static_cast<C &>(obj).*set_value)(Color(r, g, b, a));
 170 }
 171
 172 template<typename C>
 173 void Material::PropertyLoader<C>::property_value_srgb(void (C::*set_value)(const Color &), float r, float g, float b)
 174 {
 175         (static_cast<C &>(obj).*set_value)(Color(r, g, b).to_linear());
 176 }
 177
 178 template<typename C>
 179 void Material::PropertyLoader<C>::property_value_srgb_alpha(void (C::*set_value)(const Color &), float r, float g, float b, float a)
 180 {
 181         (static_cast<C &>(obj).*set_value)(Color(r, g, b, a).to_linear());
 182 }
 183
 184 template<typename C>
 185 void Material::PropertyLoader<C>::property_texture(void (C::*set_texture)(const Texture *), const std::string &name)
 186 {
 187         /* The static_cast around get_collection is needed because otherwise Android
 188         SDK's g++ 4.9 fails to parse get<Texture> as a template function call */
 189         (static_cast<C &>(obj).*set_texture)(&static_cast<Collection &>(get_collection()).get<Texture>(name));
 190 }
 191
 192
 193 template<typename T>
 194 void Material::GenericLoader::typed_material()
 195 {
 196         if(material)
 197                 throw std::logic_error("Material was already loaded");
 198         RefPtr<T> mat = new T;
 199         if(coll)
 200                 load_sub(*mat, *coll);
 201         else
 202                 load_sub(*mat);
 203         material = mat;
 204 }
 205
 206 } // namespace GL
 207 } // namespace Msp
 208
 209 #endif