SO3Engine/SO3Renderer/SO3Window.cpp

Go to the documentation of this file.

#include "SO3Window.h"
#include "SO3ViewPort.h"
#include <scol.h>
#include "../SO3Renderer/SO3Root.h"
#include "../SO3SceneGraph/SO3Camera.h"
#include "../SO3SceneGraph/SO3SubEntitySelectorBuffer.h"
#include "../SO3Utils/SO3ConversionTools.h"

extern WindowHandle hwndScol;
extern int BUFFER_PRE_RENDER_EVENT;
extern int BUFFER_POST_RENDER_EVENT;

namespace SO3
{
SWindow::SWindow() : SData("")
{
  // Forbiden constructor (private).
}

SWindow::SWindow(SRoot* parent, WindowHandle windowHandle, std::string windowName, int width, int height, std::string fsaa) : SData(windowName)
{
  scolRoot = parent;
  bBeginFrame = false;

  // Retrieve the parent window handle.
  hwnd = windowHandle;
        Ogre::String winHandle = Ogre::StringConverter::toString((size_t)(WindowHandle)hwnd);
  
  //add WS_CLIPCHILDREN flag for 3D content
  SetWindowLongPtr(hwnd, GWL_STYLE, (GetWindowLongPtr(hwnd, GWL_STYLE))|WS_CLIPCHILDREN);

  // Setting render window options
        Ogre::NameValuePairList viewConfig;
        viewConfig["externalWindowHandle"] = winHandle;
  //viewConfig["Resource Creation Policy"] = "Create on active device";
  //viewConfig["parentWindowHandle"] = winHandle;
  viewConfig["monitorIndex"] = "0";
  viewConfig["vsync"] = "Yes";

#ifdef SO3_DEBUG
  viewConfig["useNVPerfHUD"] = "Yes";
#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, width, height, false, &viewConfig);
  O3Window->setPriority(0);
  //O3Window->setDeactivateOnFocusChange(false);

  if(O3Window->isPrimary())
    scolRoot->InitRenderer();

        O3Window->addListener(this);
        O3StereoManager = new Ogre::StereoManager();
        hwndFullscreenOgre = NULL;
        styleFullscreenOgre = NULL;
        exstyleFullscreenOgre = NULL;
  currentStereoMode = SWindow::SO3_NONE_STEREO;
  // For subentity picking
  subEntitySelector = new SSubEntitySelectorBuffer(this);

  //update to create ressources
  O3Window->update();
}

SWindow::~SWindow()
{
  O3Window->removeListener(this);
  SAFE_DELETE(subEntitySelector);
  SAFE_DELETE(O3StereoManager);
  
  //remove WS_CLIPCHILDREN flag for 3D content
  SetWindowLongPtr(hwnd, GWL_STYLE, (GetWindowLongPtr(hwnd, GWL_STYLE))& ~(WS_CLIPCHILDREN));


  if((scolRoot->GetRenderSystem() == SRoot::SO3_OPENGL_RENDERER) || ((scolRoot->GetRenderSystem() != SRoot::SO3_OPENGL_RENDERER) && !O3Window->isPrimary()))
  {
    Ogre::Root::getSingleton().detachRenderTarget(GetName());
    O3Window->destroy();
  }

  O3Window = 0;
}

void SWindow::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
{
  if(subEntitySelector)
    subEntitySelector->NeedUpdate();
  SendMessage(hwndScol, BUFFER_PRE_RENDER_EVENT, (int)this,(LPARAM)NULL);
}

void SWindow::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
{
  SendMessage(hwndScol, BUFFER_POST_RENDER_EVENT, (int)this,(LPARAM)NULL);
}

void SWindow::RefreshSelector()
{
  if (subEntitySelector)
    subEntitySelector->ForceUpdate();
}

WindowHandle SWindow::GetWindowHandle()
{
  return hwnd;
}

SRoot* SWindow::GetParentRoot()
{
  return scolRoot;
}

const Ogre::RenderWindow* SWindow::GetOgreRenderWindowPointer()
{
  return O3Window;
}

SViewPort* SWindow::CreateViewport(SCamera* camera, int priority, float x, float y, float w, float h)
{
  SViewPort* newViewport = new SViewPort(this, camera, priority, x, y, w, h);
  AddViewport(newViewport);
  return newViewport;
}

void SWindow::DeleteViewport(SViewPort* existingViewport)
{
  RemoveViewport(existingViewport);
  SAFE_DELETE(existingViewport);
}

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(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(int x, 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(int x,int y,int w,int h,int ext)
{
        O3Window->resize(w,h);
        O3Window->reposition(x,y);
        O3Window->windowMovedOrResized();

  // Hack: Manualy send event, as Ogre's message pump function seems not work when Scol message loop exist.
  Ogre::WindowEventUtilities::WindowEventListeners::iterator index;
  Ogre::WindowEventUtilities::WindowEventListeners::iterator start = Ogre::WindowEventUtilities::_msListeners.lower_bound(O3Window);
  Ogre::WindowEventUtilities::WindowEventListeners::iterator end = Ogre::WindowEventUtilities::_msListeners.upper_bound(O3Window);
  for(index = start; index != end; ++index)
          (index->second)->windowResized(O3Window);

        return 0;
}

void SWindow::WindowMovedOrResized()
{
  WINDOWPLACEMENT curWinPos;

  GetWindowPlacement(hwnd, &curWinPos);
        Size(curWinPos.rcNormalPosition.left, curWinPos.rcNormalPosition.top, curWinPos.rcNormalPosition.right - curWinPos.rcNormalPosition.left, curWinPos.rcNormalPosition.bottom - curWinPos.rcNormalPosition.top, 0);
}

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, nullUintPtr, left, nullIntPtr);
  return left;
}

int SWindow::GetTop()
{
  unsigned int nullUintPtr;
  int top, nullIntPtr;
  O3Window->getMetrics(nullUintPtr, nullUintPtr, nullUintPtr, nullIntPtr, top);
  return top;
}

bool SWindow::SetFullScreen(bool fullscreen, int width, int height)
{
  //DO NOT CHANGE ANYTHING UNTIL YOU TEST BOTH OPENGL AND DIRECTX, WINDOWED AND FULLSCREEN SWITCHING
  if(!fullscreen && O3Window->isFullScreen())
        {
    if((SRoot::getSingleton().SetFullScreenState(this, fullscreen, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top)) == false)
      return false;
    
    //restore window style and parent
                SetWindowLongPtr(hwnd, GWL_STYLE, styleFullscreenOgre);
                SetWindowLongPtr(hwnd, GWL_EXSTYLE, exstyleFullscreenOgre);
                SetParent(hwnd, (WindowHandle)hwndFullscreenOgre);

    // restore last position
    Size(mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top, 0); 
    WindowMovedOrResized();
    return true;
        }
        else if(fullscreen && !O3Window->isFullScreen())
        {
    if (!CheckVideoMode(width, height))
    {
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS , "Invalid resolution parameters, fullscreen not setted", "SWindow::SetFullScreen");
      return false;
    }
    
    // get current windows parameters
                hwndFullscreenOgre = GetWindowLongPtr(hwnd, GWL_HWNDPARENT);
                styleFullscreenOgre = GetWindowLongPtr(hwnd, GWL_STYLE);
                exstyleFullscreenOgre = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
    GetWindowPlacement(hwnd, &mLastPos);

    //reset window style and parent
                SetParent(hwnd, NULL);

    //TODO test current root fullscreen state before
    if ((SRoot::getSingleton().SetFullScreenState(this, fullscreen, width, height)) == false)
    {
      //restore window style and parent
                  SetWindowLongPtr(hwnd, GWL_STYLE, styleFullscreenOgre);
                  SetWindowLongPtr(hwnd, GWL_EXSTYLE, exstyleFullscreenOgre);
                  SetParent(hwnd, (WindowHandle)hwndFullscreenOgre);

      // restore last position
      Size(mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.top, mLastPos.rcNormalPosition.right - mLastPos.rcNormalPosition.left, mLastPos.rcNormalPosition.bottom - mLastPos.rcNormalPosition.top, 0); 
      WindowMovedOrResized();
      return false;
    }

    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, width, height, SWP_FRAMECHANGED|SWP_SHOWWINDOW);
    WindowMovedOrResized();

