Add a speed parameter for animation playback

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

diff --git a/source/renderer.h b/source/renderer.h
index ef17b3e62043ad847969f4b7e6102854e52fc55c..af4bd65b594beb85c53bf76905e47698fb577f07 100644 (file)
--- a/source/renderer.h
+++ b/source/renderer.h
@@ -1,15 +1,11 @@
-/* $Id$
-
-This file is part of libmspgl
-Copyright © 2011  Mikko Rasa, Mikkosoft Productions
-Distributed under the LGPL
-*/
-

 #ifndef MSP_GL_RENDERER_H_
 #define MSP_GL_RENDERER_H_
 
 #ifndef MSP_GL_RENDERER_H_
 #define MSP_GL_RENDERER_H_
 

+#include <set>

 #include <vector>
 #include "matrix.h"
 #include <vector>
 #include "matrix.h"

+#include "programdata.h"
+#include "tag.h"

 
 namespace Msp {
 namespace GL {
 
 namespace Msp {
 namespace GL {


@@ -17,12 +13,14 @@ namespace GL {
 class Batch;
 class Buffer;
 class Camera;
 class Batch;
 class Buffer;
 class Camera;

+class Clipping;

 class Material;
 class Material;

+class Mesh;
+class Lighting;

 class Program;
 class Program;

-class ProgramData;
+class Renderable;

 class Texture;
 class Texturing;
 class Texture;
 class Texturing;

-class VertexArray;

 class WindingTest;
 
 /**
 class WindingTest;
 
 /**


@@ -31,7 +29,14 @@ particular, Objects and Scenes) can by rendered without a Renderer, using one
 will often be more efficient.  This is especially true for ObjectInstances.
 
 The Renderer works by deferring GL state changes until something is actually
 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. */
+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
 {
 public:
 class Renderer
 {
 public:


@@ -45,62 +50,123 @@ public:
                ~Push() { renderer.pop_state(); }
        };
 
                ~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
        {
 private:
        struct State
        {

+               const Camera *camera;
+               Matrix modelview_matrix;

                const Texture *texture;
                const Texturing *texturing;
                const Texture *texture;
                const Texturing *texturing;

+               unsigned lowest_effect_texunit;

                const Material *material;
                const Material *material;

+               const Lighting *lighting;
+               Matrix lighting_matrix;
+               const Clipping *clipping;
+               Matrix clipping_matrix;

                const Program *shprog;
                const Program *shprog;

-               std::vector<const ProgramData *> shdata;
+               unsigned shdata_count;
+               const Mesh *mesh;

                const WindingTest *winding_test;
                const WindingTest *winding_test;

+               bool reverse_winding;

 
                State();
        };
 
 
                State();
        };
 

-       class MtxStack: public MatrixStack
+       enum ChangeMask

        {
        {

-       private:
-               Renderer &renderer;
-
-       public:
-               MtxStack(Renderer &);
-       private:        
-               virtual void update();
+               LEGACY_MATRIX = 1,
+               MODERN_MATRIX = 2,
+               MATRIX = LEGACY_MATRIX|MODERN_MATRIX,
+               LEGACY_LIGHTING = 4,
+               LEGACY_CLIPPING = 8,
+               SHADER_DATA = 16,
+               MATERIAL_SHDATA = 32,
+               STANDARD_SHDATA = 64,
+               LEGACY_PROJECTION = 128

        };
 
        };
 

-       MtxStack mtx_stack;
-       bool mtx_changed;
-       const Camera *camera;
-       std::list<State> state_stack;
+       unsigned char changed;
+       bool matrices_loaded;
+       std::vector<State> state_stack;

        State *state;
        State *state;

-       const VertexArray *vertex_array;
-       bool vertex_array_changed;
-       const Buffer *element_buffer;
+       ProgramData standard_shdata;
+       std::vector<const ProgramData *> shdata_stack;
+       std::set<const Renderable *> excluded;

 
 public:
        Renderer(const Camera *);
        ~Renderer();
 
 
 public:
        Renderer(const Camera *);
        ~Renderer();
 

-       MatrixStack &matrix_stack() { return mtx_stack; }
+       /** Resets all internal state and restarts rendering.  There must be no
+       unpopped state in the stack.  It is permissible to call begin() multiple
+       times without an intervening end().
+
+       Deprecated; use end() and set_camera() instead.*/
+       void begin(const Camera *);
+
+       /** Sets the camera to render from.  The modelview matrix is reset to the
+       camera's view matrix. */
+       void set_camera(const Camera &);
+
+       const Camera *get_camera() const { return state->camera; }
+
+       /** Replaces the Renderer's modelview matrix. */
+       void set_matrix(const Matrix &);
+
+       /** Applies a transform to the Renderer's modelview matrix. */
+       void transform(const Matrix &);

 
 

-       const Camera *get_camera() const { return camera; }
+       /** Returns the current modelview matrix. */
+       const Matrix &get_matrix() const { return state->modelview_matrix; }

 
        void set_texture(const Texture *);
        void set_texturing(const Texturing *);
 
        void set_texture(const Texture *);
        void set_texturing(const Texturing *);

+       unsigned allocate_effect_texunit();

        void set_material(const Material *);
        void set_material(const Material *);

-       void set_shader(const Program *, const ProgramData *);
-       void add_shader_data(const ProgramData *);
-       void set_vertex_array(const VertexArray *);
-       void set_element_buffer(const Buffer *);
+
+       void set_lighting(const Lighting *);
+       void set_clipping(const Clipping *);
+
+       /** 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);
+
+       /** Adds another set of data to be use with shader programs.  The data is
+       independent of any shader program changes and remains in effect until the
+       Renderer state is popped. */
+       void add_shader_data(const ProgramData &data);
+
+       void set_mesh(const Mesh *);

        void set_winding_test(const WindingTest *);
        void set_winding_test(const WindingTest *);

+       void set_reverse_winding(bool);

 
 

+       /** Saves the current state so it can be restored later. */

        void push_state();
        void push_state();

+
+       /** Restores a previously saved state.  Must be matched with an earlier
+       push_state call. */

        void pop_state();
 
        void pop_state();
 

-       /** Prepares for temporarily bypassing the Renderer. */
-       void escape();
+       /** Unbinds all objects and resets related state.  There must be no unpopped
+       state in the stack.  The Renderer remains valid and may be reused for
+       further rendering. */
+       void end();
+
+       void exclude(const Renderable &);
+       void include(const Renderable &);

 
 

+       void render(const Renderable &, const Tag & = Tag());

        void draw(const Batch &);
 
 private:
        void draw(const Batch &);
 
 private: