SO3Material.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Technique.h"
#include "SO3Material/SO3Pass.h"
#include "SO3Material/SO3Texture.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3Renderer/SO3LightingManager.h"
 
namespace SO3
{
 
SMaterial::SMaterial(SScene* scene, const std::string& groupname, const std::string& materialName, const bool& loadedFromScript) : SData(materialName)
{
        ogreMaterial.reset();
  associatedWidget = 0;
  mIgnoreSlicePlane = false;
  mScene = scene;
  mGroupName = groupname;
 
  // For materials that are dynamicaly created inside SO3, but for which no SMaterial was setted.
  ogreMaterial = mScene->O3MaterialManager->getByName(materialName, groupname);
  
  // Clone base white to prevent modifications. Change the resource group of the clone.
  if (materialName == std::string("BaseWhite") && ogreMaterial)
    ogreMaterial = ogreMaterial.get()->clone(materialName, groupname);
 
  // If no material is found, it's either that scol user asked for the creation of a new material, or that the SResourceLoader (that "listens" to ogre script loading)
  // asked for a new material
  if (!ogreMaterial)
  {
    // Create a new Ogre::Material in the targeted resource group.
    ogreMaterial = Ogre::MaterialManager::getSingleton().create(materialName, mGroupName);
 
    // If not loaded from Ogre's script, then create a minimal material with one texture unit, and bind STechnique to Ogre::Technique. We do not do that for content loaded
    // from script because Ogre's script translator call "removeAllTechnique" just after SMaterial creation, leading to an orfan "STechnique" (mem leak).
    if(!loadedFromScript)
    {
      //ogreMaterial->getTechnique(0)->getPass(0)->createTextureUnitState();
      _BindTechniquesToOgre();
    }
  }
  else
  {
    // Bind STechnique to Ogre::Technique
    _BindTechniquesToOgre();
  }
}
 
SMaterial::SMaterial() : SData("")
{
  // Forbiden (private)
}
 
SMaterial::~SMaterial()
{
  // Unbind STechnique from Ogre::Technique
  _UnbindTechniquesToOgre();
 
  //Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(GetName(), GetGroupName());
 
  if (ogreMaterial)
  {
    //cleanup all subentity using this material
    Ogre::SceneManager::MovableObjectMap EntityList = mScene->GetOgreScenePointer()->getMovableObjects("Entity");
    Ogre::Entity* CurrentEntity = NULL;
 
    for (Ogre::SceneManager::MovableObjectMap::iterator iEntity = EntityList.begin(); iEntity != EntityList.end(); iEntity++)
    {
      CurrentEntity = static_cast<Ogre::Entity *>(iEntity->second);
      for (unsigned int k = 0; k < CurrentEntity->getNumSubEntities(); k++)
      {
        Ogre::SubEntity* subent = CurrentEntity->getSubEntity(k);
        if (subent->getMaterial() == ogreMaterial)
          subent->setMaterialName("BaseWhite");
      }
    }
    // Do not destroy Ogre's internals materials!
    if ((ogreMaterial->getGroup() != Ogre::RGN_INTERNAL) && (ogreMaterial->getGroup() == mGroupName))
    {
      ogreMaterial->unload();
      Ogre::MaterialManager::getSingletonPtr()->remove(ogreMaterial->getHandle());
    }
  }
}
 
void SMaterial::_BindTechniquesToOgre()
{
  SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreMaterial.get());
  _UnbindTechniquesToOgre();
 
  // Generate techniques
  Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
  for(unsigned int techid = 0; techid < techs.size(); techid++)
  {
    Ogre::Technique* ogreTechnique = techs[techid];
    STechnique* technique = new STechnique(this, ogreTechnique);
    ogreTechnique->getUserObjectBindings().setUserAny("STechnique", Ogre::Any(technique));
  }
}
 
void SMaterial::_UnbindTechniquesToOgre()
{
  // Destroy techniques
  Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
  for (unsigned int techid = 0; techid < techs.size(); techid++)
  {
    Ogre::Technique* ogreTechnique = techs[techid];
    Ogre::Any bindedSTechnique = ogreTechnique->getUserObjectBindings().getUserAny("STechnique");
    if(bindedSTechnique.has_value())
    {
      STechnique* technique = Ogre::any_cast<STechnique*> (bindedSTechnique);
      SO3_SAFE_DELETE(technique);
    }
  }
}
 