    return true;
        }
  return false;
}

bool SWindow::GetFullScreen()
{
  return O3Window->isFullScreen();
}

bool SWindow::CheckVideoMode(int width, int height)
{
        bool vmc = false;
        char strW[16];
        char strH[16];
        
  Ogre::ConfigOptionMap& m_system_caps = Ogre::Root::getSingleton().getRenderSystem()->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(width, strW, 10)) != string::npos && pv_itr->find(itoa(height, strH, 10)) != string::npos && pv_itr->find(itoa(width, strW, 10))<pv_itr->find(itoa(height, strH, 10))) 
            vmc = true; 

          pv_itr ++;
                   }
                }
                itr ++;
  }
  return vmc;
}

unsigned int SWindow::GetColorDepth()
{
  return O3Window->getColourDepth();
}

void SWindow::Update()
{
  O3Window->update(true);
}

unsigned int SWindow::GetBatchCount() const
{
  return O3Window->getBatchCount();
}

unsigned int SWindow::GetTriangleCount() const
{
  return O3Window->getTriangleCount();
}

float SWindow::GetBestFrameTime() const
{
  return O3Window->getBestFrameTime();
}

float SWindow::GetWorstFrameTime() const
{
  return O3Window->getWorstFrameTime();
}

float SWindow::GetBestFPS() const
{
  return O3Window->getBestFPS();
}

float SWindow::GetWorstFPS() const
{
  return O3Window->getWorstFPS();
}

float SWindow::GetAverageFPS() const
{
  return O3Window->getAverageFPS();
}

unsigned int SWindow::GetFSAA() const
{
  return O3Window->getFSAA();
}

void SWindow::SetStereoMode(StereoMode stereoMode, float eyesSpacing, float focalLength)
{
  // Stop the stereo manager if the mode is different.
  if(currentStereoMode != stereoMode)
        {
                O3StereoManager->shutdown();
    currentStereoMode = SWindow::SO3_NONE_STEREO;
        }

  switch (stereoMode)
  {
  case SWindow::SO3_ANAGLYPH_RC_STEREO:
    O3StereoManager->init(O3Window->getViewport(0), NULL, Ogre::StereoManager::SM_ANAGLYPH_RC);
    break;
  case SWindow::SO3_ANAGLYPH_YB_STEREO:
    O3StereoManager->init(O3Window->getViewport(0), NULL, Ogre::StereoManager::SM_ANAGLYPH_YB);
    break;
  case SWindow::SO3_DUALOUTPUT_STEREO:
    O3StereoManager->init(O3Window->getViewport(0), NULL, Ogre::StereoManager::SM_DUALOUTPUT);
    break;
  case SWindow::SO3_INTERLACED_CB_STEREO:
    O3StereoManager->init(O3Window->getViewport(0), NULL, Ogre::StereoManager::SM_INTERLACED_CB);
    break;
  case SWindow::SO3_INTERLACED_H_STEREO:
    O3StereoManager->init(O3Window->getViewport(0), NULL, Ogre::StereoManager::SM_INTERLACED_H);
    break;
  case SWindow::SO3_INTERLACED_V_STEREO:
    O3StereoManager->init(O3Window->getViewport(0), NULL, Ogre::StereoManager::SM_INTERLACED_V);
    break;
  };

  if (stereoMode != SWindow::SO3_NONE_STEREO)
  {
    SetStereoEyesSpacing(eyesSpacing);
    SetStereoFocalLength(focalLength);
  }
  currentStereoMode = stereoMode;
}

SWindow::StereoMode SWindow::GetStereoMode()
{
  return currentStereoMode;
}

float SWindow::GetStereoEyesSpacing()
{
  return O3StereoManager->getEyesSpacing();
}

void SWindow::SetStereoEyesSpacing(float eyesSpacing)
{
  O3StereoManager->setEyesSpacing(eyesSpacing);
}

float SWindow::GetStereoFocalLength()
{
  float returnValue;
  if (O3StereoManager->isFocalLengthInfinite())
    returnValue = -1.0f;
  else
    returnValue = O3StereoManager->getFocalLength();

  return returnValue;
}

void SWindow::SetStereoFocalLength(float focalLength)
{
  if(focalLength == -1.0f)
  {
    O3StereoManager->setFocalLengthInfinite(true);
  }
        else
        {
                O3StereoManager->setFocalLengthInfinite(false);
    O3StereoManager->setFocalLength(focalLength);
  }
}

SRaycastResult SWindow::RayCast(int pixelsX, int pixelsY)
{
  SRaycastResult raycastResults;

        // Getting Under Mouse Viewport
  SViewPort* resultViewport = GetViewport(pixelsX, pixelsY);
  if (resultViewport != 0)
  {
    // Call the raycast.
    raycastResults = resultViewport->RayCast(pixelsX, pixelsY, subEntitySelector);
  }

  lastRaycast = raycastResults;
  return raycastResults;
}

SRaycastResult& SWindow::GetLastRayCast()
{
  // Verify that raycast sub-entity allways exist, deactivating log to not overload it.
  bool lastLogstate = SRoot::getSingleton().GetLogEnable();
  SRoot::getSingleton().SetLogEnable(false);

  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.
      lastRaycast = SRaycastResult();
    }
  }
  catch(Ogre::Exception& e)
  {
    SRoot::getSingleton().SetLogEnable(lastLogstate);

    // Invalidate lastRaycast.
    lastRaycast = SRaycastResult();

    // 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;
    }
  }
  
  // Re-activate log
  SRoot::getSingleton().SetLogEnable(lastLogstate);

  return lastRaycast;
}

}

---