//////////////////////////////////////////////////////////// // // SFML - Simple and Fast Multimedia Library // Copyright (C) 2007-2021 Laurent Gomila (laurent@sfml-dev.org) // // This software is provided 'as-is', without any express or implied warranty. // In no event will the authors be held liable for any damages arising from the use of this software. // // Permission is granted to anyone to use this software for any purpose, // including commercial applications, and to alter it and redistribute it freely, // subject to the following restrictions: // // 1. The origin of this software must not be misrepresented; // you must not claim that you wrote the original software. // If you use this software in a product, an acknowledgment // in the product documentation would be appreciated but is not required. // // 2. Altered source versions must be plainly marked as such, // and must not be misrepresented as being the original software. // // 3. This notice may not be removed or altered from any source distribution. // //////////////////////////////////////////////////////////// #ifndef SFML_WINDOW_HPP #define SFML_WINDOW_HPP //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// #include #include #include namespace sf { namespace priv { class GlContext; } class Event; //////////////////////////////////////////////////////////// /// \brief Window that serves as a target for OpenGL rendering /// //////////////////////////////////////////////////////////// class SFML_WINDOW_API Window : public WindowBase, GlResource { public: //////////////////////////////////////////////////////////// /// \brief Default constructor /// /// This constructor doesn't actually create the window, /// use the other constructors or call create() to do so. /// //////////////////////////////////////////////////////////// Window(); //////////////////////////////////////////////////////////// /// \brief Construct a new window /// /// This constructor creates the window with the size and pixel /// depth defined in \a mode. An optional style can be passed to /// customize the look and behavior of the window (borders, /// title bar, resizable, closable, ...). If \a style contains /// Style::Fullscreen, then \a mode must be a valid video mode. /// /// The fourth parameter is an optional structure specifying /// advanced OpenGL context settings such as antialiasing, /// depth-buffer bits, etc. /// /// \param mode Video mode to use (defines the width, height and depth of the rendering area of the window) /// \param title Title of the window /// \param style %Window style, a bitwise OR combination of sf::Style enumerators /// \param settings Additional settings for the underlying OpenGL context /// //////////////////////////////////////////////////////////// Window(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings()); //////////////////////////////////////////////////////////// /// \brief Construct the window from an existing control /// /// Use this constructor if you want to create an OpenGL /// rendering area into an already existing control. /// /// The second parameter is an optional structure specifying /// advanced OpenGL context settings such as antialiasing, /// depth-buffer bits, etc. /// /// \param handle Platform-specific handle of the control /// \param settings Additional settings for the underlying OpenGL context /// //////////////////////////////////////////////////////////// explicit Window(WindowHandle handle, const ContextSettings& settings = ContextSettings()); //////////////////////////////////////////////////////////// /// \brief Destructor /// /// Closes the window and frees all the resources attached to it. /// //////////////////////////////////////////////////////////// virtual ~Window(); //////////////////////////////////////////////////////////// /// \brief Create (or recreate) the window /// /// If the window was already created, it closes it first. /// If \a style contains Style::Fullscreen, then \a mode /// must be a valid video mode. /// /// \param mode Video mode to use (defines the width, height and depth of the rendering area of the window) /// \param title Title of the window /// \param style %Window style, a bitwise OR combination of sf::Style enumerators /// //////////////////////////////////////////////////////////// virtual void create(VideoMode mode, const String& title, Uint32 style = Style::Default); //////////////////////////////////////////////////////////// /// \brief Create (or recreate) the window /// /// If the window was already created, it closes it first. /// If \a style contains Style::Fullscreen, then \a mode /// must be a valid video mode. /// /// The fourth parameter is an optional structure specifying /// advanced OpenGL context settings such as antialiasing, /// depth-buffer bits, etc. /// /// \param mode Video mode to use (defines the width, height and depth of the rendering area of the window) /// \param title Title of the window /// \param style %Window style, a bitwise OR combination of sf::Style enumerators /// \param settings Additional settings for the underlying OpenGL context /// //////////////////////////////////////////////////////////// virtual void create(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings); //////////////////////////////////////////////////////////// /// \brief Create (or recreate) the window from an existing control /// /// Use this function if you want to create an OpenGL /// rendering area into an already existing control. /// If the window was already created, it closes it first. /// /// \param handle Platform-specific handle of the control /// //////////////////////////////////////////////////////////// virtual void create(WindowHandle handle); //////////////////////////////////////////////////////////// /// \brief Create (or recreate) the window from an existing control /// /// Use this function if you want to create an OpenGL /// rendering area into an already existing control. /// If the window was already created, it closes it first. /// /// The second parameter is an optional structure specifying /// advanced OpenGL context settings such as antialiasing, /// depth-buffer bits, etc. /// /// \param handle Platform-specific handle of the control /// \param settings Additional settings for the underlying OpenGL context /// //////////////////////////////////////////////////////////// virtual void create(WindowHandle handle, const ContextSettings& settings); //////////////////////////////////////////////////////////// /// \brief Close the window and destroy all the attached resources /// /// After calling this function, the sf::Window instance remains /// valid and you can call create() to recreate the window. /// All other functions such as pollEvent() or display() will /// still work (i.e. you don't have to test isOpen() every time), /// and will have no effect on closed windows. /// //////////////////////////////////////////////////////////// virtual void close(); //////////////////////////////////////////////////////////// /// \brief Get the settings of the OpenGL context of the window /// /// Note that these settings may be different from what was /// passed to the constructor or the create() function, /// if one or more settings were not supported. In this case, /// SFML chose the closest match. /// /// \return Structure containing the OpenGL context settings /// //////////////////////////////////////////////////////////// const ContextSettings& getSettings() const; //////////////////////////////////////////////////////////// /// \brief Enable or disable vertical synchronization /// /// Activating vertical synchronization will limit the number /// of frames displayed to the refresh rate of the monitor. /// This can avoid some visual artifacts, and limit the framerate /// to a good value (but not constant across different computers). /// /// Vertical synchronization is disabled by default. /// /// \param enabled True to enable v-sync, false to deactivate it /// //////////////////////////////////////////////////////////// void setVerticalSyncEnabled(bool enabled); //////////////////////////////////////////////////////////// /// \brief Limit the framerate to a maximum fixed frequency /// /// If a limit is set, the window will use a small delay after /// each call to display() to ensure that the current frame /// lasted long enough to match the framerate limit. /// SFML will try to match the given limit as much as it can, /// but since it internally uses sf::sleep, whose precision /// depends on the underlying OS, the results may be a little /// unprecise as well (for example, you can get 65 FPS when /// requesting 60). /// /// \param limit Framerate limit, in frames per seconds (use 0 to disable limit) /// //////////////////////////////////////////////////////////// void setFramerateLimit(unsigned int limit); //////////////////////////////////////////////////////////// /// \brief Activate or deactivate the window as the current target /// for OpenGL rendering /// /// A window is active only on the current thread, if you want to /// make it active on another thread you have to deactivate it /// on the previous thread first if it was active. /// Only one window can be active on a thread at a time, thus /// the window previously active (if any) automatically gets deactivated. /// This is not to be confused with requestFocus(). /// /// \param active True to activate, false to deactivate /// /// \return True if operation was successful, false otherwise /// //////////////////////////////////////////////////////////// bool setActive(bool active = true) const; //////////////////////////////////////////////////////////// /// \brief Display on screen what has been rendered to the window so far /// /// This function is typically called after all OpenGL rendering /// has been done for the current frame, in order to show /// it on screen. /// //////////////////////////////////////////////////////////// void display(); private: //////////////////////////////////////////////////////////// /// \brief Processes an event before it is sent to the user /// /// This function is called every time an event is received /// from the internal window (through pollEvent or waitEvent). /// It filters out unwanted events, and performs whatever internal /// stuff the window needs before the event is returned to the /// user. /// /// \param event Event to filter /// //////////////////////////////////////////////////////////// bool filterEvent(const Event& event); //////////////////////////////////////////////////////////// /// \brief Perform some common internal initializations /// //////////////////////////////////////////////////////////// void initialize(); //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// priv::GlContext* m_context; //!< Platform-specific implementation of the OpenGL context Clock m_clock; //!< Clock for measuring the elapsed time between frames Time m_frameTimeLimit; //!< Current framerate limit }; } // namespace sf #endif // SFML_WINDOW_HPP //////////////////////////////////////////////////////////// /// \class sf::Window /// \ingroup window /// /// sf::Window is the main class of the Window module. It defines /// an OS window that is able to receive an OpenGL rendering. /// /// A sf::Window can create its own new window, or be embedded into /// an already existing control using the create(handle) function. /// This can be useful for embedding an OpenGL rendering area into /// a view which is part of a bigger GUI with existing windows, /// controls, etc. It can also serve as embedding an OpenGL rendering /// area into a window created by another (probably richer) GUI library /// like Qt or wxWidgets. /// /// The sf::Window class provides a simple interface for manipulating /// the window: move, resize, show/hide, control mouse cursor, etc. /// It also provides event handling through its pollEvent() and waitEvent() /// functions. /// /// Note that OpenGL experts can pass their own parameters (antialiasing /// level, bits for the depth and stencil buffers, etc.) to the /// OpenGL context attached to the window, with the sf::ContextSettings /// structure which is passed as an optional argument when creating the /// window. /// /// On dual-graphics systems consisting of a low-power integrated GPU /// and a powerful discrete GPU, the driver picks which GPU will run an /// SFML application. In order to inform the driver that an SFML application /// can benefit from being run on the more powerful discrete GPU, /// #SFML_DEFINE_DISCRETE_GPU_PREFERENCE can be placed in a source file /// that is compiled and linked into the final application. The macro /// should be placed outside of any scopes in the global namespace. /// /// Usage example: /// \code /// // Declare and create a new window /// sf::Window window(sf::VideoMode(800, 600), "SFML window"); /// /// // Limit the framerate to 60 frames per second (this step is optional) /// window.setFramerateLimit(60); /// /// // The main loop - ends as soon as the window is closed /// while (window.isOpen()) /// { /// // Event processing /// sf::Event event; /// while (window.pollEvent(event)) /// { /// // Request for closing the window /// if (event.type == sf::Event::Closed) /// window.close(); /// } /// /// // Activate the window for OpenGL rendering /// window.setActive(); /// /// // OpenGL drawing commands go here... /// /// // End the current frame and display its contents on screen /// window.display(); /// } /// \endcode /// ////////////////////////////////////////////////////////////