Gamedev Framework (gf)  0.3.0
A C++11 framework for 2D games
RenderWindow.h
1 /*
2  * Gamedev Framework (gf)
3  * Copyright (C) 2016 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  * Part of this file comes from SFML, with the same license:
22  * Copyright (C) 2007-2015 Laurent Gomila (laurent@sfml-dev.org)
23  */
24 #ifndef GF_RENDER_WINDOW_H
25 #define GF_RENDER_WINDOW_H
26 
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 Window;
36 
37  /**
38  * @ingroup graphics
39  * \brief A window that can serve as a target for 2D drawing
40  *
41  * gf::RenderWindow is the main class of the graphics module.
42  * It defines an OS window that can be painted using the other
43  * classes of the graphics module.
44  *
45  * Here is a typical rendering and event loop with a gf::RenderWindow:
46  *
47  * ~~~{.cc}
48  * // Declare and create a new render-window
49  * gf::Window window("New window", { 800, 600 });
50  * gf::RenderWindow renderer(window);
51  *
52  * // The main loop - ends as soon as the window is closed
53  * while (window.isOpen()) {
54  * // Event processing
55  * gf::Event event;
56  *
57  * while (window.pollEvent(event)) {
58  * // Request for closing the window
59  * if (event.type == gf::EventType::Closed) {
60  * window.close();
61  * }
62  * }
63  *
64  * // Clear the whole window before rendering a new frame
65  * renderer.clear();
66  *
67  * // Draw some graphical entities
68  * renderer.draw(sprite);
69  * renderer.draw(circle);
70  * renderer.draw(text);
71  *
72  * // End the current frame and display its contents on screen
73  * renderer.display();
74  * }
75  * ~~~
76  *
77  * \see gf::Window, gf::RenderTarget, gf::RenderTexture, gf::View
78  *
79  */
80  class GF_API RenderWindow : public RenderTarget {
81  public:
82 
83  /**
84  * @brief Constructor
85  *
86  * @param window The window to render to
87  */
88  RenderWindow(Window& window);
89 
90  virtual Vector2u getSize() const override;
91 
92  /**
93  * @brief Activate the target for rendering
94  *
95  * This function activates the render-window so that all draw calls
96  * are targeted to the window. You should call this function before
97  * you want to draw something to the target.
98  */
99  void setActive();
100 
101  /**
102  * @brief Display on screen what has been rendered to the window so far
103  *
104  * This function is typically called after all OpenGL rendering
105  * has been done for the current frame, in order to show
106  * it on screen.
107  *
108  * @sa Window::display()
109  */
110  void display();
111 
112  /**
113  * @brief Copy the current contents of the render window to an image
114  *
115  * This is a slow operation, whose main purpose is to make screenshots of
116  * the application.
117  */
118  Image capture() const;
119 
120  private:
121  Window& m_window;
122  };
123 
124 #ifndef DOXYGEN_SHOULD_SKIP_THIS
125 }
126 #endif
127 }
128 
129 #endif // GF_RENDER_WINDOW_H
void display()
Display on screen what has been rendered to the window so far.
RenderWindow(Window &window)
Constructor.
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.h:65
virtual Vector2u getSize() const override
Return the size of the rendering region of the target.
Class for loading, manipulating and saving images.
Definition: Image.h:92
Definition: Action.h:34
A window that can serve as a target for 2D drawing.
Definition: RenderWindow.h:80
An OS window.
Definition: Window.h:97
Image capture() const
Copy the current contents of the render window to an image.
#define GF_API
Definition: Portability.h:35
void setActive()
Activate the target for rendering.