#ifndef MSP_GL_SEQUENCE_H_
#define MSP_GL_SEQUENCE_H_
-#include <map>
-#include <set>
-#include "framebuffer.h"
+#include <vector>
+#include "blend.h"
+#include "depthtest.h"
+#include "frameformat.h"
#include "renderable.h"
-#include "renderbuffer.h"
-#include "rendertarget.h"
-#include "texture2d.h"
+#include "stenciltest.h"
namespace Msp {
namespace GL {
-class Blend;
-class Camera;
class Clipping;
-class DepthTest;
class Lighting;
class PostProcessor;
-class View;
+class RenderTarget;
/**
Top-level content class. Typically a Sequence is used as the content
private:
Tag tag;
const Lighting *lighting;
- const DepthTest *depth_test;
- const Blend *blend;
+ DepthTest depth_test;
+ StencilTest stencil_test;
+ Blend blend;
const Clipping *clipping;
Renderable *renderable;
Tag get_tag() const { return tag; }
void set_lighting(const Lighting *);
- void set_depth_test(const DepthTest *);
- void set_blend(const Blend *);
+ 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 Blend *get_blend() const { return blend; }
+ 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; }
};
- DEPRECATED typedef Step Pass;
-
private:
- struct Slot
+ struct PostProcStep
{
- Renderable *renderable;
- std::set<Tag> passes;
+ PostProcessor *postproc;
+ bool owned;
- Slot(Renderable *);
+ PostProcStep(PostProcessor *pp, bool o): postproc(pp), owned(o) { }
};
std::vector<Step> steps;
- const Camera *camera;
- std::vector<Slot> renderables;
- std::vector<RefPtr<PostProcessor> > postproc;
- unsigned width;
- unsigned height;
- bool hdr;
- bool alpha;
- unsigned samples;
- RenderTarget *target[2];
- RenderTarget *target_ms;
+ std::vector<PostProcStep> postproc;
+ unsigned width = 0;
+ unsigned height = 0;
+ FrameFormat target_format;
+ 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;
public:
- Sequence(unsigned, unsigned, bool = false);
- Sequence(const View &);
- Sequence(const Framebuffer &);
-private:
- void init(unsigned, unsigned);
-public:
+ Sequence() = default;
+ Sequence(unsigned, unsigned, const FrameFormat &);
~Sequence();
- /* Sets high dynamic range mode. Requires floating-point texture support.
- A ColorCurve postprocessor is recommended for full benefit. */
- void set_hdr(bool);
-
- /* Enable or disable alpha channel. When enabled, all render targets are
- created with an RGBA pixel format instead of RGB. */
- void set_alpha(bool);
-
- void set_multisample(unsigned);
-
unsigned get_width() const { return width; }
unsigned get_height() const { return height; }
- bool get_hdr() const { return hdr; }
- unsigned get_multisample() const { return samples; }
+ 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 &);
- DEPRECATED Step &add_pass(Tag t, Renderable &r) { return add_step(t, r); }
-
/** Adds a postprocessor to the sequence. */
void add_postprocessor(PostProcessor &);
virtual void render(Renderer &, Tag tag = Tag()) const;
-private:
- void create_targets(unsigned);
+ void set_debug_name(const std::string &);
};
} // namespace GL