Integrate modern shaders and VAOs with Renderer

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

diff --git a/source/renderer.h b/source/renderer.h
index 5536702b751a6d83288f14307eb6b6609b185dab..f736447e12fce15c7bf9555cd9be7333cd01b2ae 100644 (file)
--- a/source/renderer.h
+++ b/source/renderer.h
@@ -1,8 +1,11 @@
 #ifndef MSP_GL_RENDERER_H_
 #define MSP_GL_RENDERER_H_
 
+#include <set>
 #include <vector>
 #include "matrix.h"
+#include "programdata.h"
+#include "tag.h"
 
 namespace Msp {
 namespace GL {
@@ -11,11 +14,12 @@ class Batch;
 class Buffer;
 class Camera;
 class Material;
+class Mesh;
+class Lighting;
 class Program;
-class ProgramData;
+class Renderable;
 class Texture;
 class Texturing;
-class VertexArray;
 class WindingTest;
 
 /**
@@ -26,6 +30,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
 {
@@ -40,15 +49,30 @@ public:
                ~Push() { renderer.pop_state(); }
        };
 
+       class Exclude
+       {
+       private:
+               Renderer &renderer;
+               const Renderable &renderable;
+
+       public:
+               Exclude(Renderer &r, const Renderable &e): renderer(r), renderable(e) { renderer.exclude(renderable); }
+               ~Exclude() { renderer.include(renderable); }
+       };
+
 private:
        struct State
        {
                const Texture *texture;
                const Texturing *texturing;
                const Material *material;
+               const Lighting *lighting;
+               Matrix lighting_matrix;
                const Program *shprog;
-               std::vector<const ProgramData *> shdata;
+               unsigned shdata_count;
+               const Mesh *mesh;
                const WindingTest *winding_test;
+               bool reverse_winding;
 
                State();
        };
@@ -60,19 +84,21 @@ private:
 
        public:
                MtxStack(Renderer &);
-       private:        
+       private:
                virtual void update();
        };
 
        MtxStack mtx_stack;
        bool mtx_changed;
        const Camera *camera;
-       std::list<State> state_stack;
+       std::vector<State> state_stack;
        State *state;
-       const VertexArray *vertex_array;
-       bool vertex_array_changed;
-       const Buffer *element_buffer;
+       bool lighting_changed;
+       ProgramData standard_shdata;
+       std::vector<const ProgramData *> shdata_stack;
        bool shdata_changed;
+       const Buffer *element_buffer;
+       std::set<const Renderable *> excluded;
 
 public:
        Renderer(const Camera *);
@@ -86,6 +112,8 @@ public:
        void set_texturing(const Texturing *);
        void set_material(const Material *);
 
+       void set_lighting(const Lighting *);
+
        /** Sets the shader program to use.  An initial set of data can be set as
        well, with the same semantics as add_shader_data. */
        void set_shader_program(const Program *prog, const ProgramData *data = 0);
@@ -95,11 +123,16 @@ public:
        Renderer state is popped. */
        void add_shader_data(const ProgramData &data);
 
-       void set_vertex_array(const VertexArray *);
+       void set_mesh(const Mesh *);
        void set_element_buffer(const Buffer *);
        void set_winding_test(const WindingTest *);
+       void set_reverse_winding(bool);
 
+       /** 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
@@ -107,6 +140,10 @@ public:
        Renderer. */
        void escape();
 
+       void exclude(const Renderable &);
+       void include(const Renderable &);
+
+       void render(const Renderable &, const Tag & = Tag());
        void draw(const Batch &);
 
 private: