SO3SubEntitySelectorBuffer.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 "SO3SceneGraph/SO3SubEntitySelectorBuffer.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3Renderer/SO3ViewPort.h"
#include <OgreBitwise.h>
#include <OgreDepthBuffer.h>
 
namespace SO3
{
 
SSubEntitySelectorBuffer::SSubEntitySelectorBuffer(SWindow* targetWindow, bool useDepth)
{
  mBaseResourceName = std::string(SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP) +"/"+ targetWindow->GetName();
  
  Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
  if (rendererName == "Vulkan Rendering Subsystem")
    useDepth = false;
 
  // Create a custom resource group
  Ogre::ResourceGroupManager::getSingleton().createResourceGroup(mBaseResourceName, false);
 
  // Basic initializing
  mWindow = targetWindow;
  mRenderPickerBuffer = 0;
  mOgrePixelBox = 0;
  mOgreRenderTexture = 0;
  mOgreRenderDepthTexture = 0;
  mMrtTexture = 0;
  mOgreDebugOverlay = 0;
  mOgreDebugOverlayPanel = 0;
  mOgreOverlayMaterial.reset();
  mRealWidth = 0;
  mRealHeight = 0;
  mTextureWidth = 0;
  mTextureHeight = 0;
  mCompensateNPOT = false;
  mUseDepth = useDepth;
  nodeSelectorMaterialSwitcher = 0;
  mOgreRenderWindow = static_cast <Ogre::RenderTarget*> (const_cast <Ogre::RenderWindow*> (mWindow->GetOgreRenderWindowPointer()));
 
  mOgrePickerRect = 0;
  mOgrePickerRenderTexture = 0;
  mOgrePickerScene = 0;
  mOgrePickerCamera = 0;
 
  Ogre::RenderSystem* ogreRenderSystem = SRoot::getSingleton().GetOgreRenderSystem();
  const Ogre::RenderSystemCapabilities* caps = ogreRenderSystem->getCapabilities();
  if (mUseDepth && caps && !caps->hasCapability(Ogre::RSC_MRT_SAME_BIT_DEPTHS))
    mUseDepth = true;
  else
    mUseDepth = false;
 
  //get materials
  mPickerMat = Ogre::MaterialManager::getSingletonPtr()->getByName("SO3/Internal/EntitySelector/Material/MouseColor");
  if (mPickerMat)
  {
    // Create the render texture.
    CreateTexture(mOgreRenderWindow->getWidth(), mOgreRenderWindow->getHeight());
    CreatePicker();
 
    // Create our material switcher.
    nodeSelectorMaterialSwitcher = new SSubEntitySelectorMaterialSwitcher(mBaseResourceName, UseDepthBuffer());
  }
}
 
SSubEntitySelectorBuffer::SSubEntitySelectorBuffer()
{
  // Forbiden (private)
}
 
SSubEntitySelectorBuffer::~SSubEntitySelectorBuffer()
{
  DeleteTexture();
  DeletePicker();
 
  Ogre::ResourceGroupManager::getSingleton().unloadResourceGroup(mBaseResourceName);
  Ogre::ResourceGroupManager::getSingleton().clearResourceGroup(mBaseResourceName);
  Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(mBaseResourceName);
 
  SO3_SAFE_DELETE(nodeSelectorMaterialSwitcher);
}
 
void SSubEntitySelectorBuffer::DestroyBuffers()
{
  DeleteTexture();
  DeletePicker();
}
 
void SSubEntitySelectorBuffer::CreateBuffers()
{
  DeleteTexture();
  DeletePicker();
 
  CreateTexture(mOgreRenderWindow->getWidth(), mOgreRenderWindow->getHeight());
  CreatePicker();
}
 
void SSubEntitySelectorBuffer::CreatePicker()
{
  DeletePicker();
 
  Ogre::PixelFormat rttpf = Ogre::PF_A8R8G8B8;
  try
  {
    SRoot::getSingleton().GetRttPixelFormat(rttpf, mUseDepth ? true : false);
    mOgrePickerTexture = Ogre::TextureManager::getSingleton().createManual(mBaseResourceName + "/Picker", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, Ogre::TEX_TYPE_2D, 1, 1, 0, rttpf, Ogre::TU_RENDERTARGET);
          mOgrePickerTexture->load();
  }
  catch (Ogre::Exception &e)
  {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred in SSubEntitySelectorBuffer::CreatePicker : "+ e.getDescription());
          mOgrePickerTexture.reset();
  }
 
  if (mOgrePickerTexture)
  {
          // Bind to a render texture
          Ogre::HardwarePixelBufferSharedPtr ogrePixelBuffer = mOgrePickerTexture->getBuffer();
          mOgrePickerRenderTexture = ogrePixelBuffer->getRenderTarget();
          mOgrePickerRenderTexture->setAutoUpdated(false);
 
#if defined(APPLE_IOS)
    mOgrePickerRenderTexture->setDepthBufferPool(Ogre::DepthBuffer::POOL_NO_DEPTH);
#endif
 
    // Create our buffer
    size_t bufferSize = ogrePixelBuffer->getSizeInBytes();
    mRenderPickerBuffer = new Ogre::uint8[bufferSize];
    mOgrePixelBox = new Ogre::PixelBox(ogrePixelBuffer->getWidth(), ogrePixelBuffer->getHeight(), ogrePixelBuffer->getDepth(), ogrePixelBuffer->getFormat(), mRenderPickerBuffer);
 
    //create scene
    mOgrePickerScene = Ogre::Root::getSingleton().createSceneManager(Ogre::SMT_DEFAULT, mBaseResourceName+ "/Picker/Scene");
 
    Ogre::AxisAlignedBox octreeBox(-1, -1, -1, 1, 1, 1);
    int octreeDepth = 0;
    mOgrePickerScene->setOption("Size", &octreeBox);
    mOgrePickerScene->setOption("Depth", &octreeDepth);
 
    Ogre::RenderQueue* rq = mOgrePickerScene->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);
    rq->getQueueGroup(49)->setShadowsEnabled(false);
 
    //set camera
    mOgrePickerCamera = mOgrePickerScene->createCamera(mBaseResourceName+ "/Picker/Camera");
    mOgrePickerScene->getRootSceneNode()->attachObject(mOgrePickerCamera);
    mOgrePickerCamera->setFarClipDistance(100.0f);
          mOgrePickerCamera->setNearClipDistance(0.1f);
 
    Ogre::Viewport* pickerViewport = mOgrePickerRenderTexture->addViewport(mOgrePickerCamera);
    pickerViewport->setOverlaysEnabled(false);
    pickerViewport->setShadowsEnabled(false);
    //mOgrePickerViewport->setSkiesEnabled(false);
 
    //create rect
    mOgrePickerRect = new Ogre::Rectangle2D(true);
    mOgrePickerRect->setCastShadows(false);
 
    try
    {
      mOgrePickerRect->setMaterial(mPickerMat);
    }
    catch(Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
    }
 
    mOgrePickerRect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
    mOgrePickerScene->getRootSceneNode()->attachObject(mOgrePickerRect);
    mOgrePickerRect->setCorners(-1.0f, 1.0f, 1.0f, -1.0f);
 
    // Use infinite AAB to always stay visible
    Ogre::AxisAlignedBox aabInf;
    aabInf.setInfinite();
    mOgrePickerRect->setBoundingBox(aabInf);
    mOgrePickerRect->setVisible(true);
 
    // Show debug overlay.
#if SO3_SUBENTITY_SELECTOR_DEBUG_OVERLAY
    //CreateDebugOverlay();
#endif
  }
}
 
void SSubEntitySelectorBuffer::DeletePicker()
{
  // hide debug overlay.
#if SO3_SUBENTITY_SELECTOR_DEBUG_OVERLAY
  //DeleteDebugOverlay();
#endif
 
  if(mOgrePickerRect != 0)
  {
    mOgrePickerRect->detachFromParent();
    SAFE_DELETE(mOgrePickerRect);
  }
 
  if (mOgrePickerScene)
  {
    mOgrePickerScene->destroyAllCameras();
    Ogre::Root::getSingleton().destroySceneManager(mOgrePickerScene);
    mOgrePickerCamera = 0;
    mOgrePickerScene = 0;
  }
 
  if(mOgrePickerRenderTexture)
  {
    mOgrePickerRenderTexture->removeAllViewports();
    mOgrePickerRenderTexture = 0;
  }
 
  if (mOgrePickerTexture)
  {
    Ogre::TextureManager::getSingleton().remove(mOgrePickerTexture->getHandle());
    mOgrePickerTexture.reset();
  }
 
  SO3_SAFE_DELETE(mOgrePixelBox);
  SO3_SAFE_DELETE_ARRAY(mRenderPickerBuffer);
}
 
void SSubEntitySelectorBuffer::AddViewport(SViewPort* newViewport)
{
  Ogre::Viewport* renderWindowViewport = mOgreRenderWindow->getViewport(newViewport->GetPriority());
 
  mSelectorViewportList[newViewport] = 0;
}
 
