SO3Window.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3WINDOW_H__
#define __SO3WINDOW_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SCOLBasic/SO3DataScol.h"
#include "SO3Utils/SO3RayCast.h"
#include "SO3Renderer/SO3StereoManager.h"
 
namespace SO3
{
 
class SWindow : public Ogre::RenderTargetListener,
                public Ogre::FrameListener,
                public SData
{
public:
  enum SelectorMode
  {
    SO3_SELECTOR_FAST,
    SO3_SELECTOR_LIMITED,
    SO3_SELECTOR_PRECISE,
  };
protected:
private:
  SRoot* scolRoot;
  SViewPortList listOfViewPort;
  Ogre::RenderWindow* O3Window; 
  ScolWindowHandle hwnd;
  StereoManager::StereoMode mStereoMode;
  SelectorMode mSelectorMode;
  std::vector<SViewPort*> mViewportsToDel;
 
#ifdef _WIN32
  LONG_PTR hwndFullscreenOgre;
  LONG_PTR styleFullscreenOgre;
  LONG_PTR exstyleFullscreenOgre;
  HRGN mLastWindowRegion;
  WINDOWPLACEMENT mLastPos;
#endif
  StereoManager* stereoManager;
  SSubEntitySelectorBuffer* subEntitySelector;
  SRaycastResult lastRaycast;
  bool bBeginFrame;
  bool bSizeDirty;
  Ogre::Vector2 screenPos;
 
public:
  SWindow(SRoot* parent, const ScolWindowHandle& windowHandle, const std::string& windowName, const int& width, const int& height, const std::string& fsaa);
 
  Ogre::RenderWindow* GetOgreRenderWindowPointer();
 
  ~SWindow();
 
  void UpdateScreenPos();
 
  Ogre::Vector2 GetScreenPos();
 
  SRoot* GetParentRoot();
 
  ScolWindowHandle GetWindowHandle() const;
 
  void SetWindowHandle(ScolWindowHandle win);
 
  void RefreshSelector(const bool& forceRefresh = false);
 
  void SetSelectorEnable(const bool& state);
 
  void SetSelectorMode(SelectorMode mode);
 
  SelectorMode GetSelectorMode();
 
  void PauseWindow();
 
  void ResumeWindow();
 
  SViewPort* CreateViewport(SCamera* camera, int priority, const float& x, const float& y, const float& w, const float& h);
 
  void DeleteViewport(SViewPort* existingViewport);
 
  const SViewPortList& GetViewportList() const;
 
  SViewPort* GetViewport(const int& priority) const;
 
  SViewPort* GetViewport(const int& x, const int& y);
 
        void windowMoved(Ogre::RenderWindow* rw);
        
        void windowResized(Ogre::RenderWindow* rw);
        
        void windowClosed(Ogre::RenderWindow* rw);
        
        void windowFocusChange(Ogre::RenderWindow* rw);
        
        int     Size(const int& x, const int& y, const int& w, const int& h, const int& ext);
 
  void WindowMovedOrResized();
 
  unsigned int GetWidth() const;
 
  unsigned int GetHeight() const;
 
  int GetLeft();
 
  int GetTop();
 
  void SetSizeDirty();
 
  bool GetSizeDirty();
 
  bool GetFullScreen();
 
  bool SetFullScreen(const bool& fullscreen, const int& width = 0, const int& height = 0);
 
  bool CheckVideoMode(const int width, const int height);
 
  void Update();
 
  unsigned int GetBatchCount();
 
        unsigned int GetTriangleCount();
 
  float GetBestFrameTime() const;
 
  float GetWorstFrameTime() const;
 
  float GetBestFPS() const;
 
  /*
  Gets the worst frames per second (FPS) since the start of the rendering.
  */
  float GetWorstFPS() const;
 
  float GetAverageFPS() const;
 
        unsigned int GetFSAA() const;
 
  void SetStereoMode(const StereoManager::StereoMode& stereoMode);
 
  StereoManager::StereoMode GetStereoMode();
 
  float GetStereoEyesSpacing();
  
  void SetStereoEyesSpacing(const float& eyesSpacing);
 
  void SetStereoRotateView(const bool state);
 
  bool GetStereoRotateView();
 
  void SetStereoProjectionOffset(const float& offset);
 
  void SetStereoAspectRatio(const float& ratio);
 
  void SetStereoFOVy(const float& fov);
 
  void SetStereoDistortion(bool enable, Ogre::Vector4 dist);
 
  void SetStereoChromaticAbCorrection(bool enable, Ogre::Vector4 chromAbC);
 
        void SetStereoCustomProjectonMatrix(bool enable, const Ogre::Matrix4 &leftMatrix, const Ogre::Matrix4 &rightMatrix);
        void GetStereoCustomProjectonMatrix(bool &enabled, Ogre::Matrix4 &leftMatrix, Ogre::Matrix4 &rightMatrix) const;
  void SetStereoTimeWarpMatrix(const Ogre::Matrix4 &leftStartMatrix, const Ogre::Matrix4 &leftEndMatrix, const Ogre::Matrix4 &rightStartMatrix, const Ogre::Matrix4 &rightEndMatrix);
 
  void SetStereoMeshUVConfig(Ogre::Vector2 leftuvscale, Ogre::Vector2 leftuvoffset, Ogre::Vector2 rightuvscale, Ogre::Vector2 rightuvoffset);
  void SetStereoMeshRttSize(SO3::SPoint<int> leftsize, SO3::SPoint<int> rightsize);
  void SetStereoMeshLeft(std::vector<Ogre::Vector3> vertices, std::vector<std::vector<Ogre::Vector2> > uvs, std::vector<Ogre::Real> vignetteColor, std::vector<Ogre::Real> warp, std::vector<int> indexs);
  void SetStereoMeshRight(std::vector<Ogre::Vector3> vertices, std::vector<std::vector<Ogre::Vector2> > uvs, std::vector<Ogre::Real> vignetteColor, std::vector<Ogre::Real> warp, std::vector<int> indexs);
  void SetStereoWindow(SO3::SPoint<int> pos, SO3::SPoint<int> size, int index, bool state);
  std::array<SCOL_PTR_TYPE, 2> GetStereoTextures();
  std::array<SO3::SPoint<int>, 2> GetStereoViewportSize();
 
  SRaycastResult RayCast(const int& pixelsX, const int& pixelsY);
 
  SRaycastResult IndRayCast(const int& pixelsX, const int& pixelsY);
 
  SRaycastResult& GetLastRayCast();
 
  void InvalidateRayCast();
 
  void WriteContentsToFile(const std::string& path);
 
  bool UpdateStereoCompositorState(SViewPort* viewport, const Ogre::String compname, bool state);
 
  void RestoreStereoCamera(SViewPort* viewport);
 
  void UpdateStereoCamera(SViewPort* viewport, Ogre::Camera* camera);
 
  void UpdateStereoCameraMatrix(SViewPort* viewport, Ogre::Camera* camera);
 
  void UnregisterStereoViewport(SViewPort* viewport);
 
  void RegisterStereoViewport(SViewPort* viewport);
 
  void SynchStereoViewportSetup(SViewPort* viewport, bool overlay = false, bool shadow = false);
 
  bool IsStereoViewportRegistered(SViewPort* viewport);
 
  void ToPixelPos(int& px, int& py);
  
  void CleanViewports();
 
protected:
  void AddViewport(SViewPort* existingViewport);
 
  void RemoveViewport(SViewPort* existingViewport);
 
  virtual void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
        virtual void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
private:
  SWindow();
};
 
}
 
#endif