#ifndef MSP_GL_RENDERER_H_
#define MSP_GL_RENDERER_H_
+#include <set>
#include <vector>
#include "matrix.h"
+#include "tag.h"
namespace Msp {
namespace GL {
class Buffer;
class Camera;
class Material;
+class Lighting;
class Program;
class ProgramData;
+class Renderable;
class Texture;
class Texturing;
class VertexArray;
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 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 WindingTest *winding_test;
+ bool reverse_winding;
State();
};
MtxStack mtx_stack;
bool mtx_changed;
const Camera *camera;
- std::list<State> state_stack;
+ std::vector<State> state_stack;
State *state;
+ bool lighting_changed;
+ std::vector<const ProgramData *> shdata_stack;
+ bool shdata_changed;
const VertexArray *vertex_array;
- bool vertex_array_changed;
const Buffer *element_buffer;
- bool shdata_changed;
+ std::set<const Renderable *> excluded;
public:
Renderer(const Camera *);
void set_texture(const Texture *);
void set_texturing(const Texturing *);
void set_material(const Material *);
- void set_shader(const Program *, const ProgramData *);
- void add_shader_data(const ProgramData *);
+
+ 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);
+
+ /** 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_vertex_array(const VertexArray *);
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
Renderer. */
void escape();
+ void exclude(const Renderable &);
+ void include(const Renderable &);
+
+ void render(const Renderable &, const Tag & = Tag());
void draw(const Batch &);
private: