SO3Technique.cpp

Go to the documentation of this file.

 
#include <boost/format.hpp>
 
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3ShadowManager.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Technique.h"
#include "SO3Material/SO3Pass.h"
 
namespace SO3
{
 
STechnique::STechnique(SMaterial* material, Ogre::Technique* ogreTechniqueRef) : SData(ogreTechniqueRef->getName())
{
        ogreTechnique = ogreTechniqueRef;
  parentMaterial = material;
  if (ogreTechniqueRef->getSchemeName() == "" || ogreTechniqueRef->getSchemeName() == "Default" || ogreTechniqueRef->getSchemeName() == Ogre::Root::getSingleton().getRenderSystem()->_getDefaultViewportMaterialScheme())
    ogreTechniqueRef->setSchemeName("SO3_LEGACY"); //Ogre::MSN_SHADERGEN
 
  originalScheme = ogreTechniqueRef->getSchemeName();
 
  //$BB manage techniques with empty names 
  if(name.empty())
  {
    Ogre::Material::Techniques techs = ogreTechniqueRef->getParent()->getTechniques();
    for (unsigned int techid = 0; techid < techs.size() && name.empty(); techid++)
    {
      if (techs[techid] == ogreTechniqueRef)
        name = boost::str(boost::format("%1%") % techid);
    }
  }
 
  // Generate passes objects
  Ogre::Technique::Passes passes = ogreTechnique->getPasses();
  for (unsigned int passid = 0; passid < passes.size(); passid++)
  {
    Ogre::Pass* ogrePass = passes[passid];
    SPass* pass = new SPass(this, ogrePass);
    ogrePass->getUserObjectBindings().setUserAny("SPass", Ogre::Any(pass));
    //ogrePass->setDepthBias(0.1f, 0.1f);
  }
  
  //generate shadow pass
  if (parentMaterial->GetScene()->GetShadowManager())
    parentMaterial->GetScene()->GetShadowManager()->UpdateShadowMaterial(ogreTechnique);
}
 
STechnique::STechnique() : SData("")
{
  // Forbiden (private)
}
 
STechnique::~STechnique()
{
  // Destroy passes
  Ogre::Technique::Passes passes = ogreTechnique->getPasses();
  for (unsigned int passid = 0; passid < passes.size(); passid++)
  {
    Ogre::Pass* ogrePass = passes[passid];
    Ogre::Any bindedSPass = ogrePass->getUserObjectBindings().getUserAny("SPass");
    if (bindedSPass.has_value())
    {
      SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
      SO3_SAFE_DELETE(pass);
    }
  }
 
  Ogre::Any bindedSTechnique = ogreTechnique->getUserObjectBindings().getUserAny("STechnique");
  if(bindedSTechnique.has_value())
    ogreTechnique->getUserObjectBindings().eraseUserAny("STechnique");
}
 
Ogre::Technique* STechnique::GetOgreTechniquePointer() 
{
        return ogreTechnique;
}
 
SMaterial* STechnique::GetParentMaterial()
{
  return parentMaterial;
}
 
int STechnique::GetNumPasses()
{
  assert(ogreTechnique != 0);
  return ogreTechnique->getNumPasses();
}
 
SPass* STechnique::GetPass(const unsigned int& pass)
{
  assert(ogreTechnique != 0);
  if ((pass >= 0) && (pass < ogreTechnique->getNumPasses()))
  {
    Ogre::Pass* ogrePass = ogreTechnique->getPass(pass);
    Ogre::Any bindedSPass = ogrePass->getUserObjectBindings().getUserAny("SPass");
    if (!bindedSPass.has_value())
      return 0;
 
    SPass* matPass = Ogre::any_cast<SPass*> (bindedSPass);
    return matPass;
  }
  else
    return 0;
}
 
int STechnique::GetPassIndexByName(const std::string& passName)
{
  assert(ogreTechnique != 0);
 
  bool found = false;
  int index = -1;
 
  int numPass = ogreTechnique->getNumPasses();
  int p = 0;
 
  while(!found && p<numPass)
  {
          Ogre::Pass* myPass = ogreTechnique->getPass(p);
    if (myPass != 0)
    {
            if(myPass->getName() == passName)
            {
                    index = p;
                    found = true;
            }
    }
          p++;
  }
 
  return index;
}
 
void STechnique::SetSchemeName(std::string scheme)
{
  if (scheme == "" || scheme == "Default" || scheme == Ogre::Root::getSingleton().getRenderSystem()->_getDefaultViewportMaterialScheme())
    ogreTechnique->setSchemeName("SO3_LEGACY");
  else
    ogreTechnique->setSchemeName(scheme);
}
 
 
void STechnique::AddPass()
{
  // Generate pass
  Ogre::Pass* ogrePass = ogreTechnique->createPass();
  SPass* pass = new SPass(this, ogrePass);
  ogrePass->getUserObjectBindings().setUserAny("SPass", Ogre::Any(pass));
  //ogrePass->setDepthBias(0.1f, 0.1f);
}
 
void STechnique::RemovePass(const unsigned int& pass)
{
  if ((pass >= 0) && (pass < ogreTechnique->getNumPasses()))
  {
    Ogre::Pass* ogrePass = ogreTechnique->getPass(pass);
    Ogre::Any bindedSPass = ogrePass->getUserObjectBindings().getUserAny("SPass");
    assert(bindedSPass.has_value());
    SPass* matPass = Ogre::any_cast<SPass*> (bindedSPass);
    SO3_SAFE_DELETE(matPass);
  }
}
 
const Ogre::String STechnique::GetOriginalScheme()
{
  return originalScheme;
}
 
void STechnique::SetPointSize(Ogre::Real size)
{
  Ogre::Technique::Passes ogrePasses = ogreTechnique->getPasses();
  for (unsigned int i = 0; i < ogrePasses.size(); i++)
  {
    if (ogrePasses[i]->getPolygonMode() == Ogre::PM_POINTS)
      ogrePasses[i]->setPointSize(size);
  }
 
  UpdateGeneratedTech();
}
 
void STechnique::UpdateGeneratedTech(bool full)
{
  if (full)
    GetParentMaterial()->CleanUpGeneratedTechniques();
  else
    SRoot::getSingletonPtr()->RemoveGeneratedMaterial(GetParentMaterial()->getOgreMaterialPointer().get());
 
  Ogre::Technique::Passes passes = ogreTechnique->getPasses();
  for (unsigned int passid = 0; passid < passes.size(); passid++)
  {
    Ogre::Pass* ogrePass = passes[passid];
    Ogre::Any bindedSPass = ogrePass->getUserObjectBindings().getUserAny("SPass");
    if (bindedSPass.has_value())
    {
      SPass* matPass = Ogre::any_cast<SPass*> (bindedSPass);
      
      if (matPass->IsShaderGenerated())
        matPass->BuildShader(full);
    }
  }
  
  //generate shadow pass
  if (GetParentMaterial()->GetScene()->GetShadowManager())
    GetParentMaterial()->GetScene()->GetShadowManager()->UpdateShadowMaterial(GetOgreTechniquePointer());
}
 
}