/*------------------------------------------------------------------------- This source file is a part of OGRE (Object-oriented Graphics Rendering Engine) For the latest info, see http://www.ogre3d.org/ Copyright (c) 2000-2014 Torus Knot Software Ltd Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE -------------------------------------------------------------------------*/ #ifndef __RenderWindow_H__ #define __RenderWindow_H__ #include "OgrePrerequisites.h" #include "OgreRenderTarget.h" namespace Ogre { /** \addtogroup Core * @{ */ /** \addtogroup RenderSystem * @{ */ /** Manages the target rendering window. This class handles a window into which the contents of a scene are rendered. There is a many-to-1 relationship between instances of this class an instance of RenderSystem which controls the rendering of the scene. There may be more than one window in the case of level editor tools etc. This class is abstract since there may be different implementations for different windowing systems. Instances are created and communicated with by the render system although client programs can get a reference to it from the render system if required for resizing or moving. Note that you can have multiple viewpoints in the window for effects like rear-view mirrors and picture-in-picture views (see Viewport and Camera). @author Steven Streeting */ class _OgreExport RenderWindow : public RenderTarget { public: /** Default constructor. */ RenderWindow(); /** Many windowing systems that support HiDPI displays use special points to specify size of the windows and controls, so that windows and controls with hardcoded sizes does not become too small on HiDPI displays. Such points have constant density ~ 100 points per inch (probably 96 on Windows and 72 on Mac), that is independent of pixel density of real display, and are used through the all windowing system. Sometimes, such view points are chosen bigger for output devices that are viewed from larger distances, like 30" TV comparing to 30" monitor, therefore maintaining constant points angular density rather than constant linear density. In any case, all such windowing system provides the way to convert such view points to pixels, be it DisplayProperties::LogicalDpi on WinRT or backingScaleFactor on MacOSX. We use pixels consistently through the Ogre, but window/view management functions takes view points for convenience, as does the rest of windowing system. Such parameters are named using xxxxPt pattern, and should not be mixed with pixels without being converted using getViewPointToPixelScale() function. Sometimes such scale factor can change on-the-fly, for example if window is dragged to monitor with different DPI. In such situation, window size in view points is usually preserved by windowing system, and Ogre should adjust pixel size of RenderWindow. */ virtual float getViewPointToPixelScale() { return 1.0f; } /** Creates & displays the new window. @param name the internal window name. Not necessarily the title. @param widthPt The width of the window in view points. @param heightPt The height of the window in view points. @param fullScreen If true, the window fills the screen, with no title bar or border. @param miscParams A variable number of pointers to platform-specific arguments. The actual requirements must be defined by the implementing subclasses. */ virtual void create(const String& name, unsigned int widthPt, unsigned int heightPt, bool fullScreen, const NameValuePairList *miscParams) = 0; /** Alter fullscreen mode options. Nothing will happen unless the settings here are different from the current settings. @note Only implemented by few RenderSystems. Prefer native windowing API. @param fullScreen Whether to use fullscreen mode or not. @param widthPt The new width to use @param heightPt The new height to use */ virtual void setFullscreen(bool fullScreen, unsigned int widthPt, unsigned int heightPt) { (void)fullScreen; (void)widthPt; (void)heightPt; } /** Destroys the window. */ virtual void destroy(void) = 0; /** Alter the size of the window. */ virtual void resize(unsigned int widthPt, unsigned int heightPt); /** Query the current size and position from an external window handle. @note most of the time you already know the size and should call @ref resize instead. */ virtual void windowMovedOrResized() {} /** Reposition the window. @note Only implemented by few RenderSystems. Prefer native windowing API. */ virtual void reposition(int leftPt, int topPt) {} /** Indicates whether the window is visible (not minimized or obscured) */ virtual bool isVisible(void) const { return true; } /** Set the visibility state */ virtual void setVisible(bool visible) { (void)visible; } /** Indicates whether the window was set to hidden (not displayed) */ virtual bool isHidden(void) const { return false; } /** Hide (or show) the window. If called with hidden=true, this will make the window completely invisible to the user. Setting a window to hidden is useful to create a dummy primary RenderWindow hidden from the user so that you can create and recreate your actual RenderWindows without having to recreate all your resources. */ virtual void setHidden(bool hidden) { (void)hidden; } /** Enable or disable vertical sync for the RenderWindow. */ virtual void setVSyncEnabled(bool vsync) { (void)vsync; } /** Indicates whether vertical sync is activated for the window. */ virtual bool isVSyncEnabled() const { return false; } /** Set the vertical sync interval. This indicates the number of vertical retraces to wait for before swapping buffers. A value of 1 is the default. */ virtual void setVSyncInterval(unsigned int interval) { (void)interval; } /** Returns the vertical sync interval. */ unsigned int getVSyncInterval() const { return mVSyncInterval; } /** Overridden from RenderTarget, flags invisible windows as inactive */ bool isActive(void) const override { return mActive && isVisible(); } /** Indicates whether the window has been closed by the user. */ virtual bool isClosed(void) const { return mClosed; } /** Indicates whether the window is the primary window. The primary window is special in that it is destroyed when ogre is shut down, and cannot be destroyed directly. This is the case because it holds the context for vertex, index buffers and textures. */ bool isPrimary(void) const override; /** Returns true if window is running in fullscreen mode. */ virtual bool isFullScreen(void) const; /** Overloaded version of getMetrics from RenderTarget, including extra details specific to windowing systems. Result is in pixels. */ void getMetrics(unsigned int& width, unsigned int& height, int& left, int& top) const; /// Override since windows don't usually have alpha PixelFormat suggestPixelFormat() const override { return PF_BYTE_RGB; } /** Returns true if the window will automatically de-activate itself when it loses focus. */ bool isDeactivatedOnFocusChange() const; /** Indicates whether the window will automatically deactivate itself when it loses focus. * @param deactivate a value of 'true' will cause the window to deactivate itself when it loses focus. 'false' will allow it to continue to render even when window focus is lost. * @note 'true' is the default behavior. */ void setDeactivateOnFocusChange(bool deactivate); #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID || OGRE_PLATFORM == OGRE_PLATFORM_EMSCRIPTEN virtual void _notifySurfaceDestroyed() = 0; virtual void _notifySurfaceCreated(void* nativeWindow, void* config = NULL) = 0; #endif protected: bool mIsFullScreen; bool mIsPrimary; bool mAutoDeactivatedOnFocusChange; bool mClosed; int mLeft; int mTop; unsigned int mVSyncInterval; /** Indicates that this is the primary window. Only to be called by Ogre::Root */ void _setPrimary() { mIsPrimary = true; } friend class Root; }; /** @} */ /** @} */ } // Namespace #endif