SO3Root.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 __SO3ROOT_H__
#define __SO3ROOT_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3Web/SO3EmbeddedWebNavigatorPrerequisites.h"
#include <OgreSingleton.h>
#include <OgreRTShaderSystem.h>
#include <OgreShaderGenerator.h>
#include <OgreOverlaySystem.h>
#include <OgreSTBICodec.h>
#include <boost/thread/thread.hpp>
#include <boost/bind/bind.hpp>
 
namespace SO3
{
 
  typedef std::list<std::string> manualGroupList;
 
class ShaderGeneratorTechniqueResolverListener : public Ogre::MaterialManager::Listener
{
public:
 
  virtual Ogre::Technique* handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend);
 
  virtual bool afterIlluminationPassesCreated(Ogre::Technique* tech);
 
  virtual bool beforeIlluminationPassesCleared(Ogre::Technique* tech);
};
 
 
class _SO3_Export SRoot : public Ogre::Singleton<SRoot>, public Ogre::LogListener, public Ogre::RenderSystem::Listener
{
public:
  enum RenderSystem
  {
    SO3_NONE_RENDER_SYSTEM = -1,
    SO3_DIRECTX9_RENDERER,
    SO3_DIRECTX11_RENDERER,
    SO3_OPENGL_RENDERER,
    SO3_OPENGL3_RENDERER,
    SO3_VULKAN_RENDERER,
    SO3_METAL_RENDERER,
    SO3_TINY_RENDERER
  };
protected:
private:
  ShaderGeneratorTechniqueResolverListener* mMaterialMgrListener;   // Shader generator material manager listener.
 
  bool mDeviceLost;
  bool mRootInitialised;
  unsigned int windowIndex;
  RenderSystem renderSystem;
  std::string defaultFsaa;
  Ogre::RenderSystem* O3Render;
  Ogre::Root* O3Root;
  Ogre::RTShader::ShaderGenerator* mShaderGenerator;
  manualGroupList mManualGroups;
 
#ifdef SO3_BUILD_DEFERRED
  SDeferredShading* deferredManager;
#endif
 
  SO3ScolFileSystemArchiveFactory* scolFileSystemArchiveFactory;
  SSceneMap sceneList;
  SWindowMap windowList;
  SPluginManager* pluginManager;
  Ogre::ParticleFXPlugin* staticPluginParticleFX;
  Ogre::SceneManager* mDummyScene;
 
#if !defined(ANDROID) && !defined(APPLE_IOS) && !defined(SO3_USE_METAL) && !defined(RPI)
  Ogre::CgPlugin*         staticPluginCG;
#endif
 
  Ogre::OctreePlugin*     staticPluginOctree;
  Ogre::OverlaySystem*    O3OverlaySystem;
 
  SWidgetManager* widgetManager;
 
#ifdef SO3_FLASH_ENABLE
  SFlashWidgetFactory* flashWidgetFactory;
#endif
 
  SBitmapWidgetFactory* bitmapWidgetFactory;
  SObjWindowWidgetFactory* objWindowWidgetFactory;
  #if SO3_WEB_NAVIGATOR_BUILD == 1
    EmbeddedWebNavigator::WebNavigatorManager* webNavigatorManager;
    SWebNavigatorWidgetFactory* webNavigatorWidgetFactory;
  #endif
  SKeyboardHook* keyboardHook;
  SWindow* fullScreenWindow;
  typedef std::set<SLogListener*> LogListenerList;
  LogListenerList logListenerList;
  bool mLogEnable;
  bool mDebugEnable;
#ifdef SO3_DEVELOPPER_BUILD
# ifdef _WIN32
#  ifndef SO3_USE_DX11
    Ogre::D3D9Plugin* staticPluginD3D9;
#  else
    Ogre::D3D11Plugin* staticPluginD3D11;
#  endif
# endif
 
# ifndef SO3_USE_OPENGLES2
#   ifdef SO3_USE_GL3
    Ogre::GL3PlusPlugin* staticPluginOpenGL3;
#   elif !defined(SO3_USE_METAL)
    Ogre::GLPlugin* staticPluginOpenGL;
#   endif
# elif !defined(SO3_USE_METAL)
    Ogre::GLES2Plugin* staticPluginOpenGLES2;
# endif
  
# if defined(__APPLE__) && defined(SO3_USE_METAL)
    Ogre::MetalPlugin* staticPluginMetal;
# endif
 
# if defined(_WIN64)
    //Ogre::TinyPlugin* staticPluginTiny;
 
    Ogre::VulkanPlugin* staticPluginVulkan;
    Ogre::GLSLangPlugin* staticPluginGLSLang;
# endif
 
#endif
  bool mDebugInitialized;
  bool mPaused;
  Ogre::RenderWindow* dummyWindow;
  SResourceLoader* resourceLoader;
  float quadBufferFocalLength;
  float quadBufferEyesSeparation;
  bool useVSync;
  bool mResourcesReleased;
  Ogre::GpuSharedParametersPtr mSlicePlaneParams;
  Ogre::GpuSharedParametersPtr mCommonParams;
  bool mSlicePlaneState;
  Ogre::Vector4 mSlicePlane;
  bool mUpdating;
  bool mRendering;
 
#ifdef ANDROID
  int mMainWidth;
  int mMainHeight;
#endif
public:
  SRoot(const std::string& firstPartition);
 
  ~SRoot();
 
#ifdef _WIN32
  void* GetD3Ddevice();
#endif
 
  void InitRenderer(SWindow* pwin = 0);
 
  bool IsRenderInitialised();
 
  bool SetFullScreenState(SWindow* window, const bool& state, const int& width, const int& height);
 
  void AddLogListener(SLogListener* newLogListener);
 
  void RemoveLogListener(SLogListener* existingLogListener);
 
  void SetLogEnable(const bool& state);
 
  bool GetLogEnable();
 
  void SetLogMask(const Ogre::LogMessageLevel& level);
 
  Ogre::Root* GetOgreRootPointer();
 
  Ogre::RenderSystem* GetOgreRenderSystem();
 
  bool IsUpdating();
 
  bool IsRendering();
 
#ifdef SO3_BUILD_DEFERRED
  SDeferredShading* GetDeferredManager();
#endif
 
  static SRoot& getSingleton();
 
  static SRoot* getSingletonPtr();
 
  SScene* CreateScene(const std::string& newSceneName);
 
  void DeleteScene(SScene* existingScene);
 
  SScene* GetScene(const std::string& sceneName);
 
  void AddManualRessourceGroup(std::string name);
 
  void RemoveManualRessourceGroup(std::string name);
 
  void ClearManualRessourceGroups();
 
  const SSceneMap& GetSceneList() const;
 
  bool checkFSAA(const Ogre::String& val);
 
  RenderSystem GetRenderSystem();
 
  std::vector<std::string> GetMultisamplingMode(const RenderSystem& wishedRenderSystem);
 
  SWindow* CreateRenderWindow(const ScolWindowHandle windowHandle, const std::string& windowName, const int& width, const int& height, const std::string& renderWindowFsaa="default");
 
  void DeleteRenderWindow(SWindow* existingWindow);
 
  const SWindowMap& GetRenderWindowList() const;
 
  SWindow* GetRenderWindow(const std::string& windowName);
 
  SWindow* GetRenderWindow(const ScolWindowHandle& hwnd);
 
  bool CheckDirectxVersion();
 
  void SetDebugEnable(const bool& enable);
 
  bool GetDebugEnable();
 
  void SetDebugDisplay(const int& color, const int& posx, const int& posy, const int& width, const int& height, const int& charHeight);
 
  void SetDebugText(const std::string& text);
 
  void UpdateCamera(SViewPort* viewport);
 
  void RegisterViewport(SViewPort* viewport);
 
  void UnregisterViewport(SViewPort* viewport);
 
  bool Update();
 
  void DestroyInternalRessources();
 
  void ReloadInternalRessources();
 
  void Pause();
 
  void Resume();
 
  bool GetQuadBufferEnable();
 
  float GetQuadBufferFocalLength();
 
  float GetQuadBufferEyesSeparation();
 
  bool GetVSyncEnable();
 
  bool isDeviceLost();
 
  bool GetRttPixelFormat(Ogre::PixelFormat &format, bool alpha = false, bool floattex = false);
 
  void InvalidateGeneratedMaterial(Ogre::Material* mat);
 
  void RemoveGeneratedMaterial(Ogre::Material* mat);
 
  void ParseConfigFile();
 
  void SetSlicePlaneState(bool state);
 
  void SetSlicePlane(Ogre::Vector4 plane);
 
  bool GetSlicePlaneState();
 
  Ogre::Vector4 GetSlicePlane();
 
  void SetProgramCameraParameter(float fov, float znear, float zfar, float focalLength);
 
protected:
  virtual void messageLogged(const Ogre::String& message, Ogre::LogMessageLevel lml, bool maskDebug, const Ogre::String& logName, bool& skipMessage);
 
  virtual void eventOccurred(const Ogre::String &eventName, const Ogre::NameValuePairList *parameters);
 
  void AddScene(SScene* existingScene);
 
  void RemoveScene(SScene* existingScene);
 
  void RemoveScene(const std::string& sceneName);
 
  void AddRenderWindow(SWindow* existingWindow);
 
  void RemoveRenderWindow(SWindow* existingWindow);
 
  void RemoveRenderWindow(const std::string& windowName);
 
private:
  void ClearSceneManagerPassMaps();
 
  bool LoadOgrePlugins();
 
  bool UnloadOgrePlugins();
 
  void CreateBoneHelperMesh();
 
  void WriteConfigFile(const std::string& filename);
 
  void SetRenderSystem(const RenderSystem& selectedRenderSystem, const bool& activateQuadBuffer);
 
  bool initialiseRTShaderSystem();
  void destroyRTShaderSystem();
 
  SRoot();
};
 
}
 
#endif