source/renderer.h

   1 #ifndef MSP_GL_RENDERER_H_
   2 #define MSP_GL_RENDERER_H_
   3
   4 #include <set>
   5 #include <vector>
   6 #include "matrix.h"
   7 #include "programdata.h"
   8 #include "tag.h"
   9
  10 namespace Msp {
  11 namespace GL {
  12
  13 class Batch;
  14 class Buffer;
  15 class Camera;
  16 class Clipping;
  17 class Material;
  18 class Mesh;
  19 class Lighting;
  20 class Program;
  21 class Renderable;
  22 class Texture;
  23 class Texturing;
  24 class WindingTest;
  25
  26 /**
  27 A class for supervising the rendering process.  While many Renderables (in
  28 particular, Objects and Scenes) can by rendered without a Renderer, using one
  29 will often be more efficient.  This is especially true for ObjectInstances.
  30
  31 The Renderer works by deferring GL state changes until something is actually
  32 being drawn.  This avoids many unnecessary GL calls if consecutive renderables
  33 use the same resources.
  34
  35 A state stack is provided to help with state scoping.  Typically a Renderable
  36 will push the current state on entry, set whatever state it requires, render
  37 itself, and pop the state when it's done.  An RAII helper class is provided for
  38 the push/pop operation.
  39 */
  40 class Renderer
  41 {
  42 public:
  43         class Push
  44         {
  45         private:
  46                 Renderer &renderer;
  47
  48         public:
  49                 Push(Renderer &r): renderer(r) { renderer.push_state(); }
  50                 ~Push() { renderer.pop_state(); }
  51         };
  52
  53         class Exclude
  54         {
  55         private:
  56                 Renderer &renderer;
  57                 const Renderable &renderable;
  58
  59         public:
  60                 Exclude(Renderer &r, const Renderable &e): renderer(r), renderable(e) { renderer.exclude(renderable); }
  61                 ~Exclude() { renderer.include(renderable); }
  62         };
  63
  64 private:
  65         struct State
  66         {
  67                 const Texture *texture;
  68                 const Texturing *texturing;
  69                 unsigned lowest_effect_texunit;
  70                 const Material *material;
  71                 const Lighting *lighting;
  72                 Matrix lighting_matrix;
  73                 const Clipping *clipping;
  74                 Matrix clipping_matrix;
  75                 const Program *shprog;
  76                 unsigned shdata_count;
  77                 const Mesh *mesh;
  78                 const WindingTest *winding_test;
  79                 bool reverse_winding;
  80
  81                 State();
  82         };
  83
  84         class MtxStack: public MatrixStack
  85         {
  86         private:
  87                 Renderer &renderer;
  88
  89         public:
  90                 MtxStack(Renderer &);
  91         private:
  92                 virtual void update();
  93         };
  94
  95         enum ChangeMask
  96         {
  97                 LEGACY_MATRIX = 1,
  98                 MODERN_MATRIX = 2,
  99                 MATRIX = LEGACY_MATRIX|MODERN_MATRIX,
 100                 LIGHTING = 4,
 101                 CLIPPING = 8,
 102                 SHADER_DATA = 16
 103         };
 104
 105         MtxStack mtx_stack;
 106         unsigned char changed;
 107         bool matrices_loaded;
 108         unsigned shdata_applied;
 109         const Camera *camera;
 110         std::vector<State> state_stack;
 111         State *state;
 112         ProgramData standard_shdata;
 113         std::vector<const ProgramData *> shdata_stack;
 114         std::set<const Renderable *> excluded;
 115
 116 public:
 117         Renderer(const Camera *);
 118         ~Renderer();
 119
 120         /** Resets all internal state and restarts rendering.  There must be no
 121         unpopped state in the stack.  It is permissible to call begin() multiple
 122         times without an intervening end(). */
 123         void begin(const Camera *);
 124
 125         /** Deprecated as unsafe.  Use set_matrix() or transform() instead. */
 126         MatrixStack &matrix_stack() { return mtx_stack; }
 127
 128         /** Replaces the Renderer's modelview matrix. */
 129         void set_matrix(const Matrix &);
 130
 131         /** Applies a transform to the Renderer's modelview matrix. */
 132         void transform(const Matrix &);
 133
 134         /** Returns the current modelview matrix. */
 135         const Matrix &get_matrix() const { return mtx_stack.top(); }
 136
 137         const Camera *get_camera() const { return camera; }
 138
 139         void set_texture(const Texture *);
 140         void set_texturing(const Texturing *);
 141         unsigned allocate_effect_texunit();
 142         void set_material(const Material *);
 143
 144         void set_lighting(const Lighting *);
 145         void set_clipping(const Clipping *);
 146
 147         /** Sets the shader program to use.  An initial set of data can be set as
 148         well, with the same semantics as add_shader_data. */
 149         void set_shader_program(const Program *prog, const ProgramData *data = 0);
 150
 151         /** Adds another set of data to be use with shader programs.  The data is
 152         independent of any shader program changes and remains in effect until the
 153         Renderer state is popped. */
 154         void add_shader_data(const ProgramData &data);
 155
 156         void set_mesh(const Mesh *);
 157         void set_winding_test(const WindingTest *);
 158         void set_reverse_winding(bool);
 159
 160         /** Saves the current state so it can be restored later. */
 161         void push_state();
 162
 163         /** Restores a previously saved state.  Must be matched with an earlier
 164         push_state call. */
 165         void pop_state();
 166
 167         /** Prepares for temporarily bypassing the Renderer by synchronizing the
 168         current state with GL.  No additional call is necessary to resume using the
 169         Renderer.  DEPRECATED. */
 170         void escape();
 171
 172         /** Unbinds all objects and resets related state.  There must be no unpopped
 173         state in the stack.  Rendering with the same camera can be restarted without
 174         an explicit begin() call. */
 175         void end();
 176
 177         void exclude(const Renderable &);
 178         void include(const Renderable &);
 179
 180         void render(const Renderable &, const Tag & = Tag());
 181         void draw(const Batch &);
 182
 183 private:
 184         void apply_state();
 185         void reset_state();
 186 };
 187
 188 } // namespace GL
 189 } // namespace Msp
 190
 191 #endif