]> git.tdb.fi Git - libs/gl.git/blob - source/materials/technique.cpp
Add missing includes
[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                         {
83                                 new_shdata = new ProgramData;
84                                 new_shdata->copy_uniforms(*kvp.second.get_shader_data());
85                         }
86
87                         new_shdata->copy_uniform(shdata, tag);
88                         replaced = true;
89                 }
90
91                 if(new_shdata)
92                         kvp.second.set_shader_program(kvp.second.get_shader_program(), new_shdata.get());
93         }
94
95         return replaced;
96 }
97
98 void Technique::set_debug_name(const string &name)
99 {
100 #ifdef DEBUG
101         for(auto &kvp: methods)
102                 kvp.second.set_debug_name(format("%s [method:%s]", name, kvp.first.str()));
103 #else
104         (void)name;
105 #endif
106 }
107
108
109 DataFile::Loader::ActionMap Technique::Loader::shared_actions;
110
111 Technique::Loader::Loader(Technique &t, Collection &c):
112         DataFile::CollectionObjectLoader<Technique>(t, &c)
113 {
114         set_actions(shared_actions);
115 }
116
117 void Technique::Loader::init_actions()
118 {
119         add("inherit", &Loader::inherit);
120         add("method", &Loader::method);
121 }
122
123 void Technique::Loader::set_inline_base_name(const string &n)
124 {
125         inline_base_name = n;
126 }
127
128 void Technique::Loader::inherit(const string &n)
129 {
130         obj.methods = get_collection().get<Technique>(n).get_methods();
131         InheritLoader ldr(obj, get_collection());
132         load_sub_with(ldr);
133 }
134
135 void Technique::Loader::method(const string &n)
136 {
137         RenderMethod p;
138         RenderMethod::Loader ldr(p, get_collection());
139         ldr.set_inline_base_name(format("%s/%s.method", (inline_base_name.empty() ? FS::basename(get_source()) : inline_base_name), n));
140         load_sub_with(ldr);
141
142         if(!p.get_shader_program())
143                 throw logic_error("no shader program in method");
144
145         insert_unique(obj.methods, n, p);
146 }
147
148
149 Technique::InheritLoader::InheritLoader(Technique &t, Collection &c):
150         DataFile::CollectionObjectLoader<Technique>(t, &c)
151 {
152         add("material", &InheritLoader::material);
153         add("texture", &InheritLoader::texture);
154         add("uniforms", &InheritLoader::uniforms);
155 }
156
157 void Technique::InheritLoader::material(const string &slot, const string &name)
158 {
159         const Material &mat = get_collection().get<Material>(name);
160         if(obj.replace_material(slot, mat))
161                 return;
162
163         // For backwards compatibility
164         RenderMethod &method = get_item(obj.methods, slot);
165         if(const Material *base_mat = method.get_material())
166         {
167                 for(auto &kvp: obj.methods)
168                         if(kvp.second.get_material()==base_mat)
169                                 kvp.second.set_material(&mat);
170         }
171         else
172                 method.set_material(&mat);
173 }
174
175 void Technique::InheritLoader::texture(const string &slot, const string &name)
176 {
177         if(!obj.replace_texture(slot, get_collection().get<Texture>(name)))
178                 throw key_error(slot);
179 }
180
181 void Technique::InheritLoader::uniforms()
182 {
183         ProgramData shdata;
184         load_sub(shdata);
185         obj.replace_uniforms(shdata);
186 }
187
188 } // namespace GL
189 } // namespace Msp