SO3DynamicCubeMap.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3DynamicCubeMap.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Pass.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3Window.h"
 
#include <OgreDepthBuffer.h>
 
namespace SO3
{
 
  SDynamicCubeMap::SDynamicCubeMap() : SNode(0, "", SNode::DYNAMIC_CUBE_MAP_ID)
  {
    // Forbiden (private)
  }
 
  SDynamicCubeMap::SDynamicCubeMap(SScene* parent, const std::string& dynamicCubeMapName) : SNode(parent, dynamicCubeMapName, SNode::DYNAMIC_CUBE_MAP_ID)
  {
    // Store the scheme that we will use to hide objects we dont want on the cubeMap.
    cubeMapScheme = dynamicCubeMapName + "_SO3_DynamicCubeMap_Scheme";
    material.reset();
    size = 256;
    state = false;
    autoUpdate = false;
    needUpdate = false;
    needTextureUpdate = false;
    renderingEnable = false;
    techIndex = 0;
    passIndex = 0;
    unitIndex = 0;
 
    // create the camera used to render to our cubemap
    cubeMapCamera = currentScene->GetOgreScenePointer()->createCamera("camera_" + cubeMapScheme);
    camNode = currentScene->GetOgreScenePointer()->createSceneNode();
    camNode->attachObject(cubeMapCamera);
    O3SceneNode->addChild(camNode);
 
    cubeMapCamera->setFOVy(Ogre::Degree(90));
    cubeMapCamera->setAspectRatio(1);
    cubeMapCamera->setNearClipDistance(Ogre::Real(0.001));
 
    // create our dynamic cube map texture
    _CreateCubeMapTexture(size);
 
    // Create a new transparent material and set a transparent technique
    materialTransparent = Ogre::MaterialManager::getSingleton().create("SO3_Material_" + cubeMapScheme, SO3_INTERNAL_DYNAMIC_RESOURCE_GROUP);
    materialTransparent->getTechnique(0)->setColourWriteEnabled(false);
    materialTransparent->getTechnique(0)->setDepthCheckEnabled(false);
    materialTransparent->getTechnique(0)->setDepthWriteEnabled(false);
    materialTransparent->getTechnique(0)->getPass(0)->setName("SO3/TRANSPARENT/CUBEMAP");
    materialTransparent->getTechnique(0)->getPass(0)->setVertexProgram("SO3/Internal/Default_nolight_vp");
    materialTransparent->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/Internal/Default_fp");
    materialTransparent->load();
 
    // Add frame listener
    Ogre::Root::getSingleton().addFrameListener(this);
  }
 
  SDynamicCubeMap::~SDynamicCubeMap()
  {
    SetEnable(false);
    // 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 cubeMap texture.
    _DeleteCubeMapTexture();
 
    //update generated materials
    SRoot::getSingletonPtr()->RemoveGeneratedMaterial(materialTransparent.get());
 
    Ogre::MaterialManager::getSingleton().remove(materialTransparent->getHandle());
    materialTransparent.reset();
 
    // Destroy the camera
    currentScene->GetOgreScenePointer()->destroyCamera(cubeMapCamera);
    currentScene->GetOgreScenePointer()->destroySceneNode(camNode);
  }
 
