SO3Window.cpp

Go to the documentation of this file.

 
#include "SO3Renderer/SO3Window.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3SceneGraph/SO3SubEntitySelectorBuffer.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Environment.h"
 
#include "OgreMemoryAllocatorConfig.h"
 
#ifdef _WIN32
# ifndef SO3_USE_DX11
#include "OgreD3D9RenderWindow.h"
#include "OgreD3D9DeviceManager.h"
# endif
#else
char* itoa(int val, char* buf, int base){
    int i = 14;
    for (; val && i; --i, val /= base)
      buf[i] = "0123456789abcdef"[val % base];
    return &buf[i + 1];
  }
#endif
 
#ifdef APPLE_IOS
#include <QGuiApplication>
#include <QScreen>
#endif
 
extern int BUFFER_PRE_RENDER_EVENT;
extern int BUFFER_POST_RENDER_EVENT;
extern int BUFFER_STEREO_BEFORE_UPDATE_EVENT;
extern int BUFFER_STEREO_UPDATE_PARAMS_EVENT;
extern int BUFFER_STEREO_UPDATED_EVENT;
extern int getBufferPreRenderEvent(struct Mmachine*, SCOL_PTR_TYPE, SCOL_PTR_TYPE);
extern int getBufferPostRenderEvent(struct Mmachine*, SCOL_PTR_TYPE, SCOL_PTR_TYPE);
 
extern int iLastMousePos[2];
 
namespace SO3
{
SWindow::SWindow() : SData("")
{
  // Forbiden constructor (private).
}
 
SWindow::SWindow(SRoot* parent, const ScolWindowHandle& windowHandle, const std::string& windowName, const int& width, const int& height, const std::string& fsaa) : SData(windowName)
{
  scolRoot = parent;
  bBeginFrame = false;
  bSizeDirty = true;
  subEntitySelector = 0;
  mStereoMode = StereoManager::SO3_NONE_STEREO;
 
#if defined(ANDROID) || defined(APPLE_IOS) || defined(OSX) || defined(RPI)
  mSelectorMode = SO3_SELECTOR_LIMITED;
#else
  mSelectorMode = SO3_SELECTOR_FAST;
#endif
 
  //update config
  scolRoot->ParseConfigFile();
 
  int awidth = width;
  int aheight = height;
 
  // Retrieve the parent window handle.
  hwnd = (ScolWindowHandle)windowHandle;
        Ogre::String winHandle = Ogre::StringConverter::toString((size_t)(ScolWindowHandle)hwnd);
 
#ifdef _WIN32
  //add WS_CLIPCHILDREN flag for 3D content
  SetWindowLongPtr(hwnd, GWL_STYLE, (GetWindowLongPtr(hwnd, GWL_STYLE))|WS_CLIPCHILDREN);
#endif
 
  // Setting render window options
  Ogre::NameValuePairList viewConfig;
#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);
    awidth = 0;
    aheight = 0;
 
    viewConfig["externalWindowHandle"] = Ogre::StringConverter::toString(SCOL_PTR awindow);
    viewConfig["androidConfig"] = Ogre::StringConverter::toString(SCOL_PTR config);
    viewConfig["minColourBufferSize"] = Ogre::StringConverter::toString(24);
    viewConfig["preserveContext"] = "true";
    viewConfig["MSAA"] = "2";
 
    /*
    float wScale = 1.0f;
    int nwidth = (int)ANativeWindow_getWidth(awindow);
    int nheight = (int)ANativeWindow_getHeight(awindow);
 
    // portrait mode
    if (nheight > nwidth)
    {
      nwidth = (int)ANativeWindow_getHeight(awindow);
      nheight = (int)ANativeWindow_getWidth(awindow);
    }
 
    if (nwidth > 1920)
    {
      wScale = 2.0f;
    }
    else if (nwidth > 1280)
    {
      wScale = 1.5f;
    }
    //comment to avoid a bug on weird old tablets
    else if (nwidth > 1024)
    {
      wScale = 1.2f;
    }
 
    viewConfig["contentScalingFactor"] = Ogre::StringConverter::toString(wScale);
    */
  }
#elif defined(_WIN32)
  viewConfig["externalWindowHandle"] = winHandle;
  viewConfig["vsync"] = parent->GetVSyncEnable() ? "Yes" : "No";
  //viewConfig["colourDepth"] = Ogre::StringConverter::toString(32);
#elif defined(APPLE_IOS)
  viewConfig["externalViewHandle"] = winHandle;
  viewConfig["retainedBacking"] = "Yes";
  QScreen* screen = QGuiApplication::primaryScreen();
  QRect screenSize = screen->geometry();
  awidth = screenSize.width();
  aheight = screenSize.height();
  
#elif defined(__APPLE__)
  viewConfig["externalWindowHandle"] = winHandle;
#elif defined(RPI)
  viewConfig["externalWindowHandle"] = winHandle;
#else //linux X11
  viewConfig["parentWindowHandle"] = winHandle;
#endif
 
#ifdef _WIN32
  #ifdef SO3_DEBUG
    viewConfig["useNVPerfHUD"] = "Yes";
  #endif
#endif
 
  /******************************************* Options Setting  ***************************************/
  if(scolRoot->checkFSAA(fsaa))
  {
    if(fsaa.find("[Quality]") != string::npos)
    {
      viewConfig["FSAAHint"] = "Quality";
      viewConfig["FSAA"] = fsaa.substr(0, fsaa.find("[Quality]")-2);
    }
    else
    {
      viewConfig["FSAA"] = fsaa;
      viewConfig["FSAAHint"] = "";
    }
  }
 
  O3Window = Ogre::Root::getSingleton().createRenderWindow(windowName, awidth, aheight, false, &viewConfig);
 
  O3Window->setPriority(0);
  //O3Window->setDeactivateOnFocusChange(false);
 
  if(O3Window->isPrimary())
    scolRoot->InitRenderer(this);
 
        O3Window->addListener(this);
        stereoManager = new StereoManager(this);
 
#ifdef _WIN32
        hwndFullscreenOgre = NULL;
        styleFullscreenOgre = NULL;
        exstyleFullscreenOgre = NULL;
  mLastWindowRegion = NULL;
#endif
 
#ifdef ANDROID
  AConfiguration_delete(config);
#endif
 
  
  // For subentity picking
#if !defined(OSX) && !defined(APPLE_IOS)
  Ogre::PixelFormat rttformat;
  bool pfsupport = SRoot::getSingleton().GetRttPixelFormat(rttformat, true);
  if (pfsupport)
  {
    subEntitySelector = new SSubEntitySelectorBuffer(this, (mSelectorMode == SO3_SELECTOR_FAST) ? true : false);
  }
#endif
  
  UpdateScreenPos();
 
  //update to create ressources
  Update();
}
 
SWindow::~SWindow()
{
  SetFullScreen(false);
  O3Window->removeListener(this);
  SO3_SAFE_DELETE(subEntitySelector);
  SO3_SAFE_DELETE(stereoManager);
 
  MMechostr(0, "Destroy window name : %s\n", GetName().c_str());
  if(!O3Window->isPrimary())
  {
    SRoot::getSingleton().GetOgreRenderSystem()->destroyRenderWindow(GetName());
  }
 
  O3Window = 0;
 
#ifdef _WIN32
  //remove WS_CLIPCHILDREN flag for 3D content
  SetWindowLongPtr(hwnd, GWL_STYLE, (GetWindowLongPtr(hwnd, GWL_STYLE))& ~(WS_CLIPCHILDREN));
#endif
}
 
void SWindow::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
{
  if (evt.source == O3Window)
  {
    if (!SRoot::getSingletonPtr()->isDeviceLost())
    {
      getBufferPreRenderEvent(mm, SCOL_PTR this, 0);
    }
  }
}
 
void SWindow::UpdateScreenPos()
{
#ifdef _WIN32
  POINT screenPoint;
  screenPoint.x = 0;
  screenPoint.y = 0;
  ClientToScreen(hwnd, &screenPoint);
 
  screenPos.x = (Ogre::Real)screenPoint.x;
  screenPos.y = (Ogre::Real)screenPoint.y;
#endif
}
 
Ogre::Vector2 SWindow::GetScreenPos()
{
  return screenPos;
}
 
