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