SO3Root.cpp

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
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include "SO3Renderer/SO3KeyboardHook.h"
 
#ifdef SO3_FLASH_ENABLE
#include "SO3Renderer/SO3FlashWidgetFactory.h"
#endif
 
#include "SO3Renderer/SO3BitmapWidgetFactory.h"
#include "SO3Renderer/SO3ObjWindowWidgetFactory.h"
#include "SO3Renderer/SO3WebNavigatorWidgetFactory.h"
 
#ifdef SO3_BUILD_DEFERRED
#include "SO3Renderer/DeferredShading/SO3DeferredShading.h"
#endif
 
#include "SO3Material/SO3Compositor.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3ShaderGenerator.h"
#include "SO3Material/SO3Technique.h"
#include "SO3Material/SO3Pass.h"
#include "SO3Material/SO3ResourceLoader.h"
#include "SO3Material/SO3RtssClipPlane.h"
#include "SO3Material/SO3RtssCustom.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ScolFileSystem.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3Utils/SO3PluginManager.h"
#include "SO3Utils/SO3BaseMeshsTools.h"
#include "SO3Utils/SO3Exception.h"
#include "SO3Renderer/SO3LogListener.h"
#include "SO3Renderer/SO3ShadowCSM.h"
#include "SO3Renderer/SO3SsaoHandler.h"
#include "SO3SceneGraph/SO3Environment.h"
#include "SCOLPack/SO3SCOL.h"
 
#include <OgreMeshLodGenerator.h>
 
#ifdef _WIN32
# ifndef SO3_USE_DX11
  #include "OgreD3D9RenderWindow.h"
  #include "OgreD3D9DeviceManager.h"
# endif
//#include <dxdiag.h>
//#include "DSETUP.H"
#endif
 
 
#ifdef ANDROID
  #include <EGL/egl.h>
  #include <android/asset_manager.h>
  #include <OgreGLRenderSystemCommon.h>
#endif
 
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
 
extern int SO3_LOGS_MSG;
 
#ifdef _WIN32
void(*SetRenderDeviceGetFunction)(std::function<void* ()> fptr);
#endif
 
/*
//debug virtual call
int __cdecl _purecall(void)
{
  return 0;
}
*/
 
namespace Ogre
{
  template<> SRoot* Ogre::Singleton<SRoot>::msSingleton = 0;
}
 
namespace SO3
{
 
SRoot* SRoot::getSingletonPtr()
{
  return msSingleton;
}
 
SRoot& SRoot::getSingleton()
{
  assert(msSingleton);
  return (*msSingleton);
}
 
SRoot::SRoot(const std::string& firstPartition)
{
#ifdef _WIN32
  SetRenderDeviceGetFunction = (void(__cdecl *)(std::function<void* ()>))SCgetExtra("SetRenderDeviceGetFunction");
  SetRenderDeviceGetFunction(std::bind(&SRoot::GetD3Ddevice, this));
#endif
 
  mShaderGenerator = 0;
  mDeviceLost = true;
  mPaused = false;
  mResourcesReleased = false;
  mUpdating = false;
  mRendering = false;
 
  //to make sure to have only an unique window name (used as group name in selector buffer)
  windowIndex = 0;
 
  // Initialise members.
  renderSystem = SO3_NONE_RENDER_SYSTEM;
  O3Render = 0;
  fullScreenWindow = 0;
  dummyWindow = 0;
  defaultFsaa = "2";
  quadBufferFocalLength = 1.0f;
  quadBufferEyesSeparation = 0.06f;
 
  O3OverlaySystem = 0;
 
  mDebugEnable = false;
  mDebugInitialized = false;
  useVSync = false;
  mDummyScene = 0;
  mRootInitialised = false;
  mSlicePlane = Ogre::Vector4(1.0f, 0.0f, 0.0f, 0.0f);
  mSlicePlaneState = false;
 
  // Ogre's plugins
  staticPluginOctree = 0;
  
#if !defined(ANDROID) && !defined(APPLE_IOS) && !defined(SO3_USE_METAL) && !defined(RPI)
  staticPluginCG = 0;
#endif
  staticPluginParticleFX = 0;
 
#ifdef SO3_BUILD_DEFERRED
  //Deferred
  deferredManager = 0;
#endif
 
  //Shader generator
  mMaterialMgrListener = 0;
 
  // Additionals plugins for Developper mode
#ifdef SO3_DEVELOPPER_BUILD
# ifdef _WIN32
#   ifndef SO3_USE_DX11
      staticPluginD3D9 = 0;
#   else
      staticPluginD3D11 = 0;
#   endif
# endif
 
# ifndef SO3_USE_OPENGLES2
#   ifdef SO3_USE_GL3
  staticPluginOpenGL3 = 0;
#   elif !defined(SO3_USE_METAL)
  staticPluginOpenGL = 0;
#   endif
# elif !defined(SO3_USE_METAL)
  staticPluginOpenGLES2 = 0;
# endif
 
# if defined(__APPLE__) && defined(SO3_USE_METAL)
  staticPluginMetal = 0;
# endif
 
# if defined(_WIN64)
  //staticPluginTiny = 0;
 
  staticPluginVulkan = 0;
  staticPluginGLSLang = 0;
# endif
#endif
  
  // Creating Ogre's root object
#if SO3_DEBUG
# ifdef _WIN32
  O3Root = OGRE_NEW Ogre::Root();
# else
  O3Root = OGRE_NEW Ogre::Root("", "");
# endif
#else
  // No ogre log file for release builds
  O3Root = OGRE_NEW Ogre::Root("", "", "");
#endif
 
  //do not wait too much in work queue
  O3Root->getWorkQueue()->setMainThreadProcessingTimeLimit(4);
 
  // Initialise SO3 Plugin system.
  pluginManager = new SPluginManager();
 
  // Initialise SO3 3D Widget Manager
  widgetManager = new SWidgetManager();
 
  // Add Bitmap widget support
  bitmapWidgetFactory = new SBitmapWidgetFactory();
  widgetManager->AddWidgetFactory(bitmapWidgetFactory);
 
#ifdef _WIN32
  // Add ObjWindow widget support
  objWindowWidgetFactory = new SObjWindowWidgetFactory();
  widgetManager->AddWidgetFactory(objWindowWidgetFactory);
#endif
 
#ifdef SO3_FLASH_ENABLE
  // Add Flash widget support
  flashWidgetFactory = new SFlashWidgetFactory();
  widgetManager->AddWidgetFactory(flashWidgetFactory);
#endif
 
  // Add web navigator widget support
  #if SO3_WEB_NAVIGATOR_BUILD == 1
    ScolWindowHandle hwndScol = (ScolWindowHandle)SCgetExtra("hscol");
 
    // Get the first partition as cache directory
    std::string webBrowserCacheDir = firstPartition + std::string("tmp/CefCache");
 
    // Add a subdirectory for the cache, in order to avoid messy files to go in the root partition dir
    CreateDirectory(webBrowserCacheDir.c_str(), 0);
 
    // Create the web navigator manager.
    webNavigatorManager = new EmbeddedWebNavigator::WebNavigatorManager(hwndScol, webBrowserCacheDir);
 
    // Create the web browser widget factory.
    webNavigatorWidgetFactory = new SWebNavigatorWidgetFactory(hwndScol, firstPartition);
    widgetManager->AddWidgetFactory(webNavigatorWidgetFactory);
  #endif
 
  keyboardHook = new SKeyboardHook();
  // Load Ogre's plugins
  LoadOgrePlugins();
 
  mLogEnable = false;
  Ogre::LogManager::getSingleton().getDefaultLog()->addListener((Ogre::LogListener*)this);
 
  // Create Ogre's script resources loader
  resourceLoader = new SResourceLoader();
  Ogre::ScriptCompilerManager::getSingleton().setListener(resourceLoader);
 
  // Load config file, this will select the Render system to use.
  ParseConfigFile();
 
  //init overlay system
  O3OverlaySystem = new Ogre::OverlaySystem();
 
#ifdef ANDROID
  ScolWindowHandle win = (ScolWindowHandle)SCgetExtra("hscol");
 
  mMainWidth = ANativeWindow_getWidth(win);
  mMainHeight = ANativeWindow_getHeight(win);
#endif
 
  //init LOD generator
  new Ogre::MeshLodGenerator();
}
 
#ifdef _WIN32
void* SRoot::GetD3Ddevice()
{
  Ogre::String rendererName = GetOgreRenderSystem()->getName();
  if (rendererName != "Direct3D11 Rendering Subsystem")
    return NULL;
 
  Ogre::D3D11Device& device = static_cast<Ogre::D3D11RenderSystem*>(GetOgreRenderSystem())->_getDevice();
  return (void*) device.get();
}
#endif
 
Ogre::Root* SRoot::GetOgreRootPointer()
{
  return O3Root;
}
 
bool SRoot::IsRenderInitialised()
{
  return mRootInitialised;
}
 
#ifdef SO3_BUILD_DEFERRED
SDeferredShading* SRoot::GetDeferredManager()
{
  return deferredManager;
}
#endif
 
void SRoot::ClearSceneManagerPassMaps()
{
  for (const auto& m : O3Root->getSceneManagers())
  {
    Ogre::SceneManager* pScene = m.second;
    if (pScene)
    {
      Ogre::RenderQueue* pQueue = pScene->getRenderQueue();
      if (pQueue)
      {
        pQueue->clear();
      }
    }
  }
}
 
void SRoot::messageLogged(const Ogre::String& message, Ogre::LogMessageLevel lml, bool maskDebug, const Ogre::String &logName, bool& skipMessage)
{
  switch (lml)
  {
    case Ogre::LogMessageLevel::LML_CRITICAL:
    case Ogre::LogMessageLevel::LML_NORMAL:
      MMechostr(MSKRUNTIME, "%s\n", message.c_str());
      break;
    case Ogre::LogMessageLevel::LML_TRIVIAL:
      MMechostr(MSKDEBUG, "%s\n", message.c_str());
      break;
  }
 
  if (mLogEnable)
  {
    LogListenerList::iterator iLogListenerList = logListenerList.begin();
    while(iLogListenerList != logListenerList.end())
    {
      (*iLogListenerList)->messageLogged(message);
      iLogListenerList++;
    }
  }
}
 
void SRoot::AddLogListener(SLogListener* newLogListener)
{
  if(logListenerList.count(newLogListener))
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot add this listener, it already exists in the listener list!", "SRoot::AddLogListener");
 
  logListenerList.insert(newLogListener);
}
 
void SRoot::RemoveLogListener(SLogListener* existingLogListener)
{
  if(!logListenerList.count(existingLogListener))
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot remove listener, this listener does not exists in the listener list!", "SRoot::RemoveLogListener");
 
  logListenerList.erase(existingLogListener);
}
 
void SRoot::SetLogEnable(const bool& state)
{
  mLogEnable = state;
}
 
bool SRoot::GetLogEnable()
{
  return mLogEnable;
}
 
void SRoot::SetLogMask(const Ogre::LogMessageLevel& level)
{
  Ogre::LogManager::getSingleton().getDefaultLog()->setMinLogLevel(level);
}
 
bool SRoot::checkFSAA(const Ogre::String& value)
{
        bool finded = false;
  Ogre::String val = value;
  if(value.find("[Quality]") != string::npos)
    val = value.substr(0, value.find("[Quality]")-2);
 
        Ogre::ConfigOptionMap m_system_caps = this->O3Root->getRenderSystem()->getConfigOptions();
        Ogre::ConfigOptionMap::iterator itr = m_system_caps.begin();
        while(itr != m_system_caps.end()&&!finded)
        {
                if(itr->first == "FSAA" )
                {
                   Ogre::StringVector possible_values = (itr)->second.possibleValues;
                   Ogre::StringVector::iterator pv_itr = possible_values.begin();
                   while(pv_itr != possible_values.end() && !finded)
                   {
                            if(!strcmp(val.c_str(),pv_itr->c_str()))
            finded = true;
                                  pv_itr++;
                   }
                }
                itr ++;
        }
        return finded;
}
 
SRoot::~SRoot()
{
  SSceneMap sceneList = SRoot::getSingleton().GetSceneList();
  SSceneMap::iterator iScene = sceneList.begin();
  while (iScene != sceneList.end())
  {
    DeleteScene(iScene->second);
    iScene++;
  }
 
  if (Ogre::MeshLodGenerator::getSingletonPtr())
    delete Ogre::MeshLodGenerator::getSingletonPtr();
 
  mSlicePlaneParams.reset();
  mCommonParams.reset();
  destroyRTShaderSystem();
 
  delete(SO3::CSMGpuConstants::getSingletonPtr());
 
  SSsaoHandler::Reset();
  SHdrHandler::Reset();
 
  SShaderGenerator::Reset();
 
  if (O3Root->getRenderSystem())
    O3Root->getRenderSystem()->removeListener(this);
 
  SAFE_DELETE(O3OverlaySystem);
 
  // Delete the keyboard hook
  MMechostr(MSKDEBUG, "SO3Root cleanup : keyboardHook");
  SO3_SAFE_DELETE(keyboardHook);
 
#ifdef SO3_BUILD_DEFERRED
  // Unload deferred shading manager
  MMechostr(MSKDEBUG, "SO3Root cleanup : deferredManager");
  SO3_SAFE_DELETE(deferredManager);
#endif
 
  // Unload SO3's plugins
  MMechostr(MSKDEBUG, "SO3Root cleanup : pluginManager");
  SO3_SAFE_DELETE(pluginManager);
 
  // Delete SO3's Managers
  MMechostr(MSKDEBUG, "SO3Root cleanup : widgetManager");
  SO3_SAFE_DELETE(widgetManager);
 
#ifdef _WIN32
  // Delete obj window widget support (already remove from widget factory list by SWidgetManager destructor);
  MMechostr(MSKDEBUG, "SO3Root cleanup : objWindowWidgetFactory");
  SO3_SAFE_DELETE(objWindowWidgetFactory);
#endif
 
#ifdef SO3_FLASH_ENABLE
  // Delete flash widget support (already remove from widget factory list by SWidgetManager destructor);
  MMechostr(MSKDEBUG, "SO3Root cleanup : flashWidgetFactory");
  SO3_SAFE_DELETE(flashWidgetFactory);
#endif
 
  // Delete bitmap widget support (already remove from widget factory list by SWidgetManager destructor);
  MMechostr(MSKDEBUG, "SO3Root cleanup : bitmapWidgetFactory");
  SO3_SAFE_DELETE(bitmapWidgetFactory);
 
  // Delete web navigator widget support (already remove from widget factory list by SWidgetManager destructor);
  #if SO3_WEB_NAVIGATOR_BUILD == 1
    // Delete widget factory
    MMechostr(MSKDEBUG, "SO3Root cleanup : webNavigatorWidgetFactory");
    SO3_SAFE_DELETE(webNavigatorWidgetFactory);
 
    // Destroy web manager
    MMechostr(MSKDEBUG, "SO3Root cleanup : webNavigatorManager");
    EmbeddedWebNavigator::WebNavigatorManager::DestroyManager();
  #endif
 
  MMechostr(MSKDEBUG, "SO3Root cleanup : LogListener");
  Ogre::LogManager::getSingleton().getDefaultLog()->removeListener((Ogre::LogListener*)this);
 
  //destroy dummy window
  MMechostr(MSKDEBUG, "SO3Root cleanup : dummyWindow");
  if (dummyWindow)
  {
    SRoot::getSingleton().GetOgreRenderSystem()->destroyRenderWindow(dummyWindow->getName());
    dummyWindow = 0;
  }
 
  ClearManualRessourceGroups();
 
  try
  {
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(SO3_INTERNAL_DYNAMIC_RESOURCE_GROUP);
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(SO3_INTERNAL_DYNAMIC_READABLE_RESOURCE_GROUP);
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(SO3_INTERNAL_HYDRAX_RESOURCE_GROUP);
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(SO3_INTERNAL_SKYX_RESOURCE_GROUP);
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKRUNTIME, "SO3Root error: %s\n", e.getFullDescription().c_str());
  }
  
  // Destroy the resource loader
  MMechostr(MSKDEBUG, "SO3Root cleanup : resourceLoader");
  Ogre::ScriptCompilerManager::getSingleton().setListener(0);
  SO3_SAFE_DELETE(resourceLoader);
 
 
 
  // Destroy Ogre's root instance. NB that the destructor manage the plugins unloading on it's own.
  MMechostr(MSKDEBUG, "SO3Root cleanup : O3Root");
  SO3_SAFE_DELETE(O3Root);
 
  // Only useful if Ogre is statically linked, to destroy plugins instance. Do nothing if linked as a dll.
  MMechostr(MSKDEBUG, "SO3Root cleanup : UnloadOgrePlugins");
  UnloadOgrePlugins();
 
  MMechostr(MSKDEBUG, "SO3Root cleanup : Done");
}
 
SScene* SRoot::CreateScene(const std::string& newSceneName)
{
  SScene* newScene = new SScene(this, newSceneName);
  AddScene(newScene);
  return newScene;
}
 
void SRoot::DeleteScene(SScene* existingScene)
{
  RemoveScene(existingScene);
 
  ClearSceneManagerPassMaps();
 
  SO3_SAFE_DELETE(existingScene);
}
 
SScene* SRoot::GetScene(const std::string& sceneName)
{
  SSceneMap::iterator iSceneSearched = sceneList.find(sceneName);
  if(iSceneSearched != sceneList.end())
    return iSceneSearched->second;
  else
    return 0;
}
 
const SSceneMap& SRoot::GetSceneList() const
{
  return sceneList;
}
 
void SRoot::AddScene(SScene* existingScene)
{
  string sceneName = existingScene->GetName();
  SSceneMap::iterator iSceneSearched = sceneList.find(sceneName);
  if(iSceneSearched == sceneList.end())
  {
    sceneList.insert(SSceneMap::value_type(sceneName, existingScene));
    existingScene->GetOgreScenePointer()->addRenderQueueListener(O3OverlaySystem);
 
    //debug overlay
    if (mDebugEnable)
      existingScene->SetDebugEnable(true);
  }
  else
  {
    // Scene already exist in the handled scenes list.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add Scene named \""+ sceneName +"\", an element with the same name already exist!", "SRoot::AddScene");
  }
}
 
void SRoot::RemoveScene(SScene* existingScene)
{
  existingScene->GetOgreScenePointer()->removeRenderQueueListener(O3OverlaySystem);
 
  RemoveScene(existingScene->GetName());
}
 
void SRoot::RemoveScene(const std::string& sceneName)
{
  SSceneMap::iterator iSceneSearched = sceneList.find(sceneName);
  if(iSceneSearched != sceneList.end())
  {
    sceneList.erase(iSceneSearched);
  }
  else
  {
    // Scene not found in the handled scenes list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Scene named \""+ sceneName +"\", element not found!", "SRoot::RemoveScene");
  }
}
 
 
void SRoot::AddManualRessourceGroup(std::string name)
{
  try
  {
    Ogre::ResourceGroupManager::getSingleton().createResourceGroup(name, false);
    mManualGroups.push_back(name);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKRUNTIME, "AddManualRessourceGroup error: %s\n", e.getFullDescription().c_str());
  }
}
 
void SRoot::RemoveManualRessourceGroup(std::string name)
{
  try
  {
    Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(name);
    mManualGroups.remove(name);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKRUNTIME, "RemoveManualRessourceGroup error: %s\n", e.getFullDescription().c_str());
  }
}
 
void SRoot::ClearManualRessourceGroups()
{
  for (manualGroupList::iterator it = mManualGroups.begin(); it != mManualGroups.end(); it++)
  {
    try
    {
      Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(*it);
    }
    catch (Ogre::Exception &)
    {
    }
  }
 
  mManualGroups.clear();
}
 
 
bool SRoot::GetRttPixelFormat(Ogre::PixelFormat &format, bool alpha, bool floattex)
{
  if (floattex && !alpha)
  {
    if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT32_RGB, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT32_RGB;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT16_RGB, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT16_RGB;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT32_GR, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT32_GR;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT16_GR, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT16_GR;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT32_R, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT32_R;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT16_R, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT16_R;
      return true;
    }
 
    return false;
  }
 
  if (floattex)
  {
    if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT32_RGBA, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT32_RGBA;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT16_RGBA, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT16_RGBA;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_R11G11B10_FLOAT, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_R11G11B10_FLOAT;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT32_GR, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT32_GR;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_FLOAT16_GR, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_FLOAT16_GR;
      return true;
    }
 
    return false;
  }
 
  if (!alpha)
  {
    if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_R8G8B8;
      return true;
    }
    else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_B8G8R8, Ogre::TU_RENDERTARGET))
    {
      format = Ogre::PF_B8G8R8;
      return true;
    }
  }
 
  //forget alpha optim
  if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET))
  {
    format = Ogre::PF_A8R8G8B8;
    return true;
  }
  else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_A8B8G8R8, Ogre::TU_RENDERTARGET))
  {
    format = Ogre::PF_A8B8G8R8;
    return true;
  }
  else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_R8G8B8A8, Ogre::TU_RENDERTARGET))
  {
    format = Ogre::PF_R8G8B8A8;
    return true;
  }
  else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_B8G8R8A8, Ogre::TU_RENDERTARGET))
  {
    format = Ogre::PF_B8G8R8A8;
    return true;
  }
  else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_X8R8G8B8, Ogre::TU_RENDERTARGET))
  {
    format = Ogre::PF_X8R8G8B8;
    return true;
  }
  else if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_X8B8G8R8, Ogre::TU_RENDERTARGET))
  {
    format = Ogre::PF_X8B8G8R8;
    return true;
  }
 
  return false;
}
 
SWindow* SRoot::CreateRenderWindow(const ScolWindowHandle windowHandle, const std::string& windowName, const int& width, const int& height, const std::string& renderWindowFsaa)
{
  std::string newWindowName = windowName + "_" + boost::lexical_cast<std::string, unsigned int>(++windowIndex);
  SWindow* newWindow = 0;
  if(renderWindowFsaa == "default")
    newWindow = new SWindow(this, windowHandle, newWindowName, width, height, defaultFsaa);
  else
    newWindow = new SWindow(this, windowHandle, newWindowName, width, height, renderWindowFsaa);
 
#if SO3_PROFILER == 1
  Ogre::Profiler* prof = Ogre::Profiler::getSingletonPtr();
  if (prof)
    prof->setEnabled(true);
#endif
 
  AddRenderWindow(newWindow);
  return newWindow;
}
 
void SRoot::DeleteRenderWindow(SWindow* existingWindow)
{
  if (fullScreenWindow == existingWindow)
    fullScreenWindow = 0;
 
  RemoveRenderWindow(existingWindow);
  SO3_SAFE_DELETE(existingWindow);
}
 
SWindow* SRoot::GetRenderWindow(const ScolWindowHandle& hwnd)
{
  SWindow* winfound = 0;
  const SWindowMap lWin = windowList;
  SWindowMap::const_iterator iWindowSearched = lWin.begin();
 
  while((iWindowSearched != lWin.end()) && (winfound == 0))
  {
    if (iWindowSearched->second->GetWindowHandle() == hwnd)
      winfound = iWindowSearched->second;
    iWindowSearched++;
  }
 
  return winfound;
}
 
SWindow* SRoot::GetRenderWindow(const std::string& windowName)
{
  SWindowMap::iterator iWindowSearched = windowList.find(windowName);
  if(iWindowSearched != windowList.end())
    return iWindowSearched->second;
  else
    return 0;
}
 
const SWindowMap& SRoot::GetRenderWindowList() const
{
  return windowList;
}
 
void SRoot::AddRenderWindow(SWindow* existingWindow)
{
  string windowName = existingWindow->GetName();
  SWindowMap::iterator iWindowSearched = windowList.find(windowName);
  if(iWindowSearched == windowList.end())
  {
    windowList.insert(SWindowMap::value_type(windowName, existingWindow));
  }
  else
  {
    // Scene already exist in the handled scenes list.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add Window named \""+ windowName +"\", an element with the same name already exist!", "SRoot::AddWindow");
  }
}
 
void SRoot::RemoveRenderWindow(SWindow* existingWindow)
{
  RemoveRenderWindow(existingWindow->GetName());
}
 
void SRoot::RemoveRenderWindow(const std::string& windowName)
{
  SWindowMap::iterator iWindowSearched = windowList.find(windowName);
  if(iWindowSearched != windowList.end())
  {
    windowList.erase(iWindowSearched);
  }
  else
  {
    // Window not found in the handled windows list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Window named \""+ windowName +"\", element not found!", "SRoot::RemoveWindow");
  }
}
 
SRoot::RenderSystem SRoot::GetRenderSystem()
{
  return renderSystem;
}
 
Ogre::RenderSystem* SRoot::GetOgreRenderSystem()
{
  return O3Render;
}
 
void SRoot::SetRenderSystem(const RenderSystem& selectedRenderSystem, const bool& activateQuadBuffer)
{
  if (selectedRenderSystem == SO3_NONE_RENDER_SYSTEM)
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cannot set render system to \"none\", invalid render system.", "SRoot::SetRenderSystem");
 
  if (renderSystem != SO3_NONE_RENDER_SYSTEM)
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Render system is still setted, cannot change render system while running.", "SRoot::SetRenderSystem");
 
  // If our ogre is anterior to v1.7
  #if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
    Ogre::RenderSystemList* renderSystemList = O3Root->getAvailableRenderers();
    if(renderSystemList == NULL)
  #else
    const Ogre::RenderSystemList renderSystemList = O3Root->getAvailableRenderers();
    if(renderSystemList.empty())
  #endif
      OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "No supported render system found!", "SRoot::SetRenderSystem");
 
  // TODO: check if a correct render system exists before???
  try
  {
    switch(selectedRenderSystem)
    {
    case SO3_DIRECTX9_RENDERER:
                  O3Render = O3Root->getRenderSystemByName("Direct3D9 Rendering Subsystem");
      renderSystem = selectedRenderSystem;
 
      // Set render system options
      O3Render->setConfigOption("Use Multihead", "Auto");
      O3Render->setConfigOption("Resource Creation Policy", "Create on all devices");
      O3Render->setConfigOption("Auto hardware buffer management", "Yes");
      //O3Render->setConfigOption("Allow DirectX9Ex", "Yes");
      break;
    case SO3_DIRECTX11_RENDERER:
      O3Render = O3Root->getRenderSystemByName("Direct3D11 Rendering Subsystem");
      //O3Render->setConfigOption("Debug Layer", "On");
      renderSystem = selectedRenderSystem;
      break;
    case SO3_VULKAN_RENDERER:
      O3Render = O3Root->getRenderSystemByName("Vulkan Rendering Subsystem");
      renderSystem = selectedRenderSystem;
      break;
    case SO3_TINY_RENDERER:
      O3Render = O3Root->getRenderSystemByName("Tiny Rendering Subsystem");
      renderSystem = selectedRenderSystem;
      break;
    case SO3_METAL_RENDERER:
      O3Render = O3Root->getRenderSystemByName("Metal Rendering Subsystem");
      renderSystem = selectedRenderSystem;
      break;
    case SO3_OPENGL_RENDERER:
      #ifndef SO3_USE_OPENGLES2
        #ifndef SO3_USE_GL3
                    O3Render = O3Root->getRenderSystemByName("OpenGL Rendering Subsystem");
        try
        {
          if (activateQuadBuffer)
          {
            MMechostr(MSKRUNTIME, "Rendering Stereo mode : QuadBuffer\n");
            O3Render->setConfigOption("Stereo Mode", "QuadBuffer");
          }
          else
          {
            MMechostr(MSKRUNTIME, "Rendering Stereo mode : Mono\n");
            O3Render->setConfigOption("Stereo Mode", "Mono");
          }
        }
        catch (Ogre::Exception &)
        {
          MMechostr(MSKRUNTIME, "Rendering Stereo mode : Not supported\n");
        }
        #else
        O3Render = O3Root->getRenderSystemByName("OpenGL 3+ Rendering Subsystem");
        #endif
      #else
        O3Render = O3Root->getRenderSystemByName("OpenGL ES 2.x Rendering Subsystem");
      #endif
      renderSystem = selectedRenderSystem;
                  break;
          }
 
    if (!O3Render)
    {
      renderSystem = SO3_OPENGL_RENDERER;
#ifndef SO3_USE_OPENGLES2
#ifndef SO3_USE_GL3
      O3Render = O3Root->getRenderSystemByName("OpenGL Rendering Subsystem");
#else
      O3Render = O3Root->getRenderSystemByName("OpenGL 3+ Rendering Subsystem");
#endif
#else
      O3Render = O3Root->getRenderSystemByName("OpenGL ES 2.x Rendering Subsystem");
#endif
    }
    
    O3Root->setRenderSystem(O3Render);
  }
  catch(Ogre::Exception&)
  {
    // TO VERIFY
    renderSystem = SO3_OPENGL_RENDERER;
    #ifndef SO3_USE_OPENGLES2
      #ifndef SO3_USE_GL3
        O3Render = O3Root->getRenderSystemByName("OpenGL Rendering Subsystem");
      #else
        O3Render = O3Root->getRenderSystemByName("OpenGL 3+ Rendering Subsystem");
      #endif
    #else
      O3Render = O3Root->getRenderSystemByName("OpenGL ES 2.x Rendering Subsystem");
    #endif
    O3Root->setRenderSystem(O3Render);
  }
 
  //Saw that somewhere about depth buffer
  //O3Render->setConfigOption("Floating-point mode", "Consistent");
 
        O3Root->getSingleton().initialise(false);
  mDeviceLost = false;
 
  O3Root->getRenderSystem()->addListener(this);
}
 
std::vector<std::string> SRoot::GetMultisamplingMode(const RenderSystem& wishedRenderSystem)
{
  if (wishedRenderSystem == SO3_NONE_RENDER_SYSTEM)
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cannot get render system multisampling information for \"none\", invalid render system.", "SRoot::GetMultisamplingMode");
 
  Ogre::RenderSystem* selectedRenderSystem = 0;
  std::vector<std::string> multisamplingModes;
 
  try
  {
    switch(wishedRenderSystem)
    {
    case SO3_DIRECTX9_RENDERER:
    case SO3_DIRECTX11_RENDERER:
      #ifndef SO3_USE_DX11
                    selectedRenderSystem = O3Root->getRenderSystemByName("Direct3D9 Rendering Subsystem");
      #else
        selectedRenderSystem = O3Root->getRenderSystemByName("Direct3D11 Rendering Subsystem");
      #endif
      break;
    case SO3_VULKAN_RENDERER:
      selectedRenderSystem = O3Root->getRenderSystemByName("Vulkan Rendering Subsystem");
    case SO3_TINY_RENDERER:
      selectedRenderSystem = O3Root->getRenderSystemByName("Tiny Rendering Subsystem");
    case SO3_METAL_RENDERER:
      selectedRenderSystem = O3Root->getRenderSystemByName("Metal Rendering Subsystem");
    case SO3_OPENGL_RENDERER:
      #ifndef SO3_USE_OPENGLES2
        #ifndef SO3_USE_GL3
        selectedRenderSystem = O3Root->getRenderSystemByName("OpenGL Rendering Subsystem");
        #else
        selectedRenderSystem = O3Root->getRenderSystemByName("OpenGL 3+ Rendering Subsystem");
        #endif
      #else
        selectedRenderSystem = O3Root->getRenderSystemByName("OpenGL ES 2.x Rendering Subsystem");
      #endif
                  break;
          }
  }
  catch (Ogre::Exception &)
  {
    #ifndef SO3_USE_OPENGLES2
      #ifndef SO3_USE_GL3
        selectedRenderSystem = O3Root->getRenderSystemByName("OpenGL Rendering Subsystem");
      #else
        selectedRenderSystem = O3Root->getRenderSystemByName("OpenGL 3+ Rendering Subsystem");
      #endif
    #else
    selectedRenderSystem = O3Root->getRenderSystemByName("OpenGL ES 2.x Rendering Subsystem");
    #endif
  }
 
  if (selectedRenderSystem != 0)
  {
    Ogre::ConfigOptionMap m_system_caps = selectedRenderSystem->getConfigOptions();
          Ogre::ConfigOptionMap::iterator itr = m_system_caps.find("FSAA");
    if (itr == m_system_caps.end())
      itr = m_system_caps.find("Anti aliasing");
 
    if (itr != m_system_caps.end())
    {
      Ogre::StringVector possible_values = itr->second.possibleValues;
            Ogre::StringVector::iterator pv_itr = possible_values.begin();
      while (pv_itr != possible_values.end())
      {
        multisamplingModes.push_back(*pv_itr);
        pv_itr++;
      }
    }
  }
 
  return multisamplingModes;
}
 
bool SRoot::CheckDirectxVersion()
{
#ifdef _WIN32
/*
  bool directxOk = false;
  DWORD dwVersion;
        DWORD dwRevision;
        if(DirectXSetupGetVersion(&dwVersion, &dwRevision))
        {
                int a = (int)HIWORD(dwVersion);
                int b = (int)LOWORD(dwVersion);
                int c = (int)HIWORD(dwRevision);
                int d = (int)LOWORD(dwRevision);
 
                if(b == 9 && d>= 904)
      directxOk = true;
        }
  return directxOk;
  */
  return true;
#else
  return false;
#endif
}
 
