]> git.tdb.fi Git - libs/gl.git/blob - source/programdata.cpp
Rewrite light binding to match textures
[libs/gl.git] / source / programdata.cpp
1 #include <msp/gl/extensions/arb_shader_objects.h>
2 #include "buffer.h"
3 #include "color.h"
4 #include "error.h"
5 #include "matrix.h"
6 #include "program.h"
7 #include "programdata.h"
8 #include "uniform.h"
9 #include "uniformblock.h"
10 #include "vector.h"
11
12 using namespace std;
13
14 namespace Msp {
15 namespace GL {
16
17 ProgramData::ProgramData():
18         last_block(0),
19         buffer(0),
20         changes(NO_CHANGES)
21 {
22         static Require _req(ARB_shader_objects);
23 }
24
25 // Blocks are intentionally left uncopied
26 ProgramData::ProgramData(const ProgramData &other):
27         uniforms(other.uniforms),
28         last_block(0),
29         buffer(0),
30         changes(NO_CHANGES)
31 {
32         for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
33                 i->second = i->second->clone();
34 }
35
36 ProgramData &ProgramData::operator=(const ProgramData &other)
37 {
38         for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
39                 delete i->second;
40         uniforms.clear();
41
42         for(UniformMap::const_iterator i=other.uniforms.begin(); i!=other.uniforms.end(); ++i)
43                 uniforms.insert(uniforms.end(), UniformMap::value_type(i->first, i->second->clone()));
44
45         for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
46                 delete i->second.block;
47         blocks.clear();
48
49         changes = NO_CHANGES;
50
51         return *this;
52 }
53
54 ProgramData::~ProgramData()
55 {
56         for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
57                 delete i->second;
58         for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
59                 delete i->second.block;
60         delete buffer;
61 }
62
63 void ProgramData::uniform(const string &name, Uniform *uni)
64 {
65         UniformMap::iterator i = uniforms.find(name);
66         if(i!=uniforms.end())
67         {
68                 /* UniformBlock does not copy the uniforms, so existing blocks will be
69                 left with stale pointers.  This is not a problem as long as no one stores
70                 pointers to the blocks and expects them to stay valid. */
71                 delete i->second;
72                 i->second = uni;
73                 changes = VALUES_CHANGED;
74         }
75         else
76         {
77                 uniforms[name] = uni;
78                 changes = KEYS_CHANGED;
79         }
80 }
81
82 void ProgramData::uniform(const string &name, int v)
83 {
84         uniform(name, new Uniform1i(v));
85 }
86
87 void ProgramData::uniform(const string &name, float v)
88 {
89         uniform(name, new Uniform1f(v));
90 }
91
92 void ProgramData::uniform(const string &name, float v0, float v1)
93 {
94         float va[2] = { v0, v1 };
95         uniform2(name, va);
96 }
97
98 void ProgramData::uniform2(const string &name, const float *v)
99 {
100         uniform(name, new Uniform2f(v));
101 }
102
103 void ProgramData::uniform(const string &name, float v0, float v1, float v2)
104 {
105         float va[3] = { v0, v1, v2 };
106         uniform3(name, va);
107 }
108
109 void ProgramData::uniform(const string &name, const Vector3 &v)
110 {
111         uniform(name, v.x, v.y, v.z);
112 }
113
114 void ProgramData::uniform3(const string &name, const float *v)
115 {
116         uniform(name, new Uniform3f(v));
117 }
118
119 void ProgramData::uniform(const string &name, float v0, float v1, float v2, float v3)
120 {
121         float va[4] = { v0, v1, v2, v3 };
122         uniform4(name, va);
123 }
124
125 void ProgramData::uniform(const string &name, const Vector4 &v)
126 {
127         uniform(name, v.x, v.y, v.z, v.w);
128 }
129
130 void ProgramData::uniform(const string &name, const Color &c)
131 {
132         uniform(name, c.r, c.g, c.b, c.a);
133 }
134
135 void ProgramData::uniform4(const string &name, const float *v)
136 {
137         uniform(name, new Uniform4f(v));
138 }
139
140 void ProgramData::uniform_matrix2(const string &name, const float *v)
141 {
142         uniform(name, new UniformMatrix2x2f(v));
143 }
144
145 void ProgramData::uniform_matrix3(const string &name, const float *v)
146 {
147         uniform(name, new UniformMatrix3x3f(v));
148 }
149
150 void ProgramData::uniform(const string &name, const Matrix &m)
151 {
152         uniform_matrix4(name, m.data());
153 }
154
155 void ProgramData::uniform_matrix4(const string &name, const float *v)
156 {
157         uniform(name, new UniformMatrix4x4f(v));
158 }
159
160 void ProgramData::uniform1_array(const string &name, unsigned n, const float *v)
161 {
162         uniform(name, new UniformArray<Uniform1f>(n, v));
163 }
164
165 void ProgramData::uniform2_array(const string &name, unsigned n, const float *v)
166 {
167         uniform(name, new UniformArray<Uniform2f>(n, v));
168 }
169
170 void ProgramData::uniform3_array(const string &name, unsigned n, const float *v)
171 {
172         uniform(name, new UniformArray<Uniform3f>(n, v));
173 }
174
175 void ProgramData::uniform4_array(const string &name, unsigned n, const float *v)
176 {
177         uniform(name, new UniformArray<Uniform4f>(n, v));
178 }
179
180 void ProgramData::uniform_matrix4_array(const string &name, unsigned n, const float *v)
181 {
182         uniform(name, new UniformArray<UniformMatrix4x4f>(n, v));
183 }
184
185 void ProgramData::find_uniforms_for_block(Block &block, const Program::UniformBlockInfo &info) const
186 {
187         block.uniforms.clear();
188         for(vector<const Program::UniformInfo *>::const_iterator i=info.uniforms.begin(); i!=info.uniforms.end(); ++i)
189         {
190                 // XXX individual array elements
191                 UniformMap::const_iterator j = uniforms.find((*i)->name);
192                 if(j!=uniforms.end())
193                         block.uniforms[(*i)->location] = &j->second;
194         }
195 }
196
197 UniformBlock *ProgramData::create_block(const Program::UniformBlockInfo &info) const
198 {
199         UniformBlock *block = new UniformBlock(info.data_size);
200         if(!buffer)
201         {
202                 buffer = new Buffer(UNIFORM_BUFFER);
203                 buffer->set_usage(STREAM_DRAW);
204         }
205         block->use_buffer(buffer, last_block);
206         last_block = block;
207         return block;
208 }
209
210 const UniformBlock *ProgramData::get_block(const Program &prog, const Program::UniformBlockInfo *info) const
211 {
212         if(changes)
213         {
214                 for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
215                         if(i->second.changes<changes)
216                                 i->second.changes = changes;
217                 changes = NO_CHANGES;
218         }
219
220         unsigned layout_hash = (info ? info->layout_hash : prog.get_uniform_layout_hash());
221
222         map<unsigned, Block>::iterator i = blocks.find(layout_hash);
223         if(i==blocks.end())
224         {
225                 i = blocks.insert(BlockMap::value_type(layout_hash, Block())).first;
226                 if(info)
227                 {
228                         find_uniforms_for_block(i->second, *info);
229
230                         if(!i->second.uniforms.empty())
231                         {
232                                 i->second.block = create_block(*info);
233                                 i->second.changes = VALUES_CHANGED;
234                         }
235                 }
236                 else
237                 {
238                         i->second.block = new UniformBlock;
239                         i->second.changes = VALUES_CHANGED;
240                 }
241         }
242         else if(info && i->second.changes==KEYS_CHANGED)
243         {
244                 find_uniforms_for_block(i->second, *info);
245                 if(!i->second.uniforms.empty())
246                 {
247                         if(!i->second.block)
248                                 i->second.block = create_block(*info);
249                         i->second.changes = VALUES_CHANGED;
250                 }
251                 else
252                         i->second.changes = NO_CHANGES;
253         }
254
255         if(!i->second.block)
256                 return 0;
257
258         UniformBlock &block = *i->second.block;
259         if(i->second.changes)
260         {
261                 if(info)
262                 {
263                         vector<const Program::UniformInfo *>::const_iterator j = info->uniforms.begin();
264                         map<unsigned, const Uniform *const *>::const_iterator k = i->second.uniforms.begin();
265                         while(j!=info->uniforms.end() && k!=i->second.uniforms.end())
266                         {
267                                 if(k->first==(*j)->location)
268                                 {
269                                         block.attach(**j, **k->second);
270                                         ++k;
271                                 }
272                                 ++j;
273                         }
274                 }
275                 else
276                 {
277                         for(UniformMap::const_iterator j=uniforms.begin(); j!=uniforms.end(); ++j)
278                         {
279                                 int loc = prog.get_uniform_location(j->first);
280                                 if(loc>=0)
281                                         block.attach(loc, *j->second);
282                         }
283                 }
284                 i->second.changes = NO_CHANGES;
285         }
286
287         return &block;
288 }
289
290 const UniformBlock *ProgramData::get_block(const Program &prog, const string &name) const
291 {
292         if(name.empty())
293                 return get_block(prog, 0);
294         else
295                 return get_block(prog, &prog.get_uniform_block_info(name));
296 }
297
298 void ProgramData::apply() const
299 {
300         const Program *prog = Program::current();
301         if(!prog)
302                 throw invalid_operation("ProgramData::apply");
303
304         const Program::UniformBlockMap &prog_blocks = prog->get_uniform_blocks();
305         if(!prog_blocks.empty())
306         {
307                 typedef pair<const UniformBlock *, unsigned> ApplyBlock;
308                 list<ApplyBlock> apply_blocks;
309                 for(Program::UniformBlockMap::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i)
310                         if(const UniformBlock *block = get_block(*prog, &i->second))
311                                 apply_blocks.push_back(make_pair(block, i->second.bind_point));
312
313                 if(buffer)
314                         buffer->bind();
315
316                 for(list<ApplyBlock>::const_iterator i=apply_blocks.begin(); i!=apply_blocks.end(); ++i)
317                         i->first->apply(i->second);
318         }
319
320         if(const UniformBlock *block = get_block(*prog, 0))
321                 block->apply(-1);
322 }
323
324
325 ProgramData::Block::Block():
326         changes(NO_CHANGES),
327         block(0)
328 { }
329
330
331 ProgramData::Loader::Loader(ProgramData &pd):
332         DataFile::ObjectLoader<ProgramData>(pd)
333 {
334         add("uniform1i", &Loader::uniform1i);
335         add("uniform1f", &Loader::uniform1f);
336         add("uniform2f", &Loader::uniform2f);
337         add("uniform3f", &Loader::uniform3f);
338         add("uniform4f", &Loader::uniform4f);
339 }
340
341 void ProgramData::Loader::uniform1i(const string &n, int v)
342 {
343         obj.uniform(n, v);
344 }
345
346 void ProgramData::Loader::uniform1f(const string &n, float v)
347 {
348         obj.uniform(n, v);
349 }
350
351 void ProgramData::Loader::uniform2f(const string &n, float v0, float v1)
352 {
353         obj.uniform(n, v0, v1);
354 }
355
356 void ProgramData::Loader::uniform3f(const string &n, float v0, float v1, float v2)
357 {
358         obj.uniform(n, v0, v1, v2);
359 }
360
361 void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v2, float v3)
362 {
363         obj.uniform(n, v0, v1, v2, v3);
364 }
365
366 } // namespace GL
367 } // namespace Msp