void SSubEntitySelectorBuffer::RemoveViewport(SViewPort* existingViewport)
{
  SelectorViewportList::iterator iSearchedOgreViewport = mSelectorViewportList.find(existingViewport);
  if(iSearchedOgreViewport != mSelectorViewportList.end())
  {
    mSelectorViewportList.erase(iSearchedOgreViewport);
  }
}
 
bool SSubEntitySelectorBuffer::UseDepthBuffer()
{
  return mUseDepth && mOgreRenderDepthTexture;
}
 
Ogre::SubEntity* SSubEntitySelectorBuffer::GetSelectedSubEntity(int posX, int posY)
{
  if (!mPickerMat)
    return 0;
 
  if (mCompensateNPOT)
  {
    posX = (int)(((float)mTextureWidth / (float)mRealWidth) * (float)posX);
    posY = (int)(((float)mTextureHeight / (float)mRealHeight) * (float)posY);
  }
 
  if (mOgrePickerRenderTexture && (posX >= 0) && (posY >= 0))
  {
    //set material parameters
    Ogre::Technique* pickerTech = 0;
    Ogre::Material::Techniques techs = mPickerMat->getTechniques();
 
    if (techs.size() == 0)
      return 0;
 
    pickerTech = techs[0];
 
    Ogre::Vector4 mousePos;
    mousePos.x = (1.0f / (float)mTextureWidth) * (float)posX;
    mousePos.y = (1.0f / (float)mTextureHeight) * (float)posY;
 
    Ogre::ARGB argb(0);
    Ogre::ColourValue ogreColour;
 
    try
    {
      Ogre::Pass* pickerPass = pickerTech->getPass(0);
      Ogre::GpuProgramParametersSharedPtr fparams = pickerPass->getFragmentProgramParameters();
                        fparams->setNamedConstant("inMouse", mousePos);
 
      pickerPass->getTextureUnitState(0)->setTexture(mOgreTexture);
 
      // debug
      /*
      Ogre::PixelBox pb(mOgreRenderTexture->getWidth(), mOgreRenderTexture->getHeight(), 1, mOgreRenderTexture->suggestPixelFormat());
      pb.data = new uint8[pb.getConsecutiveSize()];
      mOgreRenderTexture->copyContentsToMemory(pb, pb);
 
      Ogre::Image finalImage;
      finalImage.loadDynamicImage(static_cast<unsigned char*>(pb.data), pb.getWidth(), pb.getHeight(), mOgreRenderTexture->suggestPixelFormat());
 
      //write the file on the Harddisk
      finalImage.save("E:\\Documents\\OpenSpace3D\\dselector_debug.png");
      delete[] pb.data;
      */
 
      mOgrePickerRenderTexture->update();
      mOgrePickerRenderTexture->copyContentsToMemory(Ogre::Box(0, 0, 1, 1), *mOgrePixelBox, Ogre::RenderTarget::FB_AUTO);
 
      if (mRenderPickerBuffer)
        ogreColour = mOgrePixelBox->getColourAt(0, 0, 0);
 
      ogreColour.a = 1.0f;
    }
    catch(Ogre::Exception&)
    {
      //Renderer not ready
      return 0;
    }
 
    // Get sub entity
    Ogre::SubEntity* selectedEntity = (nodeSelectorMaterialSwitcher) ? nodeSelectorMaterialSwitcher->GetSubEntity(ogreColour) : 0;
    return selectedEntity;
  }
  return 0;
}
 