bool SRoot::LoadOgrePlugins()
{
#ifdef SO3_DEVELOPPER_BUILD
# ifdef _WIN32
#   ifndef SO3_USE_DX11
    // Create renderers here, as they will be statically builded.
    try
    {
      staticPluginD3D9 = OGRE_NEW Ogre::D3D9Plugin();
      Ogre::Root::getSingleton().installPlugin(staticPluginD3D9);
    }
    catch(Ogre::Exception&)
    {
      //error on plugin load
      MMechostr(MSKRUNTIME, "Error on D3D9 plugin load\n");
    }
#   else
    try
    {
      staticPluginD3D11 = OGRE_NEW Ogre::D3D11Plugin();
      Ogre::Root::getSingleton().installPlugin(staticPluginD3D11);
    }
    catch(Ogre::Exception&)
    {
      //error on plugin load
      MMechostr(MSKRUNTIME, "Error on D3D11 plugin load\n");
    }
#   endif
#endif
 
#if !defined(SO3_USE_METAL)
  try
  {
# ifndef SO3_USE_OPENGLES2
#   ifdef SO3_USE_GL3
    staticPluginOpenGL3 = OGRE_NEW Ogre::GL3PlusPlugin();
    Ogre::Root::getSingleton().installPlugin(staticPluginOpenGL3);
#   elif !defined(SO3_USE_METAL)
    staticPluginOpenGL = OGRE_NEW Ogre::GLPlugin();
    Ogre::Root::getSingleton().installPlugin(staticPluginOpenGL);
#   endif
# elif !defined(SO3_USE_METAL)
    staticPluginOpenGLES2 = OGRE_NEW Ogre::GLES2Plugin();
    Ogre::Root::getSingleton().installPlugin(staticPluginOpenGLES2);
# endif
  }
  catch(Ogre::Exception&)
  {
    //error on plugin load
    #ifndef SO3_USE_OPENGLES2
      MMechostr(MSKRUNTIME, "Error on OpenGL plugin load\n");
    #else
      MMechostr(MSKRUNTIME, "Error on OpenGLES2 plugin load\n");
    #endif
  }
#endif
  
#  if defined(__APPLE__) && defined(SO3_USE_METAL)
      try
      {
        staticPluginMetal = OGRE_NEW Ogre::MetalPlugin();
        Ogre::Root::getSingleton().installPlugin(staticPluginMetal);
      }
      catch (Ogre::Exception&)
      {
        //error on plugin load
        MMechostr(MSKRUNTIME, "Error on Metal renderer plugin load\n");
      }
#  endif
 
#  if defined(_WIN64)
      //try
      //{
      //  staticPluginTiny = OGRE_NEW Ogre::TinyPlugin();
      //  Ogre::Root::getSingleton().installPlugin(staticPluginTiny);
      //}
      //catch (Ogre::Exception&)
      //{
      //  //error on plugin load
      //  MMechostr(MSKRUNTIME, "Error on Tiny renderer plugin load\n");
      //}
   
      try
      {
        staticPluginVulkan = OGRE_NEW Ogre::VulkanPlugin();
        Ogre::Root::getSingleton().installPlugin(staticPluginVulkan);
      }
      catch (Ogre::Exception&)
      {
        //error on plugin load
        MMechostr(MSKRUNTIME, "Error on Vulkan renderer plugin load\n");
      }
 
      try
      {
        staticPluginGLSLang = OGRE_NEW Ogre::GLSLangPlugin();
        Ogre::Root::getSingleton().installPlugin(staticPluginGLSLang);
      }
      catch (Ogre::Exception&)
      {
        //error on plugin load
        MMechostr(MSKRUNTIME, "Error on GLSLang plugin load\n");
      }
#  endif
 
# else
    // Load renderers as Ogre plugins
#   ifdef SO3_DEBUG
      Ogre::Root::getSingleton().loadPlugin("plugins/SO3_RenderSystem_GL_d.dll");
      Ogre::Root::getSingleton().loadPlugin("plugins/SO3_RenderSystem_Direct3D9_d.dll");
#   else
      Ogre::Root::getSingleton().loadPlugin("plugins/SO3_RenderSystem_GL.dll");
      Ogre::Root::getSingleton().loadPlugin("plugins/SO3_RenderSystem_Direct3D9.dll");
#   endif
# endif
 
  // Load others ogre plugins the same way (statically linking or internal build).
  try
  {
    staticPluginParticleFX = OGRE_NEW Ogre::ParticleFXPlugin();
    Ogre::Root::getSingleton().installPlugin(staticPluginParticleFX);
  }
  catch(Ogre::Exception&)
  {
    //error on plugin load
    MMechostr(MSKRUNTIME, "Error on Particle FX plugin load\n");
  }
 
  //Start STBI Image codec plugin
  Ogre::STBIImageCodec::startup();
 
#if !defined(ANDROID) && !defined(APPLE_IOS) && !defined(SO3_USE_METAL) && !defined(RPI)
  try
  {
    staticPluginCG = OGRE_NEW Ogre::CgPlugin();
    Ogre::Root::getSingleton().installPlugin(staticPluginCG);
  }
  catch(Ogre::Exception&)
  {
    //error on plugin load
    MMechostr(MSKRUNTIME, "Error on CG plugin load\n");
  }
#endif
 
  try
  {
    staticPluginOctree = OGRE_NEW Ogre::OctreePlugin();
    Ogre::Root::getSingleton().installPlugin(staticPluginOctree);
  }
  catch(Ogre::Exception&)
  {
    //error on plugin load
    MMechostr(MSKRUNTIME, "Error on Octree plugin load\n");
  }
 
 
  // Adding Scol FileSystem Archive Manager to Ogre.
  scolFileSystemArchiveFactory = OGRE_NEW SO3ScolFileSystemArchiveFactory();
  Ogre::ArchiveManager::getSingleton().addArchiveFactory(scolFileSystemArchiveFactory);
 
#ifdef ANDROID
  // Android archives
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  if (androidApp != NULL)
  {
    Ogre::ArchiveManager::getSingleton().addArchiveFactory(new Ogre::APKFileSystemArchiveFactory(androidApp->activity->assetManager));
    Ogre::ArchiveManager::getSingleton().addArchiveFactory(new Ogre::APKZipArchiveFactory(androidApp->activity->assetManager));
  }
#endif
 
  // All done!
  return true;
}
 
bool SRoot::UnloadOgrePlugins()
{
  OGRE_DELETE scolFileSystemArchiveFactory;
  OGRE_DELETE staticPluginOctree;
 
#if !defined(ANDROID) && !defined(APPLE_IOS) && !defined(SO3_USE_METAL) && !defined(RPI)
  OGRE_DELETE staticPluginCG;
#endif
 
  OGRE_DELETE staticPluginParticleFX;
 
  Ogre::STBIImageCodec::shutdown();
 
# ifdef SO3_DEVELOPPER_BUILD
# ifdef _WIN32
#  ifndef SO3_USE_DX11
    OGRE_DELETE staticPluginD3D9;
#  else
    OGRE_DELETE staticPluginD3D11;
#  endif
# endif
  
# ifndef SO3_USE_OPENGLES2
#   ifdef SO3_USE_GL3
  OGRE_DELETE staticPluginOpenGL3;
#   elif !defined(SO3_USE_METAL)
  OGRE_DELETE staticPluginOpenGL;
#   endif
# elif !defined(SO3_USE_METAL)
  OGRE_DELETE staticPluginOpenGLES2;
# endif
 
# if defined(__APPLE__) && defined(SO3_USE_METAL)
    OGRE_DELETE staticPluginMetal;
# endif
 
# if defined(_WIN64)
    //OGRE_DELETE staticPluginTiny;
    OGRE_DELETE staticPluginGLSLang;
    OGRE_DELETE staticPluginVulkan;
# endif
#endif
  return true;
}
 
void SRoot::InitRenderer(SWindow* pwin)
{
  // Initialize resource only once, right after the first window is created, otherwise Ogre is craching.
  if (dummyWindow == 0)
  {
    if (pwin == 0)
    {
      // Setting render window options
      Ogre::NameValuePairList viewConfig;
      viewConfig["hidden"] = "Yes";
      viewConfig["Resource Creation Policy"] = "Create on all devices";
      viewConfig["Multi device memory hint"] = "Auto hardware buffers management";
      viewConfig["vsync"] = "No";
 
      dummyWindow = Ogre::Root::getSingleton().createRenderWindow("OgreDummyWindow", 1, 1, false, &viewConfig);
      dummyWindow->setAutoUpdated(false);
      dummyWindow->setDeactivateOnFocusChange(false);
    }
    else
    {
      dummyWindow = const_cast<Ogre::RenderWindow*>(pwin->GetOgreRenderWindowPointer());
    }
 
    try
    {
      // add definitions for CSM shadows
      SO3::CSMGpuConstants::getSingleton();
 
      // add slice plane GPU params
      mSlicePlaneParams = Ogre::GpuProgramManager::getSingleton().createSharedParameters("SO3SlicePlaneParams");
      mSlicePlaneParams->addConstantDefinition("slicePlane", Ogre::GCT_FLOAT4);
 
      if (mSlicePlaneState)
        mSlicePlaneParams->setNamedConstant("slicePlane", mSlicePlane);
      else
        mSlicePlaneParams->setNamedConstant("slicePlane", Ogre::Vector4::ZERO);
 
      //add camera DOF target GPU params
      mCommonParams = Ogre::GpuProgramManager::getSingleton().createSharedParameters("SO3CameraParams");
      mCommonParams->addConstantDefinition("cameraProjection", Ogre::GCT_FLOAT4);
      mCommonParams->setNamedConstant("cameraProjection", Ogre::Vector4::ZERO);
      mCommonParams->addConstantDefinition("cameraParams", Ogre::GCT_FLOAT4);
      mCommonParams->setNamedConstant("cameraParams", Ogre::Vector4::ZERO);
 
      // Create an SO3 internal resource group
      // If our ogre is anterior to v1.7
      #if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_RESOURCE_GROUP);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_DYNAMIC_RESOURCE_GROUP);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_DYNAMIC_READABLE_RESOURCE_GROUP);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_HYDRAX_RESOURCE_GROUP);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_SKYX_RESOURCE_GROUP);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP);
 
#ifdef SO3_BUILD_DEFERRED
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_DEFERRED_RESOURCE_GROUP);
#endif
      #else
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_RESOURCE_GROUP, false);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_DYNAMIC_RESOURCE_GROUP, false);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_DYNAMIC_READABLE_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_HYDRAX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_SKYX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, true);
 
#ifdef SO3_BUILD_DEFERRED
        Ogre::ResourceGroupManager::getSingleton().createResourceGroup(SO3_INTERNAL_DEFERRED_RESOURCE_GROUP, true);
#endif
      #endif
 
      MMechostr(MSKDEBUG, ">> Add Ogre ressource locations\n");
 
      #ifdef _WIN32
        /*#ifdef SO3_DEBUG
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/OgreCore", "FileSystem",  Ogre::RGN_INTERNAL, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/rtshaderlib", "FileSystem", Ogre::RGN_INTERNAL, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/Hydrax", "FileSystem", SO3_INTERNAL_HYDRAX_RESOURCE_GROUP, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/SkyX", "FileSystem", SO3_INTERNAL_SKYX_RESOURCE_GROUP, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/SO3SelectionBuffer", "FileSystem", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, true);
        #else*/
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/OgreCore.zip", "Zip", Ogre::RGN_INTERNAL, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/rtshaderlib.zip", "Zip", Ogre::RGN_INTERNAL, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/SO3Core.zip", "Zip", SO3_INTERNAL_RESOURCE_GROUP, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/Hydrax.zip", "Zip", SO3_INTERNAL_HYDRAX_RESOURCE_GROUP, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/SkyX.zip", "Zip", SO3_INTERNAL_SKYX_RESOURCE_GROUP, true);
          Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/SO3SelectionBuffer.zip", "Zip", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, true);
        //#endif
