SO3ViewPort.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 __SO3VIEWPORT_H__
#define __SO3VIEWPORT_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3HdrHandler.h"
 
#ifdef SO3_BUILD_DEFERRED
#include "SO3Renderer/DeferredShading/SO3DeferredShading.h"
#endif
 
namespace SO3
{
class SSsaoHandler;
 
#define SO3_VISIBILITY_MASK_DEFAULT               0xFFFFFFFF
#define SO3_VISIBILITY_MASK_INVISIBLE_ENVIRONMENT 0xFFFFFFFE
#define SO3_VISIBILITY_MASK_VISIBLE_WATER_RTT     0x00000002
 
#define SO3_VISIBILITY_FLAGS_DEFAULT              0xFFFFFFFF
#define SO3_VISIBILITY_FLAG_INVISIBLE_ENVIRONMENT 0x00000001
#define SO3_VISIBILITY_FLAG_INTERNAL_MAXIMUM      0x00000002
 
class SViewPort : public Ogre::Viewport::Listener, Ogre::MaterialManager::Listener
{
public:
protected:
private:
  bool bClearDepth; //$BB
  bool bClearColor; //$BB
  SWindow* scolWindow;
  SCamera* scolCamera;
        Ogre::Viewport* O3ViewPort;
        SCompositorMap compList;
 
#ifdef SO3_BUILD_DEFERRED
  bool bDeferredEnable;
#endif
 
  bool bSSAOEnable;
 
#ifdef SO3_BUILD_DEFERRED
  SDeferredShading::DeferredShadingAntiAliasingMode bDeferredAntiAliasingMode;
#endif
 
  SSsaoHandler* ssaoHandler;
  SHdrHandler* hdrHandler;
public:
  SViewPort(SWindow* parent, SCamera* targetCamera, int priority, const float& x, const float& y, const float& w, const float& h);
 
  ~SViewPort();
 
  Ogre::Viewport* GetOgreViewPortPointer();
 
  SWindow* GetParentWindow() const;
 
  std::string GetMaterialScheme();
  
  void SetMaterialScheme(const std::string& existingScheme);
 
  void SetPositionAndSize(const float& x, const float& y, const float& w, const float& h);
 
  void ResizeToWindow(const float& w, const float& h);
 
  float GetLeft();
 
  float GetTop();
 
  float GetWidth();
 
  float GetHeight();
 
  int GetLeftPixels();
 
  int GetTopPixels();
 
  int GetWidthPixels();
 
  int GetHeightPixels();
 
  int GetPriority();
 
  bool GetShadowsEnabled();
 
  void SetShadowsEnabled(const bool& enableShadows);
 
  void SetBackgroundColour(const int& backgroundColor);
 
  int GetBackgroundColor();
 
  SCamera* GetCamera();
 
  void SetCamera(SCamera* camera);
  
  bool UpdateStereoCompositorState(const Ogre::String compname, bool state);
 
  void UpdateStereoCamera(Ogre::Camera* camera);
 
  void RestoreStereoCamera();
 
  void UpdateStereoCameraMatrix(Ogre::Camera* camera);
 
  void UnregisterStereoViewport();
 
  void RegisterStereoViewport();
 
  bool IsStereoViewportRegistered();
 
  bool GetClearDepth();
 
  void SetClearDepth(const bool& state);
 
  bool GetClearColor();
  
  void SetClearColor(const bool& value);
  
  void SetSkyEnable(const bool& value);
 
  bool GetSkyEnable();
 
  void SetOverlayEnable(const bool& value);
 
  bool GetOverlayEnable();
 
#ifdef SO3_BUILD_DEFERRED
  void SetDeferredEnable(const bool& value);
 
  bool GetDeferredEnable();
#endif
 
  void SetSSAOEnable(const bool& value);
 
  bool GetSSAOEnable();
 
  SSsaoHandler* GetSSAOhandler();
 
  void SetHDREnable(const bool& value);
 
  bool GetHDREnable();
 
  SHdrHandler* GetHDRhandler();
 
  void SetHDRBlurAmount(const float& value);
 
  void SetHDREffectAmount(const float& value);
 
  void SetHDRGamma(const float& value);
 
#ifdef SO3_BUILD_DEFERRED
  void SetDeferredAntiAliasingMode(const SDeferredShading::DeferredShadingAntiAliasingMode& value);
 
  SDeferredShading::DeferredShadingAntiAliasingMode GetDeferredAntiAliasingMode();
 
 
  void SetDeferredDebugMode(const int& value);
 
  int GetDeferredDebugMode();
#endif
  
  void SetVisibilityMask(const Ogre::uint32& mask);
 
  Ogre::uint32 GetVisibilityMask();
 
  void SetVisibilityMaskIndexEnable(const Ogre::uint32 flagIndex, const bool enable);
 
  bool GetVisibilityMaskIndexEnable(const Ogre::uint32 flagIndex);
 
  void Update();
 
  SCompositor* CreateCompositor(const std::string& newCompositorName, const std::string& newSchemeName);
 
  void DeleteCompositor(SCompositor* existingCompositor);
 
  void DeleteCompositor(const std::string& existingCompositorName);
 
  SCompositor* GetCompositor(const std::string& compositorName);
 
  const SCompositorMap& GetCompositorList() const;
 
  void ClearCompositors();
 
  bool GetScreenPosFromWorldPos(Ogre::Vector3 worldPosition, Ogre::Vector2 &screenPos);
 
  SRaycastResult RayCast(const int& pixelsX, const int& pixelsY, SSubEntitySelectorBuffer* subEntitySelector);
 
  SRaycastResult RayCast(const int& pixelsX, const int& pixelsY);
 
  Ogre::Vector3 RayCastCamera(const int& pixelsX, const int& pixelsY, const float distance, Ogre::Vector3 &outDirection);
  
  unsigned int GetNumRenderedFaces();
 
  unsigned int GetNumRenderedBatches();
  
  void ToPixelPos(int& px, int& py);
  void ToPixelPos(float& px, float& py);
  
  void ToWindowPos(int& px, int& py);
  void ToWindowPos(float& px, float& py);
  
protected:
  void AddCompositor(SCompositor* existingCompositor);
 
  void RemoveCompositor(SCompositor* existingCompositor);
 
  void RemoveCompositor(const std::string& compositorName);
 
  virtual void viewportDimensionsChanged(Ogre::Viewport* viewport);
 
  virtual Ogre::Technique* handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend);
 
private:
  SViewPort();
};
 
}
 
#endif