SO3ViewPort.cpp

Go to the documentation of this file.

 
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3Material/SO3Compositor.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3SceneGraph/SO3SubEntitySelectorBuffer.h"
#include "SO3Utils/SO3RayCast.h"
#include "SO3Utils/SO3Exception.h"
#include "SO3Renderer/SO3SsaoHandler.h"
#include "SO3Material/SO3Material.h"
 
namespace SO3
{
 
  SViewPort::SViewPort()
  {
    scolWindow = 0;
  }
 
  SViewPort::SViewPort(SWindow* parent, SCamera* camera, int priority, const float& x, const float& y, const float& w, const float& h)
  {
    scolWindow = parent;
 
    Ogre::RenderWindow* renderWindow = const_cast <Ogre::RenderWindow*> (const_cast <SWindow*> (scolWindow)->GetOgreRenderWindowPointer());
    priority = renderWindow->getNumViewports();
    O3ViewPort = renderWindow->addViewport(camera->GetOgreCameraPointer(), priority, x, y, w, h);
    scolCamera = camera;
    bClearColor = true;
    bClearDepth = true;
    bSSAOEnable = false;
 
#ifdef SO3_BUILD_DEFERRED
    bDeferredEnable = false;
    bDeferredAntiAliasingMode = SDeferredShading::SO3_DEFERRED_AA_NONE;
#endif
 
    // set default visibility mask to 0xfffe keep the last bit to be invisible by default in viewports
    O3ViewPort->setVisibilityMask(SO3_VISIBILITY_MASK_DEFAULT);
 
    try
    {
      ssaoHandler = new SSsaoHandler(this);
    }
    catch(Ogre::Exception& e)
    {
      ssaoHandler = 0;
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
    }
 
    try
    {
      hdrHandler = new SHdrHandler(this);
    }
    catch (Ogre::Exception& e)
    {
      hdrHandler = 0;
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
    }
 
    if (scolCamera != 0)
    {
      camera->SetCurrentViewPort(this);
    }
 
    O3ViewPort->addListener(this);
    O3ViewPort->setMaterialScheme(Ogre::MSN_SHADERGEN);
  }
 
  SViewPort::~SViewPort()
  {
    O3ViewPort->removeListener(this);
 
#ifdef SO3_BUILD_DEFERRED
    SetDeferredEnable(false);
#endif
 
    SAFE_DELETE(ssaoHandler);
    SAFE_DELETE(hdrHandler);
 
    // Clear all the compositors
    ClearCompositors();
 
    if (scolCamera != 0)
      scolCamera->SetCurrentViewPort(0);
 
    // removing this viewport from the parent window.
    const_cast <Ogre::RenderWindow*> (const_cast <SWindow*> (scolWindow)->GetOgreRenderWindowPointer())->removeViewport(O3ViewPort->getZOrder());
    O3ViewPort = 0;
  }
 
  Ogre::Viewport* SViewPort::GetOgreViewPortPointer()
  {
    return O3ViewPort;
  }
 
  SWindow* SViewPort::GetParentWindow() const
  {
    return scolWindow;
  }
 
  std::string SViewPort::GetMaterialScheme()
  {
    std::string schemeName = O3ViewPort->getMaterialScheme();
 
    if (schemeName.find("ShaderGenerator") != std::string::npos)
      schemeName = schemeName.erase(0, 15);
 
    return schemeName;
  }
 
  void SViewPort::SetMaterialScheme(const std::string& existingScheme)
  {
    if (existingScheme.empty() || existingScheme == "Default" || existingScheme == "DefaultScheme")
      O3ViewPort->setMaterialScheme(Ogre::MSN_SHADERGEN);
    else
    {
      std::string newScheme = existingScheme;      
      O3ViewPort->setMaterialScheme(newScheme);
    }
 
    scolWindow->SynchStereoViewportSetup(this);
  }
 
  void SViewPort::SetPositionAndSize(const float& x, const float& y, const float& w, const float& h)
  {
    O3ViewPort->setDimensions(static_cast <Ogre::Real> (x), static_cast <Ogre::Real> (y), static_cast <Ogre::Real> (w), static_cast <Ogre::Real> (h));
    scolWindow->RefreshSelector();
  }
 
  void SViewPort::ResizeToWindow(const float& w, const float& h)
  {
    int rw = scolWindow->GetWidth();
    int rh = scolWindow->GetHeight();
 
    if (rw <= 0)
      rw = 1;
 
    if (rh <= 0)
      rh = 1;
 
    MMechostr(MSKDEBUG, "SO3ViewportResize %i %i %f %f\n", rw, rh, (float)w / (float)rw, (float)h / (float)rh);
    SetPositionAndSize(O3ViewPort->getLeft(), O3ViewPort->getTop(), (float)w / (float)rw, (float)h / (float)rh);
    scolWindow->RefreshSelector();
  }
 
  float SViewPort::GetLeft()
  {
    return O3ViewPort->getLeft();
  }
 
  float SViewPort::GetTop()
  {
    return O3ViewPort->getTop();
  }
 
  float SViewPort::GetWidth()
  {
    return O3ViewPort->getWidth();
  }
 
  float SViewPort::GetHeight()
  {
    return O3ViewPort->getHeight();
  }
 
  int SViewPort::GetLeftPixels()
  {
    return O3ViewPort->getActualLeft();
  }
 
  int SViewPort::GetTopPixels()
  {
    return O3ViewPort->getActualTop();
  }
 
  int SViewPort::GetWidthPixels()
  {
    return O3ViewPort->getActualWidth();
  }
 
  int SViewPort::GetHeightPixels()
  {
    return O3ViewPort->getActualHeight();
  }
 
  int SViewPort::GetPriority()
  {
    return O3ViewPort->getZOrder();
  }
 
  bool SViewPort::GetShadowsEnabled()
  {
    return O3ViewPort->getShadowsEnabled();
  }
 
  void SViewPort::SetShadowsEnabled(const bool& enableShadows)
  {
    O3ViewPort->setShadowsEnabled(enableShadows);
    scolWindow->SynchStereoViewportSetup(this, false, true);
  }
 
  void SViewPort::SetBackgroundColour(const int& backgroundColor)
  {
    O3ViewPort->setBackgroundColour(ConversionTools::ScolToOgreColorRGBA(backgroundColor));
    scolWindow->SynchStereoViewportSetup(this);
  }
 
  int SViewPort::GetBackgroundColor()
  {
    return ConversionTools::OgreToScolColorRGBA(O3ViewPort->getBackgroundColour());
  }
 
  SCamera* SViewPort::GetCamera()
  {
    return scolCamera;
  }
 
  void SViewPort::SetCamera(SCamera* camera)
  {
    if (camera)
    {
      // disable viewport on previous camera
      if (scolCamera)
      {
        //restore Stereo camera
        scolWindow->RestoreStereoCamera(this);
 
        //remove the shadow viewport
        //scolCamera->GetParentScene()->GetShadowManager()->RemoveViewport(this);
        scolCamera->SetCurrentViewPort(0);
      }
 
      O3ViewPort->setCamera(camera->GetOgreCameraPointer());
 
      // 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)O3ViewPort->getActualWidth() / (float)O3ViewPort->getActualHeight();
 
      camera->SetCurrentViewPort(this);
 
      // restore the correct ratio
      camera->GetOgreCameraPointer()->setAspectRatio(cRatio);
 
      //update Stereo camera
      scolWindow->UpdateStereoCamera(this, camera->GetOgreCameraPointer());
 
      //force RTSS update
      Ogre::RTShader::ShaderGenerator::getSingletonPtr()->invalidateScheme(O3ViewPort->getMaterialScheme());
 
      //hack for SSAO not handling camera correctly on app start
      if (ssaoHandler && ssaoHandler->GetEnable())
      {
        ssaoHandler->SetEnable(false);
        ssaoHandler->SetEnable(true);
      }
    }
    else
    {
      // disable viewport on previous camera
      if (scolCamera)
      {
        //restore Stereo camera
        scolWindow->RestoreStereoCamera(this);
        scolCamera->SetCurrentViewPort(0);
      }
 
      O3ViewPort->setCamera(0);
      scolWindow->UpdateStereoCamera(this, 0);
    }
 
    // Now we can change our camera using the "normal way".
    scolCamera = camera;
 
    if (scolCamera)
      scolWindow->RefreshSelector(true);
 
    // Inform the camera
    SRoot::getSingletonPtr()->UpdateCamera(this);
 
    // Update viewport
    /*try
    {
    O3ViewPort->update();
    }
    catch (Ogre::Exception& e)
    {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
    }*/
  }
 
  bool SViewPort::UpdateStereoCompositorState(const Ogre::String compname, bool state)
  {
    return scolWindow->UpdateStereoCompositorState(this, compname, state);
  }
 
  void SViewPort::UpdateStereoCamera(Ogre::Camera* camera)
  {
    scolWindow->UpdateStereoCamera(this, camera);
  }
 
  void SViewPort::RestoreStereoCamera()
  {
    scolWindow->RestoreStereoCamera(this);
  }
 
  void SViewPort::UpdateStereoCameraMatrix(Ogre::Camera* camera)
  {
    scolWindow->UpdateStereoCameraMatrix(this, camera);
  }
 