#ifdef SO3_BUILD_DEFERRED
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/SO3Deferred.zip", "Zip", SO3_INTERNAL_DEFERRED_RESOURCE_GROUP, true);
#endif
      #elif defined(ANDROID)
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/ogrecore.zip", "APKZip", Ogre::RGN_INTERNAL, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/rtshaderlib.zip", "APKZip", Ogre::RGN_INTERNAL, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/so3core.zip", "APKZip", SO3_INTERNAL_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/hydrax.zip", "APKZip", SO3_INTERNAL_HYDRAX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/skyx.zip", "APKZip", SO3_INTERNAL_SKYX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/so3selectionbuffer.zip", "APKZip", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, true);
      #elif defined(SO3_USE_OPENGLES2)
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/ogrecore.zip", "Zip", Ogre::RGN_INTERNAL, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/rtshaderlib.zip", "Zip", Ogre::RGN_INTERNAL, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/so3core.zip", "Zip", SO3_INTERNAL_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/hydrax.zip", "Zip", SO3_INTERNAL_HYDRAX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/skyx.zip", "Zip", SO3_INTERNAL_SKYX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/so3selectionbuffer.zip", "Zip", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, true);
      #else //linux
      std::string baseDir = (char*)SCgetExtra("scolExecDir");
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/ogrecore.zip", "Zip", Ogre::RGN_INTERNAL, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/rtshaderlib.zip", "Zip", Ogre::RGN_INTERNAL, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/so3core.zip", "Zip", SO3_INTERNAL_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/hydrax.zip", "Zip", SO3_INTERNAL_HYDRAX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/skyx.zip", "Zip", SO3_INTERNAL_SKYX_RESOURCE_GROUP, true);
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/so3selectionbuffer.zip", "Zip", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, true);
      #endif
 
      initialiseRTShaderSystem();
 
      // Initialise resources
      MMechostr(MSKDEBUG, ">> Initialise Ogre ressource groups\n");
      Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
 
      const Ogre::GpuProgramManager::SyntaxCodes &syntaxCodes = Ogre::GpuProgramManager::getSingleton().getSupportedSyntax();
      for (Ogre::GpuProgramManager::SyntaxCodes::const_iterator iter = syntaxCodes.begin(); iter != syntaxCodes.end(); ++iter)
      {
        MMechostr(MSKDEBUG, ">>> Ogre Supported shader syntax %s\n", (*iter).c_str());
      }
 
      //Override default materials
      Ogre::MaterialPtr defmat = Ogre::MaterialManager::getSingletonPtr()->getByName("BaseWhite", Ogre::RGN_INTERNAL);
      defmat->setAmbient(Ogre::ColourValue(0.5f, 0.5f, 0.5f, 1.0f));
      defmat->setDiffuse(Ogre::ColourValue::White);
      defmat->setSpecular(Ogre::ColourValue::White);
      defmat->setShininess(40.0f);
      defmat->getTechnique(0)->getPass(0)->setVertexProgram("SO3/Internal/Default_vp");
      defmat->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/Internal/Default_fp");
      defmat->load();
 
      Ogre::MaterialPtr defmatnolight = Ogre::MaterialManager::getSingletonPtr()->getByName("BaseWhiteNoLighting", Ogre::RGN_INTERNAL);
      defmatnolight->setAmbient(Ogre::ColourValue::White);
      defmatnolight->setDiffuse(Ogre::ColourValue::White);
      defmatnolight->setSpecular(Ogre::ColourValue::White);
      defmatnolight->setShininess(40.0f);
      defmatnolight->setReceiveShadows(false);
      defmatnolight->getTechnique(0)->getPass(0)->setVertexProgram("SO3/Internal/Default_nolight_vp");
      defmatnolight->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/Internal/Default_fp");
      defmatnolight->load();
 
      /* Creating debug resources */
      if (!mDebugInitialized)
      {
        // Create an helper mesh for bones.
        CreateBoneHelperMesh();
 
        mDebugInitialized = true;
 
#ifdef SO3_BUILD_DEFERRED
        //Create Deffered Manager after resources
        try
        {
          deferredManager = new SDeferredShading();
        }
        catch(SExceptionUnimplemented&)
        {
          Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[WARNING] Deferred rendering not supported, deactivating it!");
          deferredManager = 0;
        }
#endif
 
      }
 
      mRootInitialised = true;
    }
    catch(Ogre::Exception &e)
    {
      MMechostr(MSKDEBUG, ">> Ogre Load error %s\n", e.getDescription().c_str());
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
    }
  }
 
  //update to create ressources
  if (dummyWindow)
    dummyWindow->update();
}
 
bool SRoot::SetFullScreenState(SWindow* window, const bool& state, const int& width, const int& height)
{
  //disable fullscreen for D3D11
  if (renderSystem == SO3_DIRECTX11_RENDERER)
    return false;
 
  // cannot set a directX non primary window in fullscreen
  if (((renderSystem != SO3_OPENGL_RENDERER) || (renderSystem != SO3_VULKAN_RENDERER) || (renderSystem != SO3_TINY_RENDERER)) && (!window->GetOgreRenderWindowPointer()->isPrimary()))
  {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: Can not set a DirectX window in fullscreen if this this not the first created window.");
    return false;
  }
 
  //Allow only one window in fullscreen mode
  if (state && (fullScreenWindow == 0))
  {
    try
    {
      const_cast <Ogre::RenderWindow*> (window->GetOgreRenderWindowPointer())->update();
      const_cast <Ogre::RenderWindow*> (window->GetOgreRenderWindowPointer())->setFullscreen(state, width, height);
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
      return false;
    }
 
    fullScreenWindow = window;
    return true;
  }
  else if (!state && (fullScreenWindow == window))
  {
    try
    {
      const_cast <Ogre::RenderWindow*> (fullScreenWindow->GetOgreRenderWindowPointer())->setFullscreen(state, width, height);
      const_cast <Ogre::RenderWindow*> (window->GetOgreRenderWindowPointer())->update();
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
      return false;
    }
 
    fullScreenWindow = 0;
    return true;
  }
 
  return false;
}
 
void SRoot::SetDebugEnable(const bool& enable)
{
  mDebugEnable = enable;
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->SetDebugEnable(enable);
    iScene++;
  }
}
 
bool SRoot::GetDebugEnable()
{
  return mDebugEnable;
}
 
void SRoot::SetDebugDisplay(const int& color, const int& posx, const int& posy, const int& width, const int& height, const int& charHeight)
{
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->SetDebugDisplay(color, posx, posy, width, height, charHeight);
    iScene++;
  }
}
 
void SRoot::SetDebugText(const std::string& text)
{
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->SetDebugText(text);
    iScene++;
  }
}
 
void SRoot::CreateBoneHelperMesh()
{
  SBaseMeshsTools::CreateOctahedron("SO3/Bone/Helper/Mesh", .2f, .1f, 1.0f, SO3_INTERNAL_RESOURCE_GROUP);
  Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("SO3/Bone/Helper/Material", SO3_INTERNAL_RESOURCE_GROUP);
  material->setReceiveShadows(false);
  material->getTechnique(0)->getPass(0)->setLightingEnabled(true);
  material->getTechnique(0)->getPass(0)->setAmbient(1, 0, 0);
  material->getTechnique(0)->getPass(0)->setDiffuse(1, 0, 0, 1);
  material->getTechnique(0)->getPass(0)->setSelfIllumination(1, 0, 0);
  material->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
}
 
void SRoot::UpdateCamera(SViewPort* viewport)
{
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->UpdateCamera(viewport);
    iScene++;
  }
}
 
void SRoot::RegisterViewport(SViewPort* viewport)
{
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->RegisterViewport(viewport);
    iScene++;
  }
}
 
void SRoot::UnregisterViewport(SViewPort* viewport)
{
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->UnregisterViewport(viewport);
    iScene++;
  }
}
 
void SRoot::eventOccurred(const Ogre::String &eventName, const Ogre::NameValuePairList *parameters)
{
  if ((eventName == "DeviceLost") || (eventName == "BeforeDeviceReset"))
  {
    mDeviceLost = true;
  }
  else if ((eventName == "DeviceRestored") || (eventName == "AfterDeviceReset"))
  {
    mDeviceLost = false;
  }
}
 
bool SRoot::isDeviceLost()
{
#ifdef _WIN32
  return mDeviceLost;
#else
  return false;
#endif
}
 
void SRoot::ReloadInternalRessources()
{
  if (windowList.empty() || !mResourcesReleased)
    return;
 
#ifdef ANDROID
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  ScolWindowHandle awindow = (ScolWindowHandle)SCgetExtra("hscol");
  AConfiguration* config = AConfiguration_new();
  if (androidApp)
  {
    AConfiguration_fromAssetManager(config, androidApp->activity->assetManager);
 
    const SWindowMap lWin = windowList;
    SWindowMap::const_iterator iWindowSearched = lWin.begin();
    while ((iWindowSearched != lWin.end()))
    {
      try
      {
        MMechostr(MSKDEBUG, ">>> ReloadInternalRessources\n");
 
        iWindowSearched->second->SetWindowHandle(awindow);
        iWindowSearched->second->GetOgreRenderWindowPointer()->_notifySurfaceCreated(awindow, config);
 
        int nwidth = (int)ANativeWindow_getWidth(awindow);
        int nheight = (int)ANativeWindow_getHeight(awindow);
 
        /*int gwidth = nwidth / 2;
        int gheight = nheight / 2;
 
        ANativeWindow_setBuffersGeometry((ScolWindowHandle)awindow, gwidth, gheight, 0);*/
 
        iWindowSearched->second->Size(0, 0, nwidth, nheight, 1);
        iWindowSearched->second->ResumeWindow();
        iWindowSearched->second->SetSizeDirty();
      }
      catch (Ogre::Exception &e)
      {
        Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("ReloadInternalRessources : An exception has occurred: " + e.getDescription());
      }
      iWindowSearched++;
    }
 
    SSceneMap sceneList = scolRoot->GetSceneList();
    SSceneMap::iterator iScene = sceneList.begin();
    while (iScene != sceneList.end())
    {
      iScene->second->ReloadInternalRessources();
      iScene++;
    }
  }
 
  //SCsetExtra("glContext", eglGetCurrentContext());
  //SCsetExtra("glDisplay", eglGetDisplay(EGL_DEFAULT_DISPLAY));
  AConfiguration_delete(config);
#endif
  mResourcesReleased = false;
}
 
void SRoot::DestroyInternalRessources()
{
  if (mResourcesReleased)
    return;
 
  mPaused = true;
 
  //const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
  //if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
  mShaderGenerator->removeAllShaderBasedTechniques();
 
  if (windowList.empty())
    return;
 
  SSceneMap sceneList = scolRoot->GetSceneList();
  SSceneMap::iterator iScene = sceneList.begin();
  while (iScene != sceneList.end())
  {
    iScene->second->DestroyInternalRessources();
    iScene++;
  }
 
  const SWindowMap lWin = windowList;
  SWindowMap::const_iterator iWindowSearched = lWin.begin();
  while ((iWindowSearched != lWin.end()))
  {
    MMechostr(MSKDEBUG, ">>> DestroyInternalRessources\n");
    try
    {
      iWindowSearched->second->PauseWindow();
#ifdef ANDROID
      iWindowSearched->second->GetOgreRenderWindowPointer()->_notifySurfaceDestroyed();
      //iWindowSearched->second->SetWindowHandle(0);
#endif
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("DestroyInternalRessources : An exception has occurred: " + e.getDescription());
    }
    iWindowSearched++;
  }
  //SCsetExtra("glContext", 0);
  //SCsetExtra("glDisplay", 0);
 
  mResourcesReleased = true;
 
  return;
}
 
void SRoot::Pause()
{
  mPaused = true;
}
 
void SRoot::Resume()
{
  if (windowList.empty())
    return;
 
  const SWindowMap lWin = windowList;
  SWindowMap::const_iterator iWindowSearched = lWin.begin();
  while ((iWindowSearched != lWin.end()))
  {
    iWindowSearched->second->SetSizeDirty();
    iWindowSearched++;
  }
 
  // Clear event times
  Ogre::Root::getSingleton().clearEventTimes();
 
  mPaused = false;
}
 
bool SRoot::IsUpdating()
{
  return mUpdating;
}
 
bool SRoot::IsRendering()
{
  return mRendering;
}
 
