Gamedev Framework (gf)  0.6.0
A C++11 framework for 2D games
RenderPipeline.h
1 /*
2  * Gamedev Framework (gf)
3  * Copyright (C) 2016-2017 Julien Bernard
4  *
5  * This software is provided 'as-is', without any express or implied
6  * warranty. In no event will the authors be held liable for any damages
7  * arising from the use of this software.
8  *
9  * Permission is granted to anyone to use this software for any purpose,
10  * including commercial applications, and to alter it and redistribute it
11  * freely, subject to the following restrictions:
12  *
13  * 1. The origin of this software must not be misrepresented; you must not
14  * claim that you wrote the original software. If you use this software
15  * in a product, an acknowledgment in the product documentation would be
16  * appreciated but is not required.
17  * 2. Altered source versions must be plainly marked as such, and must not be
18  * misrepresented as being the original software.
19  * 3. This notice may not be removed or altered from any source distribution.
20  */
21 #ifndef GF_RENDER_PIPELINE_H
22 #define GF_RENDER_PIPELINE_H
23 
24 #include <vector>
25 
26 #include "Effects.h"
27 #include "Portability.h"
28 #include "RenderTarget.h"
29 
30 namespace gf {
31 #ifndef DOXYGEN_SHOULD_SKIP_THIS
32 inline namespace v1 {
33 #endif
34 
35  class Effect;
36  class Window;
37 
38  /**
39  * @ingroup graphics
40  * @brief A render pipeline
41  *
42  * A render pipeline automates the application of post-processing effects.
43  * A good way to use this class is to make a subclass with all the effects
44  * you want to add.
45  *
46  * ~~~{.cc}
47  * class MyPipeline : public gf::RenderPipeline {
48  * public:
49  * MyPipeline(gf::Window& window)
50  * : gf::RenderPipeline(window)
51  * {
52  * addEffect(m_effect);
53  * addEffect(m_other);
54  * }
55  *
56  * protected:
57  * virtual void onFramebufferResize(Vector2u size) override {
58  * // update effects with size
59  * }
60  *
61  * private:
62  * MyEffect m_effect;
63  * MyOtherEffect m_other;
64  * };
65  * ~~~
66  *
67  * @sa gf::Effect
68  */
70  public:
71  /**
72  * @brief Constructor
73  *
74  * @param window The window to render to
75  */
76  RenderPipeline(Window& window);
77 
78  /**
79  * @brief Destructor
80  */
81  ~RenderPipeline();
82 
83  /**
84  * @brief Add an effect to the pipeline
85  *
86  * @param effect The effect
87  */
88  void addEffect(Effect& effect);
89 
90  /**
91  * @brief Clear the pipeline
92  */
93  void clearEffects();
94 
95  /**
96  * @brief Update the size of the target
97  *
98  * This function must be called when the window change its size, before
99  * anything is drawn on the target. You can do it in the event processing.
100  *
101  * ~~~{.cc}
102  * gf::Event event;
103  *
104  * // ...
105  *
106  * switch (event.type) {
107  * case gf::EventType::Resized:
108  * renderer.resized();
109  * break;
110  *
111  * // ...
112  * }
113  * ~~~
114  */
115  void resized();
116 
117  virtual Vector2u getSize() const override;
118 
119  /**
120  * @brief Apply the effects and display what has been rendered
121  */
122  void display();
123 
124  protected:
125  /**
126  * @brief Callback when the screen has just been resized
127  *
128  * This function is called by resized() with the correct size.
129  *
130  * @param size The new framebuffer size
131  */
132  virtual void onFramebufferResize(Vector2u size);
133 
134  private:
135  Window& m_window;
136 
137  struct TextureBuffer {
138  Texture texture;
139  unsigned name;
140  };
141 
142  TextureBuffer m_buffers[2];
143  int m_current;
144 
145  DefaultEffect m_defaultEffect;
146  std::vector<Effect*> m_effects;
147  };
148 
149 #ifndef DOXYGEN_SHOULD_SKIP_THIS
150 }
151 #endif
152 }
153 
154 #endif // GF_RENDER_PIPELINE_H
void addEffect(Effect &effect)
Add an effect to the pipeline.
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.h:66
A texture for colored images.
Definition: Texture.h:339
The namespace for gf classes.
Definition: Action.h:34
void clearEffects()
Clear the pipeline.
virtual Vector2u getSize() const override
Return the size of the rendering region of the target.
An OS window.
Definition: Window.h:88
~RenderPipeline()
Destructor.
A render pipeline.
Definition: RenderPipeline.h:69
void display()
Apply the effects and display what has been rendered.
void resized()
Update the size of the target.
A post-processing effect.
Definition: Effect.h:38
virtual void onFramebufferResize(Vector2u size)
Callback when the screen has just been resized.
#define GF_API
Definition: Portability.h:35
Default effect.
Definition: Effects.h:38
RenderPipeline(Window &window)
Constructor.