  void SViewPort::UnregisterStereoViewport()
  {
    scolWindow->UnregisterStereoViewport(this);
  }
 
  void SViewPort::RegisterStereoViewport()
  {
    scolWindow->RegisterStereoViewport(this);
  }
 
  bool SViewPort::IsStereoViewportRegistered()
  {
    return scolWindow->IsStereoViewportRegistered(this);
  }
 
  bool SViewPort::GetClearDepth()
  {
    return bClearDepth;
  }
 
  void SViewPort::SetClearDepth(const bool& value)
  {
    // keep the new depth state
    bClearDepth = value;
    bool bClear = value;
 
    // Update viewport clearing settings.
    int mode = Ogre::FBT_DEPTH;
    if (bClearColor && !bClearDepth)
    {
      mode = Ogre::FBT_COLOUR;
      bClear = true;
    }
    else if (bClearColor && bClearDepth)
    {
      mode = mode | Ogre::FBT_COLOUR;
      bClear = true;
    }
    O3ViewPort->setClearEveryFrame(bClear, mode);
    scolWindow->RefreshSelector();
  }
 
  bool SViewPort::GetClearColor()
  {
    return bClearColor;
  }
 
  void SViewPort::SetClearColor(const bool& value)
  {
    // keep the new color state
    bClearColor = value;
    bool bClear = value;
 
    // Update viewport clearing settings.
    int mode = Ogre::FBT_COLOUR;
    if (bClearDepth && !bClearColor)
    {
      mode = Ogre::FBT_DEPTH;
      bClear = true;
    }
    else if (bClearDepth && bClearColor)
    {
      mode = mode | Ogre::FBT_DEPTH;
      bClear = true;
    }
    O3ViewPort->setClearEveryFrame(bClear, mode);
    scolWindow->RefreshSelector();
  }
 
  void SViewPort::SetSkyEnable(const bool& value)
  {
    O3ViewPort->setSkiesEnabled(value);
    scolWindow->SynchStereoViewportSetup(this);
  }
 
  bool SViewPort::GetSkyEnable()
  {
    return O3ViewPort->getSkiesEnabled();
  }
 
  void SViewPort::SetOverlayEnable(const bool& value)
  {
    O3ViewPort->setOverlaysEnabled(value);
    scolWindow->SynchStereoViewportSetup(this, true);
  }
 
  bool SViewPort::GetOverlayEnable()
  {
    return O3ViewPort->getOverlaysEnabled();
  }
 
#ifdef SO3_BUILD_DEFERRED
  void SViewPort::SetDeferredEnable(const bool& value)
  {
    SDeferredShading* deferredManager = SRoot::getSingleton().GetDeferredManager();
    if (deferredManager != 0)
    {
      if (value)
      {
        try
        {
          deferredManager->RegisterViewport(this);
          deferredManager->SetSSAO(this, bSSAOEnable);
          deferredManager->SetAntiAliasing(this, bDeferredAntiAliasingMode);
        }
        catch (SException&)
        {
        }
      }
      else
      {
        try
        {
          deferredManager->UnregisterViewport(this);
        }
        catch (SException&)
        {
        }
      }
 
      bDeferredEnable = value;
    }
  }
 
  bool SViewPort::GetDeferredEnable()
  {
    return bDeferredEnable;
  }
 
  void SViewPort::SetDeferredAntiAliasingMode(const SDeferredShading::DeferredShadingAntiAliasingMode& value)
  {
    SDeferredShading* deferredManager = SRoot::getSingleton().GetDeferredManager();
    if (deferredManager != 0)
    {
      try
      {
        deferredManager->SetAntiAliasing(this, value);
      }
      catch (SException&)
      {
      }
    }
    bDeferredAntiAliasingMode = value;
  }
 
  SDeferredShading::DeferredShadingAntiAliasingMode SViewPort::GetDeferredAntiAliasingMode()
  {
    return bDeferredAntiAliasingMode;
  }
 
  void SViewPort::SetDeferredDebugMode(const int& value)
  {
    SDeferredShading* deferredManager = SRoot::getSingleton().GetDeferredManager();
    if (deferredManager != 0)
    {
      try
      {
        deferredManager->SetMode(static_cast<SDeferredShading::DeferredShadingMode>(value));
      }
      catch (Ogre::Exception&)
      {
      }
    }
  }
 
  int SViewPort::GetDeferredDebugMode()
  {
    int currentDebugMode = 0;
 
    SDeferredShading* deferredManager = SRoot::getSingleton().GetDeferredManager();
    if (deferredManager != 0)
    {
      currentDebugMode = static_cast<int>(deferredManager->GetMode());
    }
    return currentDebugMode;
  }
#endif
 
