source/pipeline.h

   1 #ifndef MSP_GL_PIPELINE_H_
   2 #define MSP_GL_PIPELINE_H_
   3
   4 #include <map>
   5 #include <set>
   6 #include "framebuffer.h"
   7 #include "renderable.h"
   8 #include "renderbuffer.h"
   9 #include "rendertarget.h"
  10 #include "texture2d.h"
  11
  12 namespace Msp {
  13 namespace GL {
  14
  15 class Blend;
  16 class Camera;
  17 class Clipping;
  18 class DepthTest;
  19 class Lighting;
  20 class PostProcessor;
  21 class View;
  22
  23 /**
  24 Top-level content class.  Typically a Pipeline is used as the content
  25 Renderable for a View or effects such as ShadowMap or EnvironmentMap.
  26
  27 A Pipeline contains a sequence of passes.  Each pass has a Renderable along
  28 with Lighting, Clipping, DepthTest and Blend states.  Scenes can be used to
  29 organize Renderables within a pass.
  30
  31 PostProcessors can be applied after all of the passes in the Pipeline have been
  32 rendered.  Framebuffer objects are automatically used to pass render results to
  33 the PostProcessors.  High dynamic range and multisample rendering can be
  34 requested for increased quality.
  35 */
  36 class Pipeline: public Renderable
  37 {
  38 public:
  39         class Pass
  40         {
  41         private:
  42                 Tag tag;
  43                 const Lighting *lighting;
  44                 const DepthTest *depth_test;
  45                 const Blend *blend;
  46                 const Clipping *clipping;
  47                 Renderable *renderable;
  48
  49         public:
  50                 Pass(const Tag &, Renderable *);
  51
  52                 const Tag &get_tag() const { return tag; }
  53
  54                 void set_lighting(const Lighting *);
  55                 void set_depth_test(const DepthTest *);
  56                 void set_blend(const Blend *);
  57                 void set_clipping(const Clipping *);
  58                 const Lighting *get_lighting() const { return lighting; }
  59                 const DepthTest *get_depth_test() const { return depth_test; }
  60                 const Blend *get_blend() const { return blend; }
  61                 const Clipping *get_clipping() const { return clipping; }
  62                 Renderable *get_renderable() const { return renderable; }
  63         };
  64
  65 private:
  66         struct Slot
  67         {
  68                 Renderable *renderable;
  69                 std::set<Tag> passes;
  70
  71                 Slot(Renderable *);
  72         };
  73
  74         typedef std::list<Pass> PassList;
  75
  76         PassList passes;
  77         const Camera *camera;
  78         std::vector<Slot> renderables;
  79         std::vector<RefPtr<PostProcessor> > postproc;
  80         unsigned width;
  81         unsigned height;
  82         bool hdr;
  83         unsigned samples;
  84         RenderTarget *target[2];
  85         RenderTarget *target_ms;
  86
  87 public:
  88         Pipeline(unsigned, unsigned, bool = false);
  89         Pipeline(const View &);
  90 private:
  91         void init(unsigned, unsigned);
  92 public:
  93         ~Pipeline();
  94
  95         /* Sets high dynamic range mode.  Requires floating-point texture support.
  96         A ColorCurve postprocessor is recommended for full benefit. */
  97         void set_hdr(bool);
  98
  99         void set_multisample(unsigned);
 100
 101         unsigned get_width() const { return width; }
 102         unsigned get_height() const { return height; }
 103         bool get_hdr() const { return hdr; }
 104         unsigned get_multisample() const { return samples; }
 105
 106         // Deprecated
 107         void set_camera(const Camera *);
 108         Pass &add_pass(const Tag &tag);
 109         void add_renderable(Renderable &);
 110         void add_renderable_for_pass(Renderable &, const Tag &);
 111         void remove_renderable(Renderable &);
 112
 113         /** Adds a pass to the pipeline.  It's permissible to add the same
 114         Renderable multiple times. */
 115         Pass &add_pass(const Tag &, Renderable &);
 116
 117         /** Adds a postprocessor to the pipeline. */
 118         void add_postprocessor(PostProcessor &);
 119
 120         /** Adds a postprocessor to the pipeline, transferring ownership.  The
 121         postprocessor will be deleted together with with pipeline.  It is also
 122         deleted if this call throws an exception. */
 123         void add_postprocessor_owned(PostProcessor *);
 124
 125 private:
 126         void add_postprocessor(PostProcessor *, bool);
 127
 128 public:
 129         virtual void setup_frame(Renderer &);
 130         virtual void finish_frame();
 131
 132         void render();
 133         virtual void render(Renderer &, const Tag &tag = Tag()) const;
 134
 135 private:
 136         void create_targets(unsigned);
 137 };
 138
 139 } // namespace GL
 140 } // namespace Msp
 141
 142 #endif