SO3Compositor.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3Compositor.h"
#include "SO3Material/SO3CompositorTechnique.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3Window.h"
 
namespace SO3
{
 
SCompositor::SCompositor(SViewPort* scolViewPort, const std::string& compositorName, const std::string& schemeName) : SData(compositorName)
{
  CommonConstructor(scolViewPort, schemeName, false, false);
}
 
SCompositor::SCompositor(SViewPort* scolViewPort, const std::string& compositorName, const bool& isActivated) : SData(compositorName)
{
  CommonConstructor(scolViewPort, "", true, isActivated);
}
 
SCompositor::SCompositor(const std::string& compositorName, const std::string& schemeName) : SData(compositorName)
{
  CommonConstructor(NULL, schemeName, false, false);
}
 
void SCompositor::CommonConstructor(SViewPort* scolViewPort, const std::string& schemeName, bool internalCompo, bool activateCompo)
{
  // SO3 internal compo, or loaded from script?
  isInternal = internalCompo;
  isEnable = activateCompo;
  parent = scolViewPort;
  mViewport = 0;
 
  if (scolViewPort != 0)
    mViewport = scolViewPort->GetOgreViewPortPointer();
 
  // Store a reference to the compositor.
  ogreCompositor = Ogre::CompositorManager::getSingleton().getByName(name);
 
  // Assign a scheme?
  if (schemeName.empty() || schemeName == "Default" || schemeName == "DefaultScheme" || schemeName == Ogre::Root::getSingleton().getRenderSystem()->_getDefaultViewportMaterialScheme())
    scheme = Ogre::MSN_SHADERGEN;
  else
    scheme = schemeName;
 
  if ((scheme != Ogre::MSN_SHADERGEN) && (scheme != "SO3_LEGACY"))
  {
    if (ogreCompositor)
    {
      // Iterate through compositor techniques
      Ogre::Compositor::TechniqueIterator iCompositorTechnique = ogreCompositor->getTechniqueIterator();
      while (iCompositorTechnique.hasMoreElements())
      {
        // Create SCompositorTechnique wrapper.
        Ogre::CompositionTechnique* ogreCompositionTechnique = iCompositorTechnique.getNext();
 
        Ogre::CompositionTechnique::TargetPasses passList = ogreCompositionTechnique->getTargetPasses();
        for (unsigned int p = 0; p < passList.size(); p++)
        {
          // Create SCompositorPass wrapper.
          Ogre::CompositionTargetPass* ogreCompositionTargetPass = passList[p];
 
          ogreCompositionTargetPass->setMaterialScheme(scheme);
        }
      }
    }
 
    Ogre::MaterialPtr colorMat = Ogre::MaterialManager::getSingleton().getByName("SO3/Internal/DefaultColor");
    if (colorMat)
    {
      mBlackMat = colorMat->clone("SO3/Internal/mSchemeBlack/" + name + "/" + scheme, Ogre::String("SO3/Internal"));
      mBlackMat->getTechnique(0)->getPass(0)->setAmbient(0,0,0);
      mBlackMat->getTechnique(0)->setFog(true, Ogre::FOG_NONE, Ogre::ColourValue::Black);
      mBlackMat->getTechnique(0)->setSchemeName(scheme);
 
      mBlackMatTrans = colorMat->clone("SO3/Internal/mSchemeBlackTrans/" + name + "/" + scheme, Ogre::String("SO3/Internal"));
      mBlackMatTrans->getTechnique(0)->getPass(0)->setAmbient(0,0,0);
      mBlackMatTrans->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
      mBlackMatTrans->getTechnique(0)->setFog(true, Ogre::FOG_NONE, Ogre::ColourValue::Black);
      mBlackMatTrans->getTechnique(0)->setSchemeName(scheme);
    }
  }
 
  // Attach to a SViewport?
  if(!isInternal && ogreCompositor)
  {
    if (mViewport != 0)
      _AttachToParent();
 
    // Iterate through compositor techniques, and map them to a SCompositorTechnique
    Ogre::Compositor::TechniqueIterator iCompositorTechnique = ogreCompositor->getTechniqueIterator();
    while(iCompositorTechnique.hasMoreElements())
    {
      // Create SCompositorTechnique wrapper.
      Ogre::CompositionTechnique* ogreCompositionTechnique = iCompositorTechnique.getNext();
      SCompositorTechnique* newCompositorTechnique = new SCompositorTechnique(this, ogreCompositionTechnique, compositorTechniquesByIndex.size());
 
      // Store it.
      compositorTechniquesIndexByName.insert(CompositorTechniquesIndexByName::value_type(newCompositorTechnique->GetName(), compositorTechniquesByIndex.size()));
      compositorTechniquesByIndex.push_back(newCompositorTechnique);
    }
  }
}
 
SCompositor::SCompositor() : SData("")
{
  // Forbiden (private)
}
 
SCompositor::~SCompositor()
{
  if (!isInternal)
  {
    // Detach from viewport
    if (mViewport != 0)
      _DetachFromParent();
 
    const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
    // Destroy default materials if they exists.
    if(mBlackMat)
    {
      if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
        Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(mBlackMat->getName(), mBlackMat->getGroup());
 
      Ogre::MaterialManager::getSingleton().remove(mBlackMat->getHandle());
      mBlackMat.reset();
    }
    if(mBlackMatTrans)
    {
      if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
        Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(mBlackMatTrans->getName(), mBlackMatTrans->getGroup());
 
      Ogre::MaterialManager::getSingleton().remove(mBlackMatTrans->getHandle());
      mBlackMatTrans.reset();
    }
 
    // Destroy SCompositorTechnique wrappers.
    CompositorTechniquesByIndex::iterator iCompositorTechnique = compositorTechniquesByIndex.begin();
    while(iCompositorTechnique != compositorTechniquesByIndex.end())
    {
      delete(*iCompositorTechnique);
      iCompositorTechnique++;
    }
    compositorTechniquesByIndex.clear();
    compositorTechniquesIndexByName.clear();
 
    // Release compositor pointer.
    if (ogreCompositor)
    {
      ogreCompositor->unload();
      //do not remove from the manager
      //Ogre::CompositorManager::getSingletonPtr()->remove(ogreCompositor->getHandle());
      ogreCompositor.reset();
    }
  }
}
 
void SCompositor::SetViewport(Ogre::Viewport* vp)
{
  bool state = isEnable;
 
  if (state)
    SetEnable(false);
 
  if (mViewport != 0)
    _DetachFromParent();
 
  mViewport = vp;
 
  if (mViewport != 0)
    _AttachToParent();
 
  SetEnable(state);
}
 
void SCompositor::_AttachToParent()
{
  if (mViewport == 0)
    return;
 
  if(!ogreCompositor->isLoaded())
    ogreCompositor->load();
 
  //unregister Stereo
  bool hasStereo = false;
 
  if (parent != 0)
  {
    hasStereo = parent->IsStereoViewportRegistered();
    if (hasStereo)
      parent->UnregisterStereoViewport();
  }
 
  //DoF or compositors with Depth must be assigned first
  int pos = -1;
  if (name == "DoF")
    pos = 0;
 
  // Compositor manager create a compositor chain since Ogre 1.7, so don't forget to delete it!
  try
  {
    Ogre::CompositorManager::getSingleton().addCompositor(mViewport, name, pos);
  }
  catch (Ogre::Exception &e)
  {
    Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_WARNING, false);
    return;
  }
 
  SetEnable(true);
 
  //register Stereo
  if ((parent != 0) && hasStereo)
    parent->RegisterStereoViewport();
}
 
void SCompositor::_DetachFromParent()
{
  if (mViewport == 0)
    return;
 
  SetEnable(false);
 
  //unregister Stereo
  bool hasStereo = false;
  
  if (parent != 0)
  {
    hasStereo = parent->IsStereoViewportRegistered();
    if (hasStereo)
      parent->UnregisterStereoViewport();
  }
 
// If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
  // Ogre 1.6 method
        Ogre::CompositorManager::getSingleton().removeCompositor(mViewport, name);
#else
  // New Ogre 1.7+ method
  Ogre::CompositorChain* chain = Ogre::CompositorManager::getSingleton().getCompositorChain(mViewport);
  if(chain)
  {
    Ogre::CompositorInstance* compinst = chain->getCompositor(name);
    if (compinst)
    {
      chain->_removeInstance(compinst);
      chain->_markDirty();
    }
 
    // Destroy chain if needed.
    if(chain->getCompositorInstances().empty())
      Ogre::CompositorManager::getSingleton().removeCompositorChain(mViewport);
  }
#endif
 
  //register Stereo
  if ((parent != 0) && hasStereo)
    parent->RegisterStereoViewport();
}
 
SViewPort* SCompositor::GetParentViewPort() 
{
        return parent;
}
 
bool SCompositor::GetEnable()
{
  return isEnable;
}
 
void SCompositor::SetEnable(const bool& enable)
{
  if (enable != isEnable)
  {
    if (enable)
    {
      if (scheme != "")
                    Ogre::MaterialManager::getSingleton().addListener(this, scheme);
    }
    else
    {
      Ogre::MaterialManager::getSingleton().removeListener(this, scheme);
    }
 
    try
    {
      // only enable compositor on main viewport if there is no stereo on it
      if (((mViewport != 0) && (parent == 0)) || ((parent != 0) && !parent->UpdateStereoCompositorState(name, enable)))
        Ogre::CompositorManager::getSingleton().setCompositorEnabled(mViewport, name, enable);
    }
    catch (Ogre::Exception &e)
    {
      Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_WARNING, false);
    }
 
    isEnable = enable;
  }
}
 
int SCompositor::GetNumCompositorTechniques()
{
  return ogreCompositor->getNumTechniques();
}
 
SCompositorTechnique* SCompositor::GetCompositorTechnique(const unsigned int& technique)
{
  if((technique >= 0) && (technique < compositorTechniquesByIndex.size()))
    return compositorTechniquesByIndex.at(technique);
  else
    return 0;
}
 
int SCompositor::GetCompositorTechniqueIndexByName(const std::string& techname)
{
  CompositorTechniquesIndexByName::iterator iSearchedCompositorTechniqueIndex = compositorTechniquesIndexByName.find(techname);
  if(iSearchedCompositorTechniqueIndex!= compositorTechniquesIndexByName.end())
    return iSearchedCompositorTechniqueIndex->second;
  else
    return -1;
}
 
Ogre::Technique* SCompositor::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
{
  if (!mBlackMatTrans || !mBlackMat)
    return NULL;
 
  if ((originalMaterial->getNumSupportedTechniques() > 0) && (originalMaterial->getSupportedTechnique(0)->getNumPasses() > 0) && (!originalMaterial->getSupportedTechnique(0)->getPass(0)->getDepthWriteEnabled()))
    return mBlackMatTrans->getTechnique(0);
  else
    return mBlackMat->getTechnique(0);
}
 
}