  void SViewPort::SetSSAOEnable(const bool& value)
  {
    if (!ssaoHandler)
      return;
 
#ifdef SO3_BUILD_DEFERRED
    SDeferredShading* deferredManager = SRoot::getSingleton().GetDeferredManager();
    if ((deferredManager != 0) && bDeferredEnable)
    {
      // Deferred rendering ssao.
      try
      {
        deferredManager->SetSSAO(this, value);
      }
      catch (SException&)
      {
      }
    }
    else
#endif
    {
      // Enable forward rendering SSAO
      ssaoHandler->SetEnable(value);
    }
    bSSAOEnable = value;
  }
 
  bool SViewPort::GetSSAOEnable()
  {
    return bSSAOEnable;
  }
 
  SSsaoHandler* SViewPort::GetSSAOhandler()
  {
    return ssaoHandler;
  }
 
  void SViewPort::SetHDREnable(const bool& value)
  {
    if (hdrHandler)
      hdrHandler->SetEnable(value);
  }
 
  bool SViewPort::GetHDREnable()
  {
    if (!hdrHandler)
      return false;
 
    return hdrHandler->GetEnable();
  }
 
  SHdrHandler* SViewPort::GetHDRhandler()
  {
    return hdrHandler;
  }
 
  void SViewPort::SetHDRBlurAmount(const float& value)
  {
    if (hdrHandler)
      hdrHandler->SetBlurAmount(value);
  }
 
  void SViewPort::SetHDREffectAmount(const float& value)
  {
    if (hdrHandler)
      hdrHandler->SetEffectAmount(value);
  }
 
  void SViewPort::SetHDRGamma(const float& value)
  {
    if (hdrHandler)
      hdrHandler->SetGamma(value);
  }
 
  void SViewPort::SetVisibilityMask(const Ogre::uint32& mask)
  {
    O3ViewPort->setVisibilityMask(mask);
    scolWindow->RefreshSelector();
    scolWindow->SynchStereoViewportSetup(this);
  }
 
  Ogre::uint32 SViewPort::GetVisibilityMask()
  {
    return O3ViewPort->getVisibilityMask();
  }
 
  void SViewPort::SetVisibilityMaskIndexEnable(const Ogre::uint32 flagIndex, const bool enable)
  {
    assert((flagIndex > 0) && (flagIndex < 32));
    Ogre::uint32 flag = 1 << flagIndex;
    Ogre::uint32 flags = O3ViewPort->getVisibilityMask();
    if (enable)
      O3ViewPort->setVisibilityMask(flags | flag);
    else
      O3ViewPort->setVisibilityMask(flags & ~flag);
 
    scolWindow->RefreshSelector();
    scolWindow->SynchStereoViewportSetup(this);
  }
 
  bool SViewPort::GetVisibilityMaskIndexEnable(const Ogre::uint32 flagIndex)
  {
    assert((flagIndex > 0) && (flagIndex < 32));
    Ogre::uint32 flag = 1 << flagIndex;
    if ((flag & O3ViewPort->getVisibilityMask()) > 0)
      return true;
    else
      return false;
  }
 
  void SViewPort::Update()
  {
    try
    {
      O3ViewPort->update();
    }
    catch (Ogre::Exception& e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
    }
  }
 
  SCompositor* SViewPort::GetCompositor(const std::string& compositorName)
  {
    SCompositorMap::iterator iCompositorSearched = compList.find(compositorName);
    if (iCompositorSearched != compList.end())
      return iCompositorSearched->second;
    else
      return 0;
  }
 
  const SCompositorMap& SViewPort::GetCompositorList() const
  {
    return compList;
  }
 
  SCompositor* SViewPort::CreateCompositor(const std::string& newCompositorName, const std::string& newSchemeName)
  {
    SCompositor* newCompositor = GetCompositor(newCompositorName);
    if (newCompositor == 0)
    {
      newCompositor = new SCompositor(this, newCompositorName, newSchemeName);
      AddCompositor(newCompositor);
    }
    return newCompositor;
  }
 
  void SViewPort::DeleteCompositor(const std::string& existingCompositorName)
  {
    DeleteCompositor(GetCompositor(existingCompositorName));
  }
 
  void SViewPort::DeleteCompositor(SCompositor* existingCompositor)
  {
    RemoveCompositor(existingCompositor);
    SO3_SAFE_DELETE(existingCompositor);
  }
 
