X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Frender%2Frenderer.h;h=3341d9aa061e038f3acb59c5515cc6f776c9d5d7;hb=cebf1330ef6773b7b4496dc279ec02a7ca4351bb;hp=eb23e96dab8deb8d8c10ec384bca387ef21b7085;hpb=0fa506250545acb83bc86f1734826544d6f1eda6;p=libs%2Fgl.git diff --git a/source/render/renderer.h b/source/render/renderer.h index eb23e96d..3341d9aa 100644 --- a/source/render/renderer.h +++ b/source/render/renderer.h @@ -4,45 +4,54 @@ #include #include #include "commands.h" +#include "cullface.h" #include "matrix.h" -#include "pipelinestate.h" #include "programdata.h" +#include "renderer_backend.h" #include "tag.h" namespace Msp { namespace GL { class Batch; +class Blend; class Buffer; class Camera; union ClearValue; +class DepthTest; class Material; class Mesh; class Lighting; class Program; class QueryPool; +struct Rect; class Renderable; class Sampler; +class StencilTest; class Texture; class VertexSetup; /** -A class for supervising the rendering process. While many Renderables (in -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 -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. +Rendering supervisor. This is the primary interface for setting state and +issuing draw commands. + +The Renderer class allows setting textures and uniform values by names (using +ProgramData for the latter). The names are resolved into binding points when +the resources are needed for a draw command. + +A state stack is provided to help with state management in render graphs. +Renderables can save the state by pushing it on the stack before beginning +their work, and pop it afterwards to restore it without disturbing state set +by outer scopes. */ -class Renderer +class Renderer: public RendererBackend { + friend RendererBackend; + public: + /** + RAII helper class for pushing state on the stack. + */ class Push { private: @@ -54,13 +63,25 @@ public: }; private: - struct BoundTexture + struct SampledTexture { - Tag tag; - mutable int unit = -1; const Texture *texture = 0; const Sampler *sampler = 0; + int level = -1; + + SampledTexture() = default; + SampledTexture(const Texture *t, const Sampler *s, int l): texture(t), sampler(s), level(l) { } + + bool operator==(const SampledTexture &o) const { return texture==o.texture && sampler==o.sampler && level==o.level; } + }; + + template + struct BoundResource + { + Tag tag; + mutable int binding = -1; int replaced = -1; + T resource; }; struct BoundProgramData @@ -73,6 +94,7 @@ private: struct State { + std::uintptr_t pipeline_key = 0; const Camera *camera = 0; Matrix model_matrix; const Framebuffer *framebuffer = 0; @@ -92,63 +114,99 @@ private: enum ChangeMask { + PIPELINE_KEY = 1, MATRIX = 2, + CAMERA = 4, SHADER_DATA = 16 }; + unsigned frame_index = 0; unsigned char changed = 0; std::vector state_stack; - State *state; - std::vector texture_stack; + State *current_state = 0; ProgramData standard_shdata; std::vector shdata_stack; - PipelineState pipeline_state; + std::vector> texture_stack; + const Texture &placeholder_texture; + const Sampler &default_sampler; + PipelineState *last_pipeline = 0; Commands commands; + static const Tag world_obj_matrix_tag; + static const Tag world_obj_normal_matrix_tag; + public: Renderer(); - ~Renderer(); + + /** Begins rendering, allowing commands to be issued. */ + void begin(); + + /** Ends rendering. Any global state is reset to defaults. No further + commands are allowed before the next call to begin(). */ + void end(); + + using RendererBackend::begin; + using RendererBackend::end; + + /** 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(); + +private: + State &get_state() const; + +public: + void set_pipeline_key(std::uintptr_t); + void set_pipeline_key(const void *p) { set_pipeline_key(reinterpret_cast(p)); } + + template + void set_pipeline_key(std::uintptr_t k, T d) + { set_pipeline_key(k^(static_cast(d)<<((sizeof(std::uintptr_t)-sizeof(T))*std::numeric_limits::digits))); } + + template + void set_pipeline_key(const void *p, T d) { set_pipeline_key(reinterpret_cast(p), d); } /** Sets the camera to render from. The model matrix is reset to identity. */ void set_camera(const Camera &); - const Camera *get_camera() const { return state->camera; } + const Camera *get_camera() const { return get_state().camera; } /** Replaces the Renderer's model matrix. */ void set_matrix(const Matrix &); - /** Applies a transform to the Renderer's model matrix. */ - void transform(const Matrix &); - /** Returns the current model matrix. */ - const Matrix &get_matrix() const { return state->model_matrix; } + const Matrix &get_matrix() const { return get_state().model_matrix; } void set_framebuffer(const Framebuffer *); void set_viewport(const Rect *); void set_scissor(const Rect *); - const Framebuffer *get_framebuffer() const { return state->framebuffer; } - - void set_texture(Tag, const Texture *, const Sampler * = 0); -private: - void flush_textures(); -public: - DEPRECATED void set_material(const Material *); - - DEPRECATED void set_lighting(const Lighting *); + const Framebuffer *get_framebuffer() const { return get_state().framebuffer; } - /** Sets the shader program to use. An initial set of data can be set as - well, with the same semantics as add_shader_data. */ + /** Sets the shader program to use. As a convenience, uniform values may be + specified at the same time. */ 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. */ + /** Adds uniform values, which will be available for shader programs. If + multiple ProgramData objects with the same uniforms are added, the one added + last will be used. */ void add_shader_data(const ProgramData &data); - DEPRECATED void flush_shader_data() { flush_shader_data_(); } + void set_texture(Tag, const Texture *, const Sampler * = 0); + void set_texture(Tag, const Texture *, int, const Sampler * = 0); + void set_storage_texture(Tag, const Texture *); + private: - void flush_shader_data_(); + template + static void set_resource(std::vector> &, unsigned &, Tag, const T &); + + void flush_shader_data(); + + template + static void flush_resources(std::vector> &, unsigned &); public: void set_vertex_setup(const VertexSetup *); @@ -160,31 +218,32 @@ public: void set_blend(const Blend *); void set_object_lod_bias(unsigned); - unsigned get_object_lod_bias() const { return state->object_lod_bias; } - - /** 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(); - - /** 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(); + unsigned get_object_lod_bias() const { return get_state().object_lod_bias; } - void clear(const ClearValue *); + /** Clears framebuffer contents. If values is not null, it must contain one + element for each attachment. Otherwise the framebuffer contents are + discarded and become undefined. */ + void clear(const ClearValue *values); + /** Draws a batch of primitives. A shader must be active. */ void draw(const Batch &); + + /** Draws multiple instances of a batch of primitives. A shader must be active. */ void draw_instanced(const Batch &, unsigned); - void resolve_multisample(Framebuffer &); + /** Dispatches a compute operation. */ + void dispatch(unsigned, unsigned = 1, unsigned = 1); + + /** Resolves multisample attachments from the active framebuffer into + target. */ + void resolve_multisample(Framebuffer &target); void begin_query(const QueryPool &, unsigned); void end_query(const QueryPool &, unsigned); private: + PipelineState &get_pipeline_state(); + void apply_framebuffer(); void apply_state(); };