float SSubEntitySelectorBuffer::GetSelectedZdepth(int posX, int posY)
{
  if (!mPickerMat)
    return 0;
 
  if (mCompensateNPOT)
  {
    posX = (int)(((float)mTextureWidth / (float)mRealWidth) * (float)posX);
    posY = (int)(((float)mTextureHeight / (float)mRealHeight) * (float)posY);
  }
 
  if (mOgreDepthTexture && (posX >= 0) && (posY >= 0))
  {
    //set material parameters
    Ogre::Technique* pickerTech = 0;
    Ogre::Material::Techniques techs = mPickerMat->getTechniques();
 
    if (techs.size() == 0)
      return 0;
 
    pickerTech = techs[0];
 
    Ogre::Vector4 mousePos;
    mousePos.x = (1.0f / (float)mTextureWidth) * (float)posX;
    mousePos.y = (1.0f / (float)mTextureHeight) * (float)posY;
 
    float zpos = 0.0f;
    Ogre::ARGB argb(0);
    Ogre::ColourValue ogreColour;
    try
    {
      Ogre::Pass* pickerPass = pickerTech->getPass(0);
      Ogre::GpuProgramParametersSharedPtr fparams = pickerPass->getFragmentProgramParameters();
      fparams->setNamedConstant("inMouse", mousePos);
 
      pickerPass->getTextureUnitState(0)->setTexture(mOgreDepthTexture);
 
      // debug
      /*
      Ogre::PixelBox pb(mOgreRenderDepthTexture->getWidth(), mOgreRenderDepthTexture->getHeight(), 1, mOgreRenderDepthTexture->suggestPixelFormat());
      pb.data = new uint8[pb.getConsecutiveSize()];
      mOgreRenderDepthTexture->copyContentsToMemory(pb, pb);
 
      Ogre::Image finalImage;
      finalImage.loadDynamicImage(static_cast<unsigned char*>(pb.data), pb.getWidth(), pb.getHeight(), mOgreRenderDepthTexture->suggestPixelFormat());
 
      //write the file on the Harddisk
      finalImage.save("D:\\Documents\\OpenSpace3D\\depth_debug.png");
      delete[] pb.data;
      */
 
      mOgrePickerRenderTexture->update();
      mOgrePickerRenderTexture->copyContentsToMemory(Ogre::Box(0, 0, 1, 1), *mOgrePixelBox, Ogre::RenderTarget::FB_AUTO);
 
      if (mRenderPickerBuffer)
        ogreColour = mOgrePixelBox->getColourAt(0, 0, 0);
 
      //unpack RGBA to float
      Ogre::Vector4 shift(1.0f / (256.0f * 256.0f * 256.0f), 1.0f / (256.0f * 256.0f), 1.0f / 256.0f, 1.0f);
      zpos = Ogre::Vector4(ogreColour.a, ogreColour.b, ogreColour.g, ogreColour.r).dotProduct(shift);
    }
    catch (Ogre::Exception&)
    {
      //Renderer not ready
      return 0.0f;
    }
 
    return zpos;
  }
  return 0.0f;
}
 
