SO3Pass.cpp

Go to the documentation of this file.

 
#include <boost/format.hpp>
#include <boost/algorithm/string.hpp>
 
#include "SO3Renderer/SO3Root.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Technique.h"
#include "SO3Material/SO3Pass.h"
#include "SO3Material/SO3Texture.h"
#include "SO3Material/SO3ShaderGeneratorUnified.h"
//#include "SO3Material/SO3ShaderGeneratorCG.h"
//#include "SO3Material/SO3ShaderGeneratorGLES.h"
//#include "SO3Material/SO3ShaderGeneratorGLSL.h"
//#include "SO3Material/SO3ShaderGeneratorHLSL.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
 
namespace SO3
{
 
SPass::SPass(STechnique* technique, Ogre::Pass* ogrePassRef) : SData(ogrePassRef->getName())
{
  ogrePass = ogrePassRef;
  parentTechnique = technique;
  mGeneratedShader = false;
  mPointSize = 1.0f;
 
  Ogre::ResourceGroupManager& resGrpMgr = Ogre::ResourceGroupManager::getSingleton();
 
  //remove not found textures to avoid strange behavior or crash later
  const std::vector<Ogre::TextureUnitState*> texunits = ogrePass->getTextureUnitStates();
  for(unsigned int t = 0; t < texunits.size(); t++)
  {
    Ogre::TextureUnitState* pTex = texunits[t];
    Ogre::String tex_name = pTex->getTextureName();
    //test filename validity
    if (!tex_name.empty())
    {
      try
      {
        Ogre::String res_group = resGrpMgr.findGroupContainingResource(tex_name);
        Ogre::FileInfoListPtr file_list = resGrpMgr.findResourceFileInfo(res_group, tex_name);
        Ogre::VectorIterator<Ogre::FileInfoList> file_list_itr(*file_list);
        if (!file_list_itr.hasMoreElements())
        {
          Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[WARNING] Could not find the texture file : " + tex_name);
          pTex->setBlank();
        }
      }
      catch (Ogre::Exception &)
      {
        Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[WARNING] Could not find the texture file : " + tex_name);
        pTex->setBlank();
      }
    }
  }
 
  if (ogrePass->getShininess() == 0.0)
    ogrePass->setShininess(0.01f);
 
  //ogrePass->setPointAttenuation(true);
 
  //build shader if needed
  OrderTexturesUnitsByType();
  BuildShader(true);
}
 
SPass::SPass() : SData("")
{
  // Forbiden (private)
}
 
SPass::~SPass()
{
  Ogre::Any bindedSPass = ogrePass->getUserObjectBindings().getUserAny("SPass");
  if(bindedSPass.has_value())
    ogrePass->getUserObjectBindings().eraseUserAny("SPass");
 
  CleanGeneratedShader();
}
 
std::string SPass::GetTextureUnitTypedName(Ogre::TextureUnitState* unit)
{
  Ogre::String tex_name = unit->getName();
 
  Ogre::StringUtil::toLowerCase(tex_name);
  if ((tex_name.find("ambient") != Ogre::String::npos) ||
    (tex_name.find("lightmap") != Ogre::String::npos) ||
    (tex_name.find("occlusion") != Ogre::String::npos) ||
    (tex_name.find("diffuse") != Ogre::String::npos) ||
    (tex_name.find("bump") != Ogre::String::npos) ||
    (tex_name.find("normal") != Ogre::String::npos) ||
    (tex_name.find("emissive") != Ogre::String::npos) ||
    (tex_name.find("opacity") != Ogre::String::npos) ||
    (tex_name.find("reflection_mask") != Ogre::String::npos) ||
    (tex_name.find("reflection") != Ogre::String::npos) ||
    (tex_name.find("shininess") != Ogre::String::npos) ||
    (tex_name.find("specular") != Ogre::String::npos) ||
    (tex_name.find("opacity") != Ogre::String::npos) ||
    (tex_name.find("roughness") != Ogre::String::npos))
    return tex_name;
 
  // use texture name if no unit name
  tex_name = unit->getTextureName();
  Ogre::StringUtil::toLowerCase(tex_name);
  return tex_name;
}
 
SShaderGenerator::ShaderMapType SPass::GetTextureUnitType(Ogre::TextureUnitState* unit)
{
  Ogre::String tex_name = GetTextureUnitTypedName(unit);
 
  Ogre::TextureUnitState::EffectMap effects = unit->getEffects();
  Ogre::TextureUnitState::EffectMap::const_iterator effectEnd = effects.end();
  bool envMap = false;
  if (!effects.empty() && (effects.find(Ogre::TextureUnitState::ET_ENVIRONMENT_MAP) != effectEnd))
    envMap = true;
 
  SShaderGenerator::ShaderMapType curType = SShaderGenerator::MAP_DUMMY;
 
  if (!envMap && ((tex_name.find("ambient") != Ogre::String::npos) || (tex_name.find("lightmap") != Ogre::String::npos) || (tex_name.find("occlusion") != Ogre::String::npos) || (tex_name.find("_occ") != Ogre::String::npos)))
    curType = SShaderGenerator::MAP_AMBIENT;
  else if (!envMap && ((tex_name.find("diffuse") != Ogre::String::npos) || (tex_name.find("albedo") != Ogre::String::npos) || (tex_name.find("color") != Ogre::String::npos) || (tex_name.find("colour") != Ogre::String::npos)))
    curType = SShaderGenerator::MAP_DIFFUSE;
  else if ((tex_name.find("normal") != Ogre::String::npos) || (tex_name.find("nrm") != Ogre::String::npos) || (tex_name.find("norm") != Ogre::String::npos) || (tex_name.find("_nm") != Ogre::String::npos) || (tex_name.find("_nmap") != Ogre::String::npos) || (tex_name.find("_ddn") != Ogre::String::npos))
    curType = SShaderGenerator::MAP_NORMAL;
  else if ((tex_name.find("emissive") != Ogre::String::npos) || (tex_name.find("illum") != Ogre::String::npos))
    curType = SShaderGenerator::MAP_EMISSIVE;
  else if ((tex_name.find("reflection_mask") != Ogre::String::npos) || (tex_name.find("refmask") != Ogre::String::npos))
    curType = SShaderGenerator::MAP_REFMASK;
  else if (envMap || (tex_name.find("reflection") != Ogre::String::npos) || (tex_name.find("reflect") != Ogre::String::npos))
    curType = SShaderGenerator::MAP_REFLECTION;
  else if (tex_name.find("opacity") != Ogre::String::npos)
    curType = SShaderGenerator::MAP_OPACITY;
  else if ((tex_name.find("specular") != Ogre::String::npos) || (tex_name.find("spec") != Ogre::String::npos))
    curType = SShaderGenerator::MAP_SPECULAR;
  else if (tex_name.find("shininess") != Ogre::String::npos)
    curType = SShaderGenerator::MAP_SHININESS;
  else if ((tex_name.find("metallic") != Ogre::String::npos) || (tex_name.find("metalness") != Ogre::String::npos) || (tex_name.find("roughness") != Ogre::String::npos) || (tex_name.find("metallicroughness") != Ogre::String::npos) || (tex_name.find("_orm") != Ogre::String::npos))
    curType = SShaderGenerator::MAP_ROUGHNESS;
 
  return curType;
}
 
bool SPass::IsShaderGenerated()
{
  return mGeneratedShader;
}
 
void SPass::CleanGeneratedShader()
{
  if (!mGeneratedShader)
    return;
 
  ogrePass->setVertexProgram("");
  ogrePass->setFragmentProgram("");
}
 
void SPass::BuildShader(bool force)
{
  //Ogre::RTShader::ShaderGenerator* shaderGen = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
  Ogre::Technique* tech = parentTechnique->GetOgreTechniquePointer();
 
  //check if technique is supported before the technique compilation
  bool isSupported = tech->isSupported() && ogrePass->hasVertexProgram() && ogrePass->hasFragmentProgram();
  if (!isSupported)
  {
    Ogre::StringStream errors;
    isSupported = tech->checkGPURules(errors) && tech->checkHardwareSupport(true, errors) && ogrePass->hasVertexProgram() && ogrePass->hasFragmentProgram();
  }
 
  // ignore material pass with working shaders
  if (isSupported && (!mGeneratedShader || !force))
    return;
 
  bool needed = false;
  if ((ogrePass->getIlluminationStage() == Ogre::IS_UNKNOWN) && (tech->getSchemeName() != "basic") && (tech->getSchemeName() != "basic_mat") && (!ogrePass->hasVertexProgram() || !ogrePass->hasFragmentProgram() || !isSupported || (!parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() && SRoot::getSingletonPtr()->GetSlicePlaneState())))
    needed = true;
  
  if (needed || mGeneratedShader || force)
  {
    try
    {
      ogrePass->setVertexProgram("");
      ogrePass->setFragmentProgram("");
      Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
 
      /*
      // add RTSS params
      if (!mGeneratedShader || force)
      {
        SShaderGenerator shaderRTSS(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorRTSS, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        shaderRTSS.ApplyShader();
      }
      */
 
      if (rendererName == "OpenGL ES 2.x Rendering Subsystem" || rendererName == "Metal Rendering Subsystem")
      {
        SShaderGeneratorUnified VPshader(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorVP, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        MMechostr(MSKDEBUG, ">> Vertex Shader for material %s : %s\n", parentTechnique->GetParentMaterial()->GetName().c_str(), VPshader.GetShaderName().c_str());
        VPshader.ApplyShader();
 
        SShaderGeneratorUnified FPshader(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorFP, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        MMechostr(MSKDEBUG, ">> Fragment Shader for material %s : %s\n", parentTechnique->GetParentMaterial()->GetName().c_str(), FPshader.GetShaderName().c_str());
        FPshader.ApplyShader();
 
        mGeneratedShader = true;        
      }
#ifdef _WIN32
      // INTEL HD fail with GLSL shaders ?!
      else if (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem" || rendererName == "OpenGL Rendering Subsystem" || rendererName == "Vulkan Rendering Subsystem")
      {
        SShaderGeneratorUnified VPshader(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorVP, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        MMechostr(MSKDEBUG, ">> Vertex Shader for material %s : %s\n", parentTechnique->GetParentMaterial()->GetName().c_str(), VPshader.GetShaderName().c_str());
        VPshader.ApplyShader();
 
        SShaderGeneratorUnified FPshader(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorFP, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        MMechostr(MSKDEBUG, ">> Fragment Shader for material %s : %s\n", parentTechnique->GetParentMaterial()->GetName().c_str(), FPshader.GetShaderName().c_str());
        FPshader.ApplyShader();
 
        mGeneratedShader = true;
      }
#endif
      else
      {
        SShaderGeneratorUnified VPshader(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorVP, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        MMechostr(MSKDEBUG, ">> Vertex Shader for material %s : %s\n", parentTechnique->GetParentMaterial()->GetName().c_str(), VPshader.GetShaderName().c_str());
        VPshader.ApplyShader();
 
        SShaderGeneratorUnified FPshader(parentTechnique->GetOgreTechniquePointer(), ogrePass, SShaderGenerator::ShaderGeneratorFP, parentTechnique->GetParentMaterial()->GetIgnoreSlicePlane() || !SRoot::getSingletonPtr()->GetSlicePlaneState());
        MMechostr(MSKDEBUG, ">> Fragment Shader for material %s : %s\n", parentTechnique->GetParentMaterial()->GetName().c_str(), FPshader.GetShaderName().c_str());
        FPshader.ApplyShader();
 
        mGeneratedShader = true;
      }
    }
    catch (Ogre::Exception& e)
    {
      //not supported shader
      ogrePass->setVertexProgram("");
      ogrePass->setFragmentProgram("");
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[ERROR] Could not compute shader : " + e.getFullDescription());
    }
 
    //check that new technique is supported
    Ogre::Technique* tech = parentTechnique->GetOgreTechniquePointer();
    //check if technique is supported before the technique compilation
    isSupported = tech->isSupported();
    if (!isSupported)
    {
      Ogre::StringStream errors;
      isSupported = tech->checkGPURules(errors) && tech->checkHardwareSupport(true, errors);
    }
 
    if (!isSupported)
    {
      //remove shaders
      ogrePass->setVertexProgram("");
      ogrePass->setFragmentProgram("");
    }
 
    parentTechnique->GetParentMaterial()->getOgreMaterialPointer()->_notifyNeedsRecompile();
  }
}
 
Ogre::Pass* SPass::GetOgrePassPointer() 
{
        return ogrePass;
}
 
STechnique* SPass::GetTechnique()
{
  return parentTechnique;
}
 
int SPass::GetNumTextureUnitStates()
{
  return ogrePass->getNumTextureUnitStates();
}
 
std::string SPass::GetTextureUnitName(const unsigned int& textureUnit)
{
  std::string returnValue("");
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if (tmpTextureUnit != 0)
  {
    returnValue = tmpTextureUnit->getName();
    if(returnValue.empty())
      returnValue = boost::str(boost::format("%1%") %textureUnit);
  }
  return returnValue;
}
 
int SPass::GetTextureUnitIndexByName(const std::string& texname)
{
  return ogrePass->getTextureUnitStateIndex(ogrePass->getTextureUnitState(texname));
}
 
std::string SPass::GetTextureName(const unsigned int& textureUnit)
{  
  std::string texname;
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if (tmpTextureUnit != 0)
    texname = tmpTextureUnit->getTextureName();
  
  return texname;
}
 
std::string SPass::GetTextureFileName(const unsigned int& textureUnit)
{  
  std::string texFile = "";
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if (tmpTextureUnit != 0)
  {
    Ogre::ResourceGroupManager& resGrpMgr = Ogre::ResourceGroupManager::getSingleton();
    Ogre::String tex_name = tmpTextureUnit->getTextureName();
    Ogre::String res_group = resGrpMgr.findGroupContainingResource(tex_name);
    Ogre::FileInfoListPtr file_list = resGrpMgr.findResourceFileInfo(res_group, tex_name);
    Ogre::VectorIterator<Ogre::FileInfoList> file_list_itr(*file_list);
    if (file_list_itr.hasMoreElements())
    {
      Ogre::FileInfo file_info = file_list_itr.getNext();
      texFile = file_info.filename;
    }
  }
  return texFile;
}
 
void SPass::SetTextureUScroll(const unsigned int& textureUnit, const float& value)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    tmpTextureUnit->setTextureUScroll(Ogre::Real(value));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetTextureUScroll");
 
  UpdateGeneratedPass(true);
}
 
float SPass::GetTextureUScroll(const unsigned int& textureUnit)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    return static_cast <float> (tmpTextureUnit->getTextureUScroll());
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::GetTextureUScroll");
 
  return 0.0f;
}
 
void SPass::SetTextureVScroll(const unsigned int& textureUnit, const float& value)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    tmpTextureUnit->setTextureVScroll(Ogre::Real(value));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetTextureVScroll");
 
  UpdateGeneratedPass(true);
}
 
float SPass::GetTextureVScroll(const unsigned int& textureUnit)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    return static_cast <float> (tmpTextureUnit->getTextureVScroll());
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::GetTextureVScroll");
 
  return 0.0f;
}
 
void SPass::SetTextureUScale(const unsigned int& textureUnit, const float& value)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    tmpTextureUnit->setTextureUScale(Ogre::Real(value));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetTextureUScale");
 
  UpdateGeneratedPass(true);
}
 
float SPass::GetTextureUScale(const unsigned int& textureUnit)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    return static_cast <float> (tmpTextureUnit->getTextureUScale());
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::GetTextureUScale");
 
  return 0.0f;
}
 
void SPass::SetTextureVScale(const unsigned int& textureUnit, const float& value)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    tmpTextureUnit->setTextureVScale(Ogre::Real(value));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetTextureVScale");
 
  UpdateGeneratedPass(true);
}
 
float SPass::GetTextureVScale(const unsigned int& textureUnit)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    return static_cast <float> (tmpTextureUnit->getTextureVScale());
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::GetTextureVScale");
 
  return 0.0f;
}
 
void SPass::SetTextureRotate(const unsigned int& textureUnit, const float& radianAngle)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    tmpTextureUnit->setTextureRotate(Ogre::Radian(radianAngle));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetTextureRotate");
 
  UpdateGeneratedPass(true);
}
 
const float SPass::GetTextureRotate(const unsigned int& textureUnit)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    return static_cast <float> (tmpTextureUnit->getTextureRotate().valueRadians());
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::GetTextureRotate");
 
  return 0.0f;
}
 
void SPass::SetTextureScrollAnimation(const unsigned int& textureUnit, const float& uSpeed, const float& vSpeed)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if (tmpTextureUnit != 0)
    tmpTextureUnit->setScrollAnimation(Ogre::Real(uSpeed), Ogre::Real(vSpeed));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetScrollAnimation");
 
  UpdateGeneratedPass(true);
}
 
void SPass::SetTextureRotateAnimation(const unsigned int& textureUnit, const float& speed)
{
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
  if(tmpTextureUnit != 0)
    tmpTextureUnit->setRotateAnimation(Ogre::Real(speed));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Texture unit not found on material.", "SMaterial::SetRotateAnimation");
 
  UpdateGeneratedPass(true);
}
 