void SWindow::SetSizeDirty()
{
#ifdef _WIN32
  RECT rc;
  BOOL result;
 
  // width and height represent drawable area only
  result = GetClientRect(hwnd, &rc);
  if (result == FALSE)
    return;
 
  unsigned int width = rc.right - rc.left;
  unsigned int height = rc.bottom - rc.top;
 
  if ((width > 4) && (height > 4))
  {
    bSizeDirty = true;
 
    //update viewports to get the correct pixel size
    try
    {
      O3Window->windowMovedOrResized();
    }
    catch (Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
    {
    }
  }
#else
  bSizeDirty = true;
 
  //update viewports to get the correct pixel size
  try
  {
    O3Window->windowMovedOrResized();
  }
  catch (Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
  {
  }
#endif
}
 
bool SWindow::GetSizeDirty()
{
  return bSizeDirty;
}
 
void SWindow::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
{
  if (evt.source == O3Window)
  {
    //MMechostr(MSKDEBUG, "postRenderTargetUpdate raycast : %i:%i\n", iLastMousePos[0], iLastMousePos[1]);
    if (iLastMousePos[0] > 0)
    {
      int x = iLastMousePos[0];
      int y = iLastMousePos[1];
      ToPixelPos(x, y);
      RayCast(x, y);
    }
 
    getBufferPostRenderEvent(mm, SCOL_PTR this, 0);
  }
}
 
void SWindow::RefreshSelector(const bool& forceRefresh)
{
  // Check texture size
  if (subEntitySelector)
    subEntitySelector->UpdateBufferSize(forceRefresh);
}
 
void SWindow::SetSelectorEnable(const bool& state)
{
#if !defined(OSX) && !defined(APPLE_IOS)
  Ogre::PixelFormat rttformat;
  bool pfsupport = SRoot::getSingleton().GetRttPixelFormat(rttformat, true);
  if (pfsupport)
  {
    if (state && !subEntitySelector)
    {
      subEntitySelector = new SSubEntitySelectorBuffer(this, (mSelectorMode == SO3_SELECTOR_FAST) ? true : false);
      SViewPortList::iterator iViewport = listOfViewPort.begin();
      while (iViewport != listOfViewPort.end())
      {
        subEntitySelector->AddViewport(iViewport->second);
        iViewport++;
      }
 
      subEntitySelector->UpdateBufferSize(true);
    }
    else if (!state && subEntitySelector)
      SO3_SAFE_DELETE(subEntitySelector);
  }
#endif
}
 
void SWindow::SetSelectorMode(SelectorMode mode)
{
  if (mSelectorMode != mode)
  {
#if defined(ANDROID) || defined(APPLE_IOS) || defined(OSX) || defined(RPI)
    mSelectorMode = (mode == SO3_SELECTOR_FAST) ? SO3_SELECTOR_LIMITED : mode;
#else
    mSelectorMode = mode;
#endif
 
#if !defined(OSX) && !defined(APPLE_IOS)
    bool reload = false;
 
    if (subEntitySelector)
    {
      SO3_SAFE_DELETE(subEntitySelector);
      reload = true;
    }
 
    if (reload)
    {
      Ogre::PixelFormat rttformat;
      bool pfsupport = SRoot::getSingleton().GetRttPixelFormat(rttformat, true);
      if (pfsupport)
      {
        bool useDepth = false;
        if (mSelectorMode == SO3_SELECTOR_FAST)
          useDepth = true;
 
        subEntitySelector = new SSubEntitySelectorBuffer(this, useDepth);
        SViewPortList::iterator iViewport = listOfViewPort.begin();
        while (iViewport != listOfViewPort.end())
        {
          subEntitySelector->AddViewport(iViewport->second);
          iViewport++;
        }
 
        subEntitySelector->UpdateBufferSize(true);
      }
    }
#endif
  }
}
 
SWindow::SelectorMode SWindow::GetSelectorMode()
{
  return mSelectorMode;
}
 
void SWindow::PauseWindow()
{
  // Reinit stereo
  if (mStereoMode != StereoManager::SO3_NONE_STEREO)
    stereoManager->SetStereoMode(StereoManager::SO3_NONE_STEREO);
 
  if (subEntitySelector)
    subEntitySelector->DestroyBuffers();
}
 
void SWindow::ResumeWindow()
{
  SetSizeDirty();
 
  if (subEntitySelector)
    subEntitySelector->CreateBuffers();
}
 
ScolWindowHandle SWindow::GetWindowHandle() const
{
  return hwnd;
}
 
void SWindow::SetWindowHandle(ScolWindowHandle win)
{
  hwnd = win;
}
 
SRoot* SWindow::GetParentRoot()
{
  return scolRoot;
}
 
Ogre::RenderWindow* SWindow::GetOgreRenderWindowPointer()
{
  return O3Window;
}
 
SViewPort* SWindow::CreateViewport(SCamera* camera, int priority, const float& x, const float& y, const float& w, const float& h)
{
  SViewPort* newViewport = new SViewPort(this, camera, priority, x, y, w, h);
  AddViewport(newViewport);
  SRoot::getSingleton().RegisterViewport(newViewport);
 
  if (stereoManager)
    stereoManager->RegisterViewport(newViewport);
 
  RefreshSelector(true);
  return newViewport;
}
 
void SWindow::DeleteViewport(SViewPort* existingViewport)
{
  if (scolRoot->IsUpdating())
  {
    if (std::find(mViewportsToDel.begin(), mViewportsToDel.end(), existingViewport) == mViewportsToDel.end())
      mViewportsToDel.push_back(existingViewport);
  }
  else
  {
    //remove stereo first since it can use shadows or other compositors
    if (stereoManager)
      stereoManager->UnregisterViewport(existingViewport);
 
    //remove viewports from shadows system
    //the viewport is added by the shadow system or by the viewport set camera
    SSceneMap sceneList = scolRoot->GetSceneList();
    SSceneMap::iterator iScene = sceneList.begin();
    while (iScene != sceneList.end())
    {
      //unregister environment
      iScene->second->UnregisterViewport(existingViewport);
      iScene++;
    }
 
    RemoveViewport(existingViewport);
    SRoot::getSingleton().UnregisterViewport(existingViewport);
    SO3_SAFE_DELETE(existingViewport);
    RefreshSelector(true);
  }
}
 
void SWindow::CleanViewports()
{
  for (unsigned int i = 0; i < mViewportsToDel.size(); i++)
  {
    DeleteViewport(mViewportsToDel[i]);
  }
  mViewportsToDel.clear();
}
 
bool SWindow::UpdateStereoCompositorState(SViewPort* viewport, const Ogre::String compname, bool state)
{
  return stereoManager->UpdateStereoCompositorState(viewport->GetOgreViewPortPointer(), compname, state);
}
 
void SWindow::RestoreStereoCamera(SViewPort* viewport)
{
  if (stereoManager)
    stereoManager->RestoreStereoCamera(viewport->GetOgreViewPortPointer());
}
 
void SWindow::UpdateStereoCamera(SViewPort* viewport, Ogre::Camera* camera)
{
  if (stereoManager)
    stereoManager->UpdateStereoCamera(viewport->GetOgreViewPortPointer(), camera);
}
 
void SWindow::UpdateStereoCameraMatrix(SViewPort* viewport, Ogre::Camera* camera)
{
  if (stereoManager)
    stereoManager->UpdateStereoCameraMatrix(viewport->GetOgreViewPortPointer(), camera);
}
 
void SWindow::UnregisterStereoViewport(SViewPort* viewport)
{
  if (stereoManager)
    stereoManager->UnregisterViewport(viewport);
}
 
void SWindow::RegisterStereoViewport(SViewPort* viewport)
{
  if (stereoManager)
    stereoManager->RegisterViewport(viewport);
}
 
void SWindow::SynchStereoViewportSetup(SViewPort* viewport, bool overlay, bool shadow)
{
  if (stereoManager)
    stereoManager->SynchViewportSetup(viewport, overlay, shadow);
}
 
bool SWindow::IsStereoViewportRegistered(SViewPort* viewport)
{
  if (!stereoManager)
      return false;
 
  return stereoManager->IsViewportRegistered(viewport->GetOgreViewPortPointer());
}
 
void SWindow::AddViewport(SViewPort* existingViewport)
{
  SViewPortList::iterator iViewportSearched = listOfViewPort.find(existingViewport->GetPriority());
  if(iViewportSearched == listOfViewPort.end())
  {
    listOfViewPort.insert(SViewPortList::value_type(existingViewport->GetPriority(), existingViewport));
    if (subEntitySelector != 0)
      subEntitySelector->AddViewport(existingViewport);
  }
  else
  {
    // Viewport already exist in the handled scenes list.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add Viewport, an identical element with the same priority already exist!", "SWindow::AddViewport");
  }
}
 
void SWindow::RemoveViewport(SViewPort* existingViewport)
{
  SViewPortList::iterator iViewportSearched = listOfViewPort.find(existingViewport->GetPriority());
  if(iViewportSearched != listOfViewPort.end())
  {
    listOfViewPort.erase(iViewportSearched);
    if (subEntitySelector != 0)
      subEntitySelector->RemoveViewport(existingViewport);
  }
  else
  {
    // Viewport not found in the handled viewports list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Viewport, element not found!", "SWindow::RemoveViewport");
  }
}
 
const SViewPortList& SWindow::GetViewportList() const
{
  return listOfViewPort;
}
 
SViewPort* SWindow::GetViewport(const int& priority) const
{
  SViewPort* existingViewport = 0;
  SViewPortList::const_iterator iViewportSearched = listOfViewPort.find(priority);
  if(iViewportSearched != listOfViewPort.end())
  {
    existingViewport = iViewportSearched->second;
  }
  else
  {
    // Viewport not found in the handled viewports list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not find Viewport with this priority, windows do not have such element!", "SWindow::GetViewport");
  }
  return existingViewport;
}
 
SViewPort* SWindow::GetViewport(const int& x, const int& y)
{
  int highestZ = 0;
  SViewPort* resultViewport = 0;
 
  SViewPortList::iterator iViewport = listOfViewPort.begin();
  while(iViewport != listOfViewPort.end())
  {
          int curZ   = iViewport->second->GetPriority();
          int left   = iViewport->second->GetLeftPixels();
          int top    = iViewport->second->GetTopPixels();
    int width  = iViewport->second->GetWidthPixels();
    int height = iViewport->second->GetHeightPixels();
 
    if(((x >= left)&&(y >= top)&&(x <= left + width)&&(y <= top + height)) && curZ >= highestZ)
          {
            resultViewport = iViewport->second;
            highestZ = curZ;
          }
 
    iViewport++;
  }
 
  return resultViewport;
}
 
void SWindow::windowMoved(Ogre::RenderWindow* rw)
{
}
 
void SWindow::windowResized(Ogre::RenderWindow* rw)
{
}
 
void SWindow::windowClosed(Ogre::RenderWindow* rw)
{
}
 
void SWindow::windowFocusChange(Ogre::RenderWindow* rw)
{
}
 
int     SWindow::Size(const int& x, const int& y, const int& w, const int& h, const int& ext)
{
  try
  {
    int iw = w;
    int ih = h;
    O3Window->resize(std::max(4, iw) , std::max(4, ih));
    
    //hack to avoid the window to be moved in screen view
#if !defined(LINUX) && !defined(OSX)
    O3Window->reposition(x, y);
#endif
    O3Window->windowMovedOrResized();
  }
  catch(Ogre::Exception &)
  {
    //nothing, the window is too small
    return 0;
  }
  bSizeDirty = true;
 
  //re-apply custom camera matrix and compositors
  SViewPortList::iterator iViewport = listOfViewPort.begin();
  while(iViewport != listOfViewPort.end())
  {
    SViewPort* vp = (iViewport->second);
                SCamera* camera = vp->GetCamera();
    if (camera != 0)
    {
      // last render target set the camera ratio, we need this to restore to the main viewport ratio
      float cRatio = camera->GetAspectRatio();
      if (camera->GetOgreCameraPointer()->getAutoAspectRatio())
        cRatio = (float)vp->GetOgreViewPortPointer()->getActualWidth() / (float)vp->GetOgreViewPortPointer()->getActualHeight();
 
      camera->GetOgreCameraPointer()->setAspectRatio(cRatio);
 
      if (camera->GetOgreCameraPointer()->isCustomViewMatrixEnabled())
        camera->GetOgreCameraPointer()->setCustomViewMatrix(true, camera->GetViewMatrix());
 
      if (camera->GetOgreCameraPointer()->isCustomProjectionMatrixEnabled())
          camera->GetOgreCameraPointer()->setCustomProjectionMatrix(true, camera->GetProjectionMatrix());
    }
 
    try
    {
      vp->GetOgreViewPortPointer()->_updateDimensions();
    }
    catch(Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
    {
    }
 
    iViewport++;
        }
 
        return 0;
}
 
void SWindow::WindowMovedOrResized()
{
  bool valid = true;
 
#ifdef _WIN32
# ifndef SO3_USE_DX11
  if (SRoot::getSingleton().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;
    }
  }
# endif
#endif
 
  if (SRoot::getSingleton().isDeviceLost() || !valid)
    return;
 
  try
  {
#ifdef _WIN32
    RECT rc;
    BOOL result;
 
    // width and height represent drawable area only
    result = GetClientRect(hwnd, &rc);
    if (result == FALSE)
      return;
 
    unsigned int width = rc.right - rc.left;
    unsigned int height = rc.bottom - rc.top;
 
    if ((width > 3) && (height > 3))
    {
      try
      {
        O3Window->windowMovedOrResized();
      }
      catch (Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
      {
        return;
      }
    }
#else
    try
    {
      O3Window->windowMovedOrResized();
    }
    catch (Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
    {
      return;
    }
#endif
 
    Ogre::CompositorManager &compositorManager = Ogre::CompositorManager::getSingleton();
 
    // Reinit stereo
    if (mStereoMode != StereoManager::SO3_NONE_STEREO)
    {
      stereoManager->SetStereoMode(StereoManager::SO3_NONE_STEREO);
    }
 
    //re-apply custom camera matrix and compositors
    SViewPortList::iterator iViewport = listOfViewPort.begin();
    while(iViewport != listOfViewPort.end())
    {
      SViewPort* vp = (iViewport->second);
                  SCamera* camera = vp->GetCamera();
      if (camera != 0)
      {
        SScene* scene = camera->GetParentScene();
 
        // last render target set the camera ratio, we need this to restore to the main viewport ratio
        float cRatio = camera->GetAspectRatio();
        if (camera->GetOgreCameraPointer()->getAutoAspectRatio())
          cRatio = (float)vp->GetOgreViewPortPointer()->getActualWidth() / (float)vp->GetOgreViewPortPointer()->getActualHeight();
 
        camera->GetOgreCameraPointer()->setAspectRatio(cRatio);
 
        if (camera->GetOgreCameraPointer()->isCustomViewMatrixEnabled())
          camera->GetOgreCameraPointer()->setCustomViewMatrix(true, camera->GetViewMatrix());
 
        if (camera->GetOgreCameraPointer()->isCustomProjectionMatrixEnabled())
          camera->GetOgreCameraPointer()->setCustomProjectionMatrix(true, camera->GetProjectionMatrix());
 
        if (scene->GetEnvironment() && scene->GetEnvironment()->IsRegisteredViewport(vp))
        {
          scene->GetEnvironment()->UnregisterViewport(vp);
          scene->GetEnvironment()->RegisterViewport(vp);
        }
      }
 
      try
      {
        vp->GetOgreViewPortPointer()->_updateDimensions();
      }
      catch(Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
      {
      }
 
      iViewport++;
          }
 
    try
    {
      RefreshSelector();
    }
    catch(Ogre::Exception&) //error can appen on compositor resources creation if the device is not ready
    {
    }
 
    // Reinit stereo
    if (mStereoMode != StereoManager::SO3_NONE_STEREO)
    {
      stereoManager->SetStereoMode(mStereoMode);
    }
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "SO3Engine error on window resize : %s", e.what());
    return;
  }
  bSizeDirty = false;
}
 
unsigned int SWindow::GetWidth() const
{
  return O3Window->getWidth();
}
 
unsigned int SWindow::GetHeight() const
{
  return O3Window->getHeight();
}
 
int SWindow::GetLeft()
{
  unsigned int nullUintPtr;
  int left, nullIntPtr;
  O3Window->getMetrics(nullUintPtr, nullUintPtr, nullIntPtr, left);
  return left;
}
 
int SWindow::GetTop()
{
  unsigned int nullUintPtr;
  int top, nullIntPtr;
  O3Window->getMetrics(nullUintPtr, nullUintPtr, nullIntPtr, top);
  return top;
}
 
bool SWindow::SetFullScreen(const bool& fullscreen, const int& width, const int& height)
{
  bool success = false;
  int nwidth = width;
  int nheight = height;
  
#ifdef _WIN32
  //DO NOT CHANGE ANYTHING UNTIL YOU TEST BOTH OPENGL AND DIRECTX, WINDOWED AND FULLSCREEN SWITCHING
  if(!fullscreen && O3Window->isFullScreen())
        {
    O3Window->setVSyncEnabled(scolRoot->GetVSyncEnable());
    success = SRoot::getSingleton().SetFullScreenState(this, fullscreen, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top);
 
    SetWindowPos(hwnd, HWND_NOTOPMOST, mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left -1, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top -1, SWP_FRAMECHANGED | SWP_SHOWWINDOW);
 
    // force a screen change on update
    screenPos = Ogre::Vector2(0.0f, 0.0f);
 
    //restore window style and parent
                SetParent(hwnd, (ScolWindowHandle)hwndFullscreenOgre);
    SetWindowLongPtr(hwnd, GWL_STYLE, styleFullscreenOgre);
                SetWindowLongPtr(hwnd, GWL_EXSTYLE, exstyleFullscreenOgre);
    //reset the windows client rect since a Ogre DirectX bug forget to handle that
          SetWindowRgn(hwnd, mLastWindowRegion, FALSE);
 
    //hack force a size change to force Ogre DX render to update viewports
    Size(mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left -1, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top -1, 0);
 
    // restore last position
    Size(mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top, 0);
 
    bSizeDirty = true;
        }
        else if(fullscreen && !O3Window->isFullScreen())
        {
    // check inverted size for rotated screens
    if (!CheckVideoMode(width, height) && !CheckVideoMode(height, width))
    {
      bSizeDirty = true;
      
      //try to find a valid resolution
      if (CheckVideoMode(1920, 1080))
      {
        nwidth = 1920;
        nheight = 1080;
      }
      else if (CheckVideoMode(1280, 720))
      {
        nwidth = 1280;
        nheight = 720;
      }
      else if (CheckVideoMode(1024, 768))
      {
        nwidth = 1024;
        nheight = 768;
      }
      else
      {
        OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Invalid resolution parameters, fullscreen not setted", "SWindow::SetFullScreen");
        return false;
      }
    }
 
    // get current windows parameters
                hwndFullscreenOgre = GetWindowLongPtr(hwnd, GWLP_HWNDPARENT);
                styleFullscreenOgre = GetWindowLongPtr(hwnd, GWL_STYLE);
                exstyleFullscreenOgre = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
    GetWindowPlacement(hwnd, &mLastPos);
    GetWindowRgn(hwnd, mLastWindowRegion);
 
    POINT screenPoint;
    screenPoint.x = 0;
    screenPoint.y = 0;
    ClientToScreen(hwnd, &screenPoint);
 
    //reset window style and parent
                SetParent(hwnd, NULL);
 
    SetWindowPos(hwnd, HWND_TOPMOST, mLastPos.rcNormalPosition.left + screenPoint.x, mLastPos.rcNormalPosition.top + screenPoint.y, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left -1, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top -1, SWP_NOZORDER | SWP_FRAMECHANGED);
 
    MONITORINFOEX minfos;
          minfos.cbSize = sizeof(minfos);
    GetMonitorInfo(MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST), &minfos);
 
    //force vsync for oculus
    O3Window->setVSyncEnabled(true);
 
    //TODO test current root fullscreen state before
    success = SRoot::getSingleton().SetFullScreenState(this, fullscreen, nwidth, nheight);
 
    if (!success)
    {
      SetWindowLongPtr(hwnd, GWL_STYLE, styleFullscreenOgre);
                  SetWindowLongPtr(hwnd, GWL_EXSTYLE, exstyleFullscreenOgre);
                  SetParent(hwnd, (ScolWindowHandle)hwndFullscreenOgre);
      //reset the windows client rect since a Ogre DirectX bug forget to handle that
            SetWindowRgn(hwnd, mLastWindowRegion, FALSE);
 
      SetWindowPos(hwnd, HWND_TOPMOST, mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top, SWP_FRAMECHANGED | SWP_SHOWWINDOW);
      // restore last position
      Size(mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top, 0);
      bSizeDirty = true;
      return success;
    }
 
    SetWindowPos(hwnd, HWND_TOPMOST, minfos.rcMonitor.left, minfos.rcMonitor.top, nwidth, nheight, SWP_NOZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
    Size(minfos.rcMonitor.left, minfos.rcMonitor.top, nwidth, height, 0);
 
    //FORCE Async message to avoid error (needed what ever you think)
    LPARAM wsize = ((WORD)nheight<<16) | (WORD)nwidth;
    PostMessage(hwnd, WM_SIZE, 0, wsize);
    bSizeDirty = true;
        }
#elif defined(ANDROID) || defined(APPLE_IOS) || defined(RPI)
  //return true for other platform and manage special cases like the menu bar for android
  success = true;
#else
  success = SRoot::getSingleton().SetFullScreenState(this, fullscreen, nwidth, nheight);
#endif //
 
  return success;
}
 
bool SWindow::GetFullScreen()
{
#if defined(ANDROID) || defined(APPLE_IOS) || defined(RPI)
  return true;
#else
  return O3Window->isFullScreen();
#endif
}
 
bool SWindow::CheckVideoMode(const int width, const int height)
{
        bool vmc = false;
        char strW[16];
        char strH[16];
 
  Ogre::ConfigOptionMap m_system_caps = SRoot::getSingleton().GetOgreRenderSystem()->getConfigOptions();
        Ogre::ConfigOptionMap::iterator itr = m_system_caps.begin();
        while(itr != m_system_caps.end() && !vmc)
        {
                if((itr)->first == "Video Mode" )
                {
                   Ogre::StringVector possible_values = (itr)->second.possibleValues;
                   Ogre::StringVector::iterator pv_itr = possible_values.begin();
                   while(pv_itr != possible_values.end() && !vmc)
                   {
         if (pv_itr->find(itoa((int)width, strW, 10)) != string::npos && pv_itr->find(itoa((int)height, strH, 10)) != string::npos && pv_itr->find(itoa((int)width, strW, 10))<pv_itr->find(itoa((int)height, strH, 10)))
            vmc = true;
 
          pv_itr ++;
                   }
                }
                itr ++;
  }
  return vmc;
}
 
void SWindow::Update()
{
  try
  {
    O3Window->update(true);
  }
  catch(Ogre::Exception &e)
  {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
  }
}
 
unsigned int SWindow::GetBatchCount()
{
  unsigned int bcount = 0;
 
  SViewPortList::iterator iViewport = listOfViewPort.begin();
  while (iViewport != listOfViewPort.end())
  {
    bcount += iViewport->second->GetNumRenderedBatches();
    iViewport++;
  }
 
  return bcount;
}
 
unsigned int SWindow::GetTriangleCount()
{
  unsigned int tcount = 0;
  SViewPortList::iterator iViewport = listOfViewPort.begin();
  while (iViewport != listOfViewPort.end())
  {
    tcount += iViewport->second->GetNumRenderedFaces();
    iViewport++;
  }
 
  return tcount;
}
 
float SWindow::GetBestFrameTime() const
{
  return O3Window->getStatistics().bestFrameTime;
}
 
float SWindow::GetWorstFrameTime() const
{
  return O3Window->getStatistics().worstFrameTime;
}
 
float SWindow::GetBestFPS() const
{
  return O3Window->getStatistics().bestFPS;
}
 
float SWindow::GetWorstFPS() const
{
  return O3Window->getStatistics().worstFPS;
}
 
float SWindow::GetAverageFPS() const
{
  return O3Window->getStatistics().avgFPS;
}
 
unsigned int SWindow::GetFSAA() const
{
  return O3Window->getFSAA();
}
 
void SWindow::SetStereoMode(const StereoManager::StereoMode& stereoMode)
{
  mStereoMode = stereoMode;
 
  //if(!bSizeDirty || (mStereoMode == StereoManager::StereoMode::SO3_NONE_STEREO))
    stereoManager->SetStereoMode(mStereoMode);
}
 
StereoManager::StereoMode SWindow::GetStereoMode()
{
  return mStereoMode;
}
 
float SWindow::GetStereoEyesSpacing()
{
  return stereoManager->GetEyesSpacing();
}
 
void SWindow::SetStereoEyesSpacing(const float& eyesSpacing)
{
  stereoManager->SetEyesSpacing(eyesSpacing);
}
 
void SWindow::SetStereoRotateView(const bool state)
{
  stereoManager->SetRotateView(state);
}
 
bool SWindow::GetStereoRotateView()
{
  return stereoManager->GetRotateView();
}
 
void SWindow::SetStereoProjectionOffset(const float& offset)
{
  stereoManager->SetStereoProjectionOffset(offset);
}
 
void SWindow::SetStereoAspectRatio(const float& ratio)
{
  stereoManager->SetStereoAspectRatio(ratio);
}
 
void SWindow::SetStereoFOVy(const float& fov)
{
  stereoManager->SetStereoFOVy(fov);
}
 
void SWindow::SetStereoDistortion(bool enable, Ogre::Vector4 dist)
{
  stereoManager->SetStereoDistortion(enable, dist);
}
 
void SWindow::SetStereoChromaticAbCorrection(bool enable, Ogre::Vector4 chromAbC)
{
  stereoManager->SetStereoChromaticAbCorrection(enable, chromAbC);
}
 
void SWindow::SetStereoCustomProjectonMatrix(bool enable, const Ogre::Matrix4 &leftMatrix, const Ogre::Matrix4 &rightMatrix)
{
  stereoManager->SetCustomProjectonMatrices(enable, leftMatrix, rightMatrix);
}
 
void SWindow::GetStereoCustomProjectonMatrix(bool &enabled, Ogre::Matrix4 &leftMatrix, Ogre::Matrix4 &rightMatrix) const
{
  stereoManager->GetCustomProjectonMatrices(enabled, leftMatrix, rightMatrix);
}
 
void SWindow::SetStereoTimeWarpMatrix(const Ogre::Matrix4 &leftStartMatrix, const Ogre::Matrix4 &leftEndMatrix, const Ogre::Matrix4 &rightStartMatrix, const Ogre::Matrix4 &rightEndMatrix)
{
  stereoManager->SetTimeWarpMatrix(leftStartMatrix, leftEndMatrix, rightStartMatrix, rightEndMatrix);
}
 
void SWindow::SetStereoMeshUVConfig(Ogre::Vector2 leftuvscale, Ogre::Vector2 leftuvoffset, Ogre::Vector2 rightuvscale, Ogre::Vector2 rightuvoffset)
{
  stereoManager->SetStereoMeshUVConfig(leftuvscale, leftuvoffset, rightuvscale, rightuvoffset);
}
 
void SWindow::SetStereoMeshRttSize(SO3::SPoint<int> leftsize, SO3::SPoint<int> rightsize)
{
  stereoManager->SetStereoMeshRttSize(leftsize, rightsize);
}
 
void SWindow::SetStereoWindow(SO3::SPoint<int> pos, SO3::SPoint<int> size, int index, bool state)
{
  stereoManager->SetStereoWindow(pos, size, index,state);
}
 
void SWindow::SetStereoMeshLeft(std::vector<Ogre::Vector3> vertices, std::vector<std::vector<Ogre::Vector2> > uvs, std::vector<Ogre::Real> vignetteColor, std::vector<Ogre::Real> warp, std::vector<int> indexs)
{
  stereoManager->SetStereoMeshLeft(vertices, uvs, vignetteColor, warp, indexs);
}
 
void SWindow::SetStereoMeshRight(std::vector<Ogre::Vector3> vertices, std::vector<std::vector<Ogre::Vector2> > uvs, std::vector<Ogre::Real> vignetteColor, std::vector<Ogre::Real> warp, std::vector<int> indexs)
{
  stereoManager->SetStereoMeshRight(vertices, uvs, vignetteColor, warp, indexs);
}
 
std::array<SCOL_PTR_TYPE, 2> SWindow::GetStereoTextures()
{
  return stereoManager->GetStereoTextures();
}
 
std::array<SO3::SPoint<int>, 2> SWindow::GetStereoViewportSize()
{
  return stereoManager->GetStereoViewportSize();
}
 
void SWindow::ToPixelPos(int& px, int& py)
{
#if defined(ANDROID)
  ScolWindowHandle awindow = (ScolWindowHandle)SCgetExtra("hscol");
  int nwidth = (int)ANativeWindow_getWidth(awindow);
  int nheight = (int)ANativeWindow_getHeight(awindow);
 
  px = (int)(((float)GetWidth() / (float)nwidth) * (float)px);
  py = (int)(((float)GetHeight() / (float)nheight) * (float)py);
#elif defined(APPLE_IOS)
  float ratio = GetOgreRenderWindowPointer()->getViewPointToPixelScale();
 
  px *= ratio;
  py *= ratio;
#endif
}
 
SRaycastResult SWindow::RayCast(const int& pixelsX, const int& pixelsY)
{
        // Getting Under Mouse Viewport
  SViewPort* resultViewport = GetViewport(pixelsX, pixelsY);
  if (resultViewport != 0)
  {
    // Call the raycast.
    lastRaycast = resultViewport->RayCast(pixelsX, pixelsY, subEntitySelector);
  }
 
  return lastRaycast;
}
 
SRaycastResult SWindow::IndRayCast(const int& pixelsX, const int& pixelsY)
{
  SRaycastResult raycastReturn;
 
  // Getting Under Mouse Viewport
  SViewPort* resultViewport = GetViewport(pixelsX, pixelsY);
  if (resultViewport != 0)
  {
    // Call the raycast.
    raycastReturn = resultViewport->RayCast(pixelsX, pixelsY, subEntitySelector);
  }
 
  return raycastReturn;
}
 
void SWindow::InvalidateRayCast()
{
  // Invalidate lastRaycast.
  lastRaycast = SRaycastResult();
}
 
SRaycastResult& SWindow::GetLastRayCast()
{
  try
  {
    if(lastRaycast.sceneName != "")
    {
      Ogre::SceneManager* sceneManager = Ogre::Root::getSingleton().getSceneManager(lastRaycast.sceneName);
      Ogre::Entity* entity = sceneManager->getEntity(lastRaycast.entityName);
      // If no error occurs, then no need to invalidate lastRaycast
    }
    else
    {
      // Invalidate lastRaycast.
      InvalidateRayCast();
    }
  }
  catch(Ogre::Exception&)
  {
    // Invalidate lastRaycast.
    InvalidateRayCast();
 
    // Catching Exception::ERR_ITEM_NOT_FOUND in case sceneManager or entity was deleted since last rtt update. Forwarding other errors.
    /*if(e.getNumber() != Ogre::Exception::ERR_ITEM_NOT_FOUND)
    {
      Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
      throw e;
    }*/
  }
 
  return lastRaycast;
}
 
void SWindow::WriteContentsToFile(const std::string& path)
{
#ifdef _WIN32
  O3Window->writeContentsToFile(path);
#else
  Ogre::PixelFormat pf = Ogre::PixelFormat::PF_BYTE_RGBA;
 
  uchar *data = OGRE_ALLOC_T(uchar, O3Window->getWidth() * O3Window->getHeight() * Ogre::PixelUtil::getNumElemBytes(pf), Ogre::MEMCATEGORY_RENDERSYS);
  Ogre::PixelBox pb(O3Window->getWidth(), O3Window->getHeight(), 1, pf, data);
  Ogre::Box pbs(0, 0, O3Window->getWidth(), O3Window->getHeight());
  O3Window->copyContentsToMemory(pbs, pb);
 
  Ogre::Image().loadDynamicImage(data, O3Window->getWidth(), O3Window->getHeight(), 1, pf, false, 1, 0).save(path);
 
  OGRE_FREE(data, Ogre::MEMCATEGORY_RENDERSYS);
#endif
}
 
}