bool SRoot::Update()
{
  if (windowList.empty() || mPaused)
    return false;
 
  bool ret = false;
 
  mUpdating = true;
#ifdef ANDROID
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  ScolWindowHandle awindow = (ScolWindowHandle)SCgetExtra("hscol");
  if (androidApp == 0 || awindow == 0)
    return false;
 
  int aWidth = ANativeWindow_getWidth(awindow);
  int aHeight = ANativeWindow_getHeight(awindow);
  if (aWidth != mMainWidth || aHeight != mMainHeight)
  {
    mMainWidth = aWidth;
    mMainHeight = aHeight;
 
    SWindow* so3win = SRoot::getSingleton().GetRenderWindow((const ScolWindowHandle&)awindow);
    if (so3win != NULL)
    {
      so3win->Size(0, 0, mMainWidth, mMainHeight, 1);
    }
  }
#endif
 
#ifdef _WIN32
# ifndef SO3_USE_DX11
  bool valid = true;
  if (GetRenderSystem() == SRoot::SO3_DIRECTX9_RENDERER)
  {
    try
    {
      Ogre::D3D9Device* device = static_cast<Ogre::D3D9RenderSystem*>(SRoot::getSingleton().GetOgreRenderSystem())->getDeviceManager()->getActiveDevice();
      valid = (device != 0) ? !device->isDeviceLost() : false;
    }
    catch (Ogre::Exception&)
    {
      valid = false;
    }
  }
 
  // only update ogre to keep the restore event append when we get the focus to a full screen window
  if (mDeviceLost || !valid)
  {
    const SWindowMap lWin = windowList;
    SWindowMap::const_iterator iWindowSearched = lWin.begin();
    while ((iWindowSearched != lWin.end()))
    {
      iWindowSearched->second->Update();
      iWindowSearched++;
    }
 
    return ret;
  }
# endif
 
  // manage window resize / screen change
  const SWindowMap lWin = windowList;
  SWindowMap::const_iterator iWindowSearched = lWin.begin();
  while ((iWindowSearched != lWin.end()))
  {
    /*
    POINT screenPoint;
    screenPoint.x = 0;
    screenPoint.y = 0;
    ClientToScreen(iWindowSearched->second->GetWindowHandle(), &screenPoint);
    Ogre::Vector2 curPos = iWindowSearched->second->GetScreenPos();
 
    RECT prevScreenRect;
    prevScreenRect.left = (int)curPos.x + iWindowSearched->second->GetWidth() / 2;
    prevScreenRect.top = (int)curPos.y + iWindowSearched->second->GetHeight() / 2;
    prevScreenRect.right = iWindowSearched->second->GetWidth();
    prevScreenRect.bottom = iWindowSearched->second->GetHeight();
 
    MONITORINFOEX pminfos;
    pminfos.cbSize = sizeof(pminfos);
    GetMonitorInfo(MonitorFromRect(&prevScreenRect, MONITOR_DEFAULTTONEAREST), &pminfos);
 
    RECT newScreenRect;
    newScreenRect.left = screenPoint.x + iWindowSearched->second->GetWidth() / 2;
    newScreenRect.top = screenPoint.y + iWindowSearched->second->GetHeight() / 2;
    newScreenRect.right = iWindowSearched->second->GetWidth();
    newScreenRect.bottom = iWindowSearched->second->GetHeight();
 
    MONITORINFOEX nminfos;
    nminfos.cbSize = sizeof(nminfos);
    GetMonitorInfo(MonitorFromRect(&newScreenRect, MONITOR_DEFAULTTONEAREST), &nminfos);
 
    if (Ogre::String(pminfos.szDevice) != Ogre::String(nminfos.szDevice))
    {
    Ogre::D3D9RenderWindow* rWindow = (Ogre::D3D9RenderWindow*)GetOgreRenderSystem()->getRenderTarget(iWindowSearched->second->GetOgreRenderWindowPointer()->getName());
    rWindow->getDevice()->invalidate(rWindow);
 
    // hack to restore the sky
    SSceneMap sceneList = scolRoot->GetSceneList();
    SSceneMap::iterator iScene = sceneList.begin();
    while(iScene != sceneList.end())
    {
    bool state = iScene->second->GetEnvironment()->GetSkyEnable();
    if (state)
    {
    iScene->second->GetEnvironment()->SetSkyEnable(false);
    iScene->second->GetEnvironment()->SetSkyEnable(state);
    }
 
    iScene++;
    }
    }*/
 
    //needed to update selector buffer correctly
    iWindowSearched->second->UpdateScreenPos();
    if (iWindowSearched->second->GetSizeDirty())
    {
      iWindowSearched->second->WindowMovedOrResized();
    }
    iWindowSearched++;
  }
#else
  const SWindowMap lWin = windowList;
  SWindowMap::const_iterator iWindowSearched = lWin.begin();
  while((iWindowSearched != lWin.end()))
  {
  #ifdef WIN32
    if (iWindowSearched->second->GetOgreRenderWindowPointer()->isActive())
    {
      if (iWindowSearched->second->GetSizeDirty())
        iWindowSearched->second->WindowMovedOrResized();
    }
    else
    {
      return false;
    }
  #else
    if (iWindowSearched->second->GetSizeDirty())
    {
      iWindowSearched->second->WindowMovedOrResized();
    }
  #endif
    iWindowSearched++;
  }
#endif
 
  // manage OgreWorkQueue
  //Ogre::Root::getSingleton().getWorkQueue()->processResponses();
 
  //hack to remove an ogre bug see #http://www.ogre3d.org/mantis/view.php?id=130
  //ClearSceneManagerPassMaps();
 
  // Get cef events (events were posted in one of cef's threads, so get those events back to scol's main thread for processing)
#if SO3_WEB_NAVIGATOR_BUILD == 1
  if(webNavigatorManager != 0)
    webNavigatorManager->Update();
#endif
 
  // update the scenes
  SSceneMap::iterator iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->PreUpdate();
    iScene++;
  }
 
  // Render 3D content
  Ogre::Root* ogreRoot = Ogre::Root::getSingletonPtr();
  mRendering = true;
  try
  {
    ret = ogreRoot->renderOneFrame();
  }
  catch (Ogre::Exception &e)
  {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
    ret = false;
  }
  mRendering = false;
 
  iScene = sceneList.begin();
  while(iScene != sceneList.end())
  {
    iScene->second->PostUpdate();
    iScene++;
  }
 
  mUpdating = false;
 
  //clean viewports to del
  SWindowMap::const_iterator iWindow = windowList.begin();
  while ((iWindow != windowList.end()))
  {
    iWindow->second->CleanViewports();
    iWindow++;
  }
 
  return ret;
}
 
bool SRoot::GetQuadBufferEnable()
{
#ifdef _WIN32
  if(O3Render != 0)
  {
    if(O3Render->getCapabilities() != 0)
    {
      if (O3Render->getCapabilities() && O3Render->getCapabilities()->hasCapability(Ogre::RSC_QUAD_BUFFER))
      {
        Ogre::ConfigOptionMap rendererConfigOptions = O3Render->getConfigOptions();
        Ogre::ConfigOptionMap::iterator iQuadBuffer = rendererConfigOptions.find("Stereo Mode");
        return ((renderSystem == SO3_OPENGL_RENDERER) && (iQuadBuffer != rendererConfigOptions.end()) && (iQuadBuffer->second.currentValue == "QuadBuffer"));
      }
    }
  }
#endif
  return false;
}
 
float SRoot::GetQuadBufferFocalLength()
{
  return quadBufferFocalLength;
}
 
float SRoot::GetQuadBufferEyesSeparation()
{
  return quadBufferEyesSeparation;
}
 
bool SRoot::GetVSyncEnable()
{
  return useVSync;
}
 
void SRoot::ParseConfigFile()
{
  // This var is there to check if the config file values where automatically forced by SO3Engine
  bool configForced = false;
  bool hasQuadBufferEyeSep = false;
  bool hasQuadBufferFocal = false;
 
  // Var for olding values recovered from ini file
  RenderSystem iniFileRenderSystem = SRoot::SO3_NONE_RENDER_SYSTEM;
  string iniFileFsaa = "";
  int iniFileActivateQuadBuffer = 0;
 
  //TODO get the path from scol external
#ifdef _WIN32
        // execpath
  char temporaryPath[MAX_PATH];
        GetCurrentDirectory(MAX_PATH, temporaryPath);
  std::string execpath(temporaryPath);
  boost::algorithm::replace_all(execpath, "\\", "/");
 
  // Subdir install directory path = subpath/subdir
  std::string execsubdir;
  size_t lastSlash = execpath.find_last_of('/');
  if(lastSlash != execpath.npos)
    execsubdir = execpath.substr(lastSlash);
 
  // Path to Common App Data directory: commonappdatapath/subdir
        string scolUserPath;
        HRESULT hr_scolpath = SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, temporaryPath);
        if(SUCCEEDED(hr_scolpath))
                scolUserPath = string(temporaryPath) + execsubdir;
 
#else
  std::string execpath((const char*)SCgetExtra("scolExecDir"));
  std::string scolUserPath((const char*)SCgetExtra("userFilesDir"));
#endif
  // Path to first config file
  string iniFilePath = scolUserPath + "/usmuser.ini";
 
  // Check that the config file exists
  FILE* pFile = fopen(iniFilePath.c_str(), "r");
        if(pFile!=NULL)
  {
    // File founded
    fclose (pFile);
  }
  else
  {
    // File not found, use the second config file instead
#ifndef ANDROID
    iniFilePath = execpath + "/usm.ini";
#else
    iniFilePath = "usm.ini";
#endif
  }
 
        // Open config file, and parse it.
  std::string line;
 
#ifndef ANDROID
        std::ifstream iniFile(iniFilePath.c_str());
#else
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  std::stringstream iniFile;
  if (androidApp)
  {
    AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, iniFilePath.c_str(), AASSET_MODE_RANDOM);
    if (asset)
    {
      iniFile.write(reinterpret_cast<const char *>(AAsset_getBuffer(asset)), AAsset_getLength(asset));
      AAsset_close(asset);
    }
  }
#endif
 
  if(iniFile)
        {
                while(std::getline(iniFile, line))
                {
      // Substract end of line if a comment is detected
      size_t firstComment = line.find_first_of('#');
      if(firstComment != line.npos)
        line = line.substr(0, firstComment);
 
      // Search for SO3Renderer
                        if(line.find(SO3_CONFIG_RENDERER_KEYWORD) != string::npos)
                        {
#ifdef _WIN32
        if((line.find(SO3_CONFIG_RENDERER_DIRECTX) != string::npos)
          ||(line.find(SO3_CONFIG_RENDERER_DIRECTX9) != string::npos)
          ||(line.find(SO3_CONFIG_RENDERER_DIRECTX11) != string::npos))
# ifndef SO3_USE_DX11
          iniFileRenderSystem = SRoot::SO3_DIRECTX9_RENDERER;
# else
          iniFileRenderSystem = SRoot::SO3_DIRECTX11_RENDERER;
# endif
#endif
                                if(line.find(SO3_CONFIG_RENDERER_OPENGL) != string::npos)
                                  iniFileRenderSystem = SRoot::SO3_OPENGL_RENDERER;
        else if (line.find(SO3_CONFIG_RENDERER_VULKAN) != string::npos)
          iniFileRenderSystem = SRoot::SO3_VULKAN_RENDERER;
        else if (line.find(SO3_CONFIG_RENDERER_TINY) != string::npos)
          iniFileRenderSystem = SRoot::SO3_TINY_RENDERER;
        else if (line.find(SO3_CONFIG_RENDERER_METAL) != string::npos)
          iniFileRenderSystem = SRoot::SO3_METAL_RENDERER;
 
                        }
 
      // Search FSAA
      if(line.find(SO3_CONFIG_FSAA_KEYWORD) != string::npos)
                        {
                                // Check that a value is present
        size_t keywordLength = string(SO3_CONFIG_FSAA_KEYWORD).length() + 1;
        if(line.length() > keywordLength)
          iniFileFsaa = line.substr(keywordLength);
                        }
 
      // Search VSYNC
      if(line.find(SO3_CONFIG_VSYNC_KEYWORD) != string::npos)
                        {
                                // Check that a value is present
        size_t keywordLength = string(SO3_CONFIG_VSYNC_KEYWORD).length() + 1;
        if(line.length() > keywordLength)
        {
          string vSyncValue = boost::algorithm::to_lower_copy(line.substr(keywordLength));
          if((vSyncValue == "1") || (vSyncValue == "yes") || (vSyncValue == "true") || (vSyncValue == "on"))
            useVSync = true;
        }
                        }
 
      // Stereo Quad buffer option enabled?
      if(line.find(SO3_CONFIG_QUAD_BUFFER_KEYWORD) != string::npos)
                        {
                                // Check that a value is present
        size_t keywordLength = string(SO3_CONFIG_QUAD_BUFFER_KEYWORD).length() + 1;
                                if(line.length() > keywordLength)
        {
          string quadBufferValue = boost::algorithm::to_lower_copy(line.substr(keywordLength));
          if((quadBufferValue == "1") || (quadBufferValue == "yes") || (quadBufferValue == "true") || (quadBufferValue == "on"))
            iniFileActivateQuadBuffer = 1;
          else
            iniFileActivateQuadBuffer = -1;
        }
                        }
 
      // Search stereo focal length
      if(line.find(SO3_CONFIG_FOCAL_LENGTH_KEYWORD) != string::npos)
      {
        // Check that a value is present
        size_t keywordLength = string(SO3_CONFIG_FOCAL_LENGTH_KEYWORD).length() + 1;
        if(line.length() > keywordLength)
        {
          std::istringstream is(line.substr(keywordLength));
          is >> quadBufferFocalLength;
          hasQuadBufferFocal = true;
        }
      }
 
      // Search stereo eyes separation
      if(line.find(SO3_CONFIG_EYES_SEPARATION_KEYWORD) != string::npos)
      {
        // Check that a value is present
        size_t keywordLength = string(SO3_CONFIG_EYES_SEPARATION_KEYWORD).length() + 1;
        if(line.length() > keywordLength)
        {
          std::istringstream is(line.substr(keywordLength));
          is >> quadBufferEyesSeparation;
          hasQuadBufferEyeSep = true;
        }
      }
                }
#ifndef ANDROID
          iniFile.close();
#endif
        }
 
  // If no render system was founded in the ini file, use DirectX as default (for the moment some shaders like fresnel and reflection plans don't work perfectly on openGL).
  if(iniFileRenderSystem == SRoot::SO3_NONE_RENDER_SYSTEM)
  {
    iniFileRenderSystem = SRoot::SO3_OPENGL_RENDERER;
    configForced = true;
  }
 