  void SDynamicCubeMap::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);
 
        _CreateCubeMapTexture(newSize);
        size = newSize;
        SetEnable(savedState);
      }
      else
      {
        OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cube map texture size must be a power of 2 number!", "SDynamicCubeMap::SetSize");
      }
    }
  }
 
  unsigned int SDynamicCubeMap::GetSize()
  {
    return size;
  }
 
  void SDynamicCubeMap::SetMaterial(SMaterial* targetMaterial, const int& targetTechnique, const int& targetPass, const int& targetTextureUnit)
  {
    if (targetMaterial != 0)
    {
      bool savedState = state;
      SetEnable(false);
      material = targetMaterial->getOgreMaterialPointer();
      techIndex = targetTechnique;
      passIndex = targetPass;
      unitIndex = targetTextureUnit;
      SetEnable(savedState);
    }
  }
 
  void SDynamicCubeMap::SetTextureUnit()
  {
    if (!material)
      return;
 
    Ogre::Material::Techniques suptechs = material->getSupportedTechniques();
    Ogre::Material::Techniques techs = material->getTechniques();
 
    if (techIndex >= techs.size() || (suptechs.size() == 0))
      return;
 
    Ogre::Technique::Passes matPasses;
    Ogre::Pass* tmpPass = 0;
    const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
    if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
    {
      matPasses = suptechs[0]->getPasses();
      if (passIndex >= matPasses.size())
        return;
 
      tmpPass = matPasses[passIndex];
    }
    else
    {
      matPasses = techs[techIndex]->getPasses();
      if (techIndex >= matPasses.size())
        return;
 
      tmpPass = matPasses[techIndex];
    }
 
    // Check if the targetTextureUnit is inbound
    Ogre::TextureUnitState* texState = 0;
    Ogre::Pass::TextureUnitStates texs = tmpPass->getTextureUnitStates();
    if ((texs.size() > 0) && (unitIndex < texs.size()))
      texState = texs[unitIndex];
 
    if (texState != 0)
    {
      oldTexture = texState->_getTexturePtr();
      texState->setTexture(cubeMapTexture);
      
      Ogre::Any bindedSPass = tmpPass->getUserObjectBindings().getUserAny("SPass");
      if (bindedSPass.has_value())
      {
        SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
        pass->BuildShader();
      }
      SRoot::getSingletonPtr()->RemoveGeneratedMaterial(material.get());
    }
  }
 
  void SDynamicCubeMap::ResetTextureUnit()
  {
    if (!material)
      return;
 
    Ogre::Material::Techniques suptechs = material->getSupportedTechniques();
    Ogre::Material::Techniques techs = material->getTechniques();
 
    if (techIndex >= techs.size() || (suptechs.size() == 0))
      return;
 
    Ogre::Technique::Passes matPasses;
    Ogre::Pass* tmpPass = 0;
    const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
    if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
    {
      matPasses = suptechs[0]->getPasses();
      if (passIndex >= matPasses.size())
        return;
 
      tmpPass = matPasses[passIndex];
    }
    else
    {
      matPasses = techs[techIndex]->getPasses();
      if (techIndex >= matPasses.size())
        return;
 
      tmpPass = matPasses[techIndex];
    }
 
    // Check if the targetTextureUnit is inbound
    Ogre::TextureUnitState* texState = 0;
    Ogre::Pass::TextureUnitStates texs = tmpPass->getTextureUnitStates();
    if ((texs.size() > 0) && (unitIndex < texs.size()))
      texState = texs[unitIndex];
 
    if (texState != 0)
    {
      if (!oldTexture)
        texState->setBlank();
      else
        texState->setTexture(oldTexture);
 
      Ogre::Any bindedSPass = tmpPass->getUserObjectBindings().getUserAny("SPass");
      if (bindedSPass.has_value())
      {
        SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
        pass->BuildShader();
      }
 
      SRoot::getSingletonPtr()->RemoveGeneratedMaterial(material.get());
    }
    oldTexture.reset();
  }
 
  void SDynamicCubeMap::SetEnable(const bool& newState)
  {
    if (cubeMapTexture)
    {
      if (!material)
        return;
 
      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 SDynamicCubeMap::GetEnable()
  {
    return state;
  }
 
  void SDynamicCubeMap::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 SDynamicCubeMap::GetAutoUpdate()
  {
    return autoUpdate;
  }
 
  void SDynamicCubeMap::Update()
  {
    needUpdate = true;
  }
 
  void SDynamicCubeMap::EnableRendering()
  {
    if (!renderingEnable && cubeMapTexture)
    {
      for (unsigned int i = 0; i < 6; i++)
      {
        if (cubeMapTargets[i])
        {
          cubeMapTargets[i]->setAutoUpdated(true);
          cubeMapTargets[i]->addListener(this);
        }
      }
 
      Ogre::MaterialManager::getSingleton().addListener(this);
      renderingEnable = true;
    }
  }
 
  void SDynamicCubeMap::DisableRendering()
  {
    if (renderingEnable && cubeMapTexture)
    {
      for (unsigned int i = 0; i < 6; i++)
      {
        if (cubeMapTargets[i])
        {
          cubeMapTargets[i]->setAutoUpdated(false);
          cubeMapTargets[i]->removeListener(this);
        }
      }
 
      Ogre::MaterialManager::getSingleton().removeListener(this);
      renderingEnable = false;
    }
  }
 
  void SDynamicCubeMap::_CreateCubeMapTexture(const unsigned int& newSize)
  {
    _DeleteCubeMapTexture();
    try
    {
      Ogre::PixelFormat rttformat;
      SRoot::getSingleton().GetRttPixelFormat(rttformat);
      cubeMapTexture = Ogre::TextureManager::getSingleton().createManual("texture_" + cubeMapScheme, SO3_INTERNAL_DYNAMIC_READABLE_RESOURCE_GROUP, Ogre::TEX_TYPE_CUBE_MAP, newSize, newSize, 0, rttformat, Ogre::TU_RENDERTARGET);
 
      for (unsigned int i = 0; i < 6; i++)
      {
        cubeMapTargets[i] = cubeMapTexture->getBuffer(i)->getRenderTarget();
        cubeMapTargets[i]->removeAllViewports();
 
        //$BB when cubemap is created disabled and never enabled the auto update keep on true and take a lots of fps for nothing
        cubeMapTargets[i]->setAutoUpdated(false);
#if defined (RPI)
        cubeMapTargets[i]->setDepthBufferPool(Ogre::DepthBuffer::POOL_NO_DEPTH);
#endif
 
        Ogre::Viewport* viewport = cubeMapTargets[i]->addViewport(cubeMapCamera);
        viewport->setOverlaysEnabled(false);
        viewport->setMaterialScheme(cubeMapScheme);
      }
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
      cubeMapTexture.reset();
    }
  }
 
  void SDynamicCubeMap::_DeleteCubeMapTexture()
  {
    if (cubeMapTexture)
    {
      // IMPORTANT! Do not forget to detach the target, otherwise, the texture will not be deleted cause TexturePtr ref count still will be > 1
      for (unsigned int i = 0; i < 6; i++)
      {
        cubeMapTargets[i]->removeAllViewports();
        Ogre::Root::getSingleton().detachRenderTarget(cubeMapTargets[i]);
        cubeMapTargets[i] = 0;
      }
 
      Ogre::TextureManager::getSingleton().remove(cubeMapTexture->getHandle());
      cubeMapTexture.reset();
    }
  }
 
  void SDynamicCubeMap::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
    // point the camera in the right direction based on which face of the cubemap this is
    camNode->setOrientation((camNode->getParentSceneNode()->_getDerivedOrientation().Inverse() * Ogre::Quaternion::IDENTITY));
    if (evt.source == cubeMapTargets[0])
      camNode->yaw(Ogre::Degree(-90));
    else if (evt.source == cubeMapTargets[1])
      camNode->yaw(Ogre::Degree(90));
    else if (evt.source == cubeMapTargets[2])
      camNode->pitch(Ogre::Degree(90));
    else if (evt.source == cubeMapTargets[3])
      camNode->pitch(Ogre::Degree(-90));
    else if (evt.source == cubeMapTargets[5])
      camNode->yaw(Ogre::Degree(180));
  }
 
  void SDynamicCubeMap::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
  }
 
  Ogre::Technique* SDynamicCubeMap::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
  {
    Ogre::Material::Techniques suptechs = materialTransparent->getTechniques();
    if ((cubeMapScheme == schemeName) && (originalMaterial == material.get()) && (suptechs.size() > 0))
    {
      // Set a transparent technique
      return suptechs[0];
    }
 
    return 0;
  }
 
  bool SDynamicCubeMap::frameStarted(const Ogre::FrameEvent& evt)
  {
    if (state && needUpdate)
    {
      if (needTextureUpdate)
      {
        _CreateCubeMapTexture(size);
        needTextureUpdate = false;
      }
 
      EnableRendering();
    }
 
    return true;
  }
 
  bool SDynamicCubeMap::frameEnded(const Ogre::FrameEvent& evt)
  {
    if (state && needUpdate)
    {
      DisableRendering();
      needUpdate = false;
    }
    return true;
  }
 
  void SDynamicCubeMap::windowResized(Ogre::RenderWindow* rw)
  {
    Update();
  }
 
}