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<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         // Deprecated
 102         void set_camera(const Camera *);
 103         Pass &add_pass(const Tag &tag);
 104         void add_renderable(Renderable &);
 105         void add_renderable_for_pass(Renderable &, const Tag &);
 106         void remove_renderable(Renderable &);
 107
 108         /** Adds a pass to the pipeline.  It's permissible to add the same
 109         Renderable multiple times. */
 110         Pass &add_pass(const Tag &, Renderable &);
 111
 112         /** Adds a postprocessor to the pipeline. */
 113         void add_postprocessor(PostProcessor &);
 114
 115         virtual void setup_frame(Renderer &);
 116         virtual void finish_frame();
 117
 118         void render();
 119         virtual void render(Renderer &, const Tag &tag = Tag()) const;
 120
 121 private:
 122         void create_targets(unsigned);
 123 };
 124
 125 } // namespace GL
 126 } // namespace Msp
 127
 128 #endif