X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Frenderer.cpp;h=3bef74b34039aa1db1db907eb648eff17ae69771;hb=f632bf388a58b036e265f3789c797beff5ab063a;hp=5108ff4c8a48b26ba1283bb66027d4cc17899a56;hpb=9d6c244eb728336c64ee23d5c55e45c6696aa65c;p=libs%2Fgl.git diff --git a/source/renderer.cpp b/source/renderer.cpp index 5108ff4c..3bef74b3 100644 --- a/source/renderer.cpp +++ b/source/renderer.cpp @@ -1,6 +1,7 @@ #include "batch.h" #include "buffer.h" #include "camera.h" +#include "clipping.h" #include "error.h" #include "lighting.h" #include "material.h" @@ -11,6 +12,7 @@ #include "renderer.h" #include "texture.h" #include "texturing.h" +#include "texunit.h" #include "vertexarray.h" #include "windingtest.h" @@ -20,46 +22,55 @@ namespace Msp { namespace GL { Renderer::Renderer(const Camera *c): - mtx_stack(*this), - mtx_changed(false), - camera(c), - state_stack(1), - lighting_changed(false), - element_buffer(0) + changed(0), + matrices_loaded(false), + shdata_applied(0), + camera(0), + state_stack(1) { state_stack.reserve(16); shdata_stack.reserve(32); state = &state_stack.back(); - MatrixStack::modelview().push(); + begin(c); +} + +Renderer::~Renderer() +{ + end(); +} + +void Renderer::begin(const Camera *c) +{ + if(state_stack.size()>1) + throw invalid_operation("Renderer::begin"); + + reset_state(); + excluded.clear(); + camera = c; + if(camera) { - MatrixStack::projection().push(); - camera->apply(); - mtx_stack.load(camera->get_matrix()); + state->modelview_matrix = camera->get_view_matrix(); standard_shdata.uniform("projection_matrix", camera->get_projection_matrix()); } else { + state->modelview_matrix = MatrixStack::modelview().top(); standard_shdata.uniform("projection_matrix", MatrixStack::projection().top()); - mtx_stack.load(MatrixStack::modelview().top()); } } -Renderer::~Renderer() +void Renderer::set_matrix(const Matrix &matrix) { - if(camera) - MatrixStack::projection().pop(); - MatrixStack::modelview().pop(); + state->modelview_matrix = matrix; + changed |= MATRIX; +} - Mesh::unbind(); - Texturing::unbind(); - Texture::unbind_from(0); - Material::unbind(); - Lighting::unbind(); - Program::unbind(); - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); - WindingTest::unbind(); +void Renderer::transform(const Matrix &matrix) +{ + state->modelview_matrix *= matrix; + changed |= MATRIX; } void Renderer::set_texture(const Texture *t) @@ -74,20 +85,36 @@ void Renderer::set_texturing(const Texturing *t) state->texture = 0; } +unsigned Renderer::allocate_effect_texunit() +{ + return --state->lowest_effect_texunit; +} + void Renderer::set_material(const Material *m) { state->material = m; + changed |= MATERIAL_SHDATA; } void Renderer::set_lighting(const Lighting *l) { state->lighting = l; - state->lighting_matrix = mtx_stack.top(); + state->lighting_matrix = state->modelview_matrix; if(l) - /* XXX I'm not happy with this, but can't come up with anything better - right now. */ - const_cast(l)->update_shader_data(mtx_stack.top()); - lighting_changed = true; + { + l->update_shader_data(standard_shdata, state->lighting_matrix); + changed |= STANDARD_SHDATA; + } + changed |= LEGACY_LIGHTING; +} + +void Renderer::set_clipping(const Clipping *c) +{ + state->clipping = c; + state->clipping_matrix = state->modelview_matrix; + if(c) + c->update_shader_data(standard_shdata, state->clipping_matrix); + changed |= LEGACY_CLIPPING; } void Renderer::set_shader_program(const Program *p, const ProgramData *d) @@ -95,17 +122,13 @@ void Renderer::set_shader_program(const Program *p, const ProgramData *d) state->shprog = p; if(p && d) add_shader_data(*d); - - /* Even if we have no new shdata, the existing ones need to be re-applied - to the new program */ - shdata_changed = true; } void Renderer::add_shader_data(const ProgramData &d) { shdata_stack.push_back(&d); state->shdata_count = shdata_stack.size(); - shdata_changed = true; + changed |= SHADER_DATA; } void Renderer::set_mesh(const Mesh *m) @@ -113,11 +136,6 @@ void Renderer::set_mesh(const Mesh *m) state->mesh = m; } -void Renderer::set_element_buffer(const Buffer *b) -{ - element_buffer = b; -} - void Renderer::set_winding_test(const WindingTest *w) { state->winding_test = w; @@ -132,7 +150,6 @@ void Renderer::push_state() { state_stack.push_back(state_stack.back()); state = &state_stack.back(); - mtx_stack.push(); } void Renderer::pop_state() @@ -140,19 +157,54 @@ void Renderer::pop_state() if(state_stack.size()==1) throw stack_underflow("Renderer::pop_state"); + const Lighting *old_lighting = state->lighting; + const Clipping *old_clipping = state->clipping; state_stack.pop_back(); state = &state_stack.back(); if(shdata_stack.size()>state->shdata_count) + { shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end()); - mtx_stack.pop(); - mtx_changed = true; - shdata_changed = true; + changed |= SHADER_DATA; + } + shdata_applied = min(shdata_applied, shdata_stack.size()); + changed |= MATRIX; + if(state->lighting!=old_lighting) + { + if(state->lighting) + state->lighting->update_shader_data(standard_shdata, state->lighting_matrix); + changed |= LEGACY_LIGHTING; + } + if(state->clipping!=old_clipping) + { + if(state->clipping) + state->clipping->update_shader_data(standard_shdata, state->clipping_matrix); + changed |= LEGACY_CLIPPING; + } } void Renderer::escape() { apply_state(); Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); + matrices_loaded = false; +} + +void Renderer::end() +{ + if(state_stack.size()>1) + throw invalid_operation("Renderer::end"); + + reset_state(); + + Mesh::unbind(); + Texturing::unbind(); + Texture::unbind_from(0); + Material::unbind(); + Lighting::unbind(); + Clipping::unbind(); + Program::unbind(); + Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); + WindingTest::unbind(); } void Renderer::exclude(const Renderable &renderable) @@ -176,10 +228,10 @@ void Renderer::draw(const Batch &batch) apply_state(); bool legacy_bindings = (!state->shprog || state->shprog->uses_legacy_variables()); - if(legacy_bindings) + if(state->mesh && legacy_bindings) { - if(element_buffer) - element_buffer->bind_to(ELEMENT_ARRAY_BUFFER); + if(const Buffer *ibuf = state->mesh->get_index_buffer()) + ibuf->bind_to(ELEMENT_ARRAY_BUFFER); else Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); } @@ -212,46 +264,74 @@ void Renderer::apply_state() else Material::unbind(); - if(lighting_changed) + if(changed&LEGACY_LIGHTING) { if(state->lighting) { MatrixStack::modelview() = state->lighting_matrix; state->lighting->bind(); - mtx_changed = true; - lighting_changed = false; + changed = (changed&~LEGACY_LIGHTING)|LEGACY_MATRIX; } else Lighting::unbind(); } } + if(state->clipping) + { + if(legacy_bindings) + { + if(changed&LEGACY_CLIPPING) + { + MatrixStack::modelview() = state->clipping_matrix; + state->clipping->bind(true); + changed = (changed&~LEGACY_CLIPPING)|LEGACY_MATRIX; + } + } + else + state->clipping->bind(false); + } + else + Clipping::unbind(); + if(state->shprog) { + bool shprog_changed = (state->shprog!=Program::current()); state->shprog->bind(); if(!legacy_bindings) { - const Matrix &m = mtx_stack.top(); - standard_shdata.uniform("eye_obj_matrix", mtx_stack.top()); - LinAl::SquareMatrix nm; - for(unsigned i=0; i<3; ++i) - for(unsigned j=0; j<3; ++j) - nm(i, j) = m(i, j); - nm = transpose(invert(nm)); - standard_shdata.uniform_matrix3("eye_obj_normal_matrix", &nm(0, 0)); - if(state->lighting) - state->lighting->get_shader_data().apply(); - if(state->material) + if(changed&MODERN_MATRIX) + { + standard_shdata.uniform("eye_obj_matrix", state->modelview_matrix); + LinAl::SquareMatrix nm = state->modelview_matrix.block<3, 3>(0, 0); + nm = transpose(invert(nm)); + standard_shdata.uniform_matrix3("eye_obj_normal_matrix", &nm(0, 0)); + changed = (changed&~MODERN_MATRIX)|STANDARD_SHDATA; + } + + if(state->material && (changed&MATERIAL_SHDATA)) + { state->material->get_shader_data().apply(); - standard_shdata.apply(); + changed &= ~MATERIAL_SHDATA; + } + + if(changed&STANDARD_SHDATA) + { + standard_shdata.apply(); + changed &= ~STANDARD_SHDATA; + } } - if(shdata_changed) + if((changed&SHADER_DATA) || shprog_changed) { - for(vector::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i) + vector::const_iterator i = shdata_stack.begin(); + if(!shprog_changed) + i += shdata_applied; + for(; i!=shdata_stack.end(); ++i) (*i)->apply(); - shdata_changed = false; + changed &= ~SHADER_DATA; + shdata_applied = shdata_stack.size(); } } else @@ -280,34 +360,55 @@ void Renderer::apply_state() else WindingTest::unbind(); - if(legacy_bindings && mtx_changed) + if(legacy_bindings) { - MatrixStack::modelview() = mtx_stack.top(); - mtx_changed = false; + if(!matrices_loaded) + { + MatrixStack::modelview().push(); + if(camera) + { + MatrixStack::projection().push(); + camera->apply(); + } + matrices_loaded = true; + } + + if(changed&LEGACY_MATRIX) + { + MatrixStack::modelview() = state->modelview_matrix; + changed &= ~LEGACY_MATRIX; + } } } +void Renderer::reset_state() +{ + if(!matrices_loaded) + return; + + if(camera) + MatrixStack::projection().pop(); + MatrixStack::modelview().pop(); + matrices_loaded = false; + changed |= MATRIX; + + *state = State(); +} + Renderer::State::State(): texture(0), texturing(0), + lowest_effect_texunit(TexUnit::get_n_units()), material(0), lighting(0), + clipping(0), shprog(0), shdata_count(0), mesh(0), - winding_test(0) + winding_test(0), + reverse_winding(false) { } - -Renderer::MtxStack::MtxStack(Renderer &r): - renderer(r) -{ } - -void Renderer::MtxStack::update() -{ - renderer.mtx_changed = true; -} - } // namespace GL } // namespace Msp