1 #include <msp/core/maputils.h>
2 #include <msp/debug/demangle.h>
3 #include <msp/gl/extensions/arb_direct_state_access.h>
4 #include <msp/io/print.h>
10 #include "programdata.h"
12 #include "uniformblock.h"
20 ProgramData::ProgramData(const Program *p):
27 // Blocks are intentionally left uncopied
28 ProgramData::ProgramData(const ProgramData &other):
29 tied_program(other.tied_program),
30 uniforms(other.uniforms),
35 for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
36 i->value = i->value->clone();
39 ProgramData::ProgramData(const ProgramData &other, const Program *p):
47 for(vector<NamedUniform>::const_iterator i=other.uniforms.begin(); i!=other.uniforms.end(); ++i)
48 tied_program->get_uniform_info(i->name);
51 uniforms = other.uniforms;
52 for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
53 i->value = i->value->clone();
56 ProgramData &ProgramData::operator=(const ProgramData &other)
58 tied_program = other.tied_program;
60 uniforms = other.uniforms;
61 for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
62 i->value = i->value->clone();
64 for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
65 delete i->second.block;
75 ProgramData::~ProgramData()
77 for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
79 for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
81 if(i->second.indices.type_flag==0xFE)
82 delete i->second.indices.dynamic.values;
83 delete i->second.block;
88 void ProgramData::uniform(const string &name, Uniform *uni)
93 tied_program->get_uniform_info(name);
94 else if(name[name.size()-1]==']')
95 throw invalid_argument("ProgramData::uniform");
97 catch(const exception &e)
101 IO::print(IO::cerr, "Error while setting uniform %s: %s: %s\n", name, Debug::demangle(typeid(e).name()), e.what());
108 int i = find_uniform_index(name);
111 uniforms[i].replace_value(uni);
116 if(uniforms.size()>=MASK_BITS)
119 throw too_many_uniforms(name);
122 vector<NamedUniform>::iterator j = lower_bound(uniforms.begin(), uniforms.end(), name, uniform_name_compare);
127 uniforms.insert(j, nu);
132 void ProgramData::uniform(const string &name, const Uniform &u)
134 uniform(name, u.clone());
137 void ProgramData::uniform(const string &name, int v)
139 uniform(name, new Uniform1i(v));
142 void ProgramData::uniform(const string &name, float v)
144 uniform(name, new Uniform1f(v));
147 void ProgramData::uniform(const string &name, int v0, int v1)
149 int va[2] = { v0, v1 };
153 void ProgramData::uniform(const string &name, float v0, float v1)
155 float va[2] = { v0, v1 };
159 void ProgramData::uniform2(const string &name, const int *v)
161 uniform(name, new Uniform2i(v));
164 void ProgramData::uniform2(const string &name, const float *v)
166 uniform(name, new Uniform2f(v));
169 void ProgramData::uniform(const string &name, int v0, int v1, int v2)
171 int va[3] = { v0, v1, v2 };
175 void ProgramData::uniform(const string &name, float v0, float v1, float v2)
177 float va[3] = { v0, v1, v2 };
181 void ProgramData::uniform(const string &name, const Vector3 &v)
183 uniform(name, v.x, v.y, v.z);
186 void ProgramData::uniform3(const string &name, const int *v)
188 uniform(name, new Uniform3i(v));
191 void ProgramData::uniform3(const string &name, const float *v)
193 uniform(name, new Uniform3f(v));
196 void ProgramData::uniform(const string &name, int v0, int v1, int v2, int v3)
198 int va[4] = { v0, v1, v2, v3 };
202 void ProgramData::uniform(const string &name, float v0, float v1, float v2, float v3)
204 float va[4] = { v0, v1, v2, v3 };
208 void ProgramData::uniform(const string &name, const Vector4 &v)
210 uniform(name, v.x, v.y, v.z, v.w);
213 void ProgramData::uniform(const string &name, const Color &c)
215 uniform(name, c.r, c.g, c.b, c.a);
218 void ProgramData::uniform4(const string &name, const int *v)
220 uniform(name, new Uniform4i(v));
223 void ProgramData::uniform4(const string &name, const float *v)
225 uniform(name, new Uniform4f(v));
228 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 2, 2> &m)
230 uniform_matrix2(name, &m(0, 0));
233 void ProgramData::uniform_matrix2(const string &name, const float *v)
235 uniform(name, new UniformMatrix2x2f(v));
238 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 2, 3> &m)
240 uniform_matrix3x2(name, &m(0, 0));
243 void ProgramData::uniform_matrix3x2(const string &name, const float *v)
245 uniform(name, new UniformMatrix3x2f(v));
248 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 2, 4> &m)
250 uniform_matrix4x2(name, &m(0, 0));
253 void ProgramData::uniform_matrix4x2(const string &name, const float *v)
255 uniform(name, new UniformMatrix4x2f(v));
258 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 3, 2> &m)
260 uniform_matrix2x3(name, &m(0, 0));
263 void ProgramData::uniform_matrix2x3(const string &name, const float *v)
265 uniform(name, new UniformMatrix2x3f(v));
268 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 3, 3> &m)
270 uniform_matrix3(name, &m(0, 0));
273 void ProgramData::uniform_matrix3(const string &name, const float *v)
275 uniform(name, new UniformMatrix3x3f(v));
278 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 3, 4> &m)
280 uniform_matrix4x3(name, &m(0, 0));
283 void ProgramData::uniform_matrix4x3(const string &name, const float *v)
285 uniform(name, new UniformMatrix4x3f(v));
288 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 4, 2> &m)
290 uniform_matrix2x4(name, &m(0, 0));
293 void ProgramData::uniform_matrix2x4(const string &name, const float *v)
295 uniform(name, new UniformMatrix2x4f(v));
298 void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 4, 3> &m)
300 uniform_matrix3x4(name, &m(0, 0));
303 void ProgramData::uniform_matrix3x4(const string &name, const float *v)
305 uniform(name, new UniformMatrix3x4f(v));
308 void ProgramData::uniform(const string &name, const Matrix &m)
310 uniform_matrix4(name, m.data());
313 void ProgramData::uniform_matrix4(const string &name, const float *v)
315 uniform(name, new UniformMatrix4x4f(v));
318 void ProgramData::uniform1_array(const string &name, unsigned n, const int *v)
320 uniform(name, new UniformArray<Uniform1i>(n, v));
323 void ProgramData::uniform1_array(const string &name, unsigned n, const float *v)
325 uniform(name, new UniformArray<Uniform1f>(n, v));
328 void ProgramData::uniform2_array(const string &name, unsigned n, const int *v)
330 uniform(name, new UniformArray<Uniform2i>(n, v));
333 void ProgramData::uniform2_array(const string &name, unsigned n, const float *v)
335 uniform(name, new UniformArray<Uniform2f>(n, v));
338 void ProgramData::uniform3_array(const string &name, unsigned n, const int *v)
340 uniform(name, new UniformArray<Uniform3i>(n, v));
343 void ProgramData::uniform3_array(const string &name, unsigned n, const float *v)
345 uniform(name, new UniformArray<Uniform3f>(n, v));
348 void ProgramData::uniform4_array(const string &name, unsigned n, const int *v)
350 uniform(name, new UniformArray<Uniform4i>(n, v));
353 void ProgramData::uniform4_array(const string &name, unsigned n, const float *v)
355 uniform(name, new UniformArray<Uniform4f>(n, v));
358 void ProgramData::uniform_matrix2_array(const string &name, unsigned n, const float *v)
360 uniform(name, new UniformArray<UniformMatrix2x2f>(n, v));
363 void ProgramData::uniform_matrix3x2_array(const string &name, unsigned n, const float *v)
365 uniform(name, new UniformArray<UniformMatrix3x2f>(n, v));
368 void ProgramData::uniform_matrix4x2_array(const string &name, unsigned n, const float *v)
370 uniform(name, new UniformArray<UniformMatrix4x2f>(n, v));
373 void ProgramData::uniform_matrix2x3_array(const string &name, unsigned n, const float *v)
375 uniform(name, new UniformArray<UniformMatrix2x3f>(n, v));
378 void ProgramData::uniform_matrix3_array(const string &name, unsigned n, const float *v)
380 uniform(name, new UniformArray<UniformMatrix3x3f>(n, v));
383 void ProgramData::uniform_matrix4x3_array(const string &name, unsigned n, const float *v)
385 uniform(name, new UniformArray<UniformMatrix4x3f>(n, v));
388 void ProgramData::uniform_matrix2x4_array(const string &name, unsigned n, const float *v)
390 uniform(name, new UniformArray<UniformMatrix2x4f>(n, v));
393 void ProgramData::uniform_matrix3x4_array(const string &name, unsigned n, const float *v)
395 uniform(name, new UniformArray<UniformMatrix3x4f>(n, v));
398 void ProgramData::uniform_matrix4_array(const string &name, unsigned n, const float *v)
400 uniform(name, new UniformArray<UniformMatrix4x4f>(n, v));
403 void ProgramData::remove_uniform(const string &name)
405 vector<NamedUniform>::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), name, uniform_name_compare);
406 if(i==uniforms.end() || i->name!=name)
415 vector<string> ProgramData::get_uniform_names() const
417 vector<string> names;
418 names.reserve(uniforms.size());
419 for(vector<NamedUniform>::const_iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
420 names.push_back(i->name);
424 const Uniform &ProgramData::get_uniform(const string &name) const
426 int i = find_uniform_index(name);
428 throw key_error(name);
429 return *uniforms[i].value;
432 const Uniform *ProgramData::find_uniform(const string &name) const
434 int i = find_uniform_index(name);
435 return (i>=0 ? uniforms[i].value : 0);
438 bool ProgramData::uniform_name_compare(const NamedUniform &nu, const string &name)
443 int ProgramData::find_uniform_index(const string &name) const
445 vector<NamedUniform>::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), name, uniform_name_compare);
446 return ((i!=uniforms.end() && i->name==name) ? i-uniforms.begin() : -1);
449 void ProgramData::update_block_uniform_indices(SharedBlock &block, const Program::UniformBlockInfo &info) const
451 UInt8 *indices = block.indices.values;
452 if(info.uniforms.size()>16)
454 if(block.indices.type_flag==0xFD)
456 block.indices.dynamic.values = new UInt8[info.uniforms.size()];
457 block.indices.type_flag = 0xFE;
459 indices = block.indices.dynamic.values;
463 for(unsigned i=0; i<info.uniforms.size(); ++i)
465 int j = find_uniform_index(info.uniforms[i]->name);
469 if(static_cast<unsigned>(j)<MASK_BITS)
476 block.dirty = block.used;
479 void ProgramData::update_block(SharedBlock &block, const Program::UniformBlockInfo &info) const
481 const UInt8 *indices = block.get_uniform_indices();
482 for(unsigned i=0; i<info.uniforms.size(); ++i)
484 block.block->attach(*info.uniforms[i], *uniforms[indices[i]].value);
487 ProgramData::SharedBlock *ProgramData::get_shared_block(const Program::UniformBlockInfo &info) const
489 BlockMap::iterator i = blocks.find(info.layout_hash);
492 bool any_found = false;
493 bool all_found = true;
494 for(vector<const Program::UniformInfo *>::const_iterator j=info.uniforms.begin(); j!=info.uniforms.end(); ++j)
496 if(find_uniform_index((*j)->name)>=0)
504 else if(!all_found && info.bind_point>=0)
507 IO::print(IO::cerr, "Warning: not all uniforms for block %s are present\n", info.name);
509 throw incomplete_uniform_block(info.name);
514 if(info.bind_point>=0)
517 buffer = new Buffer(UNIFORM_BUFFER);
519 block = new UniformBlock(info.data_size);
520 block->use_buffer(buffer, last_block);
524 block = new UniformBlock;
526 i = blocks.insert(BlockMap::value_type(info.layout_hash, SharedBlock(block))).first;
527 update_block_uniform_indices(i->second, info);
533 void ProgramData::apply() const
535 const Program *prog = Program::current();
537 throw invalid_operation("ProgramData::apply");
539 Program::LayoutHash layout = prog->get_uniform_layout_hash();
540 ProgramUniforms &pu = programs[layout];
542 Mask force_dirty = (dirty==ALL_ONES ? ALL_ONES : 0U);
543 Mask affected = (dirty&pu.used) | force_dirty;
544 if(affected|pu.dirty)
546 /* If the global dirty flag affects this program, add it to per-program
547 dirty flags and clear the global flag. A previously unseen program will
548 always cause this to happen. */
551 for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
552 i->second.dirty |= (dirty&i->second.used) | force_dirty;
553 for(ProgramMap::iterator i=programs.begin(); i!=programs.end(); ++i)
554 i->second.dirty |= (dirty&i->second.used) | force_dirty;
558 const Program::UniformBlockMap &prog_blocks = prog->get_uniform_blocks();
560 UniformBlock *old_last_block = last_block;
561 if(pu.dirty==ALL_ONES)
563 /* The set of uniforms has changed since this program was last used.
564 Regenerate the list of uniform blocks. */
566 pu.blocks.reserve(prog_blocks.size());
569 for(Program::UniformBlockMap::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i)
571 SharedBlock *shared = get_shared_block(i->second);
574 if(shared->dirty==ALL_ONES)
575 update_block_uniform_indices(*shared, i->second);
576 pu.used |= shared->used;
579 pu.blocks.push_back(ProgramBlock(i->second.bind_point, shared));
583 // Update the contents of all dirty blocks.
584 bool buffered_blocks_updated = false;
585 std::vector<ProgramBlock>::iterator j = pu.blocks.begin();
586 for(Program::UniformBlockMap::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i, ++j)
588 if(!j->shared || !j->shared->dirty)
591 update_block(*j->shared, i->second);
592 j->shared->dirty = 0;
593 buffered_blocks_updated |= (j->bind_point>=0);
598 /* If any blocks stored in the buffer were updated, bind the buffer here
599 to avoid state thrashing. */
600 if(buffered_blocks_updated && !ARB_direct_state_access)
603 if(last_block!=old_last_block)
605 unsigned required_size = last_block->get_required_buffer_size();
606 if(last_block->get_required_buffer_size()>buffer->get_size())
608 if(buffer->get_size()>0)
611 buffer = new Buffer(UNIFORM_BUFFER);
612 last_block->change_buffer(buffer);
615 buffer->storage(required_size);
620 for(vector<ProgramBlock>::iterator i=pu.blocks.begin(); i!=pu.blocks.end(); ++i)
622 i->block->apply(i->bind_point);
626 ProgramData::NamedUniform::NamedUniform():
630 void ProgramData::NamedUniform::replace_value(Uniform *v)
632 /* UniformBlock does not copy the uniforms, so existing default blocks
633 will be left with stale pointers. This is not a problem as long as no
634 one stores pointers to the blocks and expects them to stay valid. */
640 ProgramData::SharedBlock::SharedBlock(UniformBlock *b):
645 indices.type_flag = 0xFD;
648 const UInt8 *ProgramData::SharedBlock::get_uniform_indices() const
650 return (indices.type_flag==0xFE ? indices.dynamic.values : indices.values);
654 ProgramData::ProgramBlock::ProgramBlock():
660 ProgramData::ProgramBlock::ProgramBlock(int p, SharedBlock *b):
662 block((b && b->used) ? b->block : 0),
667 ProgramData::ProgramUniforms::ProgramUniforms():
673 ProgramData::Loader::Loader(ProgramData &pd):
674 DataFile::ObjectLoader<ProgramData>(pd)
676 add("uniform", &Loader::uniform1i);
677 add("uniform1i", &Loader::uniform1i);
678 add("uniform", &Loader::uniform1f);
679 add("uniform1f", &Loader::uniform1f);
680 add("uniform", &Loader::uniform2i);
681 add("uniform2i", &Loader::uniform2i);
682 add("uniform", &Loader::uniform2f);
683 add("uniform2f", &Loader::uniform2f);
684 add("uniform", &Loader::uniform3i);
685 add("uniform3i", &Loader::uniform3i);
686 add("uniform", &Loader::uniform3f);
687 add("uniform3f", &Loader::uniform3f);
688 add("uniform", &Loader::uniform4i);
689 add("uniform4i", &Loader::uniform4i);
690 add("uniform", &Loader::uniform4f);
691 add("uniform4f", &Loader::uniform4f);
692 add("uniform1i_array", &Loader::uniform1i_array);
693 add("uniform1f_array", &Loader::uniform1f_array);
694 add("uniform2f_array", &Loader::uniform2f_array);
695 add("uniform3f_array", &Loader::uniform3f_array);
696 add("uniform4f_array", &Loader::uniform4f_array);
697 add("uniform_array", &Loader::uniform_array);
700 void ProgramData::Loader::uniform1i(const string &n, int v)
705 void ProgramData::Loader::uniform1f(const string &n, float v)
710 void ProgramData::Loader::uniform2i(const string &n, int v0, int v1)
712 obj.uniform(n, v0, v1);
715 void ProgramData::Loader::uniform2f(const string &n, float v0, float v1)
717 obj.uniform(n, v0, v1);
720 void ProgramData::Loader::uniform3i(const string &n, int v0, int v1, int v2)
722 obj.uniform(n, v0, v1, v2);
725 void ProgramData::Loader::uniform3f(const string &n, float v0, float v1, float v2)
727 obj.uniform(n, v0, v1, v2);
730 void ProgramData::Loader::uniform4i(const string &n, int v0, int v1, int v2, int v3)
732 obj.uniform(n, v0, v1, v2, v3);
735 void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v2, float v3)
737 obj.uniform(n, v0, v1, v2, v3);
740 void ProgramData::Loader::uniform_array_(const string &n, DataType t, unsigned e)
742 ArrayLoader ldr(t, e);
744 unsigned size = ldr.get_size();
746 throw logic_error("empty uniform array");
748 DataType type = ldr.get_data_type();
749 unsigned elem_size = ldr.get_element_size();
752 const int *data = reinterpret_cast<const int *>(ldr.get_data());
754 obj.uniform1_array(n, size, data);
755 else if(elem_size==2)
756 obj.uniform2_array(n, size, data);
757 else if(elem_size==3)
758 obj.uniform3_array(n, size, data);
759 else if(elem_size==4)
760 obj.uniform4_array(n, size, data);
762 throw logic_error("unsupported combination of array type and element size");
766 const float *data = reinterpret_cast<const float *>(ldr.get_data());
768 obj.uniform1_array(n, size, data);
769 else if(elem_size==2)
770 obj.uniform2_array(n, size, data);
771 else if(elem_size==3)
772 obj.uniform3_array(n, size, data);
773 else if(elem_size==4)
774 obj.uniform4_array(n, size, data);
776 throw logic_error("unsupported combination of array type and element size");
779 throw logic_error("unsupported array type");
782 void ProgramData::Loader::uniform1i_array(const string &n)
784 uniform_array_(n, INT, 1);
787 void ProgramData::Loader::uniform1f_array(const string &n)
789 uniform_array_(n, FLOAT, 1);
792 void ProgramData::Loader::uniform2i_array(const string &n)
794 uniform_array_(n, INT, 2);
797 void ProgramData::Loader::uniform2f_array(const string &n)
799 uniform_array_(n, FLOAT, 2);
802 void ProgramData::Loader::uniform3i_array(const string &n)
804 uniform_array_(n, INT, 3);
807 void ProgramData::Loader::uniform3f_array(const string &n)
809 uniform_array_(n, FLOAT, 3);
812 void ProgramData::Loader::uniform4i_array(const string &n)
814 uniform_array_(n, INT, 4);
817 void ProgramData::Loader::uniform4f_array(const string &n)
819 uniform_array_(n, FLOAT, 4);
822 void ProgramData::Loader::uniform_array(const string &n)
824 uniform_array_(n, static_cast<DataType>(0), 0);
828 ProgramData::ArrayLoader::ArrayLoader(DataType t, unsigned e):
832 add("uniform", &ArrayLoader::uniform1i);
833 add("uniform1i", &ArrayLoader::uniform1i);
834 add("uniform", &ArrayLoader::uniform1f);
835 add("uniform1f", &ArrayLoader::uniform1f);
836 add("uniform", &ArrayLoader::uniform2f);
837 add("uniform2f", &ArrayLoader::uniform2f);
838 add("uniform", &ArrayLoader::uniform3f);
839 add("uniform3f", &ArrayLoader::uniform3f);
840 add("uniform", &ArrayLoader::uniform4f);
841 add("uniform4f", &ArrayLoader::uniform4f);
844 void ProgramData::ArrayLoader::uniform(DataType t, unsigned e, const void *v)
846 if(element_size && (t!=type || e!=element_size))
847 throw logic_error("heterogeneous array contents");
855 const char *cv = reinterpret_cast<const char *>(v);
856 data.insert(data.end(), cv, cv+element_size*4);
859 void ProgramData::ArrayLoader::uniform1i(int v)
864 void ProgramData::ArrayLoader::uniform1f(float v)
866 uniform(FLOAT, 1, &v);
869 void ProgramData::ArrayLoader::uniform2i(int v0, int v1)
871 int va[2] = { v0, v1 };
875 void ProgramData::ArrayLoader::uniform2f(float v0, float v1)
877 float va[2] = { v0, v1 };
878 uniform(FLOAT, 2, va);
881 void ProgramData::ArrayLoader::uniform3i(int v0, int v1, int v2)
883 int va[3] = { v0, v1, v2 };
887 void ProgramData::ArrayLoader::uniform3f(float v0, float v1, float v2)
889 float va[3] = { v0, v1, v2 };
890 uniform(FLOAT, 3, va);
893 void ProgramData::ArrayLoader::uniform4i(int v0, int v1, int v2, int v3)
895 int va[4] = { v0, v1, v2, v3 };
899 void ProgramData::ArrayLoader::uniform4f(float v0, float v1, float v2, float v3)
901 float va[4] = { v0, v1, v2, v3 };
902 uniform(FLOAT, 4, va);