423 lines
18 KiB
C++
423 lines
18 KiB
C++
////////////////////////////////////////////////////////////
|
|
//
|
|
// SFML - Simple and Fast Multimedia Library
|
|
// Copyright (C) 2007-2025 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.
|
|
//
|
|
////////////////////////////////////////////////////////////
|
|
|
|
#pragma once
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Headers
|
|
////////////////////////////////////////////////////////////
|
|
#include <SFML/Window/ContextSettings.hpp>
|
|
#include <SFML/Window/GlResource.hpp>
|
|
#include <SFML/Window/WindowBase.hpp>
|
|
#include <SFML/Window/WindowEnums.hpp>
|
|
#include <SFML/Window/WindowHandle.hpp>
|
|
|
|
#include <SFML/System/Clock.hpp>
|
|
#include <SFML/System/Time.hpp>
|
|
|
|
#include <memory>
|
|
|
|
#include <cstdint>
|
|
|
|
|
|
namespace sf
|
|
{
|
|
namespace priv
|
|
{
|
|
class GlContext;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \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 `mode`. An optional style can be passed to
|
|
/// customize the look and behavior of the window (borders,
|
|
/// title bar, resizable, closable, ...). An optional state can
|
|
/// be provided. If `state` is `State::Fullscreen`, then `mode`
|
|
/// must be a valid video mode.
|
|
///
|
|
/// The last parameter is an optional structure specifying
|
|
/// advanced OpenGL context settings such as anti-aliasing,
|
|
/// 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 state %Window state
|
|
/// \param settings Additional settings for the underlying OpenGL context
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
Window(VideoMode mode,
|
|
const String& title,
|
|
std::uint32_t style = Style::Default,
|
|
State state = State::Windowed,
|
|
const ContextSettings& settings = {});
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Construct a new window
|
|
///
|
|
/// This constructor creates the window with the size and pixel
|
|
/// depth defined in `mode`. If `state` is `State::Fullscreen`,
|
|
/// then `mode` must be a valid video mode.
|
|
///
|
|
/// The last parameter is an optional structure specifying
|
|
/// advanced OpenGL context settings such as anti-aliasing,
|
|
/// 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 state %Window state
|
|
/// \param settings Additional settings for the underlying OpenGL context
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
Window(VideoMode mode, const String& title, State state, const ContextSettings& settings = {});
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \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 anti-aliasing,
|
|
/// 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 = {});
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Destructor
|
|
///
|
|
/// Closes the window and frees all the resources attached to it.
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
~Window() override;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Deleted copy constructor
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
Window(const Window&) = delete;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Deleted copy assignment
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
Window& operator=(const Window&) = delete;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Move constructor
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
Window(Window&&) noexcept;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Move assignment
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
Window& operator=(Window&&) noexcept;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Create (or recreate) the window
|
|
///
|
|
/// If the window was already created, it closes it first.
|
|
/// If `state` is `State::Fullscreen`, then `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
|
|
/// \param state %Window state
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
void create(VideoMode mode, const String& title, std::uint32_t style = Style::Default, State state = State::Windowed) override;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Create (or recreate) the window
|
|
///
|
|
/// If the window was already created, it closes it first.
|
|
/// If `state` is `State::Fullscreen`, then `mode` must be
|
|
/// a valid video mode.
|
|
///
|
|
/// The last parameter is a structure specifying advanced OpenGL
|
|
/// context settings such as anti-aliasing, 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 state %Window state
|
|
/// \param settings Additional settings for the underlying OpenGL context
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
virtual void create(VideoMode mode, const String& title, std::uint32_t style, State state, const ContextSettings& settings);
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Create (or recreate) the window
|
|
///
|
|
/// If the window was already created, it closes it first.
|
|
/// If `state` is `State::Fullscreen`, then `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 state %Window state
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
void create(VideoMode mode, const String& title, State state) override;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Create (or recreate) the window
|
|
///
|
|
/// If the window was already created, it closes it first.
|
|
/// If `state` is `State::Fullscreen`, then `mode` must be
|
|
/// a valid video mode.
|
|
///
|
|
/// The last parameter is a structure specifying advanced OpenGL
|
|
/// context settings such as anti-aliasing, 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 state %Window state
|
|
/// \param settings Additional settings for the underlying OpenGL context
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
virtual void create(VideoMode mode, const String& title, State state, 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
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
void create(WindowHandle handle) override;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \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 anti-aliasing,
|
|
/// 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.
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
void close() override;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \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
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
[[nodiscard]] 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
|
|
/// imprecise 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
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
[[nodiscard]] 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 Perform some common internal initializations
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
void initialize();
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Member data
|
|
////////////////////////////////////////////////////////////
|
|
std::unique_ptr<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
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \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 (anti-aliasing
|
|
/// 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
|
|
/// while (const std::optional event = window.pollEvent())
|
|
/// {
|
|
/// // Request for closing the window
|
|
/// if (event->is<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
|
|
///
|
|
////////////////////////////////////////////////////////////
|