X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramdata.cpp;h=1ecd3a1dc42eaef6a62785f3fa4f07e1809a6405;hp=6d657d8a9354ba64d915ca6770318608d17d8ae9;hb=8f7d5b6460ef68e7316c7f556b7152d9c9f7bfe2;hpb=85e83ace47e5a9a8ae7263886255dd81afc69278 diff --git a/source/programdata.cpp b/source/programdata.cpp index 6d657d8a..1ecd3a1d 100644 --- a/source/programdata.cpp +++ b/source/programdata.cpp @@ -1,89 +1,350 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include "extension.h" +#include "arb_shader_objects.h" +#include "buffer.h" +#include "color.h" +#include "error.h" +#include "matrix.h" +#include "program.h" #include "programdata.h" #include "uniform.h" +#include "uniformblock.h" +#include "vector.h" using namespace std; namespace Msp { namespace GL { -ProgramData::ProgramData() +ProgramData::ProgramData(): + last_block(0), + buffer(0), + changes(NO_CHANGES) { - require_extension("GL_ARB_shader_objects"); + static Require _req(ARB_shader_objects); +} + +// Blocks are intentionally left uncopied +ProgramData::ProgramData(const ProgramData &other): + uniforms(other.uniforms), + last_block(0), + buffer(0), + changes(NO_CHANGES) +{ + for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) + i->second = i->second->clone(); } ProgramData::~ProgramData() { - for(map::iterator i=data.begin(); i!=data.end(); ++i) + for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) delete i->second; + for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i) + delete i->second.block; + delete buffer; } -void ProgramData::uniform(int index, Uniform *uni) +void ProgramData::uniform(const string &name, Uniform *uni) { - if(index<0) - return; - - map::iterator i=data.find(index); - if(i!=data.end()) + UniformMap::iterator i = uniforms.find(name); + if(i!=uniforms.end()) { + /* UniformBlock does not copy the uniforms, so existing blocks will be + left with stale pointers. This is not a problem as long as no one stores + pointers to the blocks and expects them to stay valid. */ delete i->second; - i->second=uni; + i->second = uni; + changes = VALUES_CHANGED; } else - data[index]=uni; + { + uniforms[name] = uni; + changes = KEYS_CHANGED; + } +} + +void ProgramData::uniform(const string &name, int v) +{ + uniform(name, new Uniform1i(v)); +} + +void ProgramData::uniform(const string &name, float v) +{ + uniform(name, new Uniform1f(v)); +} + +void ProgramData::uniform(const string &name, float v0, float v1) +{ + float va[2] = { v0, v1 }; + uniform2(name, va); +} + +void ProgramData::uniform2(const string &name, const float *v) +{ + uniform(name, new Uniform2f(v)); +} + +void ProgramData::uniform(const string &name, float v0, float v1, float v2) +{ + float va[3] = { v0, v1, v2 }; + uniform3(name, va); +} + +void ProgramData::uniform(const string &name, const Vector3 &v) +{ + uniform(name, v.x, v.y, v.z); +} + +void ProgramData::uniform3(const string &name, const float *v) +{ + uniform(name, new Uniform3f(v)); +} + +void ProgramData::uniform(const string &name, float v0, float v1, float v2, float v3) +{ + float va[4] = { v0, v1, v2, v3 }; + uniform4(name, va); +} + +void ProgramData::uniform(const string &name, const Vector4 &v) +{ + uniform(name, v.x, v.y, v.z, v.w); +} + +void ProgramData::uniform(const string &name, const Color &c) +{ + uniform(name, c.r, c.g, c.b, c.a); +} + +void ProgramData::uniform4(const string &name, const float *v) +{ + uniform(name, new Uniform4f(v)); +} + +void ProgramData::uniform_matrix2(const string &name, const float *v) +{ + uniform(name, new UniformMatrix2x2f(v)); +} + +void ProgramData::uniform_matrix3(const string &name, const float *v) +{ + uniform(name, new UniformMatrix3x3f(v)); +} + +void ProgramData::uniform_matrix4(const string &name, const float *v) +{ + uniform(name, new UniformMatrix4x4f(v)); +} + +void ProgramData::uniform_matrix4(const string &name, const Matrix &m) +{ + float v[16]; + copy(m.data(), m.data()+16, v); + uniform_matrix4(name, v); } -void ProgramData::uniform(int index, int v) +void ProgramData::uniform1_array(const string &name, unsigned n, const float *v) { - uniform(index, new Uniform1i(v)); + uniform(name, new UniformArray(n, v)); } -void ProgramData::uniform(int index, float v) +void ProgramData::uniform2_array(const string &name, unsigned n, const float *v) { - uniform(index, new Uniform1f(v)); + uniform(name, new UniformArray(n, v)); } -void ProgramData::uniform(int index, float v0, float v1) +void ProgramData::uniform3_array(const string &name, unsigned n, const float *v) { - uniform(index, new Uniform2f(v0, v1)); + uniform(name, new UniformArray(n, v)); } -void ProgramData::uniform2(int index, const float *v) +void ProgramData::uniform4_array(const string &name, unsigned n, const float *v) { - uniform(index, v[0], v[1]); + uniform(name, new UniformArray(n, v)); } -void ProgramData::uniform(int index, float v0, float v1, float v2) +void ProgramData::uniform_matrix4_array(const string &name, unsigned n, const float *v) { - uniform(index, new Uniform3f(v0, v1, v2)); + uniform(name, new UniformArray(n, v)); } -void ProgramData::uniform3(int index, const float *v) +void ProgramData::find_uniforms_for_block(Block &block, const Program::UniformBlockInfo &info) const { - uniform(index, v[0], v[1], v[2]); + block.uniforms.clear(); + for(vector::const_iterator i=info.uniforms.begin(); i!=info.uniforms.end(); ++i) + { + // XXX individual array elements + UniformMap::const_iterator j = uniforms.find((*i)->name); + if(j!=uniforms.end()) + block.uniforms[(*i)->location] = &j->second; + } } -void ProgramData::uniform(int index, float v0, float v1, float v2, float v3) +UniformBlock *ProgramData::create_block(const Program::UniformBlockInfo &info) const { - uniform(index, new Uniform4f(v0, v1, v2, v3)); + UniformBlock *block = new UniformBlock(info.data_size); + if(!buffer) + { + buffer = new Buffer(UNIFORM_BUFFER); + buffer->set_usage(STREAM_DRAW); + } + block->use_buffer(buffer, last_block); + last_block = block; + return block; +} + +const UniformBlock *ProgramData::get_block(const Program &prog, const Program::UniformBlockInfo *info) const +{ + if(changes) + { + for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i) + if(i->second.changessecond.changes = changes; + changes = NO_CHANGES; + } + + unsigned layout_hash = (info ? info->layout_hash : prog.get_uniform_layout_hash()); + + map::iterator i = blocks.find(layout_hash); + if(i==blocks.end()) + { + i = blocks.insert(BlockMap::value_type(layout_hash, Block())).first; + if(info) + { + find_uniforms_for_block(i->second, *info); + + if(!i->second.uniforms.empty()) + { + i->second.block = create_block(*info); + i->second.changes = VALUES_CHANGED; + } + } + else + { + i->second.block = new UniformBlock; + i->second.changes = VALUES_CHANGED; + } + } + else if(info && i->second.changes==KEYS_CHANGED) + { + find_uniforms_for_block(i->second, *info); + if(!i->second.uniforms.empty()) + { + if(!i->second.block) + i->second.block = create_block(*info); + i->second.changes = VALUES_CHANGED; + } + else + i->second.changes = NO_CHANGES; + } + + if(!i->second.block) + return 0; + + UniformBlock &block = *i->second.block; + if(i->second.changes) + { + if(info) + { + vector::const_iterator j = info->uniforms.begin(); + map::const_iterator k = i->second.uniforms.begin(); + while(j!=info->uniforms.end() && k!=i->second.uniforms.end()) + { + if(k->first==(*j)->location) + { + block.attach(**j, **k->second); + ++k; + } + ++j; + } + } + else + { + for(UniformMap::const_iterator j=uniforms.begin(); j!=uniforms.end(); ++j) + { + int loc = prog.get_uniform_location(j->first); + if(loc>=0) + block.attach(loc, *j->second); + } + } + i->second.changes = NO_CHANGES; + } + + return █ } -void ProgramData::uniform4(int index, const float *v) +const UniformBlock *ProgramData::get_block(const Program &prog, const string &name) const { - uniform(index, v[0], v[1], v[2], v[3]); + if(name.empty()) + return get_block(prog, 0); + else + return get_block(prog, &prog.get_uniform_block_info(name)); } void ProgramData::apply() const { - for(map::const_iterator i=data.begin(); i!=data.end(); ++i) - i->second->apply(i->first); + const Program *prog = Program::current(); + if(!prog) + throw invalid_operation("ProgramData::apply"); + + const Program::UniformBlockMap &prog_blocks = prog->get_uniform_blocks(); + if(!prog_blocks.empty()) + { + typedef pair ApplyBlock; + list apply_blocks; + for(Program::UniformBlockMap::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i) + if(const UniformBlock *block = get_block(*prog, &i->second)) + apply_blocks.push_back(make_pair(block, i->second.bind_point)); + + if(buffer) + buffer->bind(); + + for(list::const_iterator i=apply_blocks.begin(); i!=apply_blocks.end(); ++i) + i->first->apply(i->second); + } + + if(const UniformBlock *block = get_block(*prog, 0)) + block->apply(-1); +} + + +ProgramData::Block::Block(): + changes(NO_CHANGES), + block(0) +{ } + + +ProgramData::Loader::Loader(ProgramData &pd): + DataFile::ObjectLoader(pd) +{ + add("uniform1i", &Loader::uniform1i); + add("uniform1f", &Loader::uniform1f); + add("uniform2f", &Loader::uniform2f); + add("uniform3f", &Loader::uniform3f); + add("uniform4f", &Loader::uniform4f); +} + +void ProgramData::Loader::uniform1i(const string &n, int v) +{ + obj.uniform(n, v); +} + +void ProgramData::Loader::uniform1f(const string &n, float v) +{ + obj.uniform(n, v); +} + +void ProgramData::Loader::uniform2f(const string &n, float v0, float v1) +{ + obj.uniform(n, v0, v1); +} + +void ProgramData::Loader::uniform3f(const string &n, float v0, float v1, float v2) +{ + obj.uniform(n, v0, v1, v2); +} + +void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v2, float v3) +{ + obj.uniform(n, v0, v1, v2, v3); } } // namespace GL