#ifdef _WIN32
  /*
  //todo check creating D3D device
  // Checking that the dx version is supported.
  if(!scolRoot->CheckDirectxVersion())
  {
    // No dx, so check if we had already planned to use OpenGL
    if(iniFileRenderSystem != SO3_OPENGL_RENDERER)
    {
      // Force OpenGL
      iniFileRenderSystem = SRoot::SO3_OPENGL_RENDERER;
      configForced = true;
    }
  }
  */
#endif
 
  // Checking quad buffer option
  bool wantsQuadBuffer = false;
  switch(iniFileActivateQuadBuffer)
  {
  case 0:
    wantsQuadBuffer = false;
    configForced = true;
    break;
  case -1:
    wantsQuadBuffer = false;
    break;
  case 1:
    wantsQuadBuffer = true;
    break;
  }
 
  // Checking focal length
  if(!hasQuadBufferEyeSep || !hasQuadBufferFocal)
    configForced = true;
 
  // Set fsaa option.
  if(iniFileFsaa.empty())
  {
    iniFileFsaa = "0";
    configForced = true;
  }
  defaultFsaa = iniFileFsaa;
 
  // Set the render system that was detected
  if (renderSystem == SO3_NONE_RENDER_SYSTEM) //do only on init
    SetRenderSystem(iniFileRenderSystem, wantsQuadBuffer);
 
  // Rewrite ini file with the good values
  if(configForced == true)
    WriteConfigFile(iniFilePath);
}
 
void SRoot::WriteConfigFile(const std::string& filename)
{
  // Read the existing ini file.
  std::stringstream content;
  std::ifstream inputIniFile(filename.c_str());
 
  // to avoid usm default value overwritted
  bool QuadBufferSetted = false;
        if(inputIniFile)
        {
    std::string line;
                while (std::getline(inputIniFile, line))
                {
                        if((line.find(SO3_CONFIG_RENDERER_KEYWORD) == string::npos)
       &&(line.find(SO3_CONFIG_FSAA_KEYWORD) == string::npos)
       &&(line.find(SO3_CONFIG_FOCAL_LENGTH_KEYWORD) == string::npos)
       &&(line.find(SO3_CONFIG_EYES_SEPARATION_KEYWORD) == string::npos))
      {
        if (line.find(SO3_CONFIG_QUAD_BUFFER_KEYWORD) != string::npos)
          QuadBufferSetted = true;
 
        // Rewrite the line as it.
        content << line << std::endl;
      }
                }
          inputIniFile.close();
 
    // Add the renderer line in the file
    if(renderSystem == SO3_DIRECTX9_RENDERER)
    {
      content << SO3_CONFIG_RENDERER_KEYWORD << " " << SO3_CONFIG_RENDERER_DIRECTX9 << std::endl;
    }
    else if(renderSystem == SO3_DIRECTX11_RENDERER)
    {
      content << SO3_CONFIG_RENDERER_KEYWORD << " " << SO3_CONFIG_RENDERER_DIRECTX11 << std::endl;
    }
    else if(renderSystem == SO3_OPENGL_RENDERER)
    {
      content << SO3_CONFIG_RENDERER_KEYWORD << " " << SO3_CONFIG_RENDERER_OPENGL << std::endl;
    }
    else if (renderSystem == SO3_VULKAN_RENDERER)
    {
      content << SO3_CONFIG_RENDERER_KEYWORD << " " << SO3_CONFIG_RENDERER_VULKAN << std::endl;
    }
    else if (renderSystem == SO3_TINY_RENDERER)
    {
      content << SO3_CONFIG_RENDERER_KEYWORD << " " << SO3_CONFIG_RENDERER_TINY << std::endl;
    }
    else if (renderSystem == SO3_METAL_RENDERER)
    {
      content << SO3_CONFIG_RENDERER_KEYWORD << " " << SO3_CONFIG_RENDERER_METAL << std::endl;
    }
 
    // Add the FSAA line in the file
    content << SO3_CONFIG_FSAA_KEYWORD << " " << defaultFsaa << std::endl;
 
    // In case the QuadBuffer line was not found in the file
    if(O3Render != 0 && !QuadBufferSetted)
    {
      if(GetQuadBufferEnable())
      {
        // Quad buffer enable
        content << SO3_CONFIG_QUAD_BUFFER_KEYWORD << " yes" << std::endl;
      }
      else
      {
        // No quad buffer stereo support with this renderer, or quad buffer disabled.
        content << SO3_CONFIG_QUAD_BUFFER_KEYWORD << " no" << std::endl;
      }
    }
 
    // Store quad buffer focal length
    content << SO3_CONFIG_FOCAL_LENGTH_KEYWORD << " " << quadBufferFocalLength << std::endl;
 
    // Store quad buffer eyes separation distance
    content << SO3_CONFIG_EYES_SEPARATION_KEYWORD << " " << quadBufferEyesSeparation << std::endl;
 
    // Write content to file
                std::ofstream outputIniFile(filename.c_str(), std::ios::out | std::ios::trunc);
                if(outputIniFile)
                {
                        outputIniFile << content.str();
                        outputIniFile.close();
                }
  }
}
 
 
void SRoot::RemoveGeneratedMaterial(Ogre::Material* mat)
{
  if (mat)
    mShaderGenerator->removeAllShaderBasedTechniques(mat->getName(), mat->getGroup());
}
 
 
void SRoot::InvalidateGeneratedMaterial(Ogre::Material* mat)
{
  if (mat)
    mShaderGenerator->invalidateMaterial(Ogre::MSN_SHADERGEN, mat->getName(), mat->getGroup());
}
 
 
//Shader Generator
Ogre::Technique* ShaderGeneratorTechniqueResolverListener::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
{
  Ogre::RTShader::ShaderGenerator* mGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
 
  std::string cSchemeName = schemeName;
  if (cSchemeName != Ogre::MSN_SHADERGEN)
    cSchemeName = cSchemeName.erase(0, 15);
 
  //Check material for compatible scheme
  Ogre::Technique* tech = 0;
 
  //look for convertible technique
  Ogre::Material::Techniques techList = originalMaterial->getTechniques();
  for (unsigned int i = 0; i < techList.size(); i++)
  {
    Ogre::Technique* curTechnique = techList[i];
    Ogre::String curScheme = curTechnique->getSchemeName();
    Ogre::Any bindedSTechnique = curTechnique->getUserObjectBindings().getUserAny("STechnique");
    if (bindedSTechnique.has_value())
    {
      STechnique* so3Technique = Ogre::any_cast<STechnique*> (bindedSTechnique);
      curScheme = so3Technique->GetOriginalScheme();
    }
 
    if (curScheme == cSchemeName)
    {
      //reset scheme to original name
      curTechnique->setSchemeName(curScheme);
      tech = curTechnique;
      break;
    }
  }
 
  // if we have a technique for this scheme this means it's not compatible so we will try to convert it
  // otherwise we get the first compatible technique if we have one
  if (!tech)
  {
    Ogre::Material::Techniques techList = originalMaterial->getSupportedTechniques();
    tech = (techList.size() > 0) ? techList[0] : 0;
  }
 
  //check for compatible pass first
  if (tech)
  {
    int nbGoodPass = 0;
    Ogre::Technique::Passes passList = tech->getPasses();
    for (unsigned short i = 0; i < passList.size(); i++)
    {
      Ogre::Pass* pass = passList[i];
      Ogre::Any bindedSPass = pass->getUserObjectBindings().getUserAny("SPass");
      bool isGenerated = false;
      if (bindedSPass.has_value())
      {
        SPass* matPass = Ogre::any_cast<SPass*> (bindedSPass);
        isGenerated = matPass->IsShaderGenerated();
      }
 
      if (pass->hasVertexProgram() && pass->hasFragmentProgram() && !isGenerated)
      {
        Ogre::GpuProgramPtr vp = pass->getVertexProgram();
        Ogre::GpuProgramPtr fp = pass->getFragmentProgram();
        if (vp && fp && vp->isSupported() && fp->isSupported())
        {
          nbGoodPass++;
        }
      }
    }
    if (nbGoodPass == tech->getNumPasses())
    {
      tech->setSchemeName(schemeName);
      //force loading to skip this the next time
      originalMaterial->compile();
      return tech;
    }
  }
 
  //look for first convertible technique if there is no compatible or corresponding technique
  if (!tech)
  {
    techList = originalMaterial->getTechniques();
    for (unsigned int i = 0; i < techList.size(); i++)
    {
      Ogre::Technique* curTechnique = techList[i];
      if ((curTechnique->getSchemeName() == Ogre::MSN_DEFAULT) || (curTechnique->getSchemeName() == "basic_mat") || (curTechnique->getSchemeName() == "SO3_LEGACY"))
      {
        tech = curTechnique;
        break;
      }
    }
  }
 
  if (tech)
  {
    //search pass
    Ogre::Technique::Passes passList = tech->getPasses();
    for (unsigned short i = 0; i < passList.size(); i++)
    {
      Ogre::Pass* ambpass = 0;
      Ogre::Pass* pass = passList[i];
 
      bool isShadowPass = false;
      SSceneMap sceneList = SRoot::getSingleton().GetSceneList();
      SSceneMap::iterator iScene = sceneList.begin();
      while (iScene != sceneList.end())
      {
        if (iScene->second->GetShadowManager() && iScene->second->GetShadowManager()->IsShadowMaterialPass(pass))
          isShadowPass = true;
 
        iScene++;
      }
 
      if (isShadowPass)
        continue;
 
      if (pass && (pass->getIlluminationStage() == Ogre::IS_AMBIENT))
      {
        ambpass = pass;
      }
      else if (pass && (pass->getIlluminationStage() == Ogre::IS_PER_LIGHT || pass->getIteratePerLight()))
      {
        if (ambpass)
        {
          ambpass->setAmbient(pass->getAmbient());
          ambpass->setDiffuse(pass->getDiffuse());
          ambpass->setEmissive(pass->getEmissive());
          ambpass->setSpecular(pass->getSpecular());
          ambpass->setShininess(pass->getShininess());
 
          size_t nbTex = pass->getNumTextureUnitStates();
          for (size_t t = 0; t < nbTex; t++)
          {
            Ogre::TextureUnitState* ustate = pass->getTextureUnitState(t);
            ambpass->addTextureUnitState(ustate);
          }
 
          ambpass->setVertexProgram("", true);
          ambpass->setFragmentProgram("", true);
 
          ambpass->setIlluminationStage(Ogre::IS_UNKNOWN);
          tech->removePass(i);
        }
        else
        {
          pass->setIlluminationStage(Ogre::IS_UNKNOWN);
          pass->setDepthWriteEnabled(true);
          pass->setDepthCheckEnabled(true);
          pass->setVertexProgram("", true);
          pass->setFragmentProgram("", true);
          pass->setMaxSimultaneousLights(3);
          pass->setIteratePerLight(false);
        }
 
        //originalMaterial->reload();
      }
    }
  }
 
  //remove shader on technique
  //if (tech->getSchemeName() == "SO3_LEGACY")
  //{
  //  Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
  //  if (bindedSTechnique.has_value())
  //  {
  //    STechnique* so3Technique = Ogre::any_cast<STechnique*> (bindedSTechnique);
  //    int np = so3Technique->GetNumPasses();
  //    for (int p = 0; p < np; p++)
  //    {
  //      SPass* cpass = so3Technique->GetPass(p);
  //      if (cpass)
  //        cpass->CleanGeneratedShader();
  //    }
  //  }
  //}
 
  // Create shader generated technique for this material.
  bool techniqueCreated = mGenerator->createShaderBasedTechnique(
    *originalMaterial,
    tech->getSchemeName(), //Ogre::MSN_DEFAULT,
    schemeName, true);
 
  if (!techniqueCreated)
  {
    //try again with basic mat
    techniqueCreated = mGenerator->createShaderBasedTechnique(
      *originalMaterial,
      "basic_mat",
      schemeName, false);
 
    if (!techniqueCreated)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("Material scheme conversion failed from " + tech->getSchemeName() + " to " + schemeName + " on material : " + originalMaterial->getName());
      return NULL;
    }
  }
 
  // add RTSS params
  Ogre::Technique::Passes passList = tech->getPasses();
  for (unsigned short i = 0; i < passList.size(); i++)
  {
    Ogre::Pass* pass = passList[i];
    bool ignoreSlicePlane = true;
 
    Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
    if (bindedSTechnique.has_value())
    {
      STechnique* so3Technique = Ogre::any_cast<STechnique*> (bindedSTechnique);
      ignoreSlicePlane = so3Technique->GetParentMaterial()->GetIgnoreSlicePlane();
    }
    SShaderGenerator shaderRTSS(tech, pass, SShaderGenerator::ShaderGeneratorRTSS, ignoreSlicePlane || !SRoot::getSingletonPtr()->GetSlicePlaneState());
    shaderRTSS.ApplyShader();
  }
 
  // Case technique registration succeeded.
  Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("Material scheme converted from " + tech->getSchemeName() + " to " + schemeName + " on material : " + originalMaterial->getName() + " with group : " + originalMaterial->getGroup());
 
  // Force creating the shaders for the generated technique.
  try
  {
    mGenerator->validateMaterial(schemeName, originalMaterial->getName(), originalMaterial->getGroup());
  }
  catch (Ogre::Exception &)
  {
    return Ogre::MaterialManager::getSingletonPtr()->getByName("BaseWhite", Ogre::RGN_INTERNAL)->getBestTechnique();
  }
 
  if (originalMaterial->getLoadingState() == Ogre::Resource::LOADSTATE_UNLOADED)
    originalMaterial->compile();
 
  //rebuild default shaders
  //if (tech->getSchemeName() == "SO3_LEGACY")
  //{
  //  Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
  //  if (bindedSTechnique.has_value())
  //  {
  //    STechnique* so3Technique = Ogre::any_cast<STechnique*> (bindedSTechnique);
  //    int np = so3Technique->GetNumPasses();
  //    for (int p = 0; p < np; p++)
  //    {
  //      SPass* cpass = so3Technique->GetPass(p);
  //      if (cpass)
  //        cpass->BuildShader(true);
  //    }
  //  }
  //}
 
  // Grab the generated technique.
  techList = originalMaterial->getTechniques();
  for(unsigned int i = 0; i < techList.size(); i++)
  {
    Ogre::Technique* curTech = techList[i];
    MMechostr(MSKDEBUG, ">>>> Material %s technique scheme name : %s > %s\n", originalMaterial->getName().c_str(), schemeName.c_str(), curTech->getSchemeName().c_str());
    if (curTech->getSchemeName() == schemeName)
    {
      //generate shadow pass warning on multiple scene ?!
      /*
      SSceneMap sceneList = SRoot::getSingleton().GetSceneList();
      SSceneMap::iterator iScene = sceneList.begin();
      while (iScene != sceneList.end())
      {
        if (iScene->second->GetShadowManager())
          iScene->second->GetShadowManager()->UpdateShadowMaterial(curTech);
 
        iScene++;
      }
      */
      return curTech;
    }
  }
  return NULL;
}
 
