X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Ftechnique.cpp;h=d6ec7115f6e703a5b215803952a27716f934e468;hp=26837b61533167e0ddc268715f2722aee008272e;hb=1efd559eb32adf48200941402ccefc6b5422aa4c;hpb=927a1aa0a3a27e463ec0efc08bd08e7c4e969909 diff --git a/source/technique.cpp b/source/technique.cpp index 26837b61..d6ec7115 100644 --- a/source/technique.cpp +++ b/source/technique.cpp @@ -1,13 +1,6 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - #include #include -#include +#include #include "material.h" #include "program.h" #include "programdata.h" @@ -20,145 +13,163 @@ using namespace std; namespace Msp { namespace GL { -Technique::Technique(): - main_texture(0), - normal_pass(&passes[0]), - material(0) -{ } - -Technique::~Technique() +RenderPass &Technique::add_pass(const Tag &tag) { - for(PassMap::iterator i=passes.begin(); i!=passes.end(); ++i) - delete i->second.shdata; + return insert_unique(passes, tag, RenderPass())->second; } -bool Technique::has_pass(const GL::Tag &tag) const +bool Technique::has_pass(const Tag &tag) const { return passes.count(tag); } -const ObjectPass &Technique::get_pass(const GL::Tag &tag) const +const RenderPass &Technique::get_pass(const Tag &tag) const { - PassMap::const_iterator i=passes.find(tag); - if(i==passes.end()) - throw KeyError("Unknown pass"); - return i->second; + return get_item(passes, tag); } -unsigned Technique::get_texture_index(const std::string &n) const +bool Technique::replace_texture(const string &slot, const Texture &tex) { - for(unsigned i=0; isecond.get_texture_index(slot); + if(index>=0) + { + i->second.set_texture(index, &tex); + replaced = true; + } + } - throw KeyError("Unknown texture slot", n); + return replaced; } -const Texture *Technique::get_texture(unsigned i) const +bool Technique::replace_material(const string &slot, const Material &mat) { - if(i>=textures.size()) - throw KeyError("Texture index out of range"); + bool replaced = false; + for(PassMap::iterator i=passes.begin(); i!=passes.end(); ++i) + { + const string &pass_slot = i->second.get_material_slot_name(); + if(!pass_slot.empty() && pass_slot==slot) + { + i->second.set_material(&mat); + replaced = true; + } + } - return textures[i].texture; + return replaced; } +bool Technique::replace_uniforms(const ProgramData &shdata) +{ + bool replaced = false; + const vector &uniform_names = shdata.get_uniform_names(); + for(PassMap::iterator i=passes.begin(); i!=passes.end(); ++i) + { + RefPtr new_shdata; + for(vector::const_iterator j=uniform_names.begin(); j!=uniform_names.end(); ++j) + { + const string &name = i->second.get_slotted_uniform_name(*j); + if(name.empty()) + continue; + + if(!new_shdata) + new_shdata = new ProgramData(*i->second.get_shader_data()); + + new_shdata->uniform(name, shdata.get_uniform(*j)); + replaced = true; + } + + if(new_shdata) + i->second.set_shader_program(i->second.get_shader_program(), new_shdata.get()); + } + + return replaced; +} + +bool Technique::has_shaders() const +{ + for(PassMap::const_iterator i=passes.begin(); i!=passes.end(); ++i) + if(i->second.get_shader_program()) + return true; + return false; +} + + +Technique::Loader::Loader(Technique &t): + DataFile::CollectionObjectLoader(t, 0) +{ + init(); +} Technique::Loader::Loader(Technique &t, Collection &c): DataFile::CollectionObjectLoader(t, &c) { - add("material", &Technique::material); - add("material_inline", &Loader::material_inline); - add("pass", &Loader::pass); - add("shader", &Loader::shader); - add("shader_texture", &Loader::shader_texture); - add("texture", &Loader::texture); - add("texture_slot", &Loader::texture_slot); + init(); } -void Technique::Loader::finish() +void Technique::Loader::init() { - for(PassMap::iterator i=obj.passes.begin(); i!=obj.passes.end(); ++i) - if(i->second.shdata) - { - for(unsigned j=0; jsecond.shprog->get_uniform_location(obj.textures[j].name); - i->second.shdata->uniform(loc, static_cast(j)); - } - } + add("inherit", &Loader::inherit); + add("pass", &Loader::pass); } -void Technique::Loader::material_inline() +void Technique::Loader::inherit(const string &n) { - RefPtr mat=new Material; - load_sub(*mat); - coll->add(format("_%p", mat.get()), mat.get()); - obj.material=mat.release(); + obj.passes = get_collection().get(n).get_passes(); + InheritLoader ldr(obj, get_collection()); + load_sub_with(ldr); } void Technique::Loader::pass(const string &n) { - Tag tag(n); - if(obj.passes.count(tag)) - throw KeyError("Duplicate pass name", n); - ObjectPass p; - load_sub(p, *coll); - obj.passes[tag]=p; + RenderPass p; + if(coll) + load_sub(p, get_collection()); + else + load_sub(p); + + insert_unique(obj.passes, n, p); } -void Technique::Loader::shader(const string &n) -{ - Program *shprog=coll->get(n); - if(shprog) // Allow for unsupported shaders - { - RefPtr shdata=new ProgramData; - load_sub(*shdata, *shprog); - obj.normal_pass->shprog=shprog; - if(obj.normal_pass->shdata) - delete obj.normal_pass->shdata; - obj.normal_pass->shdata=shdata.release(); - } +Technique::InheritLoader::InheritLoader(Technique &t, Collection &c): + DataFile::CollectionObjectLoader(t, &c) +{ + add("material", &InheritLoader::material); + add("texture", &InheritLoader::texture); + add("uniforms", &InheritLoader::uniforms); } -void Technique::Loader::shader_texture(const string &n) +void Technique::InheritLoader::material(const string &slot, const string &name) { - string::size_type eqsign=n.find('='); - TextureSlot tex; - if(eqsign!=string::npos) + const Material &mat = get_collection().get(name); + if(obj.replace_material(slot, mat)) + return; + + // For backwards compatibility + RenderPass &pass = get_item(obj.passes, slot); + if(const Material *base_mat = pass.get_material()) { - tex.name=n.substr(0, eqsign); - tex.texture=coll->get(n.substr(eqsign+1)); + for(PassMap::iterator i=obj.passes.begin(); i!=obj.passes.end(); ++i) + if(i->second.get_material()==base_mat) + i->second.set_material(&mat); } else - { - string::size_type dot=n.rfind('.'); - tex.name=n.substr(0, dot); - tex.texture = coll->get(n); - } - for(string::iterator i=tex.name.begin(); i!=tex.name.end(); ++i) - if(!isalnum(*i)) - *i='_'; - obj.textures.push_back(tex); + pass.set_material(&mat); } -void Technique::Loader::texture(const string &n) +void Technique::InheritLoader::texture(const string &slot, const string &name) { - if(obj.main_texture) - throw Exception("Only one main texture may be specified"); - - obj.main_texture=coll->get(n); - TextureSlot tex; - tex.name="texture"; - tex.texture=obj.main_texture; - obj.textures.push_back(tex); + if(!obj.replace_texture(slot, get_collection().get(name))) + throw key_error(slot); } -void Technique::Loader::texture_slot(const string &n) +void Technique::InheritLoader::uniforms() { - TextureSlot tex; - tex.name=n; - obj.textures.push_back(tex); + ProgramData shdata; + load_sub(shdata); + obj.replace_uniforms(shdata); } } // namespace GL