Add some accessors to View

[libs/gl.git] / source / renderer.cpp

diff --git a/source/renderer.cpp b/source/renderer.cpp
index 2f253e2ab8c4f96471d3bf8e1491e450910f4bef..8daa13ce414bbc508a6924064ac282392a7bfb5c 100644 (file)
--- 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"
@@ -22,17 +23,33 @@ namespace GL {
 
 Renderer::Renderer(const Camera *c):
        mtx_stack(*this),
-       changed(MATRIX),
+       changed(0),
        matrices_loaded(false),
        shdata_applied(0),
-       camera(c),
-       state_stack(1),
-       element_buffer(0)
+       camera(0),
+       state_stack(1)
 {
        state_stack.reserve(16);
        shdata_stack.reserve(32);
        state = &state_stack.back();
 
+       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)
        {
                mtx_stack.load(camera->get_matrix());
@@ -40,14 +57,19 @@ Renderer::Renderer(const Camera *c):
        }
        else
        {
-               standard_shdata.uniform("projection_matrix", MatrixStack::projection().top());
                mtx_stack.load(MatrixStack::modelview().top());
+               standard_shdata.uniform("projection_matrix", MatrixStack::projection().top());
        }
 }
 
-Renderer::~Renderer()
+void Renderer::set_matrix(const Matrix &matrix)
 {
-       end();
+       mtx_stack.load(matrix);
+}
+
+void Renderer::transform(const Matrix &matrix)
+{
+       mtx_stack *= matrix;
 }
 
 void Renderer::set_texture(const Texture *t)
@@ -81,6 +103,15 @@ void Renderer::set_lighting(const Lighting *l)
        changed |= LIGHTING;
 }
 
+void Renderer::set_clipping(const Clipping *c)
+{
+       state->clipping = c;
+       state->clipping_matrix = mtx_stack.top();
+       if(c)
+               c->update_shader_data(standard_shdata, mtx_stack.top());
+       changed |= CLIPPING;
+}
+
 void Renderer::set_shader_program(const Program *p, const ProgramData *d)
 {
        state->shprog = p;
@@ -100,11 +131,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;
@@ -128,6 +154,7 @@ void Renderer::pop_state()
                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)
@@ -144,6 +171,12 @@ void Renderer::pop_state()
                        state->lighting->update_shader_data(standard_shdata, state->lighting_matrix);
                changed |= LIGHTING;
        }
+       if(state->clipping!=old_clipping)
+       {
+               if(state->clipping)
+                       state->clipping->update_shader_data(standard_shdata, state->clipping_matrix);
+               changed |= CLIPPING;
+       }
 }
 
 void Renderer::escape()
@@ -158,24 +191,17 @@ 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;
-       }
+       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();
-
-       *state = State();
 }
 
 void Renderer::exclude(const Renderable &renderable)
@@ -199,10 +225,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);
        }
@@ -248,6 +274,23 @@ void Renderer::apply_state()
                }
        }
 
+       if(state->clipping)
+       {
+               if(legacy_bindings)
+               {
+                       if(changed&CLIPPING)
+                       {
+                               MatrixStack::modelview() = state->clipping_matrix;
+                               state->clipping->bind(true);
+                               changed = (changed&~CLIPPING)|LEGACY_MATRIX;
+                       }
+               }
+               else
+                       state->clipping->bind(false);
+       }
+       else
+               Clipping::unbind();
+
        if(state->shprog)
        {
                bool shprog_changed = (state->shprog!=Program::current());
@@ -259,10 +302,7 @@ void Renderer::apply_state()
                        {
                                const Matrix &m = mtx_stack.top();
                                standard_shdata.uniform("eye_obj_matrix", mtx_stack.top());
-                               LinAl::SquareMatrix<float, 3> nm;
-                               for(unsigned i=0; i<3; ++i)
-                                       for(unsigned j=0; j<3; ++j)
-                                               nm(i, j) = m(i, j);
+                               LinAl::SquareMatrix<float, 3> nm = m.block<3, 3>(0, 0);
                                nm = transpose(invert(nm));
                                standard_shdata.uniform_matrix3("eye_obj_normal_matrix", &nm(0, 0));
                                changed &= ~MODERN_MATRIX;
@@ -331,6 +371,20 @@ void Renderer::apply_state()
        }
 }
 
+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),
@@ -338,6 +392,7 @@ Renderer::State::State():
        lowest_effect_texunit(TexUnit::get_n_units()),
        material(0),
        lighting(0),
+       clipping(0),
        shprog(0),
        shdata_count(0),
        mesh(0),