bool ShaderGeneratorTechniqueResolverListener::afterIlluminationPassesCreated(Ogre::Technique* tech)
{
  Ogre::RTShader::ShaderGenerator* mGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
  if (mGenerator->hasRenderState(tech->getSchemeName()))
  {
    Ogre::Material* mat = tech->getParent();
    mGenerator->validateMaterialIlluminationPasses(tech->getSchemeName(), mat->getName(), mat->getGroup());
    return true;
  }
  return false;
}
 
bool ShaderGeneratorTechniqueResolverListener::beforeIlluminationPassesCleared(Ogre::Technique* tech)
{
  Ogre::RTShader::ShaderGenerator* mGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
  if (mGenerator->hasRenderState(tech->getSchemeName()))
  {
    Ogre::Material* mat = tech->getParent();
    mGenerator->invalidateMaterialIlluminationPasses(tech->getSchemeName(), mat->getName(), mat->getGroup());
    return true;
  }
  return false;
}
 
bool SRoot::initialiseRTShaderSystem()
{
  if (Ogre::RTShader::ShaderGenerator::initialize())
  {
    mShaderGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
 
    Ogre::RTShader::SubRenderStateFactory* curFactory = OGRE_NEW FFPClipPLaneFactory;
    mShaderGenerator->addSubRenderStateFactory(curFactory);
 
    curFactory = OGRE_NEW AdvancedCookTorranceLightingFactory;
    mShaderGenerator->addSubRenderStateFactory(curFactory);
 
    // Create and register the material manager listener if it doesn't exist yet.
    if (mMaterialMgrListener == NULL)
    {
      mMaterialMgrListener = new ShaderGeneratorTechniqueResolverListener();
      Ogre::MaterialManager::getSingleton().addListener(mMaterialMgrListener);
    }
 
    // create a dummy scene before parsing resources for RTSS
    mDummyScene = O3Root->createSceneManager(Ogre::SMT_DEFAULT, "DummyScene");
    Ogre::AxisAlignedBox octreeBox(-1, -1, -1, 1, 1, 1);
    int octreeDepth = 0;
    mDummyScene->setOption("Size", &octreeBox);
    mDummyScene->setOption("Depth", &octreeDepth);
 
    Ogre::RenderQueue* rq = mDummyScene->getRenderQueue();
    rq->getQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_1)->setShadowsEnabled(false);
    rq->getQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2)->setShadowsEnabled(false);
    rq->getQueueGroup(Ogre::RENDER_QUEUE_MAIN)->setShadowsEnabled(false);
 
    mShaderGenerator->addSceneManager(mDummyScene);
 
    auto mainRenderState = mShaderGenerator->getRenderState(Ogre::MSN_SHADERGEN);
    // reset global light state
    mainRenderState->setLightCount(0);
    mainRenderState->setLightCountAutoUpdate(true);
    mainRenderState->resetToBuiltinSubRenderStates();
 
    auto perPixelLightModel = mShaderGenerator->createSubRenderState(Ogre::RTShader::SRS_PER_VERTEX_LIGHTING);
    mainRenderState->addTemplateSubRenderState(perPixelLightModel);
 
    mShaderGenerator->invalidateScheme(Ogre::MSN_SHADERGEN);
  }
 
  return true;
}
 
/*-----------------------------------------------------------------------------
| Destroy the RT Shader system.
-----------------------------------------------------------------------------*/
void SRoot::destroyRTShaderSystem()
{
  // Restore default scheme.
  Ogre::MaterialManager::getSingleton().setActiveScheme(Ogre::MSN_DEFAULT);
 
  if (mDummyScene)
  {
    mShaderGenerator->removeSceneManager(mDummyScene);
    O3Root->destroySceneManager(mDummyScene);
    mDummyScene = 0;
  }
 
  // Unregister the material manager listener.
  if (mMaterialMgrListener != NULL)
  {
    Ogre::MaterialManager::getSingleton().removeListener(mMaterialMgrListener);
    delete mMaterialMgrListener;
    mMaterialMgrListener = NULL;
  }
  
  if (mShaderGenerator)
  {
    mShaderGenerator->destroy();
    mShaderGenerator = 0;
  }
}
 
void SRoot::SetSlicePlaneState(bool state)
{
  if (!mSlicePlaneParams || (mSlicePlaneState == state))
    return;
 
  mSlicePlaneState = state;
 
  if (mSlicePlaneState)
    mSlicePlaneParams->setNamedConstant("slicePlane", mSlicePlane);
  else
    mSlicePlaneParams->setNamedConstant("slicePlane", Ogre::Vector4::ZERO);
  
  Ogre::ResourceManager::ResourceMapIterator it = Ogre::MaterialManager::getSingleton().getResourceIterator();
  while (it.hasMoreElements())
  {
    Ogre::MaterialPtr mat = Ogre::static_pointer_cast<Ogre::Material>(it.getNext());
    RemoveGeneratedMaterial(mat.get());
 
    Ogre::Material::Techniques techs = mat->getTechniques();
    for (unsigned int i = 0; i < techs.size(); i++)
    {
      Ogre::Technique* tech = techs[i];
 
      //skip generated techniques like SSAO
      if (tech->getSchemeName().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos || tech->getResourceGroup().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos)
        continue;
 
      if (((tech->getSchemeName() != Ogre::MSN_SHADERGEN) &&
        (tech->getSchemeName() != "SO3_LEGACY") &&
        (tech->getSchemeName() != "Default") &&
        (tech->getSchemeName() != "basic_mat")))
        continue;
 
      Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
      if (!bindedSTechnique.has_value())
        continue;
 
      STechnique* stechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
      if (!stechnique)
        continue;
 
      if (stechnique->GetParentMaterial()->GetIgnoreSlicePlane())
        continue;
      
      tech->setSchemeName(stechnique->GetOriginalScheme());
      stechnique->UpdateGeneratedTech(true);
    }
  }
}
 
void SRoot::SetSlicePlane(Ogre::Vector4 plane)
{
  mSlicePlane = plane;
 
  if (!mSlicePlaneParams || !mSlicePlaneState)
    return;
 
  mSlicePlaneParams->setNamedConstant("slicePlane", mSlicePlane);
}
 
bool SRoot::GetSlicePlaneState()
{
  return mSlicePlaneState;
}
 
Ogre::Vector4 SRoot::GetSlicePlane()
{
  return mSlicePlane;
}
 
 
void SRoot::SetProgramCameraParameter(float fov, float znear, float zfar, float focalLength)
{
  const Ogre::RenderSystem *renderSystem = SRoot::getSingleton().GetOgreRenderSystem();
  float prjA = 0.0;
  float prjB = 0.0;
  if (!renderSystem->isReverseDepthBufferEnabled())
  {
    prjA = zfar / (zfar - znear);             // projectionA
    prjB = (-zfar * znear) / (zfar - znear);  // projectionB
  }
  else
  {
    prjA = -znear / (zfar - znear);          // projectionA
    prjB = (zfar * znear) / (zfar - znear);  // projectionB
  }
  prjB /= zfar;
  
  mCommonParams->setNamedConstant("cameraProjection", Ogre::Vector4(prjA, prjB, 0.0, 0.0));
  mCommonParams->setNamedConstant("cameraParams", Ogre::Vector4(znear, zfar, focalLength, fov));
}
 
}