X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Frenderpass.cpp;h=835e78a672cd6203649cdd9cbba4345421fa41b8;hp=9e5b71d91f6a7a778902400d58fb0f5316dc40b7;hb=bec07999d95b76f4b47cffcc564d0cd0afc0435e;hpb=a93d6abc8a4a3e70fa8f6781d9804583e18ef636 diff --git a/source/renderpass.cpp b/source/renderpass.cpp index 9e5b71d9..835e78a6 100644 --- a/source/renderpass.cpp +++ b/source/renderpass.cpp @@ -1,182 +1,275 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include #include -#include +#include +#include "error.h" #include "material.h" #include "renderpass.h" #include "program.h" #include "programdata.h" +#include "renderer.h" #include "texture.h" +#include "texture2d.h" +#include "texturing.h" using namespace std; namespace Msp { namespace GL { -const RenderPass *RenderPass::current=0; - RenderPass::RenderPass(): shprog(0), + shprog_from_material(false), shdata(0), - own_material(false), - material(0) + material(0), + texturing(0), + back_faces(false) { } RenderPass::RenderPass(const RenderPass &other): shprog(other.shprog), - shdata(other.shdata ? new ProgramData(*other.shdata) : 0), - own_material(other.own_material), - material(own_material ? new Material(*other.material) : other.material), - textures(other.textures) + shprog_from_material(other.shprog_from_material), + shdata(other.shdata), + uniform_slots(other.uniform_slots), + material(other.material), + material_slot(other.material_slot), + texturing(other.texturing ? new Texturing(*other.texturing) : 0), + tex_names(other.tex_names), + back_faces(other.back_faces) { } -RenderPass::~RenderPass() +RenderPass &RenderPass::operator=(const RenderPass &other) { - delete shdata; - if(own_material) - delete material; + shprog = other.shprog; + shprog_from_material = other.shprog_from_material; + shdata = other.shdata; + uniform_slots = other.uniform_slots; + material = other.material; + material_slot = other.material_slot; + texturing = other.texturing ? new Texturing(*other.texturing) : 0; + tex_names = other.tex_names; + back_faces = other.back_faces; + return *this; } -void RenderPass::set_material(const Material *mat) +RenderPass::~RenderPass() { - material=mat; + delete texturing; } -unsigned RenderPass::get_texture_index(const string &slot) const +void RenderPass::finalize_material(DataFile::Collection *coll) { - for(unsigned i=0; iattach_textures_to(*texturing, *shdata); } -void RenderPass::set_texture(const string &slot, const Texture *tex) +void RenderPass::maybe_create_material_shader(DataFile::Collection *coll) { - textures[get_texture_index(slot)]=tex; -} - -void RenderPass::bind() const -{ - if(this==current) + if(shprog && !shprog_from_material) return; - const RenderPass *old=current; - current=this; - - if(shprog) + if(coll) { - shprog->bind(); - shdata->apply(); + shprog = material->create_compatible_shader(*coll); + shprog.keep(); } - else if(old && !old->shprog) - GL::Program::unbind(); + else + shprog = material->create_compatible_shader(); + + if(shdata) + shdata = new ProgramData(*shdata, shprog.get()); + + shprog_from_material = true; +} + +void RenderPass::ensure_private_shader_data() +{ + if(!shprog) + throw invalid_operation("RenderPass::ensure_private_shader_data"); + if(!shdata) + shdata = new ProgramData(shprog.get()); + else if(shdata.refcount()>1) + shdata = new ProgramData(*shdata); +} + +void RenderPass::set_shader_program(const Program *prog, const ProgramData *data) +{ + shprog = prog; + shprog.keep(); + shprog_from_material = false; + shdata = (data ? new ProgramData(*data) : 0); if(material) - material->bind(); - else if(old && !old->material) - GL::Material::unbind(); - - for(unsigned i=0; ibind_to(i); - if(old) + finalize_material(0); +} + +const string &RenderPass::get_slotted_uniform_name(const string &slot) const +{ + map::const_iterator i = uniform_slots.find(slot); + if(i==uniform_slots.end()) { - for(unsigned i=textures.size(); itextures.size(); ++i) - GL::Texture::unbind_from(i); + static string empty; + return empty; } + return i->second; } -void RenderPass::unbind() +void RenderPass::set_material(const Material *mat) { - if(current) - { - if(current->shprog) - GL::Program::unbind(); + material = mat; + material.keep(); + finalize_material(0); +} - if(current->material) - GL::Material::unbind(); +void RenderPass::set_texture(unsigned index, const Texture *tex) +{ + if(!texturing) + texturing = new Texturing; - for(unsigned i=current->textures.size(); i--; ) - GL::Texture::unbind_from(i); + texturing->attach(index, *tex, texturing->get_attached_sampler(index)); +} - current=0; - } +int RenderPass::get_texture_index(const string &n) const +{ + map::const_iterator i = tex_names.find(n); + if(i==tex_names.end()) + return -1; + return i->second; +} + +void RenderPass::apply(Renderer &renderer) const +{ + renderer.set_texturing(texturing); + renderer.set_material(material.get()); + renderer.set_shader_program(shprog.get(), shdata.get()); + renderer.set_reverse_winding(back_faces); } +RenderPass::Loader::Loader(RenderPass &p): + DataFile::CollectionObjectLoader(p, 0) +{ + init(); +} + RenderPass::Loader::Loader(RenderPass &p, Collection &c): DataFile::CollectionObjectLoader(p, &c) { - allow_pointer_reload=false; + init(); +} - add("shader", &RenderPass::shprog); +void RenderPass::Loader::init() +{ + add("shader", &Loader::shader); + add("material", &Loader::material_inline); add("material", &Loader::material); - add("material", &RenderPass::material); - add("texture", &Loader::texture); + add("material_slot", &RenderPass::material_slot); + add("back_faces",&RenderPass::back_faces); + add("texunit", &Loader::texunit); + add("texunit", &Loader::texunit_auto); + add("texunit", &Loader::texunit_named); add("uniforms", &Loader::uniforms); + add("uniform_slot", &Loader::uniform_slot); + add("uniform_slot", &Loader::uniform_slot2); } -void RenderPass::Loader::finish() +void RenderPass::Loader::material_inline() { - if(obj.shprog) - { - if(!obj.shdata) - obj.shdata=new ProgramData; - - for(unsigned i=0; iget_uniform_location(obj.textures[i].name); - obj.shdata->uniform(loc, static_cast(i)); - } - } + Material::GenericLoader ldr(coll); + load_sub_with(ldr); + obj.material = ldr.get_material(); + obj.finalize_material(coll); } -void RenderPass::Loader::material() +void RenderPass::Loader::material(const string &name) { + obj.material = &get_collection().get(name); + obj.material.keep(); + obj.finalize_material(coll); +} + +void RenderPass::Loader::shader(const string &n) +{ + obj.shprog = &get_collection().get(n); + obj.shprog.keep(); + obj.shprog_from_material = false; + if(obj.shdata) + obj.shdata = new ProgramData(*obj.shdata, obj.shprog.get()); if(obj.material) - throw InvalidState("A material is already loaded"); + obj.finalize_material(coll); +} + +void RenderPass::Loader::texunit(unsigned i) +{ + if(!obj.texturing) + obj.texturing = new Texturing; + TextureLoader ldr(*obj.texturing, i, coll); + load_sub_with(ldr); +} - RefPtr mat=new Material; - load_sub(*mat); - obj.material=mat.release(); - obj.own_material=true; +void RenderPass::Loader::texunit_auto(const string &n) +{ + if(!obj.texturing) + obj.texturing = new Texturing; + int i = obj.texturing->find_free_unit(n); + if(i<0) + throw runtime_error("no free texunit"); + texunit_named(i, n); } -void RenderPass::Loader::texture(const string &n) +void RenderPass::Loader::texunit_named(unsigned i, const string &n) { - const Texture *tex=(n.empty() ? 0 : get_collection().get(n)); - TextureSlot slot(tex); - slot.name=(obj.textures.empty() ? "texture" : format("texture%d", obj.textures.size())); - load_sub(slot); - obj.textures.push_back(slot); + texunit(i); + obj.tex_names[n] = i; + obj.ensure_private_shader_data(); + obj.shdata->uniform(n, static_cast(i)); } void RenderPass::Loader::uniforms() { - if(!obj.shprog) - throw InvalidState("Can't load uniforms without a shader program"); - if(!obj.shdata) - obj.shdata=new ProgramData; - load_sub(*obj.shdata, *obj.shprog); + obj.ensure_private_shader_data(); + load_sub(*obj.shdata); } +void RenderPass::Loader::uniform_slot(const string &name) +{ + uniform_slot2(name, name); +} -RenderPass::TextureSlot::TextureSlot(const Texture *t): - texture(t) -{ } +void RenderPass::Loader::uniform_slot2(const string &name, const string &slot) +{ + obj.uniform_slots[slot] = name; +} -RenderPass::TextureSlot::Loader::Loader(TextureSlot &s): - DataFile::ObjectLoader(s) +RenderPass::TextureLoader::TextureLoader(Texturing &t, unsigned i, Collection *c): + DataFile::CollectionObjectLoader(t, c), + index(i), + tex(0), + samp(0) +{ + add("sampler", &TextureLoader::sampler); + add("texture", &TextureLoader::texture); +} + +void RenderPass::TextureLoader::finish() +{ + if(tex) + obj.attach(index, *tex, samp); + else if(samp) + obj.attach(index, *samp); +} + +void RenderPass::TextureLoader::sampler(const string &name) +{ + samp = &get_collection().get(name); +} + +void RenderPass::TextureLoader::texture(const string &name) { - add("name", &TextureSlot::name); + tex = &get_collection().get(name); } } // namespace GL