  void SViewPort::ClearCompositors()
  {
    // clear all compositors.
    SCompositorMap::iterator iCompositorList = compList.begin();
 
    // Do not use DeleteCompositor function here, cause this one use "RemoveCompositor" function, and it breaks the iterator!
    while (iCompositorList != compList.end())
    {
      SO3_SAFE_DELETE(iCompositorList->second);
      iCompositorList++;
    }
    compList.clear();
  }
 
  void SViewPort::AddCompositor(SCompositor* existingCompositor)
  {
    string name = existingCompositor->GetName();
    SCompositorMap::iterator iCompositorSearched = compList.find(name);
    if (iCompositorSearched == compList.end())
    {
      compList.insert(SCompositorMap::value_type(name, existingCompositor));
    }
    else
    {
      // Compositor already exist in the handled compositors list.
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add Compositor named \"" + name + "\", an element with the same name already exist!", "SViewPort::AddCompositor");
    }
  }
 
  void SViewPort::RemoveCompositor(SCompositor* existingCompositor)
  {
    RemoveCompositor(existingCompositor->GetName());
  }
 
  void SViewPort::RemoveCompositor(const std::string& compositorName)
  {
    SCompositorMap::iterator iCompositorSearched = compList.find(compositorName);
    if (iCompositorSearched != compList.end())
    {
      compList.erase(iCompositorSearched);
    }
    else
    {
      // Compositor not found in the handled Compositor list
      OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Compositor named \"" + compositorName + "\", element not found!", "SViewPort::RemoveCompositor");
    }
  }
 
  bool SViewPort::GetScreenPosFromWorldPos(Ogre::Vector3 worldPosition, Ogre::Vector2 &screenPos)
  {
    if (!scolCamera)
      return false;
 
    Ogre::Camera* cam = scolCamera->GetOgreCameraPointer();
 
    // Is the camera facing that point? If not, return false
    Ogre::Plane cameraPlane = Ogre::Plane(Ogre::Vector3(cam->getDerivedOrientation().zAxis()), cam->getDerivedPosition());
    if (cameraPlane.getSide(worldPosition) != Ogre::Plane::NEGATIVE_SIDE)
      return false;
 
    Ogre::Vector3 screenPoint = cam->getProjectionMatrix() * cam->getViewMatrix() * worldPosition;
    float x = (screenPoint.x * 0.5f) + 0.5f;
    float y = 1.0f - ((screenPoint.y * 0.5f) + 0.5f);
 
    //out of screen
    if ((x < 0.0f) || (x > 1.0f) || (y < 0.0f) || (y > 1.0f))
      return false;
 
    screenPos = Ogre::Vector2(O3ViewPort->getActualWidth() * x, O3ViewPort->getActualHeight() * y);
 
    //position in viewport size not in screen
    /*
  #if defined(ANDROID) || defined(APPLE_IOS)
  ToWindowPos(screenPos.x, screenPos.y);
  #endif
  */
    return true;
  }
 
  SRaycastResult SViewPort::RayCast(const int& pixelsX, const int& pixelsY, SSubEntitySelectorBuffer* subEntitySelector)
  {
    SRaycastResult raycastReturn;
 
    float xR = (static_cast <float> (pixelsX - GetLeftPixels())) / (static_cast <float> (GetWidthPixels()));
    float yR = (static_cast <float> (pixelsY - GetTopPixels())) / (static_cast <float> (GetHeightPixels()));
 
    //subentity raycast
    if (subEntitySelector)
    {
      // First, use our selection buffer to find which sub-entity was hit
      Ogre::SubEntity* subEntity = 0;
 
      Ogre::Vector3 pos(0.0f, 0.0f, 0.0f);
      float rayLenght = 0.0f;
      if (subEntitySelector != 0)
      {
        subEntity = subEntitySelector->GetSelectedSubEntity(pixelsX, pixelsY);
 
        if (subEntity && subEntitySelector->UseDepthBuffer())
        {
          float zdepth = subEntitySelector->GetSelectedZdepth(pixelsX, pixelsY);
 
          Ogre::Camera* camera = O3ViewPort->getCamera();
          if (camera)
          {
            // x & y are in range [-1; 1];
            Ogre::Real nx = (2.0f * xR) - 1.0f;
            Ogre::Real ny = 1.0f - (2.0f * yR);
            Ogre::Vector3 nearPoint(nx, ny, -1.0f);
            Ogre::Vector3 midPoint(nx, ny, 0.0f);
 
            //get ray world position and direction
            Ogre::Matrix4 invViewMat = (camera->getProjectionMatrix() * camera->getViewMatrix(true)).inverse();
            Ogre::Vector3 rayOrigin = invViewMat * nearPoint;
            Ogre::Vector3 rayDest = invViewMat * midPoint;
            Ogre::Vector3 rayDirection = rayDest - rayOrigin;
            rayDirection.normalise();
 
            float farclip = camera->getFarClipDistance();
            float nearclip = camera->getNearClipDistance();
 
            // correct perspective
            if (camera->getProjectionType() == Ogre::PT_PERSPECTIVE)
            {
              // non linear depth
              Ogre::Vector4 viewpos = camera->getProjectionMatrixWithRSDepth().inverse() * Ogre::Vector4(nx, ny, zdepth, 1.0f);
              zdepth = viewpos.z / viewpos.w;
 
              //restore view distance from linear depth
              //zdepth *= farclip - nearclip;
 
              if (SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL3_RENDERER ||
                  SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL_RENDERER ||
                  SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_METAL_RENDERER ||
                  SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_VULKAN_RENDERER)
                zdepth += nearclip;
              else
                zdepth -= nearclip;
 
              // get new distance for ray direction
              // A B C triangle : tan(fov / 2) gives AB : AC is depth : then use pythagore to get hypotenuse BC
              double ylenght = Ogre::Math::Tan(camera->getFOVy().valueRadians() / 2.0f);
              double xlenght = ylenght * camera->getAspectRatio();
              double opx = zdepth * abs(xlenght * nx);
              double opy = zdepth * abs(ylenght * ny);
              rayLenght = Ogre::Math::Sqrt((Ogre::Real)((zdepth * zdepth) + (opx * opx) + (opy * opy)));
            }
            else
            {
              zdepth *= (farclip - nearclip);
 
              if (SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL3_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_OPENGL_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_METAL_RENDERER ||
                SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_VULKAN_RENDERER)
                zdepth *= 0.5f;
 
              rayLenght = zdepth;
            }
 
            pos = rayOrigin + (rayDirection * rayLenght);
          }
        }
      }
      //MMechostr(MSKDEBUG, ">>>>>> RayCast : %i:%i\n", pixelsX, pixelsY);
 
      if (subEntity != 0)
      {
        //MMechostr(MSKDEBUG, ">>>>>> RayCast : Entity found > %s\n", subEntity->getParent()->getName().c_str());
 
        int subid = -1;
        for (unsigned int i = 0; i < subEntity->getParent()->getNumSubEntities() && (subid == -1); i++)
        {
          if (subEntity->getParent()->getSubEntity(i) == subEntity)
            subid = i;
        }
 
        //Only on widgets when the depth is available
        if (scolCamera != 0)
        {
          if (subEntitySelector->UseDepthBuffer())
          {
            Ogre::Any bindedCustomEntity = subEntity->getUserObjectBindings().getUserAny("SEntity");
            SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
            SScene* scene = entity->GetParentScene();
            SMaterial* mat = scene->GetMaterial(entity->GetGroupName(), subEntity->getMaterial()->getName());
 
            raycastReturn.entity = entity;
            raycastReturn.entityName = entity->GetName();
            raycastReturn.scene = scene;
            raycastReturn.sceneName = scene->GetName();
            raycastReturn.viewport = this;
            raycastReturn.material = mat;
 
            // Should we force uv coordonate retrieving too?
            if (mat && (mat->GetAssociatedWidget() != 0))
              raycastReturn = SRaycast::Cast(scolCamera, xR, yR, subEntity, true);
 
            raycastReturn.point = pos;
            raycastReturn.closestDistance = rayLenght;
          }
          else if (scolWindow->GetSelectorMode() == SWindow::SO3_SELECTOR_LIMITED) // position only on widgets
          {
            Ogre::Any bindedCustomEntity = subEntity->getUserObjectBindings().getUserAny("SEntity");
            SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
            SScene* scene = entity->GetParentScene();
            SMaterial* mat = scene->GetMaterial(entity->GetGroupName(), subEntity->getMaterial()->getName());
 
            // Should we force uv coordonate retrieving too?
            if (mat && (mat->GetAssociatedWidget() != 0))
            {
              raycastReturn.entity = entity;
              raycastReturn.entityName = entity->GetName();
              raycastReturn.scene = scene;
              raycastReturn.sceneName = scene->GetName();
              raycastReturn.material = mat;
              raycastReturn.viewport = this;
              raycastReturn = SRaycast::Cast(scolCamera, xR, yR, subEntity, true);
            }
            else
            {
              float xR = (static_cast <float> (pixelsX - GetLeftPixels())) / (static_cast <float> (GetWidthPixels()));
              float yR = (static_cast <float> (pixelsY - GetTopPixels())) / (static_cast <float> (GetHeightPixels()));
              Ogre::Ray ray = scolCamera->GetOgreCameraPointer()->getCameraToViewportRay(fabs(xR), fabs(yR));
              ray.setOrigin(scolCamera->GetGlobalPosition());
              scolCamera->GetParentScene()->GetSimpleRayCast(ray, entity, raycastReturn);
 
              if (raycastReturn.scene == 0)
              {
                raycastReturn.entity = entity;
                raycastReturn.entityName = entity->GetName();
                raycastReturn.scene = scene;
                raycastReturn.sceneName = scene->GetName();
              }
              raycastReturn.material = mat;
              raycastReturn.viewport = this;
            }
          }
          else
          {
            raycastReturn = SRaycast::Cast(scolCamera, xR, yR, subEntity);
          }
        }
 
        raycastReturn.indexSubEntity = subid;
      }
    }
    else
    {
      //simple raycast
      if (scolCamera != 0)
      {
        float xR = (static_cast <float> (pixelsX - GetLeftPixels())) / (static_cast <float> (GetWidthPixels()));
        float yR = (static_cast <float> (pixelsY - GetTopPixels())) / (static_cast <float> (GetHeightPixels()));
        Ogre::Ray ray = scolCamera->GetOgreCameraPointer()->getCameraToViewportRay(fabs(xR), fabs(yR));
        ray.setOrigin(scolCamera->GetGlobalPosition());
        raycastReturn.viewport = this;
 
        scolCamera->GetParentScene()->GetSimpleRayCast(ray, raycastReturn);
      }
    }
 
    return raycastReturn;
  }
 
  SRaycastResult SViewPort::RayCast(const int& pixelsX, const int& pixelsY)
  {
    int x = pixelsX;
    int y = pixelsY;
    ToPixelPos(x, y);
 
    return scolWindow->RayCast(O3ViewPort->getActualLeft() + x, O3ViewPort->getActualTop() + y);
  }
 
  Ogre::Vector3 SViewPort::RayCastCamera(const int& pixelsX, const int& pixelsY, const float distance, Ogre::Vector3 &outDirection)
  {
    if (!scolCamera || !scolCamera->GetOgreCameraPointer())
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALID_STATE, "There is now active camera on viewport", "SViewPort::RayCastCamera");
 
    float xR = (static_cast <float> (pixelsX - GetLeftPixels())) / (static_cast <float> (GetWidthPixels()));
    float yR = (static_cast <float> (pixelsY - GetTopPixels())) / (static_cast <float> (GetHeightPixels()));
    Ogre::Ray ray = scolCamera->GetOgreCameraPointer()->getCameraToViewportRay(xR, yR);
    outDirection = ray.getDirection();
    return ray.getOrigin() + ray.getDirection() * distance;
  }
 
  void SViewPort::viewportDimensionsChanged(Ogre::Viewport* viewport)
  {
    //hack to solve a bug in opengl renderer, this is not needed in DirectX
    //reset all compositors
    if (SRoot::getSingletonPtr()->GetRenderSystem() == SRoot::SO3_OPENGL_RENDERER)
    {
      Ogre::CompositorManager &compositorManager = Ogre::CompositorManager::getSingleton();
      if (compositorManager.hasCompositorChain(O3ViewPort))
      {
        Ogre::CompositorChain* chain = compositorManager.getCompositorChain(O3ViewPort);
 
        if (chain)
        {
          Ogre::CompositorChain::Instances instances = chain->getCompositorInstances();
          for (unsigned int i = 0; i < instances.size(); i++)
          {
            Ogre::CompositorInstance *compositorInstance = instances.at(i);
            Ogre::Compositor *compositor = compositorInstance->getCompositor();
            bool state = compositorInstance->getEnabled();
            if (state)
            {
              compositorInstance->setEnabled(false);
              compositorInstance->setEnabled(true);
            }
          }
        }
      }
    }
  }
 
  Ogre::Technique* SViewPort::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
  {
    MMechostr(MSKDEBUG, ">>>>>>>>> Material scheme missed : %s for material : %s\n", schemeName.c_str(), originalMaterial->getName().c_str());
    Ogre::MaterialPtr smat = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName("SO3/Internal/Default", SO3_INTERNAL_RESOURCE_GROUP));
    if (smat)
      return smat->getTechnique(0);
    else
      return 0;
  }
 
  unsigned int SViewPort::GetNumRenderedFaces()
  {
    if (O3ViewPort)
    {
      unsigned int numFaces = 0;
 
      Ogre::CompositorManager &compositorManager = Ogre::CompositorManager::getSingleton();
      if (compositorManager.hasCompositorChain(O3ViewPort))
      {
        Ogre::CompositorChain* chain = compositorManager.getCompositorChain(O3ViewPort);
 
        if (chain)
        {
          Ogre::CompositorChain::Instances instances = chain->getCompositorInstances();
          for (unsigned int i = 0; i < instances.size(); i++)
          {
            Ogre::CompositorInstance *compositorInstance = instances.at(i);
            if (compositorInstance->getEnabled())
            {
              Ogre::CompositionTechnique::TargetPasses passList = compositorInstance->getTechnique()->getTargetPasses();
              for (unsigned int j = 0; j < passList.size(); ++j)
              {
                Ogre::RenderTarget* rendTarget = 0;
 
                try
                {
                  rendTarget = compositorInstance->getRenderTarget(passList[j]->getOutputName());
                }
                catch (Ogre::Exception &)
                {
                  rendTarget = 0;
                }
 
                if (rendTarget)
                  numFaces += rendTarget->getStatistics().triangleCount;
              }
            }
          }
        }
      }
 
      numFaces += O3ViewPort->_getNumRenderedFaces();
      return numFaces;
    }
 
    return 0;
  }
 
  unsigned int SViewPort::GetNumRenderedBatches()
  {
    if (O3ViewPort)
    {
      unsigned int numBatches = 0;
 
      Ogre::CompositorManager &compositorManager = Ogre::CompositorManager::getSingleton();
      if (compositorManager.hasCompositorChain(O3ViewPort))
      {
        Ogre::CompositorChain* chain = compositorManager.getCompositorChain(O3ViewPort);
 
        if (chain)
        {
          Ogre::CompositorChain::Instances instances = chain->getCompositorInstances();
          for (unsigned int i = 0; i < instances.size(); i++)
          {
            Ogre::CompositorInstance *compositorInstance = instances.at(i);
            if (compositorInstance->getEnabled())
            {
              Ogre::CompositionTechnique::TargetPasses passList = compositorInstance->getTechnique()->getTargetPasses();
              for (unsigned int j = 0; j < passList.size(); ++j)
              {
                Ogre::RenderTarget* rendTarget = 0;
 
                try
                {
                  rendTarget = compositorInstance->getRenderTarget(passList[j]->getOutputName());
                }
                catch (Ogre::Exception &)
                {
                  rendTarget = 0;
                }
 
                if (rendTarget)
                  numBatches += rendTarget->getStatistics().batchCount;
              }
            }
          }
        }
      }
      numBatches += O3ViewPort->_getNumRenderedBatches();
      return numBatches;      
    }
 
    return 0;
  }
 
  void SViewPort::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)GetWidthPixels() / (float)nwidth) * (float)px);
    py = (int)(((float)GetHeightPixels() / (float)nheight) * (float)py);
 
