SO3RenderToTexture.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3RenderToTexture.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Compositor.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3Window.h"
 
#include <OgreDepthBuffer.h>
 
namespace SO3
{
 
SRenderToTexture::SRenderToTexture() : SNode(0, "", SNode::RENDER_TO_TEXTURE_ID)
{
  // Forbiden (private)
}
 
SRenderToTexture::SRenderToTexture(SScene* parent, const std::string& rttName, SCamera* povCamera) : SNode(parent, rttName, SNode::RENDER_TO_TEXTURE_ID)
{
  //if(!SRoot::getSingleton().GetOgreRenderSystem()->getCapabilities()->hasCapability(Ogre::RSC_???))
        //  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Your graphics card does not support render to texture, so you cannot use this functionnality!", "SRenderToTexture::SRenderToTexture");
 
  // Store the scheme that we will use to hide objects we dont want on the rtt.
  material.reset();
  textureUnitState = 0;
  size = 256;
  state = false;
  autoUpdate = false;
  needUpdate = false;
  needTextureUpdate = false;
  renderingEnable = false;
  cameraOriginalRatio = 1.0f;
  materialScheme = Ogre::MSN_SHADERGEN;
 
        // create the camera used to render to our rtt
  rttCamera = povCamera->GetOgreCameraPointer();
 
        // create our dynamic texture
  _CreateRenderTexture(size);
 
  // Add frame listener
  Ogre::Root::getSingleton().addFrameListener(this);
}
 
SRenderToTexture::~SRenderToTexture()
{
  SetEnable(false);
 
  // Clear all the compositors
  ClearCompositors();
 
  // disable first
  DisableRendering();
 
  // remove frame listener for update on window events if autoUpdate is disable
  if(!autoUpdate)
  {
    // Remove frame listener
    Ogre::Root::getSingleton().removeFrameListener(this);
  }
 
  // Delete the rtt texture.
  _DeleteRenderTexture();
}
 
void SRenderToTexture::SetSize(const unsigned int& newSize)
{
  if (size != newSize)
  {
    // is new size valid (2^n)?
    double result = log((double)newSize)/log((double)2.0);
    double fractpart, intpart;
    fractpart = modf(result, &intpart);
    if (fractpart==0)
    {
      bool savedState = state;
 
      // Remove the render target listeners.
            SetEnable(false);
 
      _CreateRenderTexture(newSize);
      size = newSize;
      SetEnable(savedState);
    }
    else
    {
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Render to texture size must be a power of 2 number!", "SRenderToTexture::SetSize");
    }
  }
}
 
unsigned int SRenderToTexture::GetSize()
{
  return size;
}
 
void SRenderToTexture::SetMaterial(SMaterial* targetMaterial, const int& targetTechnique, const int& targetPass, const int& targetTextureUnit)
{
  if (targetMaterial != 0)
  {
    Ogre::MaterialPtr tmpMaterial = targetMaterial->getOgreMaterialPointer();
    //update generated materials
    SRoot::getSingletonPtr()->RemoveGeneratedMaterial(tmpMaterial.get());
 
    Ogre::Pass* tmpPass = tmpMaterial->getTechnique(targetTechnique)->getPass(targetPass);
 
    bool savedState = state;
    SetEnable(false);
    material = tmpMaterial;
 
    // Check if the targetTextureUnit is inbound
    int numTextureUnits = tmpPass->getNumTextureUnitStates();
 
    if ((numTextureUnits>0) && (targetTextureUnit<numTextureUnits))
    {
      Ogre::TextureUnitState* tmpTextureUnitState = tmpPass->getTextureUnitState(targetTextureUnit);
      if((tmpTextureUnitState != 0) && ((textureUnitState == 0) || (textureUnitState != tmpTextureUnitState)))
      {
        textureUnitState = tmpTextureUnitState;
      }
    }
    else
    {
      textureUnitState = 0;
    }
    SetEnable(savedState);
  }
}
 
void SRenderToTexture::SetMaterialScheme(std::string scheme)
{
  if (scheme.empty() || (scheme == "Default") || (scheme == "DefaultScheme"))
    materialScheme = Ogre::MSN_SHADERGEN;
  else
    materialScheme = scheme;
 
  if (rttTarget != 0)
    rttTarget->getViewport(0)->setMaterialScheme(materialScheme);
}
 
void SRenderToTexture::SetTextureUnit()
{
  if (textureUnitState != 0)
  {
    oldTexture = textureUnitState->_getTexturePtr();
    textureUnitState->setTextureName(name + "_texture");
 
    if (material)
      SRoot::getSingletonPtr()->RemoveGeneratedMaterial(material.get());
  }
}
 
void SRenderToTexture::ResetTextureUnit()
{
  if (textureUnitState != 0)
  {
    try
    {
      if (!oldTexture)
        textureUnitState->setBlank();
      else
        textureUnitState->setTexture(oldTexture);
    }
    catch(Ogre::Exception&)
    {
      //not found
    }
 
    if (material)
      SRoot::getSingletonPtr()->RemoveGeneratedMaterial(material.get());
  }
  oldTexture.reset();
}
 
void SRenderToTexture::SetEnable(const bool& newState)
{
  if (rttTexture)
  {
    DisableRendering();
    if ((newState == true) && (state == false))
    {
      state = true;
      SetTextureUnit();
      needUpdate = true;
 
      if(autoUpdate)
        EnableRendering();
    }
    else if ((newState == false) && (state == true))
    {
      state = false;
      needUpdate = false;
      ResetTextureUnit();
    }
  }
}
 
bool SRenderToTexture::GetEnable()
{
  return state;
}
 
void SRenderToTexture::SetAutoUpdate(const bool& newAutoUpdateValue)
{
  if ((newAutoUpdateValue == true) && (autoUpdate == false))
  {
    // Remove frame listener
    Ogre::Root::getSingleton().removeFrameListener(this);
 
    autoUpdate = true;
    renderingEnable = false;
    EnableRendering();
  }
  else if ((newAutoUpdateValue == false) && (autoUpdate == true))
  {
    autoUpdate = false;
    DisableRendering();
 
    // Add frame listener
    Ogre::Root::getSingleton().addFrameListener(this);
  }
}
 
bool SRenderToTexture::GetAutoUpdate()
{
  return autoUpdate;
}
 
void SRenderToTexture::Update()
{
  needUpdate = true;
}
 
void SRenderToTexture::EnableRendering()
{
  if(!renderingEnable)
  {
    rttTarget->setAutoUpdated(true);
    renderingEnable = true;
  }
}
 
void SRenderToTexture::DisableRendering()
{
  if(renderingEnable)
  {
    rttTarget->setAutoUpdated(false);
    renderingEnable = false;
  }
}
 
void SRenderToTexture::_CreateRenderTexture(const unsigned int& newSize)
{
  _DeleteRenderTexture();
  try
  {
    Ogre::PixelFormat rttformat;
    SRoot::getSingleton().GetRttPixelFormat(rttformat);
    // Create a new texture and setup it as a render target.
    rttTexture = Ogre::TextureManager::getSingleton().createManual(name + "_texture", SO3_INTERNAL_DYNAMIC_READABLE_RESOURCE_GROUP, Ogre::TEX_TYPE_2D, newSize, newSize, 0, rttformat, Ogre::TU_RENDERTARGET, this);
          rttTarget = rttTexture->getBuffer(0)->getRenderTarget();
    rttTarget->setAutoUpdated(false);
    rttTarget->addListener(this);
#if defined (RPI)
      rttTarget->setDepthBufferPool(Ogre::DepthBuffer::POOL_NO_DEPTH);
#endif
    
    // addViewport function modify the camera ratio, so store it and reapply it once this function is finished.
    cameraOriginalRatio = rttCamera->getAspectRatio();
    Ogre::Viewport* viewport = rttTarget->addViewport(rttCamera);
    rttCamera->setAspectRatio(cameraOriginalRatio);
 
    viewport->setMaterialScheme(materialScheme);
 
    UpdateCompositorViewport(viewport);
 
    // Disable overlays rendering on rtt
    viewport->setOverlaysEnabled(false);
  }
  catch (Ogre::Exception &e)
  {
          Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
          rttTexture.reset();
  }
}
 
void SRenderToTexture::_DeleteRenderTexture()
{
  if (rttTexture)
  {
    // IMPORTANT! Do not forget to detach the target, otherwise, the texture will not be deleted cause TexturePtr ref count still will be > 1
    rttTarget->removeListener(this);
    rttTarget->removeAllViewports();
    Ogre::Root::getSingleton().detachRenderTarget(rttTarget);
    rttTarget = 0;
 
    Ogre::TextureManager::getSingleton().remove(rttTexture->getHandle());
    rttTexture.reset();
  }
}
 
bool SRenderToTexture::frameStarted(const Ogre::FrameEvent& evt)
{
  if(state && needUpdate)
  {
    if (needTextureUpdate)
    {
      _CreateRenderTexture(size);
      needTextureUpdate = false;
    }
    EnableRendering();
  }
 
  return true;
}
 
bool SRenderToTexture::frameEnded(const Ogre::FrameEvent& evt)
{
  if (state && needUpdate)
  {
    DisableRendering();
    needUpdate = false;
  }
  return true;
}
 
void SRenderToTexture::loadResource(Ogre::Resource* resource)
{
  //needTextureUpdate = true;
  /*Ogre::Texture* tex = static_cast<Ogre::Texture*>(resource);
        tex->setTextureType(Ogre::TEX_TYPE_CUBE_MAP);
        tex->setWidth(size);
        tex->setHeight(size);
        tex->setFormat(Ogre::PF_R8G8B8);
        tex->setUsage(Ogre::TU_RENDERTARGET|Ogre::TU_AUTOMIPMAP);
        tex->createInternalResources();*/
}
 
void SRenderToTexture::windowResized(Ogre::RenderWindow* rw)
{
  Update();
}
 
void SRenderToTexture::preViewportUpdate(const Ogre::RenderTargetViewportEvent& evt)
{
  if(evt.source != 0)
  {
    Ogre::Camera* targetCamera = evt.source->getCamera();
    if(targetCamera != 0)
    {
      // Store old ratio
      cameraOriginalRatio = targetCamera->getAspectRatio();
 
      // Target texture is squared, so ratio is 1.
      targetCamera->setAspectRatio(1.0f);
    }
  }
}
 
void SRenderToTexture::postViewportUpdate(const Ogre::RenderTargetViewportEvent& evt)
{
  if(evt.source != 0)
  {
    Ogre::Camera* targetCamera = evt.source->getCamera();
    if(targetCamera != 0)
    {
      // Reset old ratio
      targetCamera->setAspectRatio(cameraOriginalRatio);
    }
  }
}
 
SCompositor* SRenderToTexture::GetCompositor(const std::string& compositorName)
{
  SCompositorMap::iterator iCompositorSearched = compList.find(compositorName);
  if (iCompositorSearched != compList.end())
    return iCompositorSearched->second;
  else
    return 0;
}
 
const SCompositorMap& SRenderToTexture::GetCompositorList() const
{
  return compList;
}
 
SCompositor* SRenderToTexture::CreateCompositor(const std::string& newCompositorName, const std::string& newSchemeName)
{
  SCompositor* newCompositor = GetCompositor(newCompositorName);
  if (newCompositor == 0)
  {
    newCompositor = new SCompositor(newCompositorName, newSchemeName);
    if (rttTarget != 0)
      newCompositor->SetViewport(rttTarget->getViewport(0));
 
    AddCompositor(newCompositor);
  }
  return newCompositor;
}
 
void SRenderToTexture::DeleteCompositor(const std::string& existingCompositorName)
{
  DeleteCompositor(GetCompositor(existingCompositorName));
}
 
void SRenderToTexture::DeleteCompositor(SCompositor* existingCompositor)
{
  RemoveCompositor(existingCompositor);
  SO3_SAFE_DELETE(existingCompositor);
}
 
void SRenderToTexture::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 SRenderToTexture::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!", "SRenderToTexture::AddCompositor");
  }
}
 
void SRenderToTexture::RemoveCompositor(SCompositor* existingCompositor)
{
  RemoveCompositor(existingCompositor->GetName());
}
 
void SRenderToTexture::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!", "SRenderToTexture::RemoveCompositor");
  }
}
 
void SRenderToTexture::UpdateCompositorViewport(Ogre::Viewport* vp)
{
  SCompositorMap::iterator iCompositorList = compList.begin();
  while (iCompositorList != compList.end())
  {
    iCompositorList->second->SetViewport(vp);
    iCompositorList++;
  }
}
 
}