]> git.tdb.fi Git - libs/gl.git/blob - source/materials/rendermethod.cpp
Support multiple PipelineStates in Renderer
[libs/gl.git] / source / materials / rendermethod.cpp
1 #include <msp/core/algorithm.h>
2 #include <msp/datafile/collection.h>
3 #include <msp/strings/format.h>
4 #include "error.h"
5 #include "rendermethod.h"
6 #include "program.h"
7 #include "programdata.h"
8 #include "renderer.h"
9 #include "texture.h"
10 #include "texture2d.h"
11
12 using namespace std;
13
14 namespace Msp {
15 namespace GL {
16
17 void RenderMethod::set_material_textures()
18 {
19         if(!material)
20                 return;
21
22         const Tag *material_texture_tags = material->get_texture_tags();
23         for(const Tag *tag=material_texture_tags; tag->id; ++tag)
24                 set_texture(*tag, material->get_texture(*tag), material->get_sampler(*tag));
25 }
26
27 void RenderMethod::maybe_create_material_shader()
28 {
29         if(!material || (shprog && !shprog_from_material))
30                 return;
31
32         map<string, int> extra_spec;
33         if(receive_shadows)
34                 extra_spec["use_shadow_map"] = true;
35         if(image_based_lighting)
36                 extra_spec["use_image_based_lighting"] = true;
37
38         shprog = material->create_compatible_shader(extra_spec);
39
40         if(shdata)
41         {
42                 RefPtr<ProgramData> old_shdata = shdata;
43                 shdata = new ProgramData(shprog);
44                 shdata->copy_uniforms(*old_shdata);
45         }
46
47         shprog_from_material = true;
48 }
49
50 void RenderMethod::set_shader_program(const Program *prog, const ProgramData *data)
51 {
52         shprog = prog;
53         shprog_from_material = false;
54         if(data)
55         {
56                 shdata = new ProgramData;
57                 shdata->copy_uniforms(*data);
58         }
59         else
60                 shdata = 0;
61         maybe_create_material_shader();
62 }
63
64 Tag RenderMethod::get_slotted_uniform_tag(Tag slot) const
65 {
66         auto i = uniform_slots.find(slot);
67         if(i==uniform_slots.end())
68                 return Tag();
69         return i->second;
70 }
71
72 void RenderMethod::set_material(const Material *mat)
73 {
74         material = mat;
75         maybe_create_material_shader();
76         set_material_textures();
77 }
78
79 void RenderMethod::set_texture(Tag tag, const Texture *tex, const Sampler *samp)
80 {
81         auto i = find_member(textures, tag, &TextureSlot::tag);
82         if(i==textures.end())
83         {
84                 textures.emplace_back(tag);
85                 i = textures.end()-1;
86         }
87         i->texture = tex;
88         if(samp)
89                 i->sampler = samp;
90 }
91
92 Tag RenderMethod::get_texture_tag(const string &slot) const
93 {
94         auto i = find_member(textures, slot, &TextureSlot::slot_name);
95         return (i!=textures.end() ? i->tag : Tag());
96 }
97
98 void RenderMethod::set_face_cull(CullMode fc)
99 {
100         face_cull = fc;
101 }
102
103 void RenderMethod::set_blend(const Blend &b)
104 {
105         blend = b;
106 }
107
108 void RenderMethod::set_receive_shadows(bool rs)
109 {
110         receive_shadows = rs;
111         maybe_create_material_shader();
112 }
113
114 void RenderMethod::set_image_based_lighting(bool ibl)
115 {
116         image_based_lighting = ibl;
117         maybe_create_material_shader();
118 }
119
120 void RenderMethod::apply(Renderer &renderer) const
121 {
122         for(const TextureSlot &t: textures)
123                 renderer.set_texture(t.tag, t.texture, t.sampler);
124         renderer.set_shader_program(shprog, shdata.get());
125         if(material)
126                 renderer.add_shader_data(material->get_shader_data());
127         renderer.set_face_cull(face_cull);
128         renderer.set_blend(&blend);
129 }
130
131 void RenderMethod::set_debug_name(const string &name)
132 {
133 #ifdef DEBUG
134         if(shdata.refcount()==1)
135                 shdata->set_debug_name(name+" [UBO]");
136 #else
137         (void)name;
138 #endif
139 }
140
141
142 DataFile::Loader::ActionMap RenderMethod::Loader::shared_actions;
143
144 RenderMethod::Loader::Loader(RenderMethod &p, Collection &c):
145         DataFile::CollectionObjectLoader<RenderMethod>(p, &c)
146 {
147         set_actions(shared_actions);
148 }
149
150 void RenderMethod::Loader::init_actions()
151 {
152         add("blend", &Loader::blend);
153         add("blend", &Loader::blend_factors);
154         add("face_cull", &RenderMethod::face_cull);
155         add("shader",   &Loader::shader);
156         add("image_based_lighting", &RenderMethod::image_based_lighting);
157         add("material", &Loader::material_inline);
158         add("material", &Loader::material);
159         add("material_slot", &RenderMethod::material_slot);
160         add("receive_shadows", &RenderMethod::receive_shadows);
161         add("texture", &Loader::texture);
162         add("uniforms", &Loader::uniforms);
163         add("uniform_slot", &Loader::uniform_slot);
164         add("uniform_slot", &Loader::uniform_slot2);
165 }
166
167 void RenderMethod::Loader::set_inline_base_name(const string &n)
168 {
169         inline_base_name = n;
170 }
171
172 void RenderMethod::Loader::finish()
173 {
174         if(obj.material)
175                 obj.maybe_create_material_shader();
176 }
177
178 void RenderMethod::Loader::blend()
179 {
180         load_sub(obj.blend);
181 }
182
183 void RenderMethod::Loader::blend_factors(BlendFactor src, BlendFactor dest)
184 {
185         obj.blend = Blend(src, dest);
186 }
187
188 void RenderMethod::Loader::material_inline()
189 {
190         Material::GenericLoader ldr(get_collection());
191         load_sub_with(ldr);
192         obj.material = ldr.store_object(get_collection(), inline_base_name+".mat");
193         obj.set_material_textures();
194 }
195
196 void RenderMethod::Loader::material(const string &name)
197 {
198         obj.material = &get_collection().get<Material>(name);
199         obj.set_material_textures();
200 }
201
202 void RenderMethod::Loader::shader(const string &n)
203 {
204         obj.shprog = &get_collection().get<Program>(n);
205         obj.shprog_from_material = false;
206         if(obj.shdata)
207         {
208                 RefPtr<ProgramData> old_shdata = obj.shdata;
209                 obj.shdata = new ProgramData(obj.shprog);
210                 obj.shdata->copy_uniforms(*old_shdata);
211         }
212 }
213
214 void RenderMethod::Loader::texture(const string &n)
215 {
216         auto i = find_member(obj.textures, Tag(n), &TextureSlot::tag);
217         if(i==obj.textures.end())
218         {
219                 obj.textures.emplace_back(n);
220                 i = obj.textures.end()-1;
221         }
222         TextureSlot::Loader ldr(*i, n, coll);
223         load_sub_with(ldr);
224 }
225
226 void RenderMethod::Loader::uniforms()
227 {
228         if(!obj.shprog || obj.shprog_from_material)
229                 throw runtime_error("Shader is required for uniforms");
230         if(!obj.shdata)
231                 obj.shdata = new ProgramData(obj.shprog);
232         else if(obj.shdata.refcount()>1)
233         {
234                 RefPtr<ProgramData> old_shdata = obj.shdata;
235                 obj.shdata = new ProgramData;
236                 obj.shdata->copy_uniforms(*old_shdata);
237         }
238         load_sub(*obj.shdata);
239 }
240
241 void RenderMethod::Loader::uniform_slot(const string &name)
242 {
243         uniform_slot2(name, name);
244 }
245
246 void RenderMethod::Loader::uniform_slot2(const string &name, const string &slot)
247 {
248         obj.uniform_slots[slot] = name;
249 }
250
251
252 RenderMethod::TextureSlot::Loader::Loader(TextureSlot &ts, const string &an, Collection *c):
253         CollectionObjectLoader<TextureSlot>(ts, c),
254         auto_slot_name(an)
255 {
256         add("sampler", &TextureSlot::sampler);
257         add("slot", &Loader::slot_auto);
258         add("slot", &TextureSlot::slot_name);
259         add("texture", &TextureSlot::texture);
260 }
261
262 void RenderMethod::TextureSlot::Loader::slot_auto()
263 {
264         obj.slot_name = auto_slot_name;
265 }
266
267 } // namespace GL
268 } // namespace Msp