More efficient stack management

Vectors are better than lists, since they don't need to allocate new
memory for every element.  A suitably sized reserve() does away with any
initial reallocations in most cases.

ProgramData in Renderer can be stored in a semi-independent stack as
well, since it can only be removed with a pop.  State is now devoid of
dynamically allocated memory, making the stack operations even faster.

diff --git a/source/matrix.cpp b/source/matrix.cpp
index 549fe8b61578ecf94958e2650519aea7579a8e00..b7f76bc77528965fcff8f15ef90b353cf3dd836b 100644 (file)
--- a/source/matrix.cpp
+++ b/source/matrix.cpp
@@ -278,12 +278,14 @@ GLenum MatrixStack::current_mode = GL_MODELVIEW;
 MatrixStack::MatrixStack(GLenum m):
        mode(m)
 {
+       matrices.reserve(mode==GL_MODELVIEW ? 32 : 4);
        matrices.push_back(Matrix());
 }
 
 MatrixStack::MatrixStack():
        mode(0)
 {
+       matrices.reserve(32);
        matrices.push_back(Matrix());
 }
 

diff --git a/source/matrix.h b/source/matrix.h
index e32df7e3872ea6ea270ecfe0d13e8fe25db82d9c..5444b8b4e4fae1c1789077ea58eb2099a06d8e58 100644 (file)
--- a/source/matrix.h
+++ b/source/matrix.h
@@ -1,7 +1,7 @@
 #ifndef MSP_GL_MATRIX_H_
 #define MSP_GL_MATRIX_H_
 
-#include <list>
+#include <vector>
 #include "gl.h"
 #include "vector.h"
 
@@ -81,7 +81,7 @@ public:
 
 private:
        GLenum mode;
-       std::list<Matrix> matrices;
+       std::vector<Matrix> matrices;
 
        static GLenum current_mode;
 

diff --git a/source/renderer.cpp b/source/renderer.cpp
index c751b0e3629d77b8bd93fee9aa4049f3a75cc57f..94875084f65e2d7519be80e0bc76f5b06500f1b7 100644 (file)
--- a/source/renderer.cpp
+++ b/source/renderer.cpp
@@ -21,11 +21,14 @@ Renderer::Renderer(const Camera *c):
        mtx_changed(false),
        camera(c),
        state_stack(1),
-       state(&state_stack.back()),
        vertex_array(0),
        vertex_array_changed(false),
        element_buffer(0)
 {
+       state_stack.reserve(16);
+       shdata_stack.reserve(32);
+       state = &state_stack.back();
+
        MatrixStack::modelview().push();
        if(camera)
        {
@@ -73,12 +76,16 @@ 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)
 {
-       state->shdata.push_back(&d);
+       shdata_stack.push_back(&d);
+       state->shdata_count = shdata_stack.size();
        shdata_changed = true;
 }
 
@@ -112,6 +119,8 @@ void 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;
@@ -170,7 +179,7 @@ void Renderer::apply_state()
                state->shprog->bind();
                if(shdata_changed)
                {
-                       for(vector<const ProgramData *>::const_iterator i=state->shdata.begin(); i!=state->shdata.end(); ++i)
+                       for(vector<const ProgramData *>::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i)
                                (*i)->apply();
                        shdata_changed = false;
                }

diff --git a/source/renderer.h b/source/renderer.h
index 5536702b751a6d83288f14307eb6b6609b185dab..6115a7feeae33deadf6bb327f2d83703cd6f2d87 100644 (file)
--- a/source/renderer.h
+++ b/source/renderer.h
@@ -26,6 +26,11 @@ will often be more efficient.  This is especially true for ObjectInstances.
 The Renderer works by deferring GL state changes until something is actually
 being drawn.  This avoids many unnecessary GL calls if consecutive renderables
 use the same resources.
+
+A state stack is provided to help with state scoping.  Typically a Renderable
+will push the current state on entry, set whatever state it requires, render
+itself, and pop the state when it's done.  An RAII helper class is provided for
+the push/pop operation.
 */
 class Renderer
 {
@@ -47,7 +52,7 @@ private:
                const Texturing *texturing;
                const Material *material;
                const Program *shprog;
-               std::vector<const ProgramData *> shdata;
+               unsigned shdata_count;
                const WindingTest *winding_test;
 
                State();
@@ -67,12 +72,13 @@ private:
        MtxStack mtx_stack;
        bool mtx_changed;
        const Camera *camera;
-       std::list<State> state_stack;
+       std::vector<State> state_stack;
        State *state;
+       std::vector<const ProgramData *> shdata_stack;
+       bool shdata_changed;
        const VertexArray *vertex_array;
        bool vertex_array_changed;
        const Buffer *element_buffer;
-       bool shdata_changed;
 
 public:
        Renderer(const Camera *);
@@ -99,7 +105,11 @@ public:
        void set_element_buffer(const Buffer *);
        void set_winding_test(const WindingTest *);
 
+       /** Saves the current state so it can be restored later. */
        void push_state();
+
+       /** Restores a previously saved state.  Must be matched with an earlier
+       push_state call. */
        void pop_state();
 
        /** Prepares for temporarily bypassing the Renderer by synchronizing the