void SMaterial::_UpdateOgreMaterialPointer()
{
  Ogre::MaterialPtr nmat = mScene->O3MaterialManager->getByName(name, mGroupName);
  if (!nmat)
    return;
 
  SRoot::getSingletonPtr()->RemoveGeneratedMaterial(nmat.get());
 
  //apply all subentity using this material with new pointer
  Ogre::SceneManager::MovableObjectMap EntityList = mScene->GetOgreScenePointer()->getMovableObjects("Entity");
  Ogre::Entity* CurrentEntity = NULL;
 
  for (Ogre::SceneManager::MovableObjectMap::iterator iEntity = EntityList.begin(); iEntity != EntityList.end(); iEntity++)
  {
    CurrentEntity = static_cast<Ogre::Entity *>(iEntity->second);
    for (unsigned int k = 0; k < CurrentEntity->getNumSubEntities(); k++)
    {
      Ogre::SubEntity* subent = CurrentEntity->getSubEntity(k);
      if (subent->getMaterial() == ogreMaterial)
        subent->setMaterial(nmat);
    }
  }
 
  ogreMaterial.reset();
 
  // For materials that are dynamicaly created inside SO3, but for which no SMaterial was setted.
  ogreMaterial = nmat;
 
  // Clone base white to prevent modifications. Change the resource group of the clone.
  if (name == std::string("BaseWhite") && ogreMaterial)
    ogreMaterial = ogreMaterial.get()->clone(name, mGroupName);
}
 
Ogre::MaterialPtr SMaterial::getOgreMaterialPointer() 
{
        return ogreMaterial;
}
 
SScene* SMaterial::GetScene()
{
  return mScene;
}
 
std::string SMaterial::GetGroupName()
{
  return mGroupName;
}
 
int SMaterial::GetNumTechniques()
{
  assert(ogreMaterial);
  return ogreMaterial->getNumTechniques();
}
 
STechnique* SMaterial::GetTechnique(const unsigned int& technique)
{
  assert(ogreMaterial);
  if ((technique >= 0) && (technique < ogreMaterial->getNumTechniques()))
  {
    Ogre::Technique* ogreTechnique = ogreMaterial->getTechnique(technique);
    Ogre::Any bindedSTechnique = ogreTechnique->getUserObjectBindings().getUserAny("STechnique");
    
    if (!bindedSTechnique.has_value())
      return 0;
 
    STechnique* matTechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
    return matTechnique;
  }
  else
    return 0;
}
 
int SMaterial::GetTechniqueIndexByName(const std::string& techname)
{
  assert(ogreMaterial);
 
        bool found = false;
  int index = -1;
  int numTech = GetNumTechniques();
  int p = 0;
 
        while(!found && p<numTech)
        {
                Ogre::Technique* myTec = ogreMaterial->getTechnique(p);
    if (myTec != 0)
    {
                  if(myTec->getName() == techname)
                  {
                          index = p;
                          found = true;
                  }
    }
                p++;
        }
 
  return index;
}
 
SWidget* SMaterial::GetAssociatedWidget()
{
  return associatedWidget;
}
 
void SMaterial::SetAssociatedWidget(SWidget* newAssociatedWidget)
{
  // Allow only one widget on a material at a time.
  if((associatedWidget != 0) && (newAssociatedWidget != 0))
    OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "Cannot set widget on material: This material is already associated to a widget instance!", "SMaterial::SetAssociatedWidget");
 
  associatedWidget = newAssociatedWidget;
}
 
bool SMaterial::GetReceiveShadows()
{
  assert(ogreMaterial);
  return ogreMaterial->getReceiveShadows();
}
 
void SMaterial::SetReceiveShadows(const bool& state)
{
  assert(ogreMaterial);
  ogreMaterial->setReceiveShadows(state);
}
 
void SMaterial::SetLightingEnabled(const bool& state)
{
  assert(ogreMaterial);
  ogreMaterial->setLightingEnabled(state);
 
  UpdateGeneratedMaterial(true);
}
 
