X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Frenderer.cpp;h=302d943727a2812e66bd6b85f748f398117bd4d9;hb=a40fc85277dba5c34402a0e703d038efd30cc57b;hp=2f253e2ab8c4f96471d3bf8e1491e450910f4bef;hpb=d41ec7dfaa635bbaea9e902d5f5c60bd4a887891;p=libs%2Fgl.git diff --git a/source/renderer.cpp b/source/renderer.cpp index 2f253e2a..302d9437 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" @@ -13,6 +14,7 @@ #include "texturing.h" #include "texunit.h" #include "vertexarray.h" +#include "vertexsetup.h" #include "windingtest.h" using namespace std; @@ -21,27 +23,20 @@ namespace Msp { namespace GL { Renderer::Renderer(const Camera *c): - mtx_stack(*this), - changed(MATRIX), - matrices_loaded(false), - shdata_applied(0), - camera(c), - state_stack(1), - element_buffer(0) + default_camera(c), + changed(0), + state_stack(1) { state_stack.reserve(16); shdata_stack.reserve(32); state = &state_stack.back(); - if(camera) - { - mtx_stack.load(camera->get_matrix()); - standard_shdata.uniform("projection_matrix", camera->get_projection_matrix()); - } + if(c) + set_camera(*c); else { - standard_shdata.uniform("projection_matrix", MatrixStack::projection().top()); - mtx_stack.load(MatrixStack::modelview().top()); + standard_shdata.uniform("projection_matrix", Matrix()); + standard_shdata.uniform("eye_world_matrix", Matrix()); } } @@ -50,6 +45,34 @@ Renderer::~Renderer() end(); } +void Renderer::begin(const Camera *c) +{ + end(); + if(c) + set_camera(*c); +} + +void Renderer::set_camera(const Camera &c) +{ + state->camera = &c; + standard_shdata.uniform("projection_matrix", state->camera->get_projection_matrix()); + standard_shdata.uniform("eye_world_matrix", state->camera->get_view_matrix()); + changed |= STANDARD_SHDATA; + set_matrix(state->camera->get_view_matrix()); +} + +void Renderer::set_matrix(const Matrix &matrix) +{ + state->modelview_matrix = matrix; + changed |= MATRIX; +} + +void Renderer::transform(const Matrix &matrix) +{ + state->modelview_matrix *= matrix; + changed |= MATRIX; +} + void Renderer::set_texture(const Texture *t) { state->texture = t; @@ -70,15 +93,29 @@ unsigned Renderer::allocate_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) - l->update_shader_data(standard_shdata, mtx_stack.top()); - changed |= LIGHTING; + { + l->update_shader_data(standard_shdata, state->lighting_matrix); + changed |= STANDARD_SHDATA; + } +} + +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 |= STANDARD_SHDATA; + } } void Renderer::set_shader_program(const Program *p, const ProgramData *d) @@ -90,9 +127,21 @@ void Renderer::set_shader_program(const Program *p, const ProgramData *d) void Renderer::add_shader_data(const ProgramData &d) { - shdata_stack.push_back(&d); - state->shdata_count = shdata_stack.size(); - changed |= SHADER_DATA; + if(state->shdata_countshdata_count]==&d) + ++state->shdata_count; + else + { + flush_shader_data(); + shdata_stack.push_back(&d); + state->shdata_count = shdata_stack.size(); + changed |= SHADER_DATA; + } +} + +void Renderer::flush_shader_data() +{ + if(shdata_stack.size()>state->shdata_count) + shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end()); } void Renderer::set_mesh(const Mesh *m) @@ -100,9 +149,9 @@ void Renderer::set_mesh(const Mesh *m) state->mesh = m; } -void Renderer::set_element_buffer(const Buffer *b) +void Renderer::set_vertex_setup(const VertexSetup *vs) { - element_buffer = b; + state->vertex_setup = vs; } void Renderer::set_winding_test(const WindingTest *w) @@ -115,11 +164,15 @@ void Renderer::set_reverse_winding(bool r) state->reverse_winding = r; } +void Renderer::set_object_lod_bias(unsigned b) +{ + state->object_lod_bias = b; +} + void Renderer::push_state() { state_stack.push_back(state_stack.back()); state = &state_stack.back(); - mtx_stack.push(); } void Renderer::pop_state() @@ -127,30 +180,46 @@ void Renderer::pop_state() if(state_stack.size()==1) throw stack_underflow("Renderer::pop_state"); + const Camera *old_camera = state->camera; 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) + changed |= MATRIX; + bool camera_changed = (state->camera!=old_camera); + if(camera_changed) { - shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end()); - changed |= SHADER_DATA; + if(state->camera) + { + standard_shdata.uniform("projection_matrix", state->camera->get_projection_matrix()); + standard_shdata.uniform("eye_world_matrix", state->camera->get_view_matrix()); + } + else + { + standard_shdata.uniform("projection_matrix", Matrix()); + standard_shdata.uniform("eye_world_matrix", Matrix()); + } + changed |= STANDARD_SHDATA; } - shdata_applied = min(shdata_applied, shdata_stack.size()); - mtx_stack.pop(); - changed |= MATRIX; - if(state->lighting!=old_lighting) + /* This actually should compare the relevant matrices rather than check for + camera, but in practice lighting and clipping is set right after the camera + and a boolean check is much faster than matrix comparison. */ + if(state->lighting!=old_lighting || camera_changed) { if(state->lighting) + { state->lighting->update_shader_data(standard_shdata, state->lighting_matrix); - changed |= LIGHTING; + changed |= STANDARD_SHDATA; + } + } + if(state->clipping!=old_clipping || camera_changed) + { + if(state->clipping) + { + state->clipping->update_shader_data(standard_shdata, state->clipping_matrix); + changed |= STANDARD_SHDATA; + } } -} - -void Renderer::escape() -{ - apply_state(); - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); - matrices_loaded = false; } void Renderer::end() @@ -158,24 +227,22 @@ void Renderer::end() if(state_stack.size()>1) throw invalid_operation("Renderer::end"); - if(matrices_loaded) - { - if(camera) - MatrixStack::projection().pop(); - MatrixStack::modelview().pop(); - matrices_loaded = false; - } + *state = State(); + if(default_camera) + set_camera(*default_camera); + else + standard_shdata.uniform("projection_matrix", Matrix()); + shdata_stack.clear(); + excluded.clear(); Mesh::unbind(); Texturing::unbind(); Texture::unbind_from(0); - Material::unbind(); - Lighting::unbind(); + Clipping::unbind(); Program::unbind(); + VertexSetup::unbind(); Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); WindingTest::unbind(); - - *state = State(); } void Renderer::exclude(const Renderable &renderable) @@ -198,25 +265,21 @@ void Renderer::draw(const Batch &batch) { apply_state(); - bool legacy_bindings = (!state->shprog || state->shprog->uses_legacy_variables()); - if(legacy_bindings) - { - if(element_buffer) - element_buffer->bind_to(ELEMENT_ARRAY_BUFFER); - else - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); - } - batch.draw(); } +void Renderer::draw_instanced(const Batch &batch, unsigned count) +{ + apply_state(); + + batch.draw_instanced(count); +} + void Renderer::apply_state() { /* We (mostly) let the objects themselves figure out if the binding has changed */ - bool legacy_bindings = (!state->shprog || state->shprog->uses_legacy_variables()); - if(state->texturing) state->texturing->bind(); else @@ -228,77 +291,62 @@ void Renderer::apply_state() Texture::unbind_from(0); } - if(legacy_bindings) - { - if(state->material) - state->material->bind(); - else - Material::unbind(); - - if(changed&LIGHTING) - { - if(state->lighting) - { - MatrixStack::modelview() = state->lighting_matrix; - state->lighting->bind(); - changed = (changed&~LIGHTING)|LEGACY_MATRIX; - } - else - Lighting::unbind(); - } - } + if(state->clipping) + state->clipping->bind(); + else + Clipping::unbind(); if(state->shprog) { bool shprog_changed = (state->shprog!=Program::current()); state->shprog->bind(); - if(!legacy_bindings) + if(changed&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&~MATRIX)|STANDARD_SHDATA; + } + + if(state->material && ((changed&MATERIAL_SHDATA) || shprog_changed)) + { + state->material->get_shader_data().apply(); + changed &= ~MATERIAL_SHDATA; + } + + if((changed&STANDARD_SHDATA) || shprog_changed) { - if(changed&MODERN_MATRIX) - { - 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)); - changed &= ~MODERN_MATRIX; - } - - if(state->material) - state->material->get_shader_data().apply(); standard_shdata.apply(); + changed &= ~STANDARD_SHDATA; } - if((changed&SHADER_DATA) || shprog_changed) + bool extra_shdata = (shdata_stack.size()>state->shdata_count); + + if((changed&SHADER_DATA) || shprog_changed || extra_shdata) { - vector::const_iterator i = shdata_stack.begin(); - if(!shprog_changed) - i += shdata_applied; - for(; i!=shdata_stack.end(); ++i) + if(extra_shdata) + shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end()); + for(vector::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i) (*i)->apply(); changed &= ~SHADER_DATA; - shdata_applied = shdata_stack.size(); } } else Program::unbind(); if(state->mesh) + state->mesh->bind(); + else { - if(legacy_bindings) - { - Mesh::unbind(); - state->mesh->get_vertices().apply(); - } + Mesh::unbind(); + + if(state->vertex_setup) + state->vertex_setup->bind(); else - state->mesh->bind(); + VertexSetup::unbind(); } - else - Mesh::unbind(); if(state->winding_test) { @@ -309,51 +357,25 @@ void Renderer::apply_state() } else WindingTest::unbind(); - - if(legacy_bindings) - { - if(!matrices_loaded) - { - MatrixStack::modelview().push(); - if(camera) - { - MatrixStack::projection().push(); - camera->apply(); - } - matrices_loaded = true; - } - - if(changed&LEGACY_MATRIX) - { - MatrixStack::modelview() = mtx_stack.top(); - changed &= ~LEGACY_MATRIX; - } - } } Renderer::State::State(): + camera(0), texture(0), texturing(0), lowest_effect_texunit(TexUnit::get_n_units()), material(0), lighting(0), + clipping(0), shprog(0), shdata_count(0), mesh(0), + vertex_setup(0), winding_test(0), - reverse_winding(false) + reverse_winding(false), + object_lod_bias(0) { } - -Renderer::MtxStack::MtxStack(Renderer &r): - renderer(r) -{ } - -void Renderer::MtxStack::update() -{ - renderer.changed |= MATRIX; -} - } // namespace GL } // namespace Msp