#elif defined(APPLE_IOS)
    float ratio = GetParentWindow()->GetOgreRenderWindowPointer()->getViewPointToPixelScale();
 
    px *= ratio;
    py *= ratio;
#endif
  }
 
  void SViewPort::ToPixelPos(float& px, float& py)
  {
#if defined(ANDROID)
    ScolWindowHandle awindow = (ScolWindowHandle)SCgetExtra("hscol");
    int nwidth = (int)ANativeWindow_getWidth(awindow);
    int nheight = (int)ANativeWindow_getHeight(awindow);
 
    px = ((float)GetWidthPixels() / (float)nwidth) * px;
    py = ((float)GetHeightPixels() / (float)nheight) * py;
 
#elif defined(APPLE_IOS)
    float ratio = GetParentWindow()->GetOgreRenderWindowPointer()->getViewPointToPixelScale();
 
    px *= ratio;
    py *= ratio;
#endif
  }
 
  void SViewPort::ToWindowPos(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)nwidth / (float)GetWidthPixels()) * (float)px);
    py = (int)(((float)nheight / (float)GetHeightPixels()) * (float)py);
 
#elif defined(APPLE_IOS)
    float ratio = GetParentWindow()->GetOgreRenderWindowPointer()->getViewPointToPixelScale();
 
    px = (int)((float)px / ratio);
    py = (int)((float)py / ratio);
#endif
  }
 
  void SViewPort::ToWindowPos(float& px, float& py)
  {
#if defined(ANDROID)
    ScolWindowHandle awindow = (ScolWindowHandle)SCgetExtra("hscol");
    int nwidth = (int)ANativeWindow_getWidth(awindow);
    int nheight = (int)ANativeWindow_getHeight(awindow);
 
    px = ((float)nwidth / (float)GetWidthPixels()) * px;
    py = ((float)nheight / (float)GetHeightPixels()) * py;
 
#elif defined(APPLE_IOS)
    float ratio = GetParentWindow()->GetOgreRenderWindowPointer()->getViewPointToPixelScale();
 
    px /= ratio;
    py /= ratio;
#endif
  }
 
 
}