source/render/programdata.cpp

   1 #include <msp/core/algorithm.h>
   2 #include <msp/debug/demangle.h>
   3 #include <msp/io/print.h>
   4 #include "buffer.h"
   5 #include "color.h"
   6 #include "error.h"
   7 #include "matrix.h"
   8 #include "pipelinestate.h"
   9 #include "program.h"
  10 #include "programdata.h"
  11 #include "uniformblock.h"
  12 #include "vector.h"
  13
  14 using namespace std;
  15
  16 namespace Msp {
  17 namespace GL {
  18
  19 ProgramData::ProgramData(const Program *p):
  20         tied_program(p)
  21 { }
  22
  23 // Blocks are intentionally left uncopied
  24 ProgramData::ProgramData(const ProgramData &other):
  25         tied_program(other.tied_program),
  26         uniforms(other.uniforms),
  27         uniform_data(other.uniform_data),
  28         generation(other.generation)
  29 { }
  30
  31 ProgramData::ProgramData(const ProgramData &other, const Program *p):
  32         tied_program(p)
  33 {
  34         if(tied_program)
  35         {
  36                 for(const TaggedUniform &u: other.uniforms)
  37                         validate_tag(u.tag);
  38         }
  39
  40         uniforms = other.uniforms;
  41         uniform_data = other.uniform_data;
  42 }
  43
  44 ProgramData &ProgramData::operator=(const ProgramData &other)
  45 {
  46         tied_program = other.tied_program;
  47
  48         uniforms = other.uniforms;
  49         uniform_data = other.uniform_data;
  50
  51         for(SharedBlock &b: blocks)
  52                 delete b.block;
  53         blocks.clear();
  54         programs.clear();
  55
  56         last_buffer_block = 0;
  57         buffer = 0;
  58         dirty = 0;
  59
  60         return *this;
  61 }
  62
  63 ProgramData::~ProgramData()
  64 {
  65         for(SharedBlock &b: blocks)
  66         {
  67                 if(b.indices.type_flag==0xFE)
  68                         delete[] b.indices.dynamic.values;
  69                 delete b.block;
  70         }
  71         delete buffer;
  72 }
  73
  74 void ProgramData::uniform(Tag tag, DataType type, unsigned array_size, const void *value)
  75 {
  76         if(!validate_tag(tag))
  77                 return;
  78
  79         auto i = lower_bound_member(uniforms, tag, &TaggedUniform::tag);
  80         if(i==uniforms.end() || i->tag!=tag)
  81         {
  82                 if(uniforms.size()>=MASK_BITS)
  83                         throw too_many_uniforms(tag.str());
  84
  85                 TaggedUniform tu;
  86                 tu.tag = tag;
  87                 tu.type = type;
  88                 tu.array_size = array_size;
  89                 tu.data_offset = uniform_data.size();
  90                 tu.data_size = array_size*get_type_size(type);
  91                 i = uniforms.insert(i, tu);
  92                 uniform_data.resize(tu.data_offset+tu.data_size);
  93
  94                 mark_dirty(ALL_ONES);
  95         }
  96         else if(type!=i->type)
  97                 throw invalid_operation("ProgramData::uniform");
  98         else if(array_size>i->array_size)
  99         {
 100                 unsigned add_bytes = (array_size-i->array_size)*get_type_size(type);
 101                 uniform_data.insert(uniform_data.begin()+i->data_offset+i->data_size, add_bytes, 0);
 102                 for(TaggedUniform &u: uniforms)
 103                         if(u.data_offset>i->data_offset)
 104                                 u.data_offset += add_bytes;
 105                 i->array_size = array_size;
 106                 i->data_size = array_size*get_type_size(type);
 107         }
 108
 109         const char *val_begin = static_cast<const char *>(value);
 110         const char *val_end = val_begin+array_size*get_type_size(type);
 111         char *store_begin = uniform_data.data()+i->data_offset;
 112         copy(val_begin, val_end, store_begin);
 113
 114         mark_dirty(1<<(i-uniforms.begin()));
 115 }
 116
 117 bool ProgramData::validate_tag(Tag tag) const
 118 {
 119 #ifdef DEBUG
 120         try
 121 #endif
 122         {
 123                 if(tied_program)
 124                 {
 125                         const ReflectData::UniformInfo &info = tied_program->get_uniform_info(tag);
 126                         if(is_image(info.type))
 127                                 throw invalid_operation("ProgramData::uniform");
 128                 }
 129                 return true;
 130         }
 131 #ifdef DEBUG
 132         catch(const exception &e)
 133         {
 134                 IO::print(IO::cerr, "Error while setting uniform %s: %s: %s\n", tag, Debug::demangle(typeid(e).name()), e.what());
 135                 return false;
 136         }
 137 #endif
 138 }
 139
 140 void ProgramData::mark_dirty(Mask bits)
 141 {
 142         if(!dirty)
 143                 ++generation;
 144         dirty |= bits;
 145 }
 146
 147 void ProgramData::uniform(Tag tag, int v)
 148 {
 149         uniform(tag, INT, 1, &v);
 150 }
 151
 152 void ProgramData::uniform(Tag tag, float v)
 153 {
 154         uniform(tag, FLOAT, 1, &v);
 155 }
 156
 157 void ProgramData::uniform(Tag tag, int v0, int v1)
 158 {
 159         int va[2] = { v0, v1 };
 160         uniform2(tag, va);
 161 }
 162
 163 void ProgramData::uniform(Tag tag, float v0, float v1)
 164 {
 165         float va[2] = { v0, v1 };
 166         uniform2(tag, va);
 167 }
 168
 169 void ProgramData::uniform2(Tag tag, const int *v)
 170 {
 171         uniform(tag, INT_VEC2, 1, v);
 172 }
 173
 174 void ProgramData::uniform2(Tag tag, const float *v)
 175 {
 176         uniform(tag, FLOAT_VEC2, 1, v);
 177 }
 178
 179 void ProgramData::uniform(Tag tag, int v0, int v1, int v2)
 180 {
 181         int va[3] = { v0, v1, v2 };
 182         uniform3(tag, va);
 183 }
 184
 185 void ProgramData::uniform(Tag tag, float v0, float v1, float v2)
 186 {
 187         float va[3] = { v0, v1, v2 };
 188         uniform3(tag, va);
 189 }
 190
 191 void ProgramData::uniform3(Tag tag, const int *v)
 192 {
 193         uniform(tag, INT_VEC3, 1, v);
 194 }
 195
 196 void ProgramData::uniform3(Tag tag, const float *v)
 197 {
 198         uniform(tag, FLOAT_VEC3, 1, v);
 199 }
 200
 201 void ProgramData::uniform(Tag tag, int v0, int v1, int v2, int v3)
 202 {
 203         int va[4] = { v0, v1, v2, v3 };
 204         uniform4(tag, va);
 205 }
 206
 207 void ProgramData::uniform(Tag tag, float v0, float v1, float v2, float v3)
 208 {
 209         float va[4] = { v0, v1, v2, v3 };
 210         uniform4(tag, va);
 211 }
 212
 213 void ProgramData::uniform(Tag tag, const Color &c)
 214 {
 215         uniform(tag, c.r, c.g, c.b, c.a);
 216 }
 217
 218 void ProgramData::uniform4(Tag tag, const int *v)
 219 {
 220         uniform(tag, INT_VEC4, 1, v);
 221 }
 222
 223 void ProgramData::uniform4(Tag tag, const float *v)
 224 {
 225         uniform(tag, FLOAT_VEC4, 1, v);
 226 }
 227
 228 void ProgramData::uniform_matrix2(Tag tag, const float *v)
 229 {
 230         uniform(tag, FLOAT_MAT2, 1, v);
 231 }
 232
 233 void ProgramData::uniform_matrix3x2(Tag tag, const float *v)
 234 {
 235         uniform(tag, FLOAT_MAT3x2, 1, v);
 236 }
 237
 238 void ProgramData::uniform_matrix4x2(Tag tag, const float *v)
 239 {
 240         uniform(tag, FLOAT_MAT4x2, 1, v);
 241 }
 242
 243 void ProgramData::uniform_matrix2x3(Tag tag, const float *v)
 244 {
 245         uniform(tag, FLOAT_MAT2x3, 1, v);
 246 }
 247
 248 void ProgramData::uniform_matrix3(Tag tag, const float *v)
 249 {
 250         uniform(tag, FLOAT_MAT3, 1, v);
 251 }
 252
 253 void ProgramData::uniform_matrix4x3(Tag tag, const float *v)
 254 {
 255         uniform(tag, FLOAT_MAT4x3, 1, v);
 256 }
 257
 258 void ProgramData::uniform_matrix2x4(Tag tag, const float *v)
 259 {
 260         uniform(tag, FLOAT_MAT2x4, 1, v);
 261 }
 262
 263 void ProgramData::uniform_matrix3x4(Tag tag, const float *v)
 264 {
 265         uniform(tag, FLOAT_MAT3x4, 1, v);
 266 }
 267
 268 void ProgramData::uniform(Tag tag, const Matrix &m)
 269 {
 270         uniform_matrix4(tag, m.data());
 271 }
 272
 273 void ProgramData::uniform_matrix4(Tag tag, const float *v)
 274 {
 275         uniform(tag, FLOAT_MAT4, 1, v);
 276 }
 277
 278 void ProgramData::uniform_array(Tag tag, unsigned n, const int *v)
 279 {
 280         uniform(tag, INT, n, v);
 281 }
 282
 283 void ProgramData::uniform_array(Tag tag, unsigned n, const float *v)
 284 {
 285         uniform(tag, FLOAT, n, v);
 286 }
 287
 288 void ProgramData::uniform1_array(Tag tag, unsigned n, const int *v)
 289 {
 290         uniform(tag, INT, n, v);
 291 }
 292
 293 void ProgramData::uniform1_array(Tag tag, unsigned n, const float *v)
 294 {
 295         uniform(tag, FLOAT, n, v);
 296 }
 297
 298 void ProgramData::uniform2_array(Tag tag, unsigned n, const int *v)
 299 {
 300         uniform(tag, INT_VEC2, n, v);
 301 }
 302
 303 void ProgramData::uniform2_array(Tag tag, unsigned n, const float *v)
 304 {
 305         uniform(tag, FLOAT_VEC2, n, v);
 306 }
 307
 308 void ProgramData::uniform3_array(Tag tag, unsigned n, const int *v)
 309 {
 310         uniform(tag, INT_VEC3, n, v);
 311 }
 312
 313 void ProgramData::uniform3_array(Tag tag, unsigned n, const float *v)
 314 {
 315         uniform(tag, FLOAT_VEC3, n, v);
 316 }
 317
 318 void ProgramData::uniform4_array(Tag tag, unsigned n, const int *v)
 319 {
 320         uniform(tag, INT_VEC4, n, v);
 321 }
 322
 323 void ProgramData::uniform4_array(Tag tag, unsigned n, const float *v)
 324 {
 325         uniform(tag, FLOAT_VEC4, n, v);
 326 }
 327
 328 void ProgramData::uniform_matrix2_array(Tag tag, unsigned n, const float *v)
 329 {
 330         uniform(tag, FLOAT_MAT2, n, v);
 331 }
 332
 333 void ProgramData::uniform_matrix3x2_array(Tag tag, unsigned n, const float *v)
 334 {
 335         uniform(tag, FLOAT_MAT3x2, n, v);
 336 }
 337
 338 void ProgramData::uniform_matrix4x2_array(Tag tag, unsigned n, const float *v)
 339 {
 340         uniform(tag, FLOAT_MAT4x2, n, v);
 341 }
 342
 343 void ProgramData::uniform_matrix2x3_array(Tag tag, unsigned n, const float *v)
 344 {
 345         uniform(tag, FLOAT_MAT2x3, n, v);
 346 }
 347
 348 void ProgramData::uniform_matrix3_array(Tag tag, unsigned n, const float *v)
 349 {
 350         uniform(tag, FLOAT_MAT3, n, v);
 351 }
 352
 353 void ProgramData::uniform_matrix4x3_array(Tag tag, unsigned n, const float *v)
 354 {
 355         uniform(tag, FLOAT_MAT4x3, n, v);
 356 }
 357
 358 void ProgramData::uniform_matrix2x4_array(Tag tag, unsigned n, const float *v)
 359 {
 360         uniform(tag, FLOAT_MAT2x4, n, v);
 361 }
 362
 363 void ProgramData::uniform_matrix3x4_array(Tag tag, unsigned n, const float *v)
 364 {
 365         uniform(tag, FLOAT_MAT3x4, n, v);
 366 }
 367
 368 void ProgramData::uniform_matrix4_array(Tag tag, unsigned n, const float *v)
 369 {
 370         uniform(tag, FLOAT_MAT4, n, v);
 371 }
 372
 373 void ProgramData::remove_uniform(Tag tag)
 374 {
 375         auto i = lower_bound_member(uniforms, tag, &TaggedUniform::tag);
 376         if(i==uniforms.end() || i->tag!=tag)
 377                 return;
 378
 379         uniform_data.erase(uniform_data.begin()+i->data_offset, uniform_data.begin()+i->data_offset+i->data_size);
 380         for(TaggedUniform &u: uniforms)
 381                 if(u.data_offset>i->data_offset)
 382                         u.data_offset -= i->data_size;
 383         uniforms.erase(i);
 384
 385         mark_dirty(ALL_ONES);
 386 }
 387
 388 vector<Tag> ProgramData::get_uniform_tags() const
 389 {
 390         vector<Tag> tags;
 391         tags.reserve(uniforms.size());
 392         for(const TaggedUniform &u: uniforms)
 393                 tags.push_back(u.tag);
 394         return tags;
 395 }
 396
 397 void ProgramData::copy_uniform(const ProgramData &source, Tag tag)
 398 {
 399         int i = source.find_uniform_index(tag);
 400         if(i<0)
 401                 throw key_error(tag);
 402         const TaggedUniform &tu = source.uniforms[i];
 403         uniform(tag, tu.type, tu.array_size, source.uniform_data.data()+tu.data_offset);
 404 }
 405
 406 int ProgramData::find_uniform_index(Tag tag) const
 407 {
 408         auto i = lower_bound_member(uniforms, tag, &TaggedUniform::tag);
 409         return ((i!=uniforms.end() && i->tag==tag) ? i-uniforms.begin() : -1);
 410 }
 411
 412 vector<ProgramData::ProgramBlock>::iterator ProgramData::get_program(const Program &prog) const
 413 {
 414         ReflectData::LayoutHash prog_hash = prog.get_uniform_layout_hash();
 415         auto i = lower_bound_member(programs, prog_hash, &ProgramBlock::prog_hash);
 416         if(i!=programs.end() && i->prog_hash==prog_hash)
 417                 return i;
 418
 419         const vector<ReflectData::UniformBlockInfo> &block_infos = prog.get_uniform_blocks();
 420         unsigned index = i-programs.begin();
 421         programs.insert(i, 1+block_infos.size(), ProgramBlock(prog_hash));
 422
 423         /* Block indices may change if new shared blocks need to be inserted.  Store
 424         the hashes so they can be matched up later. */
 425         vector<ReflectData::LayoutHash> block_hashes;
 426         block_hashes.reserve(programs.size());
 427         for(const ProgramBlock &b: programs)
 428                 block_hashes.push_back(b.block_index>=0 ? blocks[b.block_index].block_hash : 0);
 429
 430         for(unsigned j=0; j<block_infos.size(); ++j)
 431         {
 432                 const ReflectData::UniformBlockInfo &info = block_infos[j];
 433                 block_hashes[index+1+j] = info.layout_hash;
 434                 programs[index+1+j].bind_point = info.bind_point;
 435
 436                 auto k = lower_bound_member(blocks, info.layout_hash, &SharedBlock::block_hash);
 437                 if(k==blocks.end() || k->block_hash!=info.layout_hash)
 438                 {
 439                         k = blocks.insert(k, SharedBlock(info.layout_hash));
 440                         update_block_uniform_indices(*k, info);
 441                 }
 442         }
 443
 444         /* Reassign shared block indices from the stored hashes. */
 445         for(unsigned j=0; j<programs.size(); ++j)
 446         {
 447                 unsigned hash = block_hashes[j];
 448                 if(hash)
 449                 {
 450                         auto k = lower_bound_member(blocks, hash, &SharedBlock::block_hash);
 451                         programs[j].block_index = k-blocks.begin();
 452                 }
 453                 else
 454                         programs[j].block_index = -1;
 455         }
 456
 457         return programs.begin()+index;
 458 }
 459
 460 void ProgramData::update_block_uniform_indices(SharedBlock &block, const ReflectData::UniformBlockInfo &info) const
 461 {
 462         uint8_t *indices = block.indices.values;
 463         if(info.uniforms.size()>16)
 464         {
 465                 if(block.indices.type_flag==0xFD)
 466                 {
 467                         block.indices.dynamic.values = new uint8_t[info.uniforms.size()];
 468                         block.indices.type_flag = 0xFE;
 469                 }
 470                 indices = block.indices.dynamic.values;
 471         }
 472
 473         bool any_missing = false;
 474
 475         block.used = 0;
 476         for(unsigned i=0; i<info.uniforms.size(); ++i)
 477         {
 478                 int j = find_uniform_index(info.uniforms[i]->tag);
 479                 if(j>=0)
 480                 {
 481                         indices[i] = j;
 482                         if(static_cast<unsigned>(j)<MASK_BITS)
 483                                 block.used |= 1<<j;
 484                 }
 485                 else
 486                 {
 487                         indices[i] = 0xFF;
 488                         any_missing = true;
 489                 }
 490         }
 491
 492         if(block.used && any_missing && info.bind_point>=0)
 493         {
 494 #ifdef DEBUG
 495                 IO::print(IO::cerr, "Warning: not all uniforms for block %s are present\n", info.name);
 496 #else
 497                 throw incomplete_uniform_block(info.name);
 498 #endif
 499         }
 500
 501         block.dirty = block.used;
 502
 503         if(block.used && !block.block)
 504         {
 505                 block.block = new UniformBlock(info);
 506                 if(info.bind_point>=0)
 507                 {
 508                         if(!buffer)
 509                         {
 510                                 buffer = new Buffer();
 511
 512 #ifdef DEBUG
 513                                 if(!debug_name.empty())
 514                                         buffer->set_debug_name(debug_name);
 515 #endif
 516                         }
 517
 518                         block.block->use_buffer(buffer, last_buffer_block);
 519                         last_buffer_block = block.block;
 520                 }
 521         }
 522 }
 523
 524 void ProgramData::update_block(SharedBlock &block, const ReflectData::UniformBlockInfo &info) const
 525 {
 526         const uint8_t *indices = block.get_uniform_indices();
 527         for(unsigned i=0; i<info.uniforms.size(); ++i)
 528         {
 529                 if(is_image(info.uniforms[i]->type))
 530                         ;  // Temporarily ignore deprecated use of sampler uniforms in ProgramData
 531                 else if(indices[i]!=0xFF)
 532                 {
 533                         const TaggedUniform &tu = uniforms[indices[i]];
 534                         block.block->store(*info.uniforms[i], tu.array_size, uniform_data.data()+tu.data_offset);
 535                 }
 536         }
 537 }
 538
 539 vector<ProgramData::ProgramBlock>::const_iterator ProgramData::prepare_program(const Program &prog) const
 540 {
 541         UniformBlock *old_last_block = last_buffer_block;
 542         auto prog_begin = get_program(prog);
 543
 544         Mask force_dirty = (dirty==ALL_ONES ? ALL_ONES : 0U);
 545         Mask affected = (dirty&prog_begin->masks.used) | force_dirty;
 546         if(affected|prog_begin->masks.dirty)
 547         {
 548                 /* If the global dirty flag affects this program, add it to per-block and
 549                 per-program dirty flags and clear the global flag.  A previously unseen
 550                 program will cause this to happen if there's any dirty uniforms. */
 551                 if(affected)
 552                 {
 553                         for(SharedBlock &b: blocks)
 554                                 b.dirty |= (dirty&b.used) | force_dirty;
 555                         for(ProgramBlock &b: programs)
 556                                 if(b.block_index<0)
 557                                         b.masks.dirty |= (dirty&b.masks.used) | force_dirty;
 558                         dirty = 0;
 559                 }
 560
 561                 const vector<ReflectData::UniformBlockInfo> &block_infos = prog.get_uniform_blocks();
 562
 563                 if(prog_begin->masks.dirty==ALL_ONES)
 564                 {
 565                         /* The set of uniforms has changed since this program was last used.
 566                         Refresh uniform indices within the program's blocks. */
 567                         prog_begin->masks.used = 0;
 568                         auto j = prog_begin+1;
 569                         for(const ReflectData::UniformBlockInfo &b: block_infos)
 570                         {
 571                                 SharedBlock &shared = blocks[j->block_index];
 572                                 if(shared.dirty==ALL_ONES)
 573                                         update_block_uniform_indices(shared, b);
 574                                 prog_begin->masks.used |= shared.used;
 575                                 j->block = (shared.used ? shared.block : 0);
 576                                 ++j;
 577                         }
 578                 }
 579
 580                 // Update the contents of all dirty blocks.
 581                 bool buffered_blocks_updated = false;
 582                 auto j = prog_begin+1;
 583                 for(const ReflectData::UniformBlockInfo &b: block_infos)
 584                 {
 585                         SharedBlock &shared = blocks[j->block_index];
 586                         if(shared.dirty)
 587                         {
 588                                 update_block(shared, b);
 589                                 shared.dirty = 0;
 590                                 buffered_blocks_updated |= (j->bind_point>=0);
 591                         }
 592                         ++j;
 593                 }
 594
 595                 prog_begin->masks.dirty = 0;
 596
 597                 if(last_buffer_block!=old_last_block)
 598                 {
 599                         unsigned required_size = last_buffer_block->get_required_buffer_size();
 600                         if(last_buffer_block->get_required_buffer_size()>buffer->get_size())
 601                         {
 602                                 if(buffer->get_size()>0)
 603                                 {
 604                                         delete buffer;
 605                                         buffer = new Buffer();
 606                                         last_buffer_block->change_buffer(buffer);
 607
 608 #ifdef DEBUG
 609                                         if(!debug_name.empty())
 610                                                 buffer->set_debug_name(debug_name);
 611 #endif
 612                                 }
 613
 614                                 buffer->storage(required_size);
 615                         }
 616                 }
 617         }
 618
 619         return prog_begin;
 620 }
 621
 622 void ProgramData::apply(const Program &prog, PipelineState &state) const
 623 {
 624         auto prog_begin = prepare_program(prog);
 625         ReflectData::LayoutHash prog_hash = prog_begin->prog_hash;
 626         for(auto i=prog_begin+1; (i!=programs.end() && i->prog_hash==prog_hash); ++i)
 627                 if(i->block)
 628                 {
 629                         state.set_uniform_block(i->bind_point, i->block);
 630                         if(i->bind_point>=0)
 631                                 i->block->refresh();
 632                 }
 633 }
 634
 635 void ProgramData::set_debug_name(const string &name)
 636 {
 637 #ifdef DEBUG
 638         debug_name = name;
 639         if(buffer)
 640                 buffer->set_debug_name(name);
 641 #else
 642         (void)name;
 643 #endif
 644 }
 645
 646
 647 ProgramData::SharedBlock::SharedBlock(ReflectData::LayoutHash h):
 648         block_hash(h),
 649         used(0),
 650         dirty(0),
 651         block(0)
 652 {
 653         indices.type_flag = 0xFD;
 654 }
 655
 656 const uint8_t *ProgramData::SharedBlock::get_uniform_indices() const
 657 {
 658         return (indices.type_flag==0xFE ? indices.dynamic.values : indices.values);
 659 }
 660
 661
 662 ProgramData::ProgramBlock::ProgramBlock(ReflectData::LayoutHash h):
 663         prog_hash(h),
 664         bind_point(-1),
 665         block_index(-1)
 666 {
 667         masks.used = ALL_ONES;
 668         masks.dirty = ALL_ONES;
 669 }
 670
 671
 672 ProgramData::Loader::Loader(ProgramData &pd):
 673         DataFile::ObjectLoader<ProgramData>(pd)
 674 {
 675         add("uniform", &Loader::uniform1i);
 676         add("uniform1i", &Loader::uniform1i);
 677         add("uniform", &Loader::uniform1f);
 678         add("uniform1f", &Loader::uniform1f);
 679         add("uniform", &Loader::uniform2i);
 680         add("uniform2i", &Loader::uniform2i);
 681         add("uniform", &Loader::uniform2f);
 682         add("uniform2f", &Loader::uniform2f);
 683         add("uniform", &Loader::uniform3i);
 684         add("uniform3i", &Loader::uniform3i);
 685         add("uniform", &Loader::uniform3f);
 686         add("uniform3f", &Loader::uniform3f);
 687         add("uniform", &Loader::uniform4i);
 688         add("uniform4i", &Loader::uniform4i);
 689         add("uniform", &Loader::uniform4f);
 690         add("uniform4f", &Loader::uniform4f);
 691         add("uniform1i_array", &Loader::uniform1i_array);
 692         add("uniform1f_array", &Loader::uniform1f_array);
 693         add("uniform2f_array", &Loader::uniform2f_array);
 694         add("uniform3f_array", &Loader::uniform3f_array);
 695         add("uniform4f_array", &Loader::uniform4f_array);
 696         add("uniform_array", &Loader::uniform_array);
 697 }
 698
 699 void ProgramData::Loader::uniform1i(const string &n, int v)
 700 {
 701         obj.uniform(n, v);
 702 }
 703
 704 void ProgramData::Loader::uniform1f(const string &n, float v)
 705 {
 706         obj.uniform(n, v);
 707 }
 708
 709 void ProgramData::Loader::uniform2i(const string &n, int v0, int v1)
 710 {
 711         obj.uniform(n, v0, v1);
 712 }
 713
 714 void ProgramData::Loader::uniform2f(const string &n, float v0, float v1)
 715 {
 716         obj.uniform(n, v0, v1);
 717 }
 718
 719 void ProgramData::Loader::uniform3i(const string &n, int v0, int v1, int v2)
 720 {
 721         obj.uniform(n, v0, v1, v2);
 722 }
 723
 724 void ProgramData::Loader::uniform3f(const string &n, float v0, float v1, float v2)
 725 {
 726         obj.uniform(n, v0, v1, v2);
 727 }
 728
 729 void ProgramData::Loader::uniform4i(const string &n, int v0, int v1, int v2, int v3)
 730 {
 731         obj.uniform(n, v0, v1, v2, v3);
 732 }
 733
 734 void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v2, float v3)
 735 {
 736         obj.uniform(n, v0, v1, v2, v3);
 737 }
 738
 739 void ProgramData::Loader::uniform_array_(const string &n, DataType t, unsigned e)
 740 {
 741         ArrayLoader ldr(t, e);
 742         load_sub_with(ldr);
 743         unsigned size = ldr.get_size();
 744         if(!size)
 745                 throw logic_error("empty uniform array");
 746
 747         DataType type = ldr.get_data_type();
 748         unsigned elem_size = ldr.get_element_size();
 749         if(type==INT)
 750         {
 751                 const int *data = reinterpret_cast<const int *>(ldr.get_data());
 752                 if(elem_size==1)
 753                         obj.uniform1_array(n, size, data);
 754                 else if(elem_size==2)
 755                         obj.uniform2_array(n, size, data);
 756                 else if(elem_size==3)
 757                         obj.uniform3_array(n, size, data);
 758                 else if(elem_size==4)
 759                         obj.uniform4_array(n, size, data);
 760                 else
 761                         throw logic_error("unsupported combination of array type and element size");
 762         }
 763         else if(type==FLOAT)
 764         {
 765                 const float *data = reinterpret_cast<const float *>(ldr.get_data());
 766                 if(elem_size==1)
 767                         obj.uniform1_array(n, size, data);
 768                 else if(elem_size==2)
 769                         obj.uniform2_array(n, size, data);
 770                 else if(elem_size==3)
 771                         obj.uniform3_array(n, size, data);
 772                 else if(elem_size==4)
 773                         obj.uniform4_array(n, size, data);
 774                 else
 775                         throw logic_error("unsupported combination of array type and element size");
 776         }
 777         else
 778                 throw logic_error("unsupported array type");
 779 }
 780
 781 void ProgramData::Loader::uniform1i_array(const string &n)
 782 {
 783         uniform_array_(n, INT, 1);
 784 }
 785
 786 void ProgramData::Loader::uniform1f_array(const string &n)
 787 {
 788         uniform_array_(n, FLOAT, 1);
 789 }
 790
 791 void ProgramData::Loader::uniform2i_array(const string &n)
 792 {
 793         uniform_array_(n, INT, 2);
 794 }
 795
 796 void ProgramData::Loader::uniform2f_array(const string &n)
 797 {
 798         uniform_array_(n, FLOAT, 2);
 799 }
 800
 801 void ProgramData::Loader::uniform3i_array(const string &n)
 802 {
 803         uniform_array_(n, INT, 3);
 804 }
 805
 806 void ProgramData::Loader::uniform3f_array(const string &n)
 807 {
 808         uniform_array_(n, FLOAT, 3);
 809 }
 810
 811 void ProgramData::Loader::uniform4i_array(const string &n)
 812 {
 813         uniform_array_(n, INT, 4);
 814 }
 815
 816 void ProgramData::Loader::uniform4f_array(const string &n)
 817 {
 818         uniform_array_(n, FLOAT, 4);
 819 }
 820
 821 void ProgramData::Loader::uniform_array(const string &n)
 822 {
 823         uniform_array_(n, static_cast<DataType>(0), 0);
 824 }
 825
 826
 827 ProgramData::ArrayLoader::ArrayLoader(DataType t, unsigned e):
 828         type(t),
 829         element_size(e)
 830 {
 831         add("uniform", &ArrayLoader::uniform1i);
 832         add("uniform1i", &ArrayLoader::uniform1i);
 833         add("uniform", &ArrayLoader::uniform1f);
 834         add("uniform1f", &ArrayLoader::uniform1f);
 835         add("uniform", &ArrayLoader::uniform2f);
 836         add("uniform2f", &ArrayLoader::uniform2f);
 837         add("uniform", &ArrayLoader::uniform3f);
 838         add("uniform3f", &ArrayLoader::uniform3f);
 839         add("uniform", &ArrayLoader::uniform4f);
 840         add("uniform4f", &ArrayLoader::uniform4f);
 841 }
 842
 843 void ProgramData::ArrayLoader::uniform(DataType t, unsigned e, const void *v)
 844 {
 845         if(element_size && (t!=type || e!=element_size))
 846                 throw logic_error("heterogeneous array contents");
 847
 848         if(!element_size)
 849         {
 850                 type = t;
 851                 element_size = e;
 852         }
 853
 854         const char *cv = reinterpret_cast<const char *>(v);
 855         data.insert(data.end(), cv, cv+element_size*4);
 856 }
 857
 858 void ProgramData::ArrayLoader::uniform1i(int v)
 859 {
 860         uniform(INT, 1, &v);
 861 }
 862
 863 void ProgramData::ArrayLoader::uniform1f(float v)
 864 {
 865         uniform(FLOAT, 1, &v);
 866 }
 867
 868 void ProgramData::ArrayLoader::uniform2i(int v0, int v1)
 869 {
 870         int va[2] = { v0, v1 };
 871         uniform(INT, 2, va);
 872 }
 873
 874 void ProgramData::ArrayLoader::uniform2f(float v0, float v1)
 875 {
 876         float va[2] = { v0, v1 };
 877         uniform(FLOAT, 2, va);
 878 }
 879
 880 void ProgramData::ArrayLoader::uniform3i(int v0, int v1, int v2)
 881 {
 882         int va[3] = { v0, v1, v2 };
 883         uniform(INT, 3, va);
 884 }
 885
 886 void ProgramData::ArrayLoader::uniform3f(float v0, float v1, float v2)
 887 {
 888         float va[3] = { v0, v1, v2 };
 889         uniform(FLOAT, 3, va);
 890 }
 891
 892 void ProgramData::ArrayLoader::uniform4i(int v0, int v1, int v2, int v3)
 893 {
 894         int va[4] = { v0, v1, v2, v3 };
 895         uniform(INT, 4, va);
 896 }
 897
 898 void ProgramData::ArrayLoader::uniform4f(float v0, float v1, float v2, float v3)
 899 {
 900         float va[4] = { v0, v1, v2, v3 };
 901         uniform(FLOAT, 4, va);
 902 }
 903
 904 } // namespace GL
 905 } // namespace Msp