void SSubEntitySelectorBuffer::CreateTexture(const unsigned int& width, const unsigned int& height)
{
  // Check if size need pow2
  Ogre::RenderSystem* ogreRenderSystem = SRoot::getSingleton().GetOgreRenderSystem();
  const Ogre::RenderSystemCapabilities* caps = ogreRenderSystem->getCapabilities();
 
  //optim test divide the texture size to get a faster frame rate on copyContentsToMemory
  if (caps && (!caps->hasCapability(Ogre::RSC_NON_POWER_OF_2_TEXTURES)
#ifdef APPLE_IOS
      || caps->getNonPOW2TexturesLimited()
#endif
    ))
  {
    mTextureWidth = Ogre::Bitwise::firstPO2From(width / 3) / 2;
    mTextureHeight = Ogre::Bitwise::firstPO2From(height / 3) / 2;
 
    mTextureWidth = std::max(mTextureWidth, mTextureHeight);
    mTextureHeight = mTextureWidth;
  }
  else
  {
#ifdef _WIN32
    mTextureWidth = width; // / 2;
    mTextureHeight = height; // / 2;
#else
    mTextureWidth = (width / 4);
    mTextureHeight = (height / 4);
#endif
  }
 
  mCompensateNPOT = true;
 
  mRealWidth = width;
  mRealHeight = height;
 
  // Generate a texture with an unique name.
  std::string textureName = mBaseResourceName+ "/Texture";
  try
  {
    Ogre::PixelFormat rttpf = Ogre::PF_A8R8G8B8;
    SRoot::getSingleton().GetRttPixelFormat(rttpf, mUseDepth ? true : false);
    mOgreTexture = Ogre::TextureManager::getSingleton().createManual(textureName, SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, Ogre::TEX_TYPE_2D, mTextureWidth, mTextureHeight, 0, rttpf, Ogre::TU_RENDERTARGET);
          mOgreTexture->load();
 
    if (mUseDepth)
    {
      SRoot::getSingleton().GetRttPixelFormat(rttpf, true);
      mOgreDepthTexture = Ogre::TextureManager::getSingleton().createManual(textureName + "/Depth", SO3_INTERNAL_SUBENTITY_SELECTOR_RESOURCE_GROUP, Ogre::TEX_TYPE_2D, mTextureWidth, mTextureHeight, 0, rttpf, Ogre::TU_RENDERTARGET);
      mOgreDepthTexture->load();
    }
  }
  catch (Ogre::Exception &e)
  {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred in SSubEntitySelectorBuffer::CreateTexture : "+ e.getDescription());
          mOgreTexture.reset();
    mOgreDepthTexture.reset();
  }
 
  if (mOgreTexture)
  {
          // Bind to a render texture
          Ogre::HardwarePixelBufferSharedPtr ogrePixelBuffer = mOgreTexture->getBuffer();
          mOgreRenderTexture = ogrePixelBuffer->getRenderTarget();
          mOgreRenderTexture->setAutoUpdated(true);
          mOgreRenderTexture->setPriority(100);
 
#if defined(APPLE_IOS)
    mOgreRenderTexture->setDepthBufferPool(Ogre::DepthBuffer::POOL_NO_DEPTH);
#endif
 
    if (mOgreDepthTexture)
    {
      Ogre::HardwarePixelBufferSharedPtr ogreDepthPixelBuffer = mOgreDepthTexture->getBuffer();
      mOgreRenderDepthTexture = ogreDepthPixelBuffer->getRenderTarget();
      mOgreRenderDepthTexture->setAutoUpdated(false);
      mOgreRenderDepthTexture->setPriority(100);
 
      //also disable auto render on entity texture for mrt
      mOgreRenderTexture->setAutoUpdated(false);
 
#if defined(APPLE_IOS)
      mOgreRenderDepthTexture->setDepthBufferPool(Ogre::DepthBuffer::POOL_NO_DEPTH);
#endif
      mMrtTexture = Ogre::Root::getSingleton().getRenderSystem()->createMultiRenderTarget(textureName + "/MRT");
      if (mMrtTexture)
      {
        mMrtTexture->bindSurface(0, mOgreRenderTexture);
        mMrtTexture->bindSurface(1, mOgreRenderDepthTexture);
        mMrtTexture->setAutoUpdated(true);
      }
    }
 
    // Handle camera switching and multiples viewports on a mWindow.
    const SelectorViewportList viewportListCopy = mSelectorViewportList;
    SelectorViewportList::const_iterator iOgreViewportList = viewportListCopy.begin();
    while(iOgreViewportList != viewportListCopy.end())
    {
      // Get windows viewport infos.
      SViewPort* renderWindowViewport = iOgreViewportList->first;
      SCamera* renderWindowCamera = renderWindowViewport->GetCamera();
      if (renderWindowCamera)
      {
        Ogre::Camera* ogreRenderWindowCamera = renderWindowCamera->GetOgreCameraPointer();
        Ogre::Real ratio = ogreRenderWindowCamera->getAspectRatio();
        Ogre::Viewport* ogreRenderWindowViewport = renderWindowViewport->GetOgreViewPortPointer();
        Ogre::Viewport* ogreRenderTextureViewport = mOgreRenderTexture->addViewport(ogreRenderWindowCamera, ogreRenderWindowViewport->getZOrder(), ogreRenderWindowViewport->getLeft(), ogreRenderWindowViewport->getTop(), ogreRenderWindowViewport->getWidth(), ogreRenderWindowViewport->getHeight());
 
        ogreRenderTextureViewport->setClearEveryFrame(true);
        ogreRenderTextureViewport->setOverlaysEnabled(false);
        ogreRenderTextureViewport->setMaterialScheme(mBaseResourceName);
        ogreRenderTextureViewport->setShadowsEnabled(false);
        ogreRenderTextureViewport->setSkiesEnabled(false);
        ogreRenderTextureViewport->setVisibilityMask(ogreRenderWindowViewport->getVisibilityMask() & ~SO3_VISIBILITY_FLAG_INVISIBLE_ENVIRONMENT &~Ogre::SceneManager::FX_TYPE_MASK &~Ogre::SceneManager::LIGHT_TYPE_MASK); // Hide environment object in this rtt (skyx & hydrax).
 
        Ogre::Viewport* ogreRenderDepthTextureViewport = 0;
        if (mOgreRenderDepthTexture)
        {
          ogreRenderDepthTextureViewport = mOgreRenderDepthTexture->addViewport(ogreRenderWindowCamera, ogreRenderWindowViewport->getZOrder(), ogreRenderWindowViewport->getLeft(), ogreRenderWindowViewport->getTop(), ogreRenderWindowViewport->getWidth(), ogreRenderWindowViewport->getHeight());
          ogreRenderDepthTextureViewport->setClearEveryFrame(true);
          ogreRenderDepthTextureViewport->setOverlaysEnabled(false);
          ogreRenderDepthTextureViewport->setMaterialScheme(mBaseResourceName);
          ogreRenderDepthTextureViewport->setShadowsEnabled(false);
          ogreRenderDepthTextureViewport->setSkiesEnabled(false);
          ogreRenderDepthTextureViewport->setVisibilityMask(ogreRenderWindowViewport->getVisibilityMask() & ~SO3_VISIBILITY_FLAG_INVISIBLE_ENVIRONMENT &~Ogre::SceneManager::FX_TYPE_MASK &~Ogre::SceneManager::LIGHT_TYPE_MASK); // Hide environment object in this rtt (skyx & hydrax).
        }
 
        Ogre::Viewport* ogreRenderMrtViewport = 0;
        if (mMrtTexture)
        {
          ogreRenderMrtViewport = mMrtTexture->addViewport(ogreRenderWindowCamera, ogreRenderWindowViewport->getZOrder(), ogreRenderWindowViewport->getLeft(), ogreRenderWindowViewport->getTop(), ogreRenderWindowViewport->getWidth(), ogreRenderWindowViewport->getHeight());
          ogreRenderMrtViewport->setClearEveryFrame(true);
          ogreRenderMrtViewport->setOverlaysEnabled(false);
          ogreRenderMrtViewport->setMaterialScheme(mBaseResourceName);
          ogreRenderMrtViewport->setShadowsEnabled(false);
          ogreRenderMrtViewport->setSkiesEnabled(false);
          ogreRenderMrtViewport->setVisibilityMask(ogreRenderWindowViewport->getVisibilityMask() & ~SO3_VISIBILITY_FLAG_INVISIBLE_ENVIRONMENT &~Ogre::SceneManager::FX_TYPE_MASK &~Ogre::SceneManager::LIGHT_TYPE_MASK); // Hide environment object in this rtt (skyx & hydrax).
        }
 
        // Restore aspect ratio
        ogreRenderWindowCamera->setAspectRatio(ratio);
 
        // Restore viewport
        ogreRenderWindowCamera->_notifyViewport(ogreRenderWindowViewport);
 
        // Update viewport clearing settings.
        if(renderWindowViewport->GetClearColor() || renderWindowViewport->GetClearDepth())
        {
          int mode = 0;
          if(renderWindowViewport->GetClearDepth() && renderWindowViewport->GetClearColor())
            mode = Ogre::FBT_COLOUR|Ogre::FBT_DEPTH;
          else if (renderWindowViewport->GetClearDepth())
            mode = Ogre::FBT_DEPTH;
          else
            mode = Ogre::FBT_COLOUR;
          ogreRenderTextureViewport->setClearEveryFrame(true, mode);
 
          if (ogreRenderDepthTextureViewport)
            ogreRenderDepthTextureViewport->setClearEveryFrame(true, mode);
 
          if (ogreRenderMrtViewport)
            ogreRenderMrtViewport->setClearEveryFrame(true, mode);
        }
        mSelectorViewportList[renderWindowViewport] = ogreRenderTextureViewport;
      }
 
      iOgreViewportList++;
    }
 
    // Add a frame listener to detect each new frame (one selection buffer render per frame max).
    if (!mMrtTexture)
      mOgreRenderTexture->addListener(this);
    else
      mMrtTexture->addListener(this);
 
#if SO3_SUBENTITY_SELECTOR_DEBUG_OVERLAY
    CreateDebugOverlay();
#endif
  }
}
 
