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
{
const Texturing *texturing;
const Material *material;
const Program *shprog;
- std::vector<const ProgramData *> shdata;
+ unsigned shdata_count;
const WindingTest *winding_test;
State();
MtxStack mtx_stack;
bool mtx_changed;
const Camera *camera;
- std::list<State> state_stack;
+ std::vector<State> state_stack;
State *state;
+ std::vector<const ProgramData *> shdata_stack;
+ bool shdata_changed;
const VertexArray *vertex_array;
bool vertex_array_changed;
const Buffer *element_buffer;
- bool shdata_changed;
public:
Renderer(const Camera *);
void set_element_buffer(const Buffer *);
void set_winding_test(const WindingTest *);
+ /** 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