]> git.tdb.fi Git - libs/gl.git/blob - source/materials/technique.cpp
Refactor the builtin occluder shader
[libs/gl.git] / source / materials / technique.cpp
1 #include <msp/core/refptr.h>
2 #include <msp/datafile/collection.h>
3 #include <msp/fs/utils.h>
4 #include <msp/strings/format.h>
5 #include "material.h"
6 #include "programdata.h"
7 #include "technique.h"
8 #include "texture.h"
9
10 using namespace std;
11
12 namespace Msp {
13 namespace GL {
14
15 RenderMethod &Technique::add_method(Tag tag)
16 {
17         return insert_unique(methods, tag, RenderMethod())->second;
18 }
19
20 bool Technique::has_method(Tag tag) const
21 {
22         return methods.count(tag);
23 }
24
25 const RenderMethod &Technique::get_method(Tag tag) const
26 {
27         return get_item(methods, tag);
28 }
29
30 const RenderMethod *Technique::find_method(Tag tag) const
31 {
32         auto i = methods.find(tag);
33         return (i!=methods.end() ? &i->second : 0);
34 }
35
36 bool Technique::replace_texture(const string &slot, const Texture &tex)
37 {
38         bool replaced = false;
39         for(auto &kvp: methods)
40         {
41                 Tag tag = kvp.second.get_texture_tag(slot);
42                 if(tag.id)
43                 {
44                         kvp.second.set_texture(tag, &tex);
45                         replaced = true;
46                 }
47         }
48
49         return replaced;
50 }
51
52 bool Technique::replace_material(const string &slot, const Material &mat)
53 {
54         bool replaced = false;
55         for(auto &kvp: methods)
56         {
57                 const string &pass_slot = kvp.second.get_material_slot_name();
58                 if(!pass_slot.empty() && pass_slot==slot)
59                 {
60                         kvp.second.set_material(&mat);
61                         replaced = true;
62                 }
63         }
64
65         return replaced;
66 }
67
68 bool Technique::replace_uniforms(const ProgramData &shdata)
69 {
70         bool replaced = false;
71         const vector<Tag> &uniform_tags = shdata.get_uniform_tags();
72         for(auto &kvp: methods)
73         {
74                 RefPtr<ProgramData> new_shdata;
75                 for(Tag t: uniform_tags)
76                 {
77                         Tag tag = kvp.second.get_slotted_uniform_tag(t);
78                         if(!tag.id)
79                                 continue;
80
81                         if(!new_shdata)
82                                 new_shdata = new ProgramData(*kvp.second.get_shader_data());
83
84                         new_shdata->copy_uniform(shdata, tag);
85                         replaced = true;
86                 }
87
88                 if(new_shdata)
89                         kvp.second.set_shader_program(kvp.second.get_shader_program(), new_shdata.get());
90         }
91
92         return replaced;
93 }
94
95 void Technique::set_debug_name(const string &name)
96 {
97 #ifdef DEBUG
98         for(auto &kvp: methods)
99                 kvp.second.set_debug_name(format("%s [method:%s]", name, kvp.first.str()));
100 #else
101         (void)name;
102 #endif
103 }
104
105
106 DataFile::Loader::ActionMap Technique::Loader::shared_actions;
107
108 Technique::Loader::Loader(Technique &t, Collection &c):
109         DataFile::CollectionObjectLoader<Technique>(t, &c)
110 {
111         set_actions(shared_actions);
112 }
113
114 void Technique::Loader::init_actions()
115 {
116         add("inherit", &Loader::inherit);
117         add("method", &Loader::method);
118 }
119
120 void Technique::Loader::set_inline_base_name(const string &n)
121 {
122         inline_base_name = n;
123 }
124
125 void Technique::Loader::inherit(const string &n)
126 {
127         obj.methods = get_collection().get<Technique>(n).get_methods();
128         InheritLoader ldr(obj, get_collection());
129         load_sub_with(ldr);
130 }
131
132 void Technique::Loader::method(const string &n)
133 {
134         RenderMethod p;
135         RenderMethod::Loader ldr(p, get_collection());
136         ldr.set_inline_base_name(format("%s/%s.method", (inline_base_name.empty() ? FS::basename(get_source()) : inline_base_name), n));
137         load_sub_with(ldr);
138
139         if(!p.get_shader_program())
140                 throw logic_error("no shader program in method");
141
142         insert_unique(obj.methods, n, p);
143 }
144
145
146 Technique::InheritLoader::InheritLoader(Technique &t, Collection &c):
147         DataFile::CollectionObjectLoader<Technique>(t, &c)
148 {
149         add("material", &InheritLoader::material);
150         add("texture", &InheritLoader::texture);
151         add("uniforms", &InheritLoader::uniforms);
152 }
153
154 void Technique::InheritLoader::material(const string &slot, const string &name)
155 {
156         const Material &mat = get_collection().get<Material>(name);
157         if(obj.replace_material(slot, mat))
158                 return;
159
160         // For backwards compatibility
161         RenderMethod &method = get_item(obj.methods, slot);
162         if(const Material *base_mat = method.get_material())
163         {
164                 for(auto &kvp: obj.methods)
165                         if(kvp.second.get_material()==base_mat)
166                                 kvp.second.set_material(&mat);
167         }
168         else
169                 method.set_material(&mat);
170 }
171
172 void Technique::InheritLoader::texture(const string &slot, const string &name)
173 {
174         if(!obj.replace_texture(slot, get_collection().get<Texture>(name)))
175                 throw key_error(slot);
176 }
177
178 void Technique::InheritLoader::uniforms()
179 {
180         ProgramData shdata;
181         load_sub(shdata);
182         obj.replace_uniforms(shdata);
183 }
184
185 } // namespace GL
186 } // namespace Msp