X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Frender%2Fprogramdata.cpp;h=1ef013ddac86e5a6be72643fe711764f01428d30;hp=9c23e8a5eb26eefd2da1654975ccf5af62d1d4b2;hb=3a1b9cbe2441ae670a97541dc8ccb0a2860c8302;hpb=fa2b4c8a93ebad2497cacfdeaa9a2c20be486520 diff --git a/source/render/programdata.cpp b/source/render/programdata.cpp index 9c23e8a5..1ef013dd 100644 --- a/source/render/programdata.cpp +++ b/source/render/programdata.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -6,6 +7,7 @@ #include "color.h" #include "error.h" #include "matrix.h" +#include "pipelinestate.h" #include "program.h" #include "programdata.h" #include "uniform.h" @@ -19,7 +21,8 @@ namespace GL { ProgramData::ProgramData(const Program *p): tied_program(p), - last_block(0), + generation(0), + last_buffer_block(0), buffer(0), dirty(0) { } @@ -28,29 +31,30 @@ ProgramData::ProgramData(const Program *p): ProgramData::ProgramData(const ProgramData &other): tied_program(other.tied_program), uniforms(other.uniforms), - last_block(0), + generation(other.generation), + last_buffer_block(0), buffer(0), dirty(0) { - for(vector::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) - i->value = i->value->clone(); + for(TaggedUniform &u: uniforms) + u.value = u.value->clone(); } ProgramData::ProgramData(const ProgramData &other, const Program *p): tied_program(p), - last_block(0), + last_buffer_block(0), buffer(0), dirty(0) { if(tied_program) { - for(vector::const_iterator i=other.uniforms.begin(); i!=other.uniforms.end(); ++i) - validate_tag(i->tag); + for(const TaggedUniform &u: other.uniforms) + validate_tag(u.tag); } uniforms = other.uniforms; - for(vector::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) - i->value = i->value->clone(); + for(TaggedUniform &u: uniforms) + u.value = u.value->clone(); } ProgramData &ProgramData::operator=(const ProgramData &other) @@ -58,14 +62,15 @@ ProgramData &ProgramData::operator=(const ProgramData &other) tied_program = other.tied_program; uniforms = other.uniforms; - for(vector::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) - i->value = i->value->clone(); + for(TaggedUniform &u: uniforms) + u.value = u.value->clone(); - for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i) - delete i->second.block; + for(SharedBlock &b: blocks) + delete b.block; + blocks.clear(); programs.clear(); - last_block = 0; + last_buffer_block = 0; buffer = 0; dirty = 0; @@ -74,13 +79,13 @@ ProgramData &ProgramData::operator=(const ProgramData &other) ProgramData::~ProgramData() { - for(vector::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) - delete i->value; - for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i) + for(TaggedUniform &u: uniforms) + delete u.value; + for(SharedBlock &b: blocks) { - if(i->second.indices.type_flag==0xFE) - delete[] i->second.indices.dynamic.values; - delete i->second.block; + if(b.indices.type_flag==0xFE) + delete[] b.indices.dynamic.values; + delete b.block; } delete buffer; } @@ -106,7 +111,7 @@ void ProgramData::uniform(Tag tag, Uniform *uni) return add_uniform(tag, uni); uniforms[i].replace_value(uni); - dirty |= 1< @@ -124,7 +129,7 @@ void ProgramData::uniform(Tag tag, V value) else uniforms[i].replace_value(new T(value)); - dirty |= 1< @@ -143,7 +148,7 @@ void ProgramData::uniform_array(Tag tag, unsigned n, V value) else uniforms[i].replace_value(new UniformArray(n, value)); - dirty |= 1<get_uniform_info(tag); + { + const Program::UniformInfo &info = tied_program->get_uniform_info(tag); + if(is_image(info.type)) + throw invalid_operation("ProgramData::uniform"); + } return true; } #ifdef DEBUG @@ -173,14 +182,21 @@ void ProgramData::add_uniform(Tag tag, Uniform *uni) throw too_many_uniforms(tag.str()); } - vector::iterator j = lower_bound(uniforms.begin(), uniforms.end(), tag, uniform_tag_compare); + auto j = lower_bound_member(uniforms, tag, &TaggedUniform::tag); TaggedUniform nu; nu.tag = tag; nu.value = uni; uniforms.insert(j, nu); - dirty = ALL_ONES; + mark_dirty(ALL_ONES); +} + +void ProgramData::mark_dirty(Mask bits) +{ + if(!dirty) + ++generation; + dirty |= bits; } void ProgramData::uniform(Tag tag, const Uniform &u) @@ -232,11 +248,6 @@ void ProgramData::uniform(Tag tag, float v0, float v1, float v2) uniform3(tag, va); } -void ProgramData::uniform(Tag tag, const Vector3 &v) -{ - uniform(tag, v.x, v.y, v.z); -} - void ProgramData::uniform3(Tag tag, const int *v) { uniform(tag, v); @@ -259,11 +270,6 @@ void ProgramData::uniform(Tag tag, float v0, float v1, float v2, float v3) uniform4(tag, va); } -void ProgramData::uniform(Tag tag, const Vector4 &v) -{ - uniform(tag, v.x, v.y, v.z, v.w); -} - void ProgramData::uniform(Tag tag, const Color &c) { uniform(tag, c.r, c.g, c.b, c.a); @@ -279,81 +285,41 @@ void ProgramData::uniform4(Tag tag, const float *v) uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix2(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix2(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix3x2(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix3x2(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix4x2(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix4x2(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix2x3(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix2x3(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix3(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix3(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix4x3(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix4x3(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix2x4(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix2x4(Tag tag, const float *v) { uniform(tag, v); } -void ProgramData::uniform(Tag tag, const LinAl::Matrix &m) -{ - uniform_matrix3x4(tag, &m(0, 0)); -} - void ProgramData::uniform_matrix3x4(Tag tag, const float *v) { uniform(tag, v); @@ -369,6 +335,16 @@ void ProgramData::uniform_matrix4(Tag tag, const float *v) uniform(tag, v); } +void ProgramData::uniform_array(Tag tag, unsigned n, const int *v) +{ + uniform_array(tag, n, v); +} + +void ProgramData::uniform_array(Tag tag, unsigned n, const float *v) +{ + uniform_array(tag, n, v); +} + void ProgramData::uniform1_array(Tag tag, unsigned n, const int *v) { uniform_array(tag, n, v); @@ -456,22 +432,22 @@ void ProgramData::uniform_matrix4_array(Tag tag, unsigned n, const float *v) void ProgramData::remove_uniform(Tag tag) { - vector::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), tag, uniform_tag_compare); + auto i = lower_bound_member(uniforms, tag, &TaggedUniform::tag); if(i==uniforms.end() || i->tag!=tag) return; delete i->value; uniforms.erase(i); - dirty = ALL_ONES; + mark_dirty(ALL_ONES); } vector ProgramData::get_uniform_tags() const { vector tags; tags.reserve(uniforms.size()); - for(vector::const_iterator i=uniforms.begin(); i!=uniforms.end(); ++i) - tags.push_back(i->tag); + for(const TaggedUniform &u: uniforms) + tags.push_back(u.tag); return tags; } @@ -489,30 +465,75 @@ const Uniform *ProgramData::find_uniform(Tag tag) const return (i>=0 ? uniforms[i].value : 0); } -bool ProgramData::uniform_tag_compare(const TaggedUniform &tu, Tag tag) +int ProgramData::find_uniform_index(Tag tag) const { - return tu.tagtag==tag) ? i-uniforms.begin() : -1); } -int ProgramData::find_uniform_index(Tag tag) const +vector::iterator ProgramData::get_program(const Program &prog) const { - vector::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), tag, uniform_tag_compare); - return ((i!=uniforms.end() && i->tag==tag) ? i-uniforms.begin() : -1); + Program::LayoutHash prog_hash = prog.get_uniform_layout_hash(); + auto i = lower_bound_member(programs, prog_hash, &ProgramBlock::prog_hash); + if(i!=programs.end() && i->prog_hash==prog_hash) + return i; + + const vector &block_infos = prog.get_uniform_blocks(); + unsigned index = i-programs.begin(); + programs.insert(i, 1+block_infos.size(), ProgramBlock(prog_hash)); + + /* Block indices may change if new shared blocks need to be inserted. Store + the hashes so they can be matched up later. */ + vector block_hashes; + block_hashes.reserve(programs.size()); + for(const ProgramBlock &b: programs) + block_hashes.push_back(b.block_index>=0 ? blocks[b.block_index].block_hash : 0); + + for(unsigned j=0; jblock_hash!=info.layout_hash) + { + k = blocks.insert(k, SharedBlock(info.layout_hash)); + update_block_uniform_indices(*k, info); + } + } + + /* Reassign shared block indices from the stored hashes. */ + for(unsigned j=0; j16) { if(block.indices.type_flag==0xFD) { - block.indices.dynamic.values = new UInt8[info.uniforms.size()]; + block.indices.dynamic.values = new uint8_t[info.uniforms.size()]; block.indices.type_flag = 0xFE; } indices = block.indices.dynamic.values; } + bool any_missing = false; + block.used = 0; for(unsigned i=0; iattach(*info.uniforms[i], *uniforms[indices[i]].value); -} - -ProgramData::SharedBlock *ProgramData::get_shared_block(const Program::UniformBlockInfo &info) const -{ - BlockMap::iterator i = blocks.find(info.layout_hash); - if(i==blocks.end()) + if(block.used && any_missing && info.bind_point>=0) { - bool any_found = false; - bool all_found = true; - for(vector::const_iterator j=info.uniforms.begin(); j!=info.uniforms.end(); ++j) - { - if(find_uniform_index((*j)->name)>=0) - any_found = true; - else - all_found = false; - } - - if(!any_found) - return 0; - else if(!all_found && info.bind_point>=0) - { #ifdef DEBUG - IO::print(IO::cerr, "Warning: not all uniforms for block %s are present\n", info.name); + IO::print(IO::cerr, "Warning: not all uniforms for block %s are present\n", info.name); #else - throw incomplete_uniform_block(info.name); + throw incomplete_uniform_block(info.name); #endif - } + } - UniformBlock *block; + block.dirty = block.used; + + if(block.used && !block.block) + { if(info.bind_point>=0) { if(!buffer) - buffer = new Buffer(UNIFORM_BUFFER); + { + buffer = new Buffer(); + +#ifdef DEBUG + if(!debug_name.empty()) + buffer->set_debug_name(debug_name); +#endif + } - block = new UniformBlock(info.data_size); - block->use_buffer(buffer, last_block); - last_block = block; + BufferBackedUniformBlock *bb_block = new BufferBackedUniformBlock(info.data_size); + block.block = bb_block; + bb_block->use_buffer(buffer, last_buffer_block); + last_buffer_block = bb_block; } else - block = new UniformBlock; - - i = blocks.insert(BlockMap::value_type(info.layout_hash, SharedBlock(block))).first; - update_block_uniform_indices(i->second, info); + block.block = new DefaultUniformBlock; } - - return &i->second; } -void ProgramData::apply() const +void ProgramData::update_block(SharedBlock &block, const Program::UniformBlockInfo &info) const { - const Program *prog = Program::current(); - if(!prog) - throw invalid_operation("ProgramData::apply"); + const uint8_t *indices = block.get_uniform_indices(); + for(unsigned i=0; itype)) + ; // Temporarily ignore deprecated use of sampler uniforms in ProgramData + else if(indices[i]!=0xFF) + block.block->attach(*info.uniforms[i], *uniforms[indices[i]].value); + } +} - Program::LayoutHash layout = prog->get_uniform_layout_hash(); - ProgramUniforms &pu = programs[layout]; +vector::const_iterator ProgramData::prepare_program(const Program &prog) const +{ + BufferBackedUniformBlock *old_last_block = last_buffer_block; + auto prog_begin = get_program(prog); Mask force_dirty = (dirty==ALL_ONES ? ALL_ONES : 0U); - Mask affected = (dirty&pu.used) | force_dirty; - if(affected|pu.dirty) + Mask affected = (dirty&prog_begin->masks.used) | force_dirty; + if(affected|prog_begin->masks.dirty) { - /* If the global dirty flag affects this program, add it to per-program - dirty flags and clear the global flag. A previously unseen program will - cause this to happen if there's any dirty uniforms. */ + /* If the global dirty flag affects this program, add it to per-block and + per-program dirty flags and clear the global flag. A previously unseen + program will cause this to happen if there's any dirty uniforms. */ if(affected) { - for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i) - i->second.dirty |= (dirty&i->second.used) | force_dirty; - for(ProgramMap::iterator i=programs.begin(); i!=programs.end(); ++i) - i->second.dirty |= (dirty&i->second.used) | force_dirty; + for(SharedBlock &b: blocks) + b.dirty |= (dirty&b.used) | force_dirty; + for(ProgramBlock &b: programs) + if(b.block_index<0) + b.masks.dirty |= (dirty&b.masks.used) | force_dirty; dirty = 0; } - const vector &prog_blocks = prog->get_uniform_blocks(); + const vector &block_infos = prog.get_uniform_blocks(); - UniformBlock *old_last_block = last_block; - if(pu.dirty==ALL_ONES) + if(prog_begin->masks.dirty==ALL_ONES) { /* The set of uniforms has changed since this program was last used. - Regenerate the list of uniform blocks. */ - pu.blocks.clear(); - pu.blocks.reserve(prog_blocks.size()); - - pu.used = 0; - for(vector::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i) + Refresh uniform indices within the program's blocks. */ + prog_begin->masks.used = 0; + auto j = prog_begin+1; + for(const Program::UniformBlockInfo &b: block_infos) { - SharedBlock *shared = get_shared_block(*i); - if(shared) - { - if(shared->dirty==ALL_ONES) - update_block_uniform_indices(*shared, *i); - pu.used |= shared->used; - } - - pu.blocks.push_back(ProgramBlock(i->bind_point, shared)); + SharedBlock &shared = blocks[j->block_index]; + if(shared.dirty==ALL_ONES) + update_block_uniform_indices(shared, b); + prog_begin->masks.used |= shared.used; + j->block = (shared.used ? shared.block : 0); + ++j; } } // Update the contents of all dirty blocks. bool buffered_blocks_updated = false; - std::vector::iterator j = pu.blocks.begin(); - for(vector::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i, ++j) + auto j = prog_begin+1; + for(const Program::UniformBlockInfo &b: block_infos) { - if(!j->shared || !j->shared->dirty) - continue; - - update_block(*j->shared, *i); - j->shared->dirty = 0; - buffered_blocks_updated |= (j->bind_point>=0); + SharedBlock &shared = blocks[j->block_index]; + if(shared.dirty) + { + update_block(shared, b); + shared.dirty = 0; + buffered_blocks_updated |= (j->bind_point>=0); + } + ++j; } - pu.dirty = 0; + prog_begin->masks.dirty = 0; - /* If any blocks stored in the buffer were updated, bind the buffer here - to avoid state thrashing. */ - if(buffered_blocks_updated && !ARB_direct_state_access) - buffer->bind(); - - if(last_block!=old_last_block) + if(last_buffer_block!=old_last_block) { - unsigned required_size = last_block->get_required_buffer_size(); - if(last_block->get_required_buffer_size()>buffer->get_size()) + unsigned required_size = last_buffer_block->get_required_buffer_size(); + if(last_buffer_block->get_required_buffer_size()>buffer->get_size()) { if(buffer->get_size()>0) { delete buffer; - buffer = new Buffer(UNIFORM_BUFFER); - last_block->change_buffer(buffer); + buffer = new Buffer(); + last_buffer_block->change_buffer(buffer); + +#ifdef DEBUG + if(!debug_name.empty()) + buffer->set_debug_name(debug_name); +#endif } buffer->storage(required_size); @@ -671,9 +678,36 @@ void ProgramData::apply() const } } - for(vector::iterator i=pu.blocks.begin(); i!=pu.blocks.end(); ++i) + return prog_begin; +} + +void ProgramData::apply(const Program &prog, PipelineState &state) const +{ + auto prog_begin = prepare_program(prog); + Program::LayoutHash prog_hash = prog_begin->prog_hash; + for(auto i=prog_begin+1; (i!=programs.end() && i->prog_hash==prog_hash); ++i) if(i->block) - i->block->apply(i->bind_point); + { + if(i->bind_point<0) + state.set_uniforms(static_cast(i->block)); + else + { + const BufferBackedUniformBlock *block = static_cast(i->block); + block->refresh(); + state.set_uniform_block(i->bind_point, block); + } + } +} + +void ProgramData::set_debug_name(const string &name) +{ +#ifdef DEBUG + debug_name = name; + if(buffer) + buffer->set_debug_name(name); +#else + (void)name; +#endif } @@ -691,37 +725,29 @@ void ProgramData::TaggedUniform::replace_value(Uniform *v) } -ProgramData::SharedBlock::SharedBlock(UniformBlock *b): +ProgramData::SharedBlock::SharedBlock(Program::LayoutHash h): + block_hash(h), used(0), dirty(0), - block(b) + block(0) { indices.type_flag = 0xFD; } -const UInt8 *ProgramData::SharedBlock::get_uniform_indices() const +const uint8_t *ProgramData::SharedBlock::get_uniform_indices() const { return (indices.type_flag==0xFE ? indices.dynamic.values : indices.values); } -ProgramData::ProgramBlock::ProgramBlock(): +ProgramData::ProgramBlock::ProgramBlock(Program::LayoutHash h): + prog_hash(h), bind_point(-1), - block(0), - shared(0) -{ } - -ProgramData::ProgramBlock::ProgramBlock(int p, SharedBlock *b): - bind_point(p), - block((b && b->used) ? b->block : 0), - shared(b) -{ } - - -ProgramData::ProgramUniforms::ProgramUniforms(): - used(ALL_ONES), - dirty(ALL_ONES) -{ } + block_index(-1) +{ + masks.used = ALL_ONES; + masks.dirty = ALL_ONES; +} ProgramData::Loader::Loader(ProgramData &pd):