X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Frenderer.cpp;h=5108ff4c8a48b26ba1283bb66027d4cc17899a56;hb=9d6c244eb728336c64ee23d5c55e45c6696aa65c;hp=bfd446e9f42ccc30aa47306d26f6d535fe1b4ea9;hpb=90a26a1740d5843b60d07d9c39d8567bfed5189c;p=libs%2Fgl.git diff --git a/source/renderer.cpp b/source/renderer.cpp index bfd446e9..5108ff4c 100644 --- a/source/renderer.cpp +++ b/source/renderer.cpp @@ -1,21 +1,18 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2011 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include #include "batch.h" #include "buffer.h" #include "camera.h" +#include "error.h" +#include "lighting.h" #include "material.h" +#include "mesh.h" #include "program.h" #include "programdata.h" +#include "renderable.h" #include "renderer.h" #include "texture.h" #include "texturing.h" #include "vertexarray.h" +#include "windingtest.h" using namespace std; @@ -27,20 +24,26 @@ Renderer::Renderer(const Camera *c): mtx_changed(false), camera(c), state_stack(1), - state(&state_stack.back()), - vertex_array(0), - vertex_array_changed(false), + lighting_changed(false), element_buffer(0) { + state_stack.reserve(16); + shdata_stack.reserve(32); + state = &state_stack.back(); + MatrixStack::modelview().push(); if(camera) { MatrixStack::projection().push(); camera->apply(); mtx_stack.load(camera->get_matrix()); + standard_shdata.uniform("projection_matrix", camera->get_projection_matrix()); } else + { + standard_shdata.uniform("projection_matrix", MatrixStack::projection().top()); mtx_stack.load(MatrixStack::modelview().top()); + } } Renderer::~Renderer() @@ -49,11 +52,14 @@ Renderer::~Renderer() MatrixStack::projection().pop(); MatrixStack::modelview().pop(); + Mesh::unbind(); Texturing::unbind(); Texture::unbind_from(0); Material::unbind(); + Lighting::unbind(); Program::unbind(); Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); + WindingTest::unbind(); } void Renderer::set_texture(const Texture *t) @@ -73,27 +79,38 @@ void Renderer::set_material(const Material *m) state->material = m; } -void Renderer::set_shader(const Program *p, const ProgramData *d) +void Renderer::set_lighting(const Lighting *l) { - state->shprog = p; - if(d) - state->shdata.assign(1, d); - else - state->shdata.clear(); + state->lighting = l; + state->lighting_matrix = mtx_stack.top(); + 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; } -void Renderer::add_shader_data(const ProgramData *d) +void Renderer::set_shader_program(const Program *p, const ProgramData *d) { - if(!state->shprog) - throw InvalidState("No shader program"); + 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; +} - state->shdata.push_back(d); +void Renderer::add_shader_data(const ProgramData &d) +{ + shdata_stack.push_back(&d); + state->shdata_count = shdata_stack.size(); + shdata_changed = true; } -void Renderer::set_vertex_array(const VertexArray *a) +void Renderer::set_mesh(const Mesh *m) { - vertex_array_changed = (a!=vertex_array); - vertex_array = a; + state->mesh = m; } void Renderer::set_element_buffer(const Buffer *b) @@ -101,6 +118,16 @@ void Renderer::set_element_buffer(const Buffer *b) element_buffer = b; } +void Renderer::set_winding_test(const WindingTest *w) +{ + state->winding_test = w; +} + +void Renderer::set_reverse_winding(bool r) +{ + state->reverse_winding = r; +} + void Renderer::push_state() { state_stack.push_back(state_stack.back()); @@ -111,12 +138,15 @@ void Renderer::push_state() void Renderer::pop_state() { if(state_stack.size()==1) - throw InvalidState("Can't pop the last state"); + throw stack_underflow("Renderer::pop_state"); 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; } void Renderer::escape() @@ -125,28 +155,44 @@ void Renderer::escape() Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); } -void Renderer::draw(const Batch &batch) +void Renderer::exclude(const Renderable &renderable) { - if(!vertex_array) - throw InvalidState("Can't draw without a vertex array"); + excluded.insert(&renderable); +} - apply_state(); +void Renderer::include(const Renderable &renderable) +{ + excluded.erase(&renderable); +} - // Until VertexArray acquires VAO support and becomes Bindable - if(vertex_array_changed) - vertex_array->apply(); +void Renderer::render(const Renderable &renderable, const Tag &tag) +{ + if(!excluded.count(&renderable)) + renderable.render(*this, tag); +} - if(element_buffer) - element_buffer->bind_to(ELEMENT_ARRAY_BUFFER); - else - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); +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::apply_state() { - // We let the objects themselves figure out if the binding has changed + /* 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(); @@ -159,21 +205,82 @@ void Renderer::apply_state() Texture::unbind_from(0); } - if(state->material) - state->material->bind(); - else - Material::unbind(); + if(legacy_bindings) + { + if(state->material) + state->material->bind(); + else + Material::unbind(); + + if(lighting_changed) + { + if(state->lighting) + { + MatrixStack::modelview() = state->lighting_matrix; + state->lighting->bind(); + mtx_changed = true; + lighting_changed = false; + } + else + Lighting::unbind(); + } + } if(state->shprog) { state->shprog->bind(); - for(vector::const_iterator i=state->shdata.begin(); i!=state->shdata.end(); ++i) - (*i)->apply(); + + 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) + state->material->get_shader_data().apply(); + standard_shdata.apply(); + } + + if(shdata_changed) + { + for(vector::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i) + (*i)->apply(); + shdata_changed = false; + } } else Program::unbind(); - if(mtx_changed) + if(state->mesh) + { + if(legacy_bindings) + { + Mesh::unbind(); + state->mesh->get_vertices().apply(); + } + else + state->mesh->bind(); + } + else + Mesh::unbind(); + + if(state->winding_test) + { + if(state->reverse_winding) + state->winding_test->get_reverse().bind(); + else + state->winding_test->bind(); + } + else + WindingTest::unbind(); + + if(legacy_bindings && mtx_changed) { MatrixStack::modelview() = mtx_stack.top(); mtx_changed = false; @@ -185,7 +292,11 @@ Renderer::State::State(): texture(0), texturing(0), material(0), - shprog(0) + lighting(0), + shprog(0), + shdata_count(0), + mesh(0), + winding_test(0) { }