bool SPass::GetLightingEnabled()
{
  return ogrePass->getLightingEnabled();
}
 
void SPass::SetLightingEnabled(const bool& state)
{
  ogrePass->setLightingEnabled(state);
 
  UpdateGeneratedPass(true);
}
 
void SPass::SetAmbientColor(const int& color)
{
  ogrePass->setAmbient(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedPass();
}
 
void SPass::SetAmbientColor(Ogre::ColourValue color)
{
  ogrePass->setAmbient(color);
 
  UpdateGeneratedPass();
}
 
int SPass::GetAmbientColor()
{
  return ConversionTools::OgreToScolColorRGBA(ogrePass->getAmbient());
}
 
void SPass::SetDiffuseColor(const int& color)
{
  ogrePass->setDiffuse(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedPass();
}
 
void SPass::SetDiffuseColor(Ogre::ColourValue color)
{
  ogrePass->setDiffuse(color);
 
  UpdateGeneratedPass();
}
 
int SPass::GetDiffuseColor()
{
  return ConversionTools::OgreToScolColorRGBA(ogrePass->getDiffuse());
}
 
void SPass::SetSpecularColor(const int& color)
{
  ogrePass->setSpecular(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedPass();
}
 
void SPass::SetSpecularColor(Ogre::ColourValue color)
{
  ogrePass->setSpecular(color);
 
  UpdateGeneratedPass();
}
 
int SPass::GetSpecularColor()
{
  return ConversionTools::OgreToScolColorRGBA(ogrePass->getSpecular());
}
 
void SPass::SetSelfIlluminationColor(const int& color)
{
  ogrePass->setSelfIllumination(ConversionTools::ScolToOgreColorRGBA(color));
 
  UpdateGeneratedPass();
}
 
void SPass::SetSelfIlluminationColor(Ogre::ColourValue color)
{
  ogrePass->setSelfIllumination(color);
 
  UpdateGeneratedPass();
}
 
int SPass::GetSelfIlluminationColor()
{
  return ConversionTools::OgreToScolColorRGBA(ogrePass->getSelfIllumination());
}
 
void SPass::SetShininess(const float& value)
{
  if (value == 0.0f)
    ogrePass->setShininess(0.01f);
  else
    ogrePass->setShininess(value);
 
  UpdateGeneratedPass();
}
 
float SPass::GetShininess()
{
  return ogrePass->getShininess();
}
 
void SPass::SetUseVertexColor(bool state)
{
  if (state)
    ogrePass->setVertexColourTracking(Ogre::TVC_AMBIENT | Ogre::TVC_DIFFUSE);
  else
    ogrePass->setVertexColourTracking(Ogre::TVC_NONE);
 
  UpdateGeneratedPass(true);
}
 
bool SPass::GetUseVertexColor()
{
  return (bool)((ogrePass->getVertexColourTracking() & Ogre::TVC_AMBIENT) || (ogrePass->getVertexColourTracking() == Ogre::TVC_DIFFUSE));
}
 
void SPass::SetTexture(const unsigned int& textureUnit, STexture* texture, std::string name)
{
  bool unitsUpdated = false;
  Ogre::TextureUnitState* tmpTextureUnit = GetTextureUnitState(textureUnit);
 
  try
  {
    if (tmpTextureUnit != 0)
    {
      if ((texture != 0) /*&& (tmpTextureUnit->_getTexturePtr() != texture->getOgreTexturePointer())*/) // this test crash on deleted textures
      {
        if (!texture->getOgreTexturePointer())
          tmpTextureUnit->setBlank();
        else
          tmpTextureUnit->setTexture(texture->getOgreTexturePointer());
 
        if (!name.empty())
          tmpTextureUnit->setName(name);
        tmpTextureUnit->retryTextureLoad();
      }
      else
      {
        if (textureUnit == (ogrePass->getNumTextureUnitStates() - 1))
        {
          ogrePass->removeTextureUnitState(textureUnit);
          unitsUpdated = true;
        }
      }
    }
    else if (texture != 0)
    {
      while (ogrePass->getNumTextureUnitStates() < (textureUnit + 1))
      {
        tmpTextureUnit = ogrePass->createTextureUnitState();
        unitsUpdated = true;
      }
 
      if (!name.empty())
        tmpTextureUnit->setName(name);
 
      if (!texture->getOgreTexturePointer())
        tmpTextureUnit->setBlank();
      else
        tmpTextureUnit->setTexture(texture->getOgreTexturePointer());
      tmpTextureUnit->retryTextureLoad();
    }
  }
  catch (Ogre::Exception &)
  {
    Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[WARNING] Could not apply the texture file");
    if (tmpTextureUnit != 0)
      tmpTextureUnit->setBlank();
  }
 
  if (unitsUpdated)
    OrderTexturesUnitsByType();
 
  UpdateGeneratedPass(unitsUpdated);
}
 
STexture* SPass::GetTexture(const unsigned int& textureUnit)
{
  std::string texname = GetTextureName(textureUnit);
  std::string texfile = texname; //;GetTextureFileName(textureUnit); // this bug on android
  if (texname.empty())
    return 0;
 
  SScene* scene = parentTechnique->GetParentMaterial()->GetScene();
  std::string groupName = parentTechnique->GetParentMaterial()->GetGroupName();
  STexture* newTex = scene->GetTexture(groupName, texname);
  if (newTex == 0) // && (!texfile.empty()))
    newTex = scene->CreateTexture(groupName, texname, texfile);
 
  return newTex;
}
 
int SPass::GetTextureUnitByType(SShaderGenerator::ShaderMapType type)
{
  Ogre::TextureUnitState* foundTex = 0;
  int unitId = -1;
 
  Ogre::Pass::TextureUnitStates units = ogrePass->getTextureUnitStates();
  for (unsigned int i = 0; i < units.size() && !foundTex; i++)
  {
    Ogre::TextureUnitState* pTex = units[i];
    Ogre::String tex_name = GetTextureUnitTypedName(pTex);
 
    Ogre::TextureUnitState::EffectMap effects = pTex->getEffects();
    Ogre::TextureUnitState::EffectMap::const_iterator effectEnd = effects.end();
    bool envMap = false;
    if (!effects.empty() && (effects.find(Ogre::TextureUnitState::ET_ENVIRONMENT_MAP) != effectEnd))
      envMap = true;
 
    SShaderGenerator::ShaderMapType curType = SShaderGenerator::MAP_DUMMY;
 
    if (!envMap && ((tex_name.find("ambient") != Ogre::String::npos) || (tex_name.find("lightmap") != Ogre::String::npos) || (tex_name.find("occlusion") != Ogre::String::npos) || (tex_name.find("_occ") != Ogre::String::npos)))
      curType = SShaderGenerator::MAP_AMBIENT;
    else if ((tex_name.find("normal") != Ogre::String::npos) || (tex_name.find("nrm") != Ogre::String::npos) || (tex_name.find("norm") != Ogre::String::npos) || (tex_name.find("_nm") != Ogre::String::npos) || (tex_name.find("_nmap") != Ogre::String::npos))
      curType = SShaderGenerator::MAP_NORMAL;
    else if ((tex_name.find("emissive") != Ogre::String::npos) || (tex_name.find("illum") != Ogre::String::npos))
      curType = SShaderGenerator::MAP_EMISSIVE;
    else if ((tex_name.find("reflection_mask") != Ogre::String::npos) || (tex_name.find("refmask") != Ogre::String::npos))
      curType = SShaderGenerator::MAP_REFMASK;
    else if (envMap || (tex_name.find("reflection") != Ogre::String::npos) || (tex_name.find("reflect") != Ogre::String::npos))
      curType = SShaderGenerator::MAP_REFLECTION;
    else if (tex_name.find("opacity") != Ogre::String::npos)
      curType = SShaderGenerator::MAP_OPACITY;
    else if ((tex_name.find("specular") != Ogre::String::npos) || (tex_name.find("spec") != Ogre::String::npos))
      curType = SShaderGenerator::MAP_SPECULAR;
    else if (tex_name.find("shininess") != Ogre::String::npos)
      curType = SShaderGenerator::MAP_SHININESS;
    else if ((tex_name.find("metallic") != Ogre::String::npos) || (tex_name.find("metalness") != Ogre::String::npos) || (tex_name.find("roughness") != Ogre::String::npos) || (tex_name.find("metallicroughness") != Ogre::String::npos) || (tex_name.find("_orm") != Ogre::String::npos))
      curType = SShaderGenerator::MAP_ROUGHNESS;
    else
      curType = SShaderGenerator::MAP_DIFFUSE;
 
    if (curType == type)
      foundTex = pTex;
 
    unitId++;
  }
 
  if (foundTex)
    return unitId;
  else
    return -1;
}
 
Ogre::TextureUnitState* SPass::GetTextureUnitState(const unsigned int& textureUnit)
{
  // Check if the targetTextureUnit is inbound
  Ogre::TextureUnitState* returnValue = 0;
 
  // Check if inbound
  size_t numTextureUnits = ogrePass->getNumTextureUnitStates();
  if ((numTextureUnits > 0) && (textureUnit < numTextureUnits))
    returnValue = ogrePass->getTextureUnitState(textureUnit);
 
  return returnValue;
}
 
const Ogre::GpuNamedConstants SPass::GetVertexProgramParameters()
{
  Ogre::GpuNamedConstants paramList;
  if(ogrePass->hasVertexProgram())
  {
    // Get param list
    Ogre::GpuProgramParametersSharedPtr vertexProgramParameters = ogrePass->getVertexProgramParameters();
    paramList = vertexProgramParameters->getConstantDefinitions();
 
    // Filter the list
    Ogre::GpuConstantDefinitionMap::iterator it = paramList.map.begin();
    while(it != paramList.map.end())
    {
      if(boost::algorithm::ends_with(it->first, "[0]"))
      {
        // Erase duplicate entry
        it = paramList.map.erase(it);
      }
      else
        it++;
    }
  }
  return paramList;
}
 
void SPass::SetVertexProgramAutoParameter(const std::string& paramName, const Ogre::GpuProgramParameters::AutoConstantType& paramType, const size_t& paramExtraInfos)
{
  if(ogrePass->hasVertexProgram())
  {
    Ogre::GpuProgramParametersSharedPtr vertexProgramParameters = ogrePass->getVertexProgramParameters();
    if(vertexProgramParameters->_findNamedConstantDefinition(paramName))
      vertexProgramParameters->setNamedAutoConstant(paramName, paramType, paramExtraInfos);
  }
}
 
void SPass::SetVertexProgramParameter(const std::string& paramName, const std::string& value)
{
  if(ogrePass->hasVertexProgram())
  {
    Ogre::GpuProgramParametersSharedPtr vertexProgramParameters = ogrePass->getVertexProgramParameters();
    const Ogre::GpuConstantDefinition* constantDefinition = vertexProgramParameters->_findNamedConstantDefinition(paramName);
    if(constantDefinition != 0)
    {
      // Try to convert from string to constant definition type.
      switch(constantDefinition->constType)
      {
      case Ogre::GCT_INT1:
        if(Ogre::StringConverter::isNumber(value))
          vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseInt(value));
        break;
      /*case Ogre::GCT_INT2:
        vertexProgramParameters->setNamedConstant((paramName, Ogre::StringConverter::parseVector2(value));
        break;*/
      case Ogre::GCT_INT3:
        vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector3(value));
        break;
      case Ogre::GCT_INT4:
        vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector4(value));
        break;
      case Ogre::GCT_FLOAT1:
        if(Ogre::StringConverter::isNumber(value))
          vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseReal(value));
        break;
      /*case Ogre::GCT_FLOAT2:
        vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector2(value));
        break;*/
      case Ogre::GCT_FLOAT3:
        vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector3(value));
        break;
      case Ogre::GCT_FLOAT4:
        vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector4(value));
        break;
      case Ogre::GCT_MATRIX_4X4:
        vertexProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseMatrix4(value));
        break;
      };
    }
  }
}
 
const Ogre::GpuNamedConstants SPass::GetFragmentProgramParameters()
{
  Ogre::GpuNamedConstants paramList;
  if(ogrePass->hasFragmentProgram())
  {
    // Get param list
    Ogre::GpuProgramParametersSharedPtr fragmentProgramParameters = ogrePass->getFragmentProgramParameters();
    paramList = fragmentProgramParameters->getConstantDefinitions();
 
    // Filter the list
    Ogre::GpuConstantDefinitionMap::iterator it = paramList.map.begin();
    while(it != paramList.map.end())
    {
      if(boost::algorithm::ends_with(it->first, "[0]"))
      {
        // Erase duplicate entry
        it = paramList.map.erase(it);
      }
      else
        it++;
    }
  }
  return paramList;
}
 
void SPass::SetFragmentProgramAutoParameter(const std::string& paramName, const Ogre::GpuProgramParameters::AutoConstantType& paramType, const size_t& paramExtraInfos)
{
  if(ogrePass->hasFragmentProgram())
  {
    Ogre::GpuProgramParametersSharedPtr fragmentProgramParameters = ogrePass->getFragmentProgramParameters();
    if(fragmentProgramParameters->_findNamedConstantDefinition(paramName))
      fragmentProgramParameters->setNamedAutoConstant(paramName, paramType, paramExtraInfos);
  }
}
 
void SPass::SetFragmentProgramParameter(const std::string& paramName, const std::string& value)
{
  if(ogrePass->hasFragmentProgram())
  {
    Ogre::GpuProgramParametersSharedPtr fragmentProgramParameters = ogrePass->getFragmentProgramParameters();
    const Ogre::GpuConstantDefinition* constantDefinition = fragmentProgramParameters->_findNamedConstantDefinition(paramName);
    if(constantDefinition != 0)
    {
      // Try to convert from string to constant definition type.
      switch(constantDefinition->constType)
      {
      case Ogre::GCT_INT1:
        if(Ogre::StringConverter::isNumber(value))
          fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseInt(value));
        break;
      /*case Ogre::GCT_INT2:
        fragmentProgramParameters->setNamedConstant((paramName, Ogre::StringConverter::parseVector2(value));
        break;*/
      case Ogre::GCT_INT3:
        fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector3(value));
        break;
      case Ogre::GCT_INT4:
        fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector4(value));
        break;
      case Ogre::GCT_FLOAT1:
        if(Ogre::StringConverter::isNumber(value))
          fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseReal(value));
        break;
      /*case Ogre::GCT_FLOAT2:
        fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector2(value));
        break;*/
      case Ogre::GCT_FLOAT3:
        fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector3(value));
        break;
      case Ogre::GCT_FLOAT4:
        fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseVector4(value));
        break;
      case Ogre::GCT_MATRIX_4X4:
        fragmentProgramParameters->setNamedConstant(paramName, Ogre::StringConverter::parseMatrix4(value));
        break;
      };
    }
  }
}
 
SPass::SceneBlendFactor SPass::GetSourceBlendFactor() const
{
  return static_cast<SPass::SceneBlendFactor>(static_cast<int>(ogrePass->getSourceBlendFactor()));
}
 
SPass::SceneBlendFactor SPass::GetDestBlendFactor() const
{
  return static_cast<SPass::SceneBlendFactor>(static_cast<int>(ogrePass->getDestBlendFactor()));
}
 
SPass::SceneBlendFactor SPass::GetSourceBlendFactorAlpha() const
{
  return static_cast<SPass::SceneBlendFactor>(static_cast<int>(ogrePass->getSourceBlendFactorAlpha()));
}
 
SPass::SceneBlendFactor SPass::GetDestBlendFactorAlpha() const
{
  return static_cast<SPass::SceneBlendFactor>(static_cast<int>(ogrePass->getDestBlendFactorAlpha()));
}
 
void SPass::SetSceneBlending(const SPass::SceneBlendFactor sourceFactor, const SPass::SceneBlendFactor destFactor)
{
  ogrePass->setSceneBlending(static_cast<Ogre::SceneBlendFactor>(static_cast<int>(sourceFactor)),
    static_cast<Ogre::SceneBlendFactor>(static_cast<int>(destFactor)));
 
  UpdateGeneratedPass(true);  
}
 
void SPass::SetSceneBlending(const SPass::SceneBlendFactor sourceFactor, const SPass::SceneBlendFactor destFactor, const SPass::SceneBlendFactor sourceFactorAlpha, const SPass::SceneBlendFactor destFactorAlpha)
{
  ogrePass->setSeparateSceneBlending(static_cast<Ogre::SceneBlendFactor>(static_cast<int>(sourceFactor)),
                                     static_cast<Ogre::SceneBlendFactor>(static_cast<int>(destFactor)),
                                     static_cast<Ogre::SceneBlendFactor>(static_cast<int>(sourceFactorAlpha)),
                                     static_cast<Ogre::SceneBlendFactor>(static_cast<int>(destFactorAlpha)));
 
  UpdateGeneratedPass(true);
}
 
SPass::SceneBlendOperation SPass::GetSceneBlendingOperation() const
{
  return static_cast<SPass::SceneBlendOperation>(static_cast<int>(ogrePass->getSceneBlendingOperation()));
}
 
SPass::SceneBlendOperation SPass::GetSceneBlendingOperationAlpha() const
{
  return static_cast<SPass::SceneBlendOperation>(static_cast<int>(ogrePass->getSceneBlendingOperationAlpha()));
}
 
void SPass::SetSceneBlendingOperation(SPass::SceneBlendOperation op, SPass::SceneBlendOperation alphaOp)
{
  ogrePass->setSeparateSceneBlendingOperation(static_cast<Ogre::SceneBlendOperation>(static_cast<int>(op)),
                                              static_cast<Ogre::SceneBlendOperation>(static_cast<int>(alphaOp)));
 
  UpdateGeneratedPass(true);
}
 
void SPass::SetDepthCheckEnabled(bool enabled)
{
  ogrePass->setDepthCheckEnabled(enabled);
 
  UpdateGeneratedPass(true);
}
        
bool SPass::GetDepthCheckEnabled() const
{
  return ogrePass->getDepthCheckEnabled();
}
 
void SPass::SetDepthWriteEnabled(bool enabled)
{
  ogrePass->setDepthWriteEnabled(enabled);
  ogrePass->getParent()->getParent()->setTransparencyCastsShadows(!enabled);
 
  UpdateGeneratedPass(true);
}
 
bool SPass::GetDepthWriteEnabled() const
{
  return ogrePass->getDepthWriteEnabled();
}
 
void SPass::SetDepthFunction(SPass::CompareFunction func)
{
  ogrePass->setDepthFunction(static_cast<Ogre::CompareFunction>(static_cast<int>(func)));
 
  UpdateGeneratedPass(true);
}
 
SPass::CompareFunction SPass::GetDepthFunction() const
{
  return static_cast<SPass::CompareFunction>(static_cast<int>(ogrePass->getDepthFunction()));
}
 
void SPass::SetAlphaRejection(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled)
{
  ogrePass->setAlphaRejectSettings(static_cast<Ogre::CompareFunction>(static_cast<int>(func)), value, alphaToCoverageEnabled);
  
  UpdateGeneratedPass(true);
}
 
SPass::CompareFunction SPass::GetAlphaRejectionFunction() const
{
  return static_cast<SPass::CompareFunction>(static_cast<int>(ogrePass->getAlphaRejectFunction()));
}
 
unsigned char SPass::GetAlphaRejectionValue() const
{
  return ogrePass->getAlphaRejectValue();
}
 
bool SPass::GetAlphaToCoverage() const
{
  return ogrePass->isAlphaToCoverageEnabled();
}
 
void SPass::SetColourWriteEnabled(bool state)
{
  ogrePass->setColourWriteEnabled(state);
  
  UpdateGeneratedPass(true);
}
 
bool SPass::GetColourWriteEnabled() const
{
  return ogrePass->getColourWriteEnabled();
}
 
void SPass::SetCullingMode(const bool state)
{
  Ogre::CullingMode mode = (state) ? Ogre::CULL_CLOCKWISE : Ogre::CULL_NONE;
  ogrePass->setCullingMode(mode);
 
  ogrePass->getParent()->getParent()->setTransparencyCastsShadows(!state && !ogrePass->getDepthWriteEnabled());
 
  UpdateGeneratedPass(true);
}
 
bool SPass::GetCullingMode() const
{
  if (ogrePass->getCullingMode() == Ogre::CULL_NONE)
    return false;
  else
    return true;
}
 
void SPass::SetPointSize(Ogre::Real size)
{
  mPointSize = size;
 
  if (ogrePass->getPolygonMode() == Ogre::PM_POINTS)
  {
    ogrePass->setPointSize(mPointSize);
    //ogrePass->setPointAttenuation(true);
  }
  UpdateGeneratedPass();
}
 
float SPass::GetPointSize()
{
  return ogrePass->getPointSize();
}
 
bool SPass::IsPointCloud()
{
  if (ogrePass->getPolygonMode() == Ogre::PM_POINTS)
    return true;
 
  return false;
}
 
void SPass::SetPolygonMode(PolygonMode mode)
{
  ogrePass->setPolygonMode(static_cast<Ogre::PolygonMode>(mode));
 
  if (ogrePass->getPolygonMode() == Ogre::PM_POINTS)
  {
    ogrePass->setPointSize(mPointSize);
    //ogrePass->setPointAttenuation(true);
  }
  else
  {
    ogrePass->setPointSize(1.0f);
    //ogrePass->setPointAttenuation(false);
  }
 
  if (mode == SO3_POLYGONMODE_POINTS)
    ogrePass->setPolygonModeOverrideable(false);
  else
    ogrePass->setPolygonModeOverrideable(true);
  
  UpdateGeneratedPass(true);
}
 
SPass::PolygonMode SPass::GetPolygonMode()
{
  return static_cast<SPass::PolygonMode>(ogrePass->getPolygonMode());
}
 
void SPass::SetTextureUnitColorBlendModeFactor(const unsigned int& textureUnit, float factor)
{
  if (textureUnit < ogrePass->getNumTextureUnitStates())
  {
    Ogre::TextureUnitState* pTex = ogrePass->getTextureUnitState(textureUnit);
    if (!pTex)
      return;
 
    pTex->setColourOperationEx(Ogre::LBX_BLEND_MANUAL, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT, Ogre::ColourValue::Black, Ogre::ColourValue::White, factor);
 
    /*
    Ogre::RTShader::ShaderGenerator* shaderGen = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
    Ogre::RTShader::RenderState* rs = shaderGen->getRenderState(Ogre::MSN_SHADERGEN, *(parentTechnique->GetOgreTechniquePointer()->getParent()), ogrePass->getIndex());
 
    if (rs)
    {
      Ogre::RTShader::SubRenderState* srs = rs->getSubRenderState(Ogre::RTShader::SRS_IMAGE_BASED_LIGHTING);
 
      const Ogre::LayerBlendModeEx& bl = ogrePass->getTextureUnitState(textureUnit)->getColourBlendMode();
      if (srs)
        srs->setParameter("luminance", std::to_string((bl.factor == 0.0) ? 1.0 : bl.factor));
    }*/
 
    UpdateGeneratedPass(true);
  }
}
 
float SPass::GetTextureUnitColorBlendModeFactor(const unsigned int& textureUnit)
{
  if (textureUnit < ogrePass->getNumTextureUnitStates())
    return ogrePass->getTextureUnitState(textureUnit)->getColourBlendMode().factor;
  
  return 1.0f;
}
 
void SPass::RemoveTexture(const unsigned int& textureUnit)
{
  if (textureUnit < ogrePass->getNumTextureUnitStates())
  {
    ogrePass->removeTextureUnitState(textureUnit);
    OrderTexturesUnitsByType();
  }
    
  UpdateGeneratedPass(true);
}
 
void SPass::OrderTexturesUnitsByType()
{
  const Ogre::Pass::TextureUnitStates& texunits = ogrePass->getTextureUnitStates();
 
  if (texunits.size() <= 1)
    return;
 
  int passConf = 0;
 
  Ogre::TextureUnitState amb(ogrePass, *texunits[0]);
  Ogre::TextureUnitState diff(ogrePass, *texunits[0]);
  Ogre::TextureUnitState ref(ogrePass, *texunits[0]);
  Ogre::TextureUnitState ill(ogrePass, *texunits[0]);
  Ogre::TextureUnitState norm(ogrePass, *texunits[0]);
  Ogre::TextureUnitState roughn(ogrePass, *texunits[0]);
  Ogre::TextureUnitState opacity(ogrePass, *texunits[0]);
 
  std::vector<Ogre::TextureUnitState> otherUnits;
 
  for (unsigned int t = 0; t < texunits.size(); t++)
  {
    Ogre::TextureUnitState* pTex = texunits[t];
    SShaderGenerator::ShaderMapType type = GetTextureUnitType(pTex);
 
    switch (type)
    {
    case SShaderGenerator::MAP_AMBIENT:
      amb = *pTex;
      passConf |= SShaderGenerator::MAP_AMBIENT;
      break;
    case SShaderGenerator::MAP_DIFFUSE:
      diff = *pTex;
      passConf |= SShaderGenerator::MAP_DIFFUSE;
      break;
    case SShaderGenerator::MAP_EMISSIVE:
      ill = *pTex;
      passConf |= SShaderGenerator::MAP_EMISSIVE;
      break;
    case SShaderGenerator::MAP_NORMAL:
      norm = *pTex;
      passConf |= SShaderGenerator::MAP_NORMAL;
      break;
    case SShaderGenerator::MAP_REFLECTION:
      ref = *pTex;
      passConf |= SShaderGenerator::MAP_REFLECTION;
      break;
    case SShaderGenerator::MAP_ROUGHNESS:
      roughn = *pTex;
      passConf |= SShaderGenerator::MAP_ROUGHNESS;
      break;
    case SShaderGenerator::MAP_OPACITY:
      opacity = *pTex;
      passConf |= SShaderGenerator::MAP_OPACITY;
      break;
    default:
      otherUnits.push_back(Ogre::TextureUnitState(ogrePass, *pTex));
    }
  }
 
  if (passConf == 0)
    return;
 
  ogrePass->removeAllTextureUnitStates();
 
  Ogre::TextureUnitState* newUnit = 0;
  if (passConf & SShaderGenerator::MAP_AMBIENT)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(amb);
  }
 
  if (passConf & SShaderGenerator::MAP_DIFFUSE)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(diff);
  }
 
  if (passConf & SShaderGenerator::MAP_NORMAL)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(norm);
  }
 
  for (auto u : otherUnits)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(u);
  }
 
  if (passConf & SShaderGenerator::MAP_REFLECTION)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(ref);
  }
 
  if (passConf & SShaderGenerator::MAP_EMISSIVE)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(ill);
  }
 
  if (passConf & SShaderGenerator::MAP_ROUGHNESS)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(roughn);
  }
 
  if (passConf & SShaderGenerator::MAP_OPACITY)
  {
    newUnit = ogrePass->createTextureUnitState();
    *newUnit = Ogre::TextureUnitState(opacity);
  }
}
 
void SPass::SetTextureByType(STexture* tex, SShaderGenerator::ShaderMapType type)
{
  int tindex = GetTextureUnitByType(type);
  Ogre::TextureUnitState* tunit = 0;
 
  bool newUnit = false;
  if (tindex >= 0)
  {
    tunit = ogrePass->getTextureUnitState(tindex);
  }
  else
  {
    tunit = ogrePass->createTextureUnitState();
    tunit->setName(GetTextureUnitNameByType(type));
    newUnit = true;
  }
 
  if (!tex || !tex->getOgreTexturePointer())
    tunit->setBlank();
  else
    tunit->setTexture(tex->getOgreTexturePointer());
 
  if (type == SShaderGenerator::MAP_REFLECTION)
  {
    if (tex && tex->getOgreTexturePointer() && tex->getOgreTexturePointer()->getNumFaces() == 6)
      tunit->setEnvironmentMap(true, Ogre::TextureUnitState::ENV_REFLECTION);
    else
      tunit->setEnvironmentMap(true, Ogre::TextureUnitState::ENV_CURVED);
  }
 
  if (newUnit)
    OrderTexturesUnitsByType();
 
  UpdateGeneratedPass(true);
}
 
std::string SPass::GetTextureUnitNameByType(SShaderGenerator::ShaderMapType type)
{
  std::string name = "";
  switch (type)
  {
  case SShaderGenerator::MAP_AMBIENT:
    name = "ambient";
    break;
  case SShaderGenerator::MAP_DIFFUSE:
    name = "diffuse";
    break;
  case SShaderGenerator::MAP_BUMP:
    name = "bump";
    break;
  case SShaderGenerator::MAP_EMISSIVE:
    name = "emissive";
    break;
  case SShaderGenerator::MAP_NORMAL:
    name = "normal";
    break;
  case SShaderGenerator::MAP_OPACITY:
    name = "opacity";
    break;
  case SShaderGenerator::MAP_REFMASK:
    name = "reflection_mask";
    break;
  case SShaderGenerator::MAP_REFLECTION:
    name = "reflection";
    break;
  case SShaderGenerator::MAP_SHININESS:
    name = "shininess";
    break;
  case SShaderGenerator::MAP_SPECULAR:
    name = "specular";
    break;
  case SShaderGenerator::MAP_ROUGHNESS:
    name = "roughness";
    break;
  }
 
  return name;
}
 
void SPass::UpdateGeneratedPass(bool full)
{
  if (full)
  {
    parentTechnique->GetParentMaterial()->CleanUpGeneratedTechniques();
 
    if (mGeneratedShader)
      BuildShader(true);
 
    //generate shadow pass
    if (parentTechnique->GetParentMaterial()->GetScene()->GetShadowManager())
      parentTechnique->GetParentMaterial()->GetScene()->GetShadowManager()->UpdateShadowMaterial(parentTechnique->GetOgreTechniquePointer());
  }
  else
  {
    //update generated materials
    SRoot::getSingletonPtr()->InvalidateGeneratedMaterial(parentTechnique->GetParentMaterial()->getOgreMaterialPointer().get());
 
    if (mGeneratedShader)
      BuildShader();
 
    //generate shadow pass
    if (parentTechnique->GetParentMaterial()->GetScene()->GetShadowManager())
      parentTechnique->GetParentMaterial()->GetScene()->GetShadowManager()->UpdateShadowMaterial(parentTechnique->GetOgreTechniquePointer());
  }
}
 
}