void SSubEntitySelectorBuffer::DeleteTexture()
{
  if(mOgreRenderTexture)
  {
#if SO3_SUBENTITY_SELECTOR_DEBUG_OVERLAY
    DeleteDebugOverlay();
#endif
 
    if (!mMrtTexture)
      mOgreRenderTexture->removeListener(this);
    mOgreRenderTexture->removeAllViewports();
 
    mOgreRenderTexture = 0;
  }
 
  if (mOgreRenderDepthTexture)
  {
    mOgreRenderDepthTexture->removeAllViewports();
    mOgreRenderDepthTexture = 0;
  }
 
 
  if (mMrtTexture)
  {
    mMrtTexture->removeListener(this);
    mMrtTexture->removeAllViewports();
    Ogre::Root::getSingleton().getRenderSystem()->destroyRenderTarget(mBaseResourceName + "/Texture/MRT");
    mMrtTexture = 0;
  }
 
  if (mOgreTexture)
  {
    Ogre::TextureManager::getSingleton().remove(mOgreTexture->getHandle());
    mOgreTexture.reset();
  }
 
  if (mOgreDepthTexture)
  {
    Ogre::TextureManager::getSingleton().remove(mOgreDepthTexture->getHandle());
    mOgreDepthTexture.reset();
  }
}
 
void SSubEntitySelectorBuffer::CreateDebugOverlay()
{
  if (!mOgreDebugOverlay)
  {
    std::string ogreOverlayMaterialName = mBaseResourceName+ "/Material/DebugOverlay";
    mOgreOverlayMaterial = Ogre::MaterialManager::getSingleton().create(ogreOverlayMaterialName, mBaseResourceName);
    mOgreOverlayMaterial->getTechnique(0)->getPass(0)->createTextureUnitState()->setTexture(mOgreTexture); //mOgrePickerTexture
    mOgreOverlayMaterial->getTechnique(0)->setLightingEnabled(false);
 
    Ogre::OverlayManager* overlayManager = Ogre::OverlayManager::getSingletonPtr();
    mOgreDebugOverlay = overlayManager->create(mBaseResourceName+ "/Overlay/DebugOverlay");
    mOgreDebugOverlayPanel = static_cast<Ogre::OverlayContainer*> (overlayManager->createOverlayElement("Panel", mBaseResourceName+ "/Overlay/DebugOverlayPanel"));
    mOgreDebugOverlayPanel->setPosition(0.5f, 0.5f);
    mOgreDebugOverlayPanel->setDimensions(0.5f, 0.5f);
    mOgreDebugOverlayPanel->setMaterialName(ogreOverlayMaterialName);
    mOgreDebugOverlay->add2D(mOgreDebugOverlayPanel);
    mOgreDebugOverlay->show();
  }
}
 
void SSubEntitySelectorBuffer::DeleteDebugOverlay()
{
  if (mOgreDebugOverlay)
  {
    // Delete overlay elements.
    Ogre::OverlayManager* overlayManager = Ogre::OverlayManager::getSingletonPtr();
    mOgreDebugOverlay->remove2D(mOgreDebugOverlayPanel);
    overlayManager->destroyOverlayElement(mOgreDebugOverlayPanel);
    mOgreDebugOverlayPanel = 0;
    overlayManager->destroy(mOgreDebugOverlay);
    mOgreDebugOverlay = 0;
 
    // Delete material.
    //const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
    //if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
      Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(mOgreOverlayMaterial->getName(), mOgreOverlayMaterial->getGroup());
 
    Ogre::MaterialManager::getSingleton().remove(mOgreOverlayMaterial->getHandle());
    mOgreOverlayMaterial.reset();
  }
}
 
void SSubEntitySelectorBuffer::Update()
{
  /*unsigned int newWidth = mOgreRenderWindow->getWidth();
  unsigned int newHeight = mOgreRenderWindow->getHeight();
  // Update only once per frame (in case we call GetSelectedEntity multiple times in the same frame).
  // Or if the buffer size changed
  if(needUpdate || forceUpdate || ((newWidth != mRealWidth)||(newHeight != mRealHeight)) || (!mOgreRenderTexture))
  {
    // Check if mWindow size has changed. Re-generate render texture if needed.
    // forceUpdate recreate the texture
    UpdateBufferSize();
 
    // Update render texture
    if (mOgreRenderTexture)
    {
      try
      {
        mOgreRenderTexture->update();
 
        //create the DebugSelector directory to use
        //mOgreRenderTexture->writeContentsToTimestampedFile("./DebugSelector/", ".bmp");
      }
      catch(Ogre::Exception)
      {
      }
    }
  }*/
}
 
void SSubEntitySelectorBuffer::UpdateBufferSize(const bool& forceRefresh)
{
  unsigned int newWidth = mOgreRenderWindow->getWidth();
  unsigned int newHeight = mOgreRenderWindow->getHeight();
 
  if ((newWidth != mRealWidth)
    ||(newHeight != mRealHeight)
    ||forceRefresh
    ||(!mOgreRenderTexture))
  {
    DeleteTexture();
    try
    {
      CreateTexture(newWidth, newHeight);
    }
    catch(Ogre::Exception &)
    {
      // could not create the texture, renderer not ready ?
    }
  }
}
 
void SSubEntitySelectorBuffer::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
{
  if (nodeSelectorMaterialSwitcher)
  {
    if (evt.source == mOgreRenderTexture || evt.source == mMrtTexture)
    {
      // Reset switcher
      nodeSelectorMaterialSwitcher->ResetSwitcher();
 
      //Get a list of non polygon solid camera
      SelectorViewportList::iterator iOgreViewportList = mSelectorViewportList.begin();
      while(iOgreViewportList != mSelectorViewportList.end())
      {
        SViewPort* viewport = iOgreViewportList->first;
        SCamera* camera = viewport->GetCamera();
        if(camera)
        {
          // Store camera that renders non-solid objects
          Ogre::Camera* ogreWindowCamera = camera->GetOgreCameraPointer();
          if (ogreWindowCamera->getPolygonMode() != Ogre::PM_SOLID)
          {
            mWireCameraList[ogreWindowCamera] = ogreWindowCamera->getPolygonMode();
            ogreWindowCamera->setPolygonMode(Ogre::PM_SOLID);
          }
 
          // Force viewport to Rtt viewport
          ogreWindowCamera->_notifyViewport(iOgreViewportList->second);
        }
 
        iOgreViewportList++;
      }
    }
 
    Ogre::MaterialManager::getSingleton().addListener(nodeSelectorMaterialSwitcher, mBaseResourceName);
  }
}
 
void SSubEntitySelectorBuffer::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
{
  if (((evt.source == mOgreRenderTexture) && mOgreRenderTexture->isActive()) || ((evt.source == mMrtTexture) && mMrtTexture->isActive()))
  {
    // Restore viewport to render mWindow's viewport (otherwise, the Ogre::Camera class member named mLastViewport is not coherent!).
    SelectorViewportList::iterator iOgreViewportList = mSelectorViewportList.begin();
    while(iOgreViewportList != mSelectorViewportList.end())
    {
      if (iOgreViewportList->second && iOgreViewportList->second->getCamera())
        iOgreViewportList->second->getCamera()->_notifyViewport(iOgreViewportList->first->GetOgreViewPortPointer());
      iOgreViewportList++;
    }
 
    // Restore list of non solid polygon camera
    WireCameraList::iterator iWireCameraList = mWireCameraList.begin();
    while(iWireCameraList != mWireCameraList.end())
    {
      iWireCameraList->first->setPolygonMode(iWireCameraList->second);
      iWireCameraList++;
    }
    mWireCameraList.clear();
 
    if (nodeSelectorMaterialSwitcher)
      nodeSelectorMaterialSwitcher->ResetPriorizedObject();
  }
 
  if (nodeSelectorMaterialSwitcher)
    Ogre::MaterialManager::getSingleton().removeListener(nodeSelectorMaterialSwitcher, mBaseResourceName);
}
 
}