void SMaterial::SetAmbientColor(const int& color)
{
  assert(ogreMaterial);
  ogreMaterial->setAmbient(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetDiffuseColor(const int& color)
{
  assert(ogreMaterial);
  ogreMaterial->setDiffuse(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetSpecularColor(const int& color)
{
  assert(ogreMaterial);
  ogreMaterial->setSpecular(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetSelfIlluminationColor(const int& color)
{
  assert(ogreMaterial);
  ogreMaterial->setSelfIllumination(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetAmbientColor(float r, float g, float b, float a)
{
  assert(ogreMaterial);
  ogreMaterial->setAmbient(Ogre::ColourValue(r, g, b, a));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetDiffuseColor(float r, float g, float b, float a)
{
  assert(ogreMaterial);
  ogreMaterial->setDiffuse(Ogre::ColourValue(r, g, b, a));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetSpecularColor(float r, float g, float b, float a)
{
  assert(ogreMaterial);
  ogreMaterial->setSpecular(Ogre::ColourValue(r, g, b, a));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetSelfIlluminationColor(float r, float g, float b, float a)
{
  assert(ogreMaterial);
  ogreMaterial->setSelfIllumination(Ogre::ColourValue(r, g, b, a));
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::SetShininess(const float& value)
{
  assert(ogreMaterial);
  ogreMaterial->setShininess(value);
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::AddTechnique()
{
  // Generate technique
  Ogre::Technique* ogreTechnique = ogreMaterial->createTechnique();
  STechnique* technique = new STechnique(this, ogreTechnique);
  ogreTechnique->getUserObjectBindings().setUserAny("STechnique", Ogre::Any(technique));
}
 
void SMaterial::RemoveTechnique(const unsigned int& technique)
{
  //update generated materials
  SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreMaterial.get());
 
  if ((technique >= 0) && (technique < ogreMaterial->getNumTechniques()))
  {
    Ogre::Technique* ogreTechnique = ogreMaterial->getTechnique(technique);
    Ogre::Any bindedSTechnique = ogreTechnique->getUserObjectBindings().getUserAny("STechnique");
    assert(bindedSTechnique.has_value());
    STechnique* matTechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
    SO3_SAFE_DELETE(matTechnique);
  }
}
 
void SMaterial::SetPointSize(Ogre::Real size)
{
  Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
  for (unsigned int i = 0; i < techs.size(); i++)
  {
    Ogre::Technique* ogreTechnique = techs[i];    
    Ogre::Technique::Passes ogrePasses = ogreTechnique->getPasses();
    for (unsigned int j = 0; j < ogrePasses.size(); j++)
    {
      if (ogrePasses[j]->getPolygonMode() == Ogre::PM_POINTS)
        ogrePasses[j]->setPointSize(size);
    }
  }
 
  UpdateGeneratedMaterial();
}
 
void SMaterial::CleanUpGeneratedTechniques(Ogre::Material* mat)
{
  Ogre::Material::Techniques techs = mat->getTechniques();
  unsigned int id = 0;
  for (unsigned int i = 0; i < techs.size(); i++, id++)
  {
    Ogre::Technique* tech = techs[i];
 
    //remove generated techniques like SSAO
    if (tech->getSchemeName().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos)
    {
      mat->removeTechnique(id);
      id--;
      continue;
    }
 
    Ogre::Technique::Passes passes = tech->getPasses();
    for (unsigned int j = 0; j < passes.size(); j++)
    {
      Ogre::Any bindedSPass = passes[j]->getUserObjectBindings().getUserAny("SPass");
      if (bindedSPass.has_value())
      {
        SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
        if (pass && pass->IsShaderGenerated())
        {
          pass->BuildShader();
        }
      }
    }
  }
}
 
void SMaterial::CleanUpGeneratedTechniques()
{
  SRoot::getSingletonPtr()->RemoveGeneratedMaterial(ogreMaterial.get());
 
  Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
  unsigned int id = 0;
  for (unsigned int i = 0; i < techs.size(); i++, id++)
  {
    Ogre::Technique* tech = techs[i];
 
    //remove generated techniques like SSAO
    if (tech->getSchemeName().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos)
    {
      ogreMaterial->removeTechnique(id);
      id--;
      continue;
    }
  }
}
 
void SMaterial::WriteMaterialFile(std::string path)
{
  Ogre::MaterialSerializer ogreMaterialSerializer;
  std::vector<SPass*> generatedShaderPasses;
  std::vector<STechnique*> generatedShadowTechs;
  std::vector<STechnique*> generatedShaderGenTechs;
  std::vector<STechnique*> generatedShaderLegacyTechs;
 
  //save in the original material file
  Ogre::String matPath = (path.empty()) ? ogreMaterial->getOrigin() : path;
 
  if (matPath.empty())
    return; //nothing to do with no filename
 
  //Get file from user partition
  packdir mypack = (packdir)SCgetExtra("FirstPack");
  boost::filesystem::path upartitionPath(mypack->path);
  upartitionPath = upartitionPath.generic_string();
 
  std::string ufilepath(matPath);
 
  while (mypack)
  {
    std::string curPart = boost::filesystem::path(mypack->path).generic_string();
    if (matPath.find(curPart) != std::string::npos)
    {
      ufilepath = upartitionPath.append(ufilepath.substr(curPart.length())).generic_string();
      //Create all folders
      if (!boost::filesystem::exists(ufilepath))
      {
        boost::system::error_code ec;
        boost::filesystem::path subd(ufilepath);
        subd.remove_filename();
        boost::filesystem::create_directories(subd, ec);
      }
 
      break;
    }
 
    mypack = mypack->next;
  }
 
  bool addnew = true;
 
  Ogre::ResourceManager::ResourceMapIterator it = Ogre::MaterialManager::getSingleton().getResourceIterator();
  while (it.hasMoreElements())
  {
    Ogre::MaterialPtr mat = Ogre::static_pointer_cast<Ogre::Material>(it.getNext());
    Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(*mat.get());
 
    if (mat->getGroup() == ogreMaterial->getGroup() && mat->getOrigin() == matPath)
    {
      if (mat == ogreMaterial)
        addnew = false;
 
      Ogre::Material::Techniques techs = mat->getTechniques();
      unsigned int id = 0;
      for (unsigned int i = 0; i < techs.size(); i++, id++)
      {
        Ogre::Technique* tech = techs[i];
 
        //remove generated techniques like SSAO
        if (tech->getSchemeName().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos)
        {
          mat->removeTechnique(id);
          id--;
          continue;
        }        
 
        //remove shadow pass
        Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
        if (bindedSTechnique.has_value())
        {
          STechnique* stechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
 
          if (tech->getSchemeName() == Ogre::MSN_SHADERGEN)
          {
            tech->setSchemeName(Ogre::MSN_DEFAULT);
            generatedShaderGenTechs.push_back(stechnique);
          }
 
          if (tech->getSchemeName() == "SO3_LEGACY")
          {
            tech->setSchemeName(Ogre::MSN_DEFAULT);
            generatedShaderLegacyTechs.push_back(stechnique);
          }
 
          if (stechnique->GetParentMaterial()->GetScene()->GetShadowManager())
          {
            stechnique->GetParentMaterial()->GetScene()->GetShadowManager()->CleanShadowMaterial(tech);
            generatedShadowTechs.push_back(stechnique);
          }
        }
 
        Ogre::Technique::Passes passes = tech->getPasses();
        for (unsigned int j = 0; j < passes.size(); j++)
        {
          Ogre::Any bindedSPass = passes[j]->getUserObjectBindings().getUserAny("SPass");
          if (bindedSPass.has_value())
          {
            SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
            if (pass && pass->IsShaderGenerated())
            {
              pass->CleanGeneratedShader();
              generatedShaderPasses.push_back(pass);
            }
          }
        }
      }
        
      ogreMaterialSerializer.queueForExport(mat);
    }        
  }
 
  if (addnew)
  {
    Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(*ogreMaterial.get());
    Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
    unsigned int id = 0;
    for (unsigned int i = 0; i < techs.size(); i++, id++)
    {
      Ogre::Technique* tech = techs[i];
 
      //remove generated techniques like SSAO
      if (tech->getSchemeName().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos)
      {
        ogreMaterial->removeTechnique(id);
        id--;
        continue;
      }
 
      //remove shadow pass
      Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
      if (bindedSTechnique.has_value())
      {
        STechnique* stechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
 
        if (tech->getSchemeName() == Ogre::MSN_SHADERGEN)
        {
          tech->setSchemeName(Ogre::MSN_DEFAULT);
          generatedShaderGenTechs.push_back(stechnique);
        }
 
        if (tech->getSchemeName() == "SO3_LEGACY")
        {
          tech->setSchemeName(Ogre::MSN_DEFAULT);
          generatedShaderLegacyTechs.push_back(stechnique);
        }
 
        if (stechnique->GetParentMaterial()->GetScene()->GetShadowManager())
        {
          stechnique->GetParentMaterial()->GetScene()->GetShadowManager()->CleanShadowMaterial(tech);
          generatedShadowTechs.push_back(stechnique);
        }
      }
 
      Ogre::Technique::Passes passes = tech->getPasses();
      for (unsigned int j = 0; j < passes.size(); j++)
      {
        Ogre::Any bindedSPass = passes[j]->getUserObjectBindings().getUserAny("SPass");
        if (bindedSPass.has_value())
        {
          SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
          if (pass && pass->IsShaderGenerated())
          {
            pass->CleanGeneratedShader();
            generatedShaderPasses.push_back(pass);
          }
        }
      }
    }
 
    //set ogreMaterial Origin
    ogreMaterial->_notifyOrigin(matPath);
 
    ogreMaterialSerializer.queueForExport(ogreMaterial);
  }
 
  //write file
  ogreMaterialSerializer.exportQueued(ufilepath);
 
  //rebuild generated shaders
  for (unsigned int i = 0; i < generatedShaderPasses.size(); i++)
  {
    generatedShaderPasses[i]->BuildShader(true);
  }
 
  for (unsigned int i = 0; i < generatedShaderGenTechs.size(); i++)
  {
    generatedShaderGenTechs[i]->SetSchemeName(Ogre::MSN_SHADERGEN);
  }
 
  for (unsigned int i = 0; i < generatedShaderLegacyTechs.size(); i++)
  {
    generatedShaderLegacyTechs[i]->SetSchemeName("SO3_LEGACY");
  }
 
  // update shadows
  for (unsigned int i = 0; i < generatedShadowTechs.size(); i++)
  {
    STechnique* stech = generatedShadowTechs[i];
    stech->GetParentMaterial()->GetScene()->GetShadowManager()->UpdateShadowMaterial(stech->GetOgreTechniquePointer());
  }
}
 
void SMaterial::UpdateMaterialScript(std::string path)
{
  Ogre::MaterialSerializer ogreMaterialSerializer;
  std::vector<SPass*> generatedShaderPasses;
  std::vector<STechnique*> generatedShadowTechs;
  std::vector<STechnique*> generatedShaderGenTechs;
  std::vector<STechnique*> generatedShaderLegacyTechs;
 
  if (path.empty())
    return; //nothing to do with no filename
 
  //Get file from user partition
  packdir mypack = (packdir)SCgetExtra("FirstPack");
  boost::filesystem::path upartitionPath(mypack->path);
  upartitionPath = upartitionPath.generic_string();
 
  std::string ufilepath(path);
 
  while (mypack)
  {
    std::string curPart = boost::filesystem::path(mypack->path).generic_string();
    if (path.find(curPart) != std::string::npos)
    {
      ufilepath = upartitionPath.append(ufilepath.substr(curPart.length())).generic_string();
 
      //Create all folders
      if (!boost::filesystem::exists(ufilepath))
      {
        boost::system::error_code ec;
        boost::filesystem::path subd(ufilepath);
        subd.remove_filename();
        boost::filesystem::create_directories(subd, ec);
      }
      break;
    }
 
    mypack = mypack->next;
  }
 
  Ogre::ResourceManager::ResourceMapIterator it = Ogre::MaterialManager::getSingleton().getResourceIterator();
  while (it.hasMoreElements())
  {
    Ogre::MaterialPtr mat = Ogre::static_pointer_cast<Ogre::Material>(it.getNext());
    Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques(*mat.get());
 
    if (mat->getOrigin() == path)
    {
      Ogre::Material::Techniques techs = mat->getTechniques();
      unsigned int id = 0;
      for (unsigned int i = 0; i < techs.size(); i++, id++)
      {
        Ogre::Technique* tech = techs[i];
 
        //remove generated techniques like SSAO
        if (tech->getSchemeName().find(std::string(SO3_INTERNAL_RESOURCE_GROUP)) != Ogre::String::npos)
        {
          mat->removeTechnique(id);
          id--;
          continue;
        }
 
        //remove shadow pass
        Ogre::Any bindedSTechnique = tech->getUserObjectBindings().getUserAny("STechnique");
        if (bindedSTechnique.has_value())
        {
          STechnique* stechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
          if (tech->getSchemeName() == Ogre::MSN_SHADERGEN)
          {
            tech->setSchemeName(Ogre::MSN_DEFAULT);
            generatedShaderGenTechs.push_back(stechnique);
          }
 
          if (tech->getSchemeName() == "SO3_LEGACY")
          {
            tech->setSchemeName(Ogre::MSN_DEFAULT);
            generatedShaderLegacyTechs.push_back(stechnique);
          }
          
 
          if (stechnique->GetParentMaterial()->GetScene()->GetShadowManager())
          {
            stechnique->GetParentMaterial()->GetScene()->GetShadowManager()->CleanShadowMaterial(tech);
            generatedShadowTechs.push_back(stechnique);
          }
        }
 
        Ogre::Technique::Passes passes = tech->getPasses();
        for (unsigned int j = 0; j < passes.size(); j++)
        {
          Ogre::Any bindedSPass = passes[j]->getUserObjectBindings().getUserAny("SPass");
          if (bindedSPass.has_value())
          {
            SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
            if (pass && pass->IsShaderGenerated())
            {
              pass->CleanGeneratedShader();
              generatedShaderPasses.push_back(pass);
            }
          }
        }
      }
 
      ogreMaterialSerializer.queueForExport(mat);
    }
  }
 
  //write file
  ogreMaterialSerializer.exportQueued(ufilepath);
 
  //rebuild generated shaders
  for (unsigned int i = 0; i < generatedShaderPasses.size(); i++)
  {
    generatedShaderPasses[i]->BuildShader(true);
  }
 
  for (unsigned int i = 0; i < generatedShaderGenTechs.size(); i++)
  {
    generatedShaderGenTechs[i]->SetSchemeName(Ogre::MSN_SHADERGEN);
  }
  
  for (unsigned int i = 0; i < generatedShaderLegacyTechs.size(); i++)
  {
    generatedShaderLegacyTechs[i]->SetSchemeName("SO3_LEGACY");
  }
  
  // update shadows
  for (unsigned int i = 0; i < generatedShadowTechs.size(); i++)
  {
    STechnique* stech = generatedShadowTechs[i];
    stech->GetParentMaterial()->GetScene()->GetShadowManager()->UpdateShadowMaterial(stech->GetOgreTechniquePointer());
  }
}
 
int SMaterial::CountMaterialsInScript(std::string path)
{
  int numMats = 0;
  Ogre::ResourceManager::ResourceMapIterator it = Ogre::MaterialManager::getSingleton().getResourceIterator();
  while (it.hasMoreElements())
  {
    Ogre::MaterialPtr mat = Ogre::static_pointer_cast<Ogre::Material>(it.getNext());
    if (mat->getOrigin() == path)
    {
      numMats++;
    }
  }
  return numMats;
}
 
void SMaterial::SetIgnoreSlicePlane(bool state)
{
  mIgnoreSlicePlane = state;
 
  CleanUpGeneratedTechniques();
 
  //update shaders
  Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
  for (unsigned int i = 0; i < techs.size(); i++)
  {
    Ogre::Technique* tech = techs[i];
    Ogre::Technique::Passes passes = tech->getPasses();
    for (unsigned int j = 0; j < passes.size(); j++)
    {
      Ogre::Any bindedSPass = passes[j]->getUserObjectBindings().getUserAny("SPass");
      if (bindedSPass.has_value())
      {
        SPass* pass = Ogre::any_cast<SPass*> (bindedSPass);
        if (pass && pass->IsShaderGenerated())
        {
          pass->BuildShader(true);
        }
      }
    }
 
    //generate shadow pass
    if (GetScene()->GetShadowManager())
      GetScene()->GetShadowManager()->UpdateShadowMaterial(tech);
  }
}
 
bool SMaterial::GetIgnoreSlicePlane()
{
  return mIgnoreSlicePlane;
}
 
void SMaterial::UpdateGeneratedMaterial(bool full)
{
  if (full)
    CleanUpGeneratedTechniques();
  else
    SRoot::getSingletonPtr()->RemoveGeneratedMaterial(getOgreMaterialPointer().get());
 
  Ogre::Material::Techniques techs = ogreMaterial->getTechniques();
  unsigned int id = 0;
  for (unsigned int i = 0; i < techs.size(); i++, id++)
  {
    Ogre::Technique* tech = techs[i];
    Ogre::Technique::Passes passes = tech->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 (GetScene()->GetShadowManager())
      GetScene()->GetShadowManager()->UpdateShadowMaterial(tech);
  }
}
 
}