SO3DynamicReflectionMap.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3DynamicReflectionMap.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Pass.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3Renderer/SO3ViewPort.h"
 
#include <OgreDepthBuffer.h>
 
namespace SO3
{
 
  SDynamicReflectionMap::SDynamicReflectionMap() : SNode(0, "", SNode::DYNAMIC_REFLECTION_MAP_ID)
  {
    // Forbiden (private)
  }
 
  SDynamicReflectionMap::SDynamicReflectionMap(SScene* parent, SViewPort* viewport, const std::string& dynamicReflectionMapName) : SNode(parent, dynamicReflectionMapName, SNode::DYNAMIC_REFLECTION_MAP_ID)
  {
    // Store the scheme that we will use to hide objects we dont want on the reflectionMap.
    reflectionMapScheme = dynamicReflectionMapName + "_SO3_DynamicReflectionMap_Scheme";
    material.reset();
    size = 256;
    revertClipPlane = false;
    needTextureUpdate = false;
    state = false;
    renderingEnable = false;
    flipClipPlane = false;
    techIndex = 0;
    passIndex = 0;
    unitIndex = 0;
 
    reflectionMapTargets = 0;
    reflectionMapViewport = viewport;
 
    // create reflection plane
    reflectionMapPlane = new Ogre::MovablePlane("reflectionPlane" + reflectionMapScheme);
    reflectionMapPlane->redefine(Ogre::Vector3::UNIT_Y, Ogre::Vector3::ZERO);
    O3SceneNode->attachObject(reflectionMapPlane);
    reflectionMapPlane->setVisible(false);
    reflectionMapPlane->normal = Ogre::Vector3::UNIT_Y;
 
    // create clip plane
    cameraClipPlane = new Ogre::MovablePlane("CameraClipPlane" + reflectionMapScheme);
    cameraClipPlane->redefine(Ogre::Vector3::UNIT_Y, Ogre::Vector3::ZERO);
    O3SceneNode->attachObject(cameraClipPlane);
    cameraClipPlane->normal = Ogre::Vector3::UNIT_Y;
    cameraClipPlane->setVisible(false);
 
    // create the camera used to render to our cubemap
    reflectionMapCamera = currentScene->GetOgreScenePointer()->createCamera("camera_" + reflectionMapScheme);
    camNode = currentScene->GetOgreScenePointer()->createSceneNode();
    camNode->attachObject(reflectionMapCamera);
    O3SceneNode->addChild(camNode);
 
    reflectionMapCamera->setFOVy(Ogre::Degree(45));
    reflectionMapCamera->setAspectRatio(1);
    reflectionMapCamera->setNearClipDistance(Ogre::Real(0.001));
 
    // enable reflection plane
    reflectionMapCamera->enableReflection(reflectionMapPlane);
 
    // cut the geometry under the reflection plan
    reflectionMapCamera->enableCustomNearClipPlane(cameraClipPlane);
 
    // create our dynamic reflection map texture
    _CreateReflectionMapTexture(size);
 
    // Create a new transparent material and set a transparent technique
    materialTransparent = Ogre::MaterialManager::getSingleton().create("SO3_Material_" + reflectionMapScheme, 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/REFMAP");
    materialTransparent->getTechnique(0)->getPass(0)->setVertexProgram("SO3/Internal/Default_nolight_vp");
    materialTransparent->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/Internal/Default_fp");
    materialTransparent->load();
  }
 
  SDynamicReflectionMap::~SDynamicReflectionMap()
  {
    // disable first
    SetEnable(false);
 
    // Delete the reflectionMap texture.
    _DeleteReflectionMapTexture();
 
    // Delete the transparent material
    //update generated materials
    SRoot::getSingletonPtr()->RemoveGeneratedMaterial(materialTransparent.get());
 
    Ogre::MaterialManager::getSingleton().remove(materialTransparent->getHandle());
    materialTransparent.reset();
    reflectionMapCamera->disableCustomNearClipPlane();
    reflectionMapCamera->disableReflection();
 
    currentScene->GetOgreScenePointer()->destroyCamera(reflectionMapCamera);
    currentScene->GetOgreScenePointer()->destroySceneNode(camNode);
 
    O3SceneNode->detachObject(reflectionMapPlane);
    SO3_SAFE_DELETE(reflectionMapPlane);
 
    O3SceneNode->detachObject(cameraClipPlane);
    SO3_SAFE_DELETE(cameraClipPlane);
  }
 
  void SDynamicReflectionMap::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);
 
        _CreateReflectionMapTexture(newSize);
        size = newSize;
 
        SetEnable(savedState);
      }
      else
      {
        OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Reflection map texture size must be a power of 2 number!", "SDynamicReflectionMap::SetSize");
      }
    }
  }
 
  unsigned int SDynamicReflectionMap::GetSize()
  {
    return size;
  }
 
  void SDynamicReflectionMap::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;
 
      if (!material)
        return;
 
      SetEnable(savedState);
    }
  }
 
  void SDynamicReflectionMap::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();
      oldTextureType = texState->getTextureType();
      oldAdressingMode = texState->getTextureAddressingMode();
 
      Ogre::TextureUnitState::EffectMap effects = texState->getEffects();
      Ogre::TextureUnitState::EffectMap::iterator ei = effects.find(Ogre::TextureUnitState::ET_ENVIRONMENT_MAP);
      oldTextureEnvState = ei != effects.end();
 
      if (oldTextureEnvState)
        oldTextureEnvType = (Ogre::TextureUnitState::EnvMapType)ei->second.subtype;
 
      texState->setTexture(reflectionMapTexture);
      texState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
      texState->setEnvironmentMap(false);
      texState->setProjectiveTexturing(true, reflectionMapCamera);
 
      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 SDynamicReflectionMap::ResetTextureUnit()
  {
    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)
    {
      texState->setProjectiveTexturing(false);
      texState->setTextureAddressingMode(oldAdressingMode);
 
      if (oldTextureEnvState)
        texState->setEnvironmentMap(oldTextureEnvState, oldTextureEnvType);
 
      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 SDynamicReflectionMap::SetEnable(const bool& newState)
  {
    if (reflectionMapTexture)
    {
      if (!material)
        return;
 
      if ((newState == true) && (state == false))
      {
        state = true;
        SetTextureUnit();
        EnableRendering();
      }
      else if ((newState == false) && (state == true))
      {
        DisableRendering();
        state = false;
        ResetTextureUnit();
      }
    }
  }
 
  bool SDynamicReflectionMap::GetEnable()
  {
    return state;
  }
 
  void SDynamicReflectionMap::FlipPlane(const bool& newFlip)
  {
    if (newFlip != flipClipPlane)
    {
      flipClipPlane = newFlip;
 
      //redefine clip plane is not enought since the skies are not rendered in texture while the node is not modified
      reflectionMapCamera->disableCustomNearClipPlane();
      reflectionMapCamera->disableReflection();
 
      // delete the current clip plane
      O3SceneNode->detachObject(cameraClipPlane);
      SO3_SAFE_DELETE(cameraClipPlane);
 
      // delete the current reflection plane
      O3SceneNode->detachObject(reflectionMapPlane);
      SO3_SAFE_DELETE(reflectionMapPlane);
 
      // create clip plane
      cameraClipPlane = new Ogre::MovablePlane("CameraClipPlane" + reflectionMapScheme);
      cameraClipPlane->redefine(((flipClipPlane && !revertClipPlane) || (revertClipPlane && !flipClipPlane)) ? Ogre::Vector3::NEGATIVE_UNIT_Y : Ogre::Vector3::UNIT_Y, Ogre::Vector3::ZERO);
      O3SceneNode->attachObject(cameraClipPlane);
 
      cameraClipPlane->normal = Ogre::Vector3::UNIT_Y;
      cameraClipPlane->setVisible(false);
 
      // create reflection plane
      reflectionMapPlane = new Ogre::MovablePlane("reflectionPlane" + reflectionMapScheme);
      reflectionMapPlane->redefine(flipClipPlane ? (Ogre::Vector3::NEGATIVE_UNIT_Y) : (Ogre::Vector3::UNIT_Y), Ogre::Vector3::ZERO);
      O3SceneNode->attachObject(reflectionMapPlane);
 
      reflectionMapPlane->normal = Ogre::Vector3::UNIT_Y;
      reflectionMapPlane->setVisible(false);
 
      // cut the geometry under the reflection plan
      reflectionMapCamera->enableCustomNearClipPlane(cameraClipPlane);
 
      //apply reflection
      if (!revertClipPlane)
        reflectionMapCamera->enableReflection(reflectionMapPlane);
    }
  }
 
  void SDynamicReflectionMap::SetRevertClipPlane(const bool& newRevertClipPlaneValue)
  {
    if (newRevertClipPlaneValue != revertClipPlane)
    {
      revertClipPlane = newRevertClipPlaneValue;
 
      //redefine clip plane is not enought since the skies are not rendered in texture while the node is not modified
      reflectionMapCamera->disableCustomNearClipPlane();
 
      // delete the current clip plane
      O3SceneNode->detachObject(cameraClipPlane);
      SO3_SAFE_DELETE(cameraClipPlane);
 
      // create clip plane
      cameraClipPlane = new Ogre::MovablePlane("CameraClipPlane" + reflectionMapScheme);
      cameraClipPlane->redefine(revertClipPlane ? -Ogre::Vector3::UNIT_Y : Ogre::Vector3::UNIT_Y, Ogre::Vector3::ZERO);
      O3SceneNode->attachObject(cameraClipPlane);
      cameraClipPlane->setVisible(false);
 
      // cut the geometry under the reflection plan
      reflectionMapCamera->enableCustomNearClipPlane(cameraClipPlane);
 
      // disable reflection plane for refract
      if (revertClipPlane)
        reflectionMapCamera->disableReflection();
      else
        reflectionMapCamera->enableReflection(reflectionMapPlane);
    }
  }
 
  bool SDynamicReflectionMap::GetRevertClipPlane()
  {
    return revertClipPlane;
  }
 
 
  void SDynamicReflectionMap::EnableRendering()
  {
    if (!renderingEnable)
    {
      reflectionMapTargets->addListener(this);
      reflectionMapTargets->setAutoUpdated(true);
 
      //Ogre::MaterialManager::getSingleton().addListener(this);
      renderingEnable = true;
    }
  }
 
  void SDynamicReflectionMap::DisableRendering()
  {
    if (renderingEnable)
    {
      reflectionMapTargets->removeListener(this);
      reflectionMapTargets->setAutoUpdated(false);
 
      //Ogre::MaterialManager::getSingleton().removeListener(this);
      renderingEnable = false;
    }
  }
 
  void SDynamicReflectionMap::_CreateReflectionMapTexture(const unsigned int& newSize)
  {
    _DeleteReflectionMapTexture();
    try
    {
      Ogre::PixelFormat rttformat;
      SRoot::getSingleton().GetRttPixelFormat(rttformat);
 
      reflectionMapTexture = Ogre::TextureManager::getSingleton().createManual("texture_" + reflectionMapScheme, SO3_INTERNAL_DYNAMIC_READABLE_RESOURCE_GROUP, Ogre::TEX_TYPE_2D, newSize, newSize, Ogre::MIP_DEFAULT, rttformat, Ogre::TU_RENDERTARGET | Ogre::TU_AUTOMIPMAP);
      reflectionMapTargets = reflectionMapTexture->getBuffer()->getRenderTarget();
 
#if defined (RPI)
      reflectionMapTargets->setDepthBufferPool(Ogre::DepthBuffer::POOL_NO_DEPTH);
#endif
 
      Ogre::Viewport* viewport = reflectionMapTargets->addViewport(reflectionMapCamera);
      viewport->setOverlaysEnabled(false);
      viewport->setMaterialScheme(reflectionMapScheme);
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: " + e.getDescription());
      reflectionMapTexture.reset();
    }
  }
 
  void SDynamicReflectionMap::_DeleteReflectionMapTexture()
  {
    if (reflectionMapTexture)
    {
      // IMPORTANT! Do not forget to detach the target, otherwise, the texture will not be deleted cause TexturePtr ref count still will be > 1
      if (reflectionMapTargets)
      {
        reflectionMapTargets->removeAllViewports();
        Ogre::Root::getSingleton().detachRenderTarget(reflectionMapTargets);
        reflectionMapTargets = 0;
      }
 
      Ogre::TextureManager::getSingleton().remove(reflectionMapTexture->getHandle());
      reflectionMapTexture.reset();
    }
  }
 
  void SDynamicReflectionMap::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
    if (needTextureUpdate)
    {
      _CreateReflectionMapTexture(size);
      needTextureUpdate = false;
    }
 
    // Get the current viewport camera
    SCamera* camera = reflectionMapViewport->GetCamera();
 
    // Reposition the reflection camera
    camNode->_setDerivedPosition(camera->GetGlobalPosition());
    camNode->_setDerivedOrientation(camera->GetGlobalOrientation());
 
    //reflectionMapPlane->redefine(Ogre::Vector3::UNIT_Y, O3SceneNode->_getDerivedPosition());
    //cameraClipPlane->redefine(Ogre::Vector3::UNIT_Y, O3SceneNode->_getDerivedPosition());
 
    reflectionMapCamera->setFOVy(camera->GetOgreCameraPointer()->getFOVy());
    reflectionMapCamera->setNearClipDistance(camera->GetNearClipDistance());
    reflectionMapCamera->setFarClipDistance(camera->GetFarClipDistance());
    reflectionMapCamera->setAspectRatio(camera->GetOgreCameraPointer()->getAspectRatio());
    reflectionMapCamera->setCustomProjectionMatrix(camera->GetOgreCameraPointer()->isCustomProjectionMatrixEnabled(), camera->GetProjectionMatrix());
    reflectionMapCamera->setCullingFrustum(camera->GetOgreCameraPointer()->getCullingFrustum());
 
    // flip plane if needed to camera direction
    if (reflectionMapPlane->getSide((GetTransformationMatrix().inverse() * camera->GetTransformationMatrix()).getTrans()) == Ogre::Plane::NEGATIVE_SIDE)
      FlipPlane(!flipClipPlane);
  }
 
  void SDynamicReflectionMap::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
  }
 
  Ogre::Technique* SDynamicReflectionMap::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 ((reflectionMapScheme == schemeName) && (originalMaterial == material.get()) && (suptechs.size() > 0))
    {
      // Set a transparent technique
      return suptechs[0];
    }
 
    return 0;
  }
 
}