@ce. * Useful for example to change aspect ratio of the view or stretch it * to cover the full page. See @ref platforms-html5-layout for more * information about possible values. Note that this replaces any * existing class, to set multiple classes separate them with * whitespace. * * @note Only available on @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten". */ void setContainerCssClass(const std::string& cssClass); #endif /** * @brief Swap buffers * * Paints currently rendered framebuffer on screen. * @see @ref setSwapInterval() */ void swapBuffers(); /** @brief Swap interval */ Int swapInterval() const; /** * @brief Set swap interval * * Set @cpp 0 @ce for no VSync, @cpp 1 @ce for enabled VSync. Some * platforms support @cpp -1 @ce for late swap tearing. Prints error * message and returns @cpp false @ce if swap interval cannot be set, * @cpp true @ce otherwise. Default is driver-dependent, you can query * the value with @ref swapInterval(). * @see @ref setMinimalLoopPeriod() */ bool setSwapInterval(Int interval); #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief Set minimal loop period * * This setting reduces the main loop frequency in case VSync is * not/cannot be enabled or no drawing is done. Default is @cpp 0 @ce * (i.e. looping at maximum frequency). * @note Not available in @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten", * the browser is managing the frequency instead. * @see @ref setSwapInterval() */ void setMinimalLoopPeriod(UnsignedInt milliseconds) { _minimalLoopPeriod = milliseconds; } #endif /** * @brief Redraw immediately * * Marks the window for redrawing, resulting in call to @ref drawEvent() * in the next iteration. You can call it from @ref drawEvent() itself * to redraw immediately without waiting for user input. */ void redraw() { _flags |= Flag::Redraw; } private: /** * @brief Viewport event * * Called when window size changes. The default implementation does * nothing. If you want to respond to size changes, you should pass the * new *framebuffer* size to @ref GL::DefaultFramebuffer::setViewport() * (if using OpenGL) and possibly elsewhere (to * @ref SceneGraph::Camera::setViewport(), other framebuffers...) and * the new *window* size and DPI scaling to APIs that respond to user * events or scale UI elements. * * Note that this function might not get called at all if the window * size doesn't change. You should configure the initial state of your * cameras, framebuffers etc. in application constructor rather than * relying on this function to be called. Size of the window can be * retrieved using @ref windowSize(), size of the backing framebuffer * via @ref framebufferSize() and DPI scaling using @ref dpiScaling(). * See @ref Platform-Sdl2Application-dpi for detailed info about these * values. */ virtual void viewportEvent(ViewportEvent& event); #ifdef MAGNUM_BUILD_DEPRECATED /** @brief @copybrief viewportEvent(ViewportEvent&) * @deprecated Use @ref viewportEvent(ViewportEvent&) instead. * To preserve backwards compatibility, this function is called * from @ref viewportEvent(ViewportEvent&) with * @ref ViewportEvent::framebufferSize() passed to @p size. * Overriding the new function will cause this function to not be * called anymore. */ virtual CORRADE_DEPRECATED("use viewportEvent(ViewportEvent&) instead") void viewportEvent(const Vector2i& size); #endif /** * @brief Draw event * * Called when the screen is redrawn. You should clean the framebuffer * using @ref GL::DefaultFramebuffer::clear() (if using OpenGL) and * then add your own drawing functions. After drawing is finished, call * @ref swapBuffers(). If you want to draw immediately again, call also * @ref redraw(). */ virtual void drawEvent() = 0; /*@}*/ /** @{ @name Keyboard handling */ /** * @brief Key press event * * Called when an key is pressed. Default implementation does nothing. */ virtual void keyPressEvent(KeyEvent& event); /** * @brief Key release event * * Called when an key is released. Default implementation does nothing. */ virtual void keyReleaseEvent(KeyEvent& event); /*@}*/ /** @{ @name Mouse handling */ public: #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief Cursor type * * @see @ref setCursor() */ enum class Cursor: UnsignedInt { Arrow, /**< Arrow */ TextInput, /**< Text input */ Wait, /**< Wait */ Crosshair, /**< Crosshair */ WaitArrow, /**< Small wait cursor */ ResizeNWSE, /**< Double arrow pointing northwest and southeast */ ResizeNESW, /**< Double arrow pointing northeast and southwest */ ResizeWE, /**< Double arrow pointing west and east */ ResizeNS, /**< Double arrow pointing north and south */ ResizeAll, /**< Four pointed arrow pointing north, south, east, and west */ No, /**< Slashed circle or crossbones */ Hand, /**< Hand */ Hidden, /**< Hidden */ HiddenLocked /**< Hidden and locked */ }; #endif #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief Set cursor type * * Default is @ref Cursor::Arrow. */ void setCursor(Cursor cursor); /** @brief Get current cursor type */ Cursor cursor(); #endif #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief Warp mouse cursor to given coordinates * * @note Not available in @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten". */ void warpCursor(const Vector2i& position) { SDL_WarpMouseInWindow(_window, position.x(), position.y()); } #endif /** @brief Whether mouse is locked */ bool isMouseLocked() const { return SDL_GetRelativeMouseMode(); } /** * @brief Enable or disable mouse locking * * When mouse is locked, the cursor is hidden and only * @ref MouseMoveEvent::relativePosition() is changing, absolute * position stays the same. */ void setMouseLocked(bool enabled); private: /** * @brief Mouse press event * * Called when mouse button is pressed. Default implementation does * nothing. */ virtual void mousePressEvent(MouseEvent& event); /** * @brief Mouse release event * * Called when mouse button is released. Default implementation does * nothing. */ virtual void mouseReleaseEvent(MouseEvent& event); /** * @brief Mouse move event * * Called when mouse is moved. Default implementation does nothing. */ virtual void mouseMoveEvent(MouseMoveEvent& event); /** * @brief Mouse scroll event * * Called when a scrolling device is used (mouse wheel or scrolling * area on a touchpad). Default implementation does nothing. */ virtual void mouseScrollEvent(MouseScrollEvent& event); /*@}*/ /** @{ @name Touch gesture handling */ /** * @brief Multi gesture event * * Called when the user performs a gesture using multiple fingers. * Default implementation does nothing. * @experimental */ virtual void multiGestureEvent(MultiGestureEvent& event); /*@}*/ /** @{ @name Text input handling */ public: /** * @brief Whether text input is active * * If text input is active, text input events go to @ref textInputEvent() * and @ref textEditingEvent(). * @note Note that in @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten" the * value is emulated and might not reflect external events like * closing on-screen keyboard. * @see @ref startTextInput(), @ref stopTextInput() */ bool isTextInputActive(); /** * @brief Start text input * * Starts text input that will go to @ref textInputEvent() and * @ref textEditingEvent(). * @see @ref stopTextInput(), @ref isTextInputActive(), * @ref setTextInputRect() */ void startTextInput(); /** * @brief Stop text input * * Stops text input that went to @ref textInputEvent() and * @ref textEditingEvent(). * @see @ref startTextInput(), @ref isTextInputActive(), @ref textInputEvent() * @ref textEditingEvent() */ void stopTextInput(); /** * @brief Set text input rectangle * * The @p rect defines an area where the text is being displayed, for * example to hint the system where to place on-screen keyboard. */ void setTextInputRect(const Range2Di& rect); private: /** * @brief Text input event * * Called when text input is active and the text is being input. * @see @ref isTextInputActive() */ virtual void textInputEvent(TextInputEvent& event); /** * @brief Text editing event * * Called when text input is active and the text is being edited. */ virtual void textEditingEvent(TextEditingEvent& event); /*@}*/ /** @{ @name Special events */ /** * @brief Exit event * * If implemented, it allows the application to react to an application * exit (for example to save its internal state) and suppress it as * well (for example to show a exit confirmation dialog). The default * implementation calls @ref ExitEvent::setAccepted() on @p event, * which tells the application that it's safe to exit. * * SDL has special behavior on POSIX systems regarding `SIGINT` and * `SIGTERM` handling, see @ref Platform-Sdl2Application-usage-posix * for more information. */ virtual void exitEvent(ExitEvent& event); protected: /** * @brief Tick event * * If implemented, this function is called periodically after * processing all input events and before draw event even though there * might be no input events and redraw is not requested. Useful e.g. * for asynchronous task polling. Use @ref setMinimalLoopPeriod()/ * @ref setSwapInterval() to control main loop frequency. * * If this implementation gets called from its @cpp override @ce, it * will effectively stop the tick event from being fired and the app * returns back to waiting for input events. This can be used to * disable the tick event when not needed. */ virtual void tickEvent(); private: /** * @brief Any event * * Called in case a SDL event is not handled by any other event * functions above. * @see @ref ViewportEvent::event(), @ref InputEvent::event(), * @ref MultiGestureEvent::event(), @ref TextInputEvent::event(), * @ref TextEditingEvent::event(), @ref ExitEvent::event() */ virtual void anyEvent(SDL_Event& event); /*@}*/ private: enum class Flag: UnsignedByte { Redraw = 1 << 0, VSyncEnabled = 1 << 1, NoTickEvent = 1 << 2, NoAnyEvent = 1 << 3, Exit = 1 << 4, #ifdef CORRADE_TARGET_EMSCRIPTEN TextInputActive = 1 << 5, Resizable = 1 << 6 #endif }; typedef Containers::EnumSet Flags; CORRADE_ENUMSET_FRIEND_OPERATORS(Flags) #ifndef CORRADE_TARGET_EMSCRIPTEN SDL_Cursor* _cursors[14]{}; #endif /* These are saved from command-line arguments */ bool _verboseLog{}; Implementation::Sdl2DpiScalingPolicy _commandLineDpiScalingPolicy{}; Vector2 _commandLineDpiScaling; Vector2 _dpiScaling; #ifndef CORRADE_TARGET_EMSCRIPTEN SDL_Window* _window{}; UnsignedInt _minimalLoopPeriod; #else SDL_Surface* _surface{}; Vector2i _lastKnownCanvasSize; #endif #ifdef MAGNUM_TARGET_GL #ifndef CORRADE_TARGET_EMSCRIPTEN SDL_GLContext _glContext{}; #endif Containers::Pointer _context; #endif Flags _flags; int _exitCode = 0; }; #ifdef MAGNUM_TARGET_GL /** @brief OpenGL context configuration The created window is always with a double-buffered OpenGL context. @note This function is available only if Magnum is compiled with @ref MAGNUM_TARGET_GL enabled (done by default). See @ref building-features for more information. @see @ref Sdl2Application(), @ref create(), @ref tryCreate() */ class Sdl2Application::GLConfiguration { public: #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief Context flag * * @see @ref Flags, @ref setFlags(), @ref GL::Context::Flag * @requires_gles Context flags are not available in WebGL. */ enum class Flag: int { #ifndef MAGNUM_TARGET_GLES /** * Forward compatible context * * @requires_gl Core/compatibility profile distinction and forward * compatibility applies only to desktop GL. */ ForwardCompatible = SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, #endif /** * Debug context. Enabled automatically if the * `--magnum-gpu-validation` @ref GL-Context-command-line "command-line option" * is present. */ Debug = SDL_GL_CONTEXT_DEBUG_FLAG, /** Context with robust access */ RobustAccess = SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG, /** Context with reset isolation */ ResetIsolation = SDL_GL_CONTEXT_RESET_ISOLATION_FLAG }; /** * @brief Context flags * * @see @ref setFlags(), @ref GL::Context::Flags * @requires_gles Context flags are not available in WebGL. */ #ifndef DOXYGEN_GENERATING_OUTPUT typedef Containers::EnumSet Flags; #else typedef Containers::EnumSet Flags; #endif #endif explicit GLConfiguration(); ~GLConfiguration(); #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief Context flags * * @requires_gles Context flags are not available in WebGL. */ Flags flags() const { return _flags; } /** * @brief Set context flags * @return Reference to self (for method chaining) * * Default is @ref Flag::ForwardCompatible on desktop GL and no flags * on OpenGL ES. * @see @ref addFlags(), @ref clearFlags(), @ref GL::Context::flags() * @requires_gles Context flags are not available in WebGL. */ GLConfiguration& setFlags(Flags flags) { _flags = flags; return *this; } /** * @brief Add context flags * @return Reference to self (for method chaining) * * Unlike @ref setFlags(), ORs the flags with existing instead of * replacing them. Useful for preserving the defaults. * @see @ref clearFlags() * @requires_gles Context flags are not available in WebGL. */ GLConfiguration& addFlags(Flags flags) { _flags |= flags; return *this; } /** * @brief Clear context flags * @return Reference to self (for method chaining) * * Unlike @ref setFlags(), ANDs the inverse of @p flags with existing * instead of replacing them. Useful for removing default flags. * @see @ref addFlags() * @requires_gles Context flags are not available in WebGL. */ GLConfiguration& clearFlags(Flags flags) { _flags &= ~flags; return *this; } /** * @brief Context version * * @note Not available in @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten". */ GL::Version version() const { return _version; } #endif /** * @brief Set context version * * If requesting version greater or equal to OpenGL 3.1, core profile * is used. The created context will then have any version which is * backwards-compatible with requested one. Default is * @ref GL::Version::None, i.e. any provided version is used. * @note In @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten" this function * does nothing (@ref GL::Version::GLES200 or * @ref GL::Version::GLES300 is used implicitly based on the * target). */ GLConfiguration& setVersion(GL::Version version) { #ifndef CORRADE_TARGET_EMSCRIPTEN _version = version; #else static_cast(version); #endif return *this; } /** @brief Color buffer size */ Vector4i colorBufferSize() const { return _colorBufferSize; } /** * @brief Set color buffer size * * Default is @cpp {8, 8, 8, 0} @ce (8-bit-per-channel RGB, no alpha). * @see @ref setDepthBufferSize(), @ref setStencilBufferSize() */ GLConfiguration& setColorBufferSize(const Vector4i& size) { _colorBufferSize = size; return *this; } /** @brief Depth buffer size */ Int depthBufferSize() const { return _depthBufferSize; } /** * @brief Set depth buffer size * * Default is @cpp 24 @ce bits. * @see @ref setColorBufferSize(), @ref setStencilBufferSize() */ GLConfiguration& setDepthBufferSize(Int size) { _depthBufferSize = size; return *this; } /** @brief Stencil buffer size */ Int stencilBufferSize() const { return _stencilBufferSize; } /** * @brief Set stencil buffer size * * Default is @cpp 0 @ce bits (i.e., no stencil buffer). * @see @ref setColorBufferSize(), @ref setDepthBufferSize() */ GLConfiguration& setStencilBufferSize(Int size) { _stencilBufferSize = size; return *this; } /** @brief Sample count */ Int sampleCount() const { return _sampleCount; } /** * @brief Set sample count * @return Reference to self (for method chaining) * * Default is @cpp 0 @ce, thus no multisampling. See also * @ref GL::Renderer::Feature::Multisampling. */ GLConfiguration& setSampleCount(Int count) { _sampleCount = count; return *this; } #ifndef CORRADE_TARGET_EMSCRIPTEN /** * @brief sRGB-capable default framebuffer * * @note Not available in @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten". */ bool isSrgbCapable() const { return _srgbCapable; } /** * @brief Set sRGB-capable default framebuffer * @return Reference to self (for method chaining) * * Default is @cpp false @ce. See also * @ref GL::Renderer::Feature::FramebufferSrgb. * @note Not available in @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten". */ GLConfiguration& setSrgbCapable(bool enabled) { _srgbCapable = enabled; return *this; } #ifdef MAGNUM_BUILD_DEPRECATED /** * @brief @copybrief isSrgbCapable() * @deprecated Use @ref isSrgbCapable() instead. */ CORRADE_DEPRECATED("use isSrgbCapable() instead") bool isSRGBCapable() const { return isSrgbCapable(); } /** * @brief @copybrief setSrgbCapable() * @deprecated Use @ref setSrgbCapable() instead. */ CORRADE_DEPRECATED("use setSrgbCapable() instead") GLConfiguration& setSRGBCapable(bool enabled) { return setSrgbCapable(enabled); } #endif #endif private: Vector4i _colorBufferSize; Int _depthBufferSize, _stencilBufferSize; Int _sampleCount; #ifndef CORRADE_TARGET_EMSCRIPTEN GL::Version _version; Flags _flags; bool _srgbCapable; #endif }; #ifndef CORRADE_TARGET_EMSCRIPTEN CORRADE_ENUMSET_OPERATORS(Sdl2Application::GLConfiguration::Flags) #endif #endif namespace Implementation { enum class Sdl2DpiScalingPolicy: UnsignedByte { /* Using 0 for an "unset" value */ #ifdef CORRADE_TARGET_APPLE Framebuffer = 1, #endif #ifndef CORRADE_TARGET_APPLE #if !defined(CORRADE_TARGET_EMSCRIPTEN) && !defined(CORRADE_TARGET_ANDROID) Virtual = 2, #endif Physical = 3, #endif Default #ifdef CORRADE_TARGET_APPLE = Framebuffer #elif !defined(CORRADE_TARGET_EMSCRIPTEN) && !defined(CORRADE_TARGET_ANDROID) = Virtual #else = Physical #endif }; } /** @brief Configuration @see @ref Sdl2Application(), @ref GLConfiguration, @ref create(), @ref tryCreate() */ class Sdl2Application::Configuration { public: /** * @brief Window flag * * @see @ref WindowFlags, @ref setWindowFlags() */ enum class WindowFlag: Uint32 { /** * Resizable window. On iOS this allows the application to respond * to display orientation changes, on * @ref CORRADE_TARGET_EMSCRIPTEN "Emscripten" this causes the * framebuffer to be resized when the @cb{.html}