]> git.tdb.fi Git - libs/gl.git/blob - source/materials/material.h
Add push_back_nocopy to NodeContainer for clarity
[libs/gl.git] / 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 const Program *create_compatible_shader(DataFile::Collection &) const;
100 protected:
101         virtual void fill_program_info(std::string &, std::map<std::string, int> &) const = 0;
102
103 public:
104         /** Returns the uniforms for the material. */
105         const ProgramData &get_shader_data() const { return shdata; }
106
107 protected:
108         void attach_texture_to(const Texture *, Texturing &, ProgramData &, const std::string &) const;
109 public:
110         virtual void attach_textures_to(Texturing &, ProgramData &) const = 0;
111
112         template<typename T>
113         static void register_type(const std::string &);
114 private:
115         static MaterialRegistry &get_material_registry();
116 };
117
118 template<typename T>
119 void Material::register_type(const std::string &kw)
120 {
121         get_material_registry().register_type<T>(kw);
122 }
123
124
125 template<typename C>
126 void Material::PropertyLoader<C>::add_property(const std::string &kw, void (C::*set_value)(float), void (C::*set_texture)(const Texture *))
127 {
128         add(kw, &PropertyLoader<C>::property_value_scalar, set_value);
129         if(set_texture)
130                 add(kw+"_map", &PropertyLoader<C>::property_texture, set_texture);
131 }
132
133 template<typename C>
134 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)
135 {
136         add(kw, &PropertyLoader<C>::property_value_rgb, set_value);
137         add(kw+"_srgb", &PropertyLoader<C>::property_value_srgb, set_value);
138         if(allow_alpha)
139         {
140                 add(kw, &PropertyLoader<C>::property_value_rgba, set_value);
141                 add(kw+"_srgb", &PropertyLoader<C>::property_value_srgb_alpha, set_value);
142         }
143         if(set_texture)
144                 add(kw+"_map", &PropertyLoader<C>::property_texture, set_texture);
145 }
146
147 template<typename C>
148 void Material::PropertyLoader<C>::add_property(const std::string &kw, void (C::*set_texture)(const Texture *))
149 {
150         add(kw+"_map", &PropertyLoader<C>::property_texture, set_texture);
151 }
152
153 template<typename C>
154 void Material::PropertyLoader<C>::property_value_scalar(void (C::*set_value)(float), float value)
155 {
156         (static_cast<C &>(obj).*set_value)(value);
157 }
158
159 template<typename C>
160 void Material::PropertyLoader<C>::property_value_rgb(void (C::*set_value)(const Color &), float r, float g, float b)
161 {
162         (static_cast<C &>(obj).*set_value)(Color(r, g, b));
163 }
164
165 template<typename C>
166 void Material::PropertyLoader<C>::property_value_rgba(void (C::*set_value)(const Color &), float r, float g, float b, float a)
167 {
168         (static_cast<C &>(obj).*set_value)(Color(r, g, b, a));
169 }
170
171 template<typename C>
172 void Material::PropertyLoader<C>::property_value_srgb(void (C::*set_value)(const Color &), float r, float g, float b)
173 {
174         (static_cast<C &>(obj).*set_value)(Color(r, g, b).to_linear());
175 }
176
177 template<typename C>
178 void Material::PropertyLoader<C>::property_value_srgb_alpha(void (C::*set_value)(const Color &), float r, float g, float b, float a)
179 {
180         (static_cast<C &>(obj).*set_value)(Color(r, g, b, a).to_linear());
181 }
182
183 template<typename C>
184 void Material::PropertyLoader<C>::property_texture(void (C::*set_texture)(const Texture *), const std::string &name)
185 {
186         /* The static_cast around get_collection is needed because otherwise Android
187         SDK's g++ 4.9 fails to parse get<Texture> as a template function call */
188         (static_cast<C &>(obj).*set_texture)(&static_cast<Collection &>(get_collection()).get<Texture>(name));
189 }
190
191
192 template<typename T>
193 void Material::GenericLoader::typed_material()
194 {
195         if(material)
196                 throw std::logic_error("Material was already loaded");
197         RefPtr<T> mat = new T;
198         if(coll)
199                 load_sub(*mat, *coll);
200         else
201                 load_sub(*mat);
202         material = mat;
203 }
204
205 } // namespace GL
206 } // namespace Msp
207
208 #endif