#ifndef MSP_GL_SEQUENCE_H_
#define MSP_GL_SEQUENCE_H_
-#include <map>
-#include <set>
-#include "blend.h"
+#include <vector>
+#include "color.h"
#include "depthtest.h"
-#include "framebuffer.h"
+#include "frameformat.h"
#include "renderable.h"
-#include "rendertarget.h"
#include "stenciltest.h"
-#include "texture2d.h"
namespace Msp {
namespace GL {
-class Blend;
-class Camera;
-class Clipping;
class Lighting;
class PostProcessor;
+class RenderTarget;
/**
Top-level content class. Typically a Sequence is used as the content
Renderable for a View or effects such as ShadowMap or EnvironmentMap.
A Sequence consists of a number of steps. Each step is defined with a
-Renderable and a tag to render it with and may also have Lighting, Clipping,
-DepthTest and Blend states. Scenes can be used to further organize Renderables
-within a step.
+Renderable and a tag to render it with and may also have Lighting, DepthTest
+and Blend states. Scenes can be used to further organize Renderables within a
+step.
PostProcessors can be applied after all of the steps in the Sequence have been
processed. Framebuffer objects are automatically used to pass render results
const Lighting *lighting;
DepthTest depth_test;
StencilTest stencil_test;
- Blend blend;
- const Clipping *clipping;
Renderable *renderable;
public:
void set_lighting(const Lighting *);
void set_depth_test(const DepthTest &);
void set_stencil_test(const StencilTest &);
- void set_blend(const Blend &);
- void set_clipping(const Clipping *);
const Lighting *get_lighting() const { return lighting; }
const DepthTest &get_depth_test() const { return depth_test; }
const StencilTest &get_stencil_test() const { return stencil_test; }
- const Blend &get_blend() const { return blend; }
- const Clipping *get_clipping() const { return clipping; }
Renderable *get_renderable() const { return renderable; }
};
private:
- struct PostProcStep
+ struct OwnedObject
{
- PostProcessor *postproc;
- bool owned;
+ void *pointer = 0;
+ void (*delete_func)(void *) = 0;
- PostProcStep(PostProcessor *pp, bool o): postproc(pp), owned(o) { }
+ OwnedObject(void *p, void (*d)(void *)): pointer(p), delete_func(d) { }
};
std::vector<Step> steps;
- std::vector<PostProcStep> postproc;
- unsigned width;
- unsigned height;
+ std::vector<PostProcessor *> postproc;
+ unsigned width = 0;
+ unsigned height = 0;
FrameFormat target_format;
- RenderTarget *target[2];
- RenderTarget *target_ms;
+ RenderTarget *target[2] = { 0, 0 };
+ RenderTarget *target_ms = 0;
+ bool clear_enabled = false;
+ std::vector<Color> clear_colors;
+ float clear_depth = 1.0f;
+ int clear_stencil = 0;
+ std::vector<OwnedObject> owned_data;
+
+ static Tag noclear_tag;
public:
- Sequence();
+ Sequence() = default;
Sequence(unsigned, unsigned, const FrameFormat &);
~Sequence();
unsigned get_height() const { return height; }
const FrameFormat &get_target_format() { return target_format; }
+ void set_clear_enabled(bool);
+ void set_clear_colors(const std::vector<Color> &);
+ void set_clear_depth(float);
+ void set_clear_stencil(int);
+
/** Adds a step to the sequence. It's permissible to add the same
Renderable multiple times. */
Step &add_step(Tag, Renderable &);
+ const std::vector<Step> &get_steps() const { return steps; }
+
/** Adds a postprocessor to the sequence. */
void add_postprocessor(PostProcessor &);
- /** Adds a postprocessor to the sequence, transferring ownership. The
- postprocessor will be deleted together with with sequence. It is also
- deleted if this call throws an exception. */
- void add_postprocessor_owned(PostProcessor *);
+ const std::vector<PostProcessor *> &get_postprocessors() const { return postproc; }
-private:
- void add_postprocessor(PostProcessor *, bool);
+ /** Adds an owned object, which will be deleted together with the sequence. */
+ template<typename T>
+ void add_owned(T *p)
+ { owned_data.push_back({ p, [](void *ptr){ delete static_cast<T *>(ptr); } }); }
-public:
virtual void setup_frame(Renderer &);
virtual void finish_frame();