#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 {
class Batch;
class Buffer;
class Camera;
+class Clipping;
class Material;
+class Mesh;
+class Lighting;
class Program;
-class ProgramData;
+class Renderable;
class Texture;
class Texturing;
-class VertexArray;
+class VertexSetup;
class WindingTest;
/**
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
{
~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 Camera *camera;
+ Matrix modelview_matrix;
const Texture *texture;
const Texturing *texturing;
+ unsigned lowest_effect_texunit;
const Material *material;
+ const Lighting *lighting;
+ Matrix lighting_matrix;
+ const Clipping *clipping;
+ Matrix clipping_matrix;
const Program *shprog;
- std::vector<const ProgramData *> shdata;
+ unsigned shdata_count;
+ const Mesh *mesh;
+ const VertexSetup *vertex_setup;
const WindingTest *winding_test;
+ bool reverse_winding;
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;
+ const Camera *default_camera;
+ unsigned char changed;
+ bool matrices_loaded;
+ std::vector<State> state_stack;
State *state;
- const VertexArray *vertex_array;
- bool vertex_array_changed;
- const Buffer *element_buffer;
- bool shdata_changed;
+ ProgramData standard_shdata;
+ std::vector<const ProgramData *> shdata_stack;
+ std::set<const Renderable *> excluded;
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().
- const Camera *get_camera() const { return camera; }
+ 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 &);
+
+ /** Returns the current modelview matrix. */
+ const Matrix &get_matrix() const { return state->modelview_matrix; }
void set_texture(const Texture *);
void set_texturing(const Texturing *);
+ unsigned allocate_effect_texunit();
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_vertex_setup(const VertexSetup *);
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
- current state with GL. No additional call is necessary to resume using 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:
projects / libs / gl.git / blobdiff