SO3ShaderGenerator.cpp

Go to the documentation of this file.

 
#include <boost/format.hpp>
#include <boost/algorithm/string.hpp>
 
#include "SO3Renderer/SO3Root.h"
#include "SO3Material/SO3ShaderGenerator.h"
#include "SO3Material/SO3Pass.h"
#include "SO3Material/SO3RtssClipPlane.h"
#include "SO3Material/SO3RtssCustom.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
 
namespace SO3
{
SShaderGenerator::GeneratedShaders SShaderGenerator::mGeneratedShaders;
 
SShaderGenerator::SShaderGenerator(Ogre::Technique* technique, Ogre::Pass* pass, ShaderType type, bool ignoreSlicePlane)
{
  mTechnique = technique;
  mPass = pass;
  mType = type;
  mConfig = 0;
  mShaderName = "";
  mHighProfile = false;
  mRefTexCoef = 1.0f;
  mNotLight = false;
  mNbLights = 6;
  mUseVertexColor = false;
  mUseAlphaRejection = false;
  mIgnoreSlicePlane = ignoreSlicePlane;
  ComputePass();
}
 
SShaderGenerator::SShaderGenerator()
{
  // Forbiden (private)
}
 
SShaderGenerator::~SShaderGenerator()
{
 
}
 
int SShaderGenerator::GetConfig()
{
  return mConfig;
}
 
void SShaderGenerator::ComputePass()
{
  std::stringstream out;
  out << "SO3";
 
  if (mPass->getAlphaRejectValue() > 120.0f)
    mUseAlphaRejection = true;
 
  switch (mType)
  {
    case ShaderGeneratorRTSS:
    {
      bool lightSet = false;
      Ogre::RTShader::ShaderGenerator* shaderGen = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
      Ogre::RTShader::RenderState* rs = shaderGen->getRenderState(Ogre::MSN_SHADERGEN, *mTechnique->getParent(), mPass->getIndex());
 
      if (!rs)
        return;
 
      //clean up first
      rs->resetToBuiltinSubRenderStates();
 
      Ogre::Any any = mPass->getUserObjectBindings().getUserAny("_RTSS_nonFFP_TUS");
      if (any.has_value())
        mPass->getUserObjectBindings().eraseUserAny("_RTSS_nonFFP_TUS");
 
      if ((mPass->getVertexColourTracking() & Ogre::TVC_AMBIENT) || (mPass->getVertexColourTracking() == Ogre::TVC_DIFFUSE))
      {
        mUseVertexColor = true;
                
        Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_VERTEX_COLOUR);
        rs->addTemplateSubRenderState(srs);
      }
 
      if (!mIgnoreSlicePlane)
      {
        Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(SRS_CLIP_PLANE);
        rs->addTemplateSubRenderState(srs);
      }
      
      unsigned int refIndex = 0;
      unsigned int specIndex = 0;
 
      Ogre::Pass::TextureUnitStates units = mPass->getTextureUnitStates();
      for (unsigned int i = 0; i < units.size(); i++)
      {
        Ogre::TextureUnitState* pTex = units[i];
        ShaderMapType uType = SPass::GetTextureUnitType(pTex);
        Ogre::String tex_filename = pTex->getTextureName();
        Ogre::StringUtil::toLowerCase(tex_filename);
 
        Ogre::TextureUnitState::EffectMap effects = pTex->getEffects();
        Ogre::TextureUnitState::EffectMap::const_iterator effectEnd = effects.end();
 
        bool animatedUv = false;
        if (!effects.empty() && ((effects.find(Ogre::TextureUnitState::ET_ROTATE) != effectEnd) ||
          (effects.find(Ogre::TextureUnitState::ET_TRANSFORM) != effectEnd) ||
          (effects.find(Ogre::TextureUnitState::ET_USCROLL) != effectEnd) ||
          (effects.find(Ogre::TextureUnitState::ET_VSCROLL) != effectEnd) ||
          (effects.find(Ogre::TextureUnitState::ET_UVSCROLL) != effectEnd)))
        {
          animatedUv = true;
        }
 
        if ((pTex->getTextureUScroll() != 0.0f) || (pTex->getTextureVScroll() != 0.0f) ||
          (pTex->getTextureUScale() != 1.0f) || (pTex->getTextureVScale() != 1.0f) ||
          (pTex->getTextureRotate().valueRadians() != 0.0f))
        {
          animatedUv = true;
        }
 
        bool envMap = false;
        if (!effects.empty() && (effects.find(Ogre::TextureUnitState::ET_ENVIRONMENT_MAP) != effectEnd))
          envMap = true;
 
        if (!(mConfig & MAP_NORMAL) && (uType == MAP_NORMAL))
        {
          mConfig |= MAP_NORMAL;
          Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
          Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_NORMALMAP);
          srs->setParameter("texture_index", std::to_string(mPass->getTextureUnitStateIndex(pTex)));
 
          if (tex_filename.find("object") != Ogre::String::npos)
            srs->setParameter("normalmap_space", "object_space");
          else if (tex_filename.find("parallax") != Ogre::String::npos)
            srs->setParameter("normalmap_space", "parallax");
          else if ((tex_filename.find("parallax_oc") != Ogre::String::npos) || (tex_filename.find("normheight") != Ogre::String::npos) || (tex_filename.find("parallax_occlusion") != Ogre::String::npos))
            srs->setParameter("normalmap_space", "parallax_occlusion");
          else
            srs->setParameter("normalmap_space", "tangent_space");
          
          srs->setParameter("height_scale", "0.1");
 
          rs->addTemplateSubRenderState(srs);
        }
        else if (!(mConfig & MAP_ROUGHNESS) && (uType == MAP_ROUGHNESS))
        {
          mConfig |= MAP_ROUGHNESS;
 
          Ogre::RTShader::SubRenderState* lightsrs = shaderGen->createSubRenderState(SRS_ADV_COOK_TORRANCE_LIGHTING);
          //Ogre::RTShader::SubRenderState* lightsrs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_COOK_TORRANCE_LIGHTING);
          if (mPass->getCullingMode() == Ogre::CULL_NONE)
            lightsrs->setParameter("two_sided", "1");
 
          Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
          lightsrs->setParameter("texture", pTex->getTextureName());
          if ((tex_filename.find("occlusion") != Ogre::String::npos) || (tex_filename.find("orm") != Ogre::String::npos) || (tex_filename.find("occ_") != Ogre::String::npos))
            lightsrs->setParameter("occlusion", "YES");
          
          rs->addTemplateSubRenderState(lightsrs);
 
          Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_TEXTURING);
          srs->setParameter("late_add_blend", "true");
          rs->addTemplateSubRenderState(srs);
          lightSet = true;
        }
        else if (!(mConfig & MAP_EMISSIVE) && (uType == MAP_EMISSIVE))
        {
          mConfig |= MAP_EMISSIVE;
          Ogre::RTShader::LayeredBlending* lrs = static_cast<Ogre::RTShader::LayeredBlending*>(shaderGen->createSubRenderState(Ogre::RTShader::SRS_LAYERED_BLENDING));
          lrs->setBlendMode(i, "add");
          rs->addTemplateSubRenderState(lrs);
        }
        else if (!(mConfig & MAP_REFMASK) && (uType == MAP_REFMASK))
        {
          mConfig |= MAP_REFMASK;
          Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
        }
        else if (!(mConfig & MAP_REFLECTION) && (uType == MAP_REFLECTION))
        {
          mConfig |= MAP_REFLECTION;
          refIndex = i;
        }
        else if (!(mConfig & MAP_OPACITY) && (uType == MAP_OPACITY))
        {
          mConfig |= MAP_OPACITY;
          Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_ALPHA_TEST);
          rs->addTemplateSubRenderState(srs);
        }
        else if (!(mConfig & MAP_SPECULAR) && (uType == MAP_SPECULAR))
        {
          mConfig |= MAP_SPECULAR;
          pTex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_TEXTURE, Ogre::LBS_SPECULAR, Ogre::ColourValue::White, Ogre::ColourValue::White, 1.0);
          specIndex = i;
        }
        else if (!(mConfig & MAP_SHININESS) && (uType == MAP_SHININESS))
        {
          mConfig |= MAP_SHININESS;
          Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
        }
        else if (!(mConfig & MAP_DIFFUSE)) // only one
        {
          mConfig |= MAP_DIFFUSE;
        }
        else //dummy
        {
          mConfig |= MAP_DUMMY;
        }
      }
 
      //use specular map as roughness
      /*if (mConfig & MAP_SPECULAR)
      {
        Ogre::TextureUnitState* pTex = mPass->getTextureUnitState(specIndex);
        if (pTex)
        {
          if (mConfig & MAP_ROUGHNESS)
          {
            //ignore texture unit
            Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
          }
          else
          {
            mConfig |= MAP_ROUGHNESS;
 
            Ogre::RTShader::SubRenderState* lightsrs = shaderGen->createSubRenderState(SRS_ADV_COOK_TORRANCE_LIGHTING);
            if (mPass->getCullingMode() == Ogre::CULL_NONE)
              lightsrs->setParameter("two_sided", "1");
 
            Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
            lightsrs->setParameter("texture", pTex->getTextureName());
 
            Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_TEXTURING);
            srs->setParameter("late_add_blend", "true");
            rs->addTemplateSubRenderState(srs);
            rs->addTemplateSubRenderState(lightsrs);
            lightSet = true;
          }
        }
      }*/    
 
      if (!lightSet)
      {
        Ogre::RTShader::SubRenderState* lightsrs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_PER_PIXEL_LIGHTING);
        if (mPass->getCullingMode() == Ogre::CULL_NONE)
          lightsrs->setParameter("two_sided", "1");
        rs->addTemplateSubRenderState(lightsrs);
      }
 
      // use reflection coef
      if ((mConfig & MAP_REFLECTION) && (mConfig & MAP_ROUGHNESS))
      {
        Ogre::TextureUnitState* pTex = mPass->getTextureUnitState(refIndex);
 
        if (pTex)
        {
          const Ogre::LayerBlendModeEx& bl = pTex->getColourBlendMode();
          Ogre::RTShader::ShaderGenerator::_markNonFFP(pTex);
          Ogre::RTShader::SubRenderState* srs = shaderGen->createSubRenderState(Ogre::RTShader::SRS_IMAGE_BASED_LIGHTING);
          srs->setParameter("texture", pTex->getTextureName());
          srs->setParameter("luminance", std::to_string((bl.factor == 0.0f) ? 4.0f : bl.factor * 4.0f));
          rs->addTemplateSubRenderState(srs);
        }
      }
      //else if (mConfig & MAP_REFLECTION)
      //{
      //  Ogre::TextureUnitState* pTex = mPass->getTextureUnitState(refIndex);
      //
      //  if (pTex)
      //  {
      //    Ogre::RTShader::LayeredBlending* srs = static_cast<Ogre::RTShader::LayeredBlending*>(shaderGen->createSubRenderState(Ogre::RTShader::SRS_LAYERED_BLENDING));
      //    srs->setBlendMode(refIndex, "multiply");
      //    rs->addTemplateSubRenderState(srs);
      //  }
      //}
    }
    case ShaderGeneratorVP:
    {
      if (!mPass->getLightingEnabled())
      {
        out << "vsNoLightGEN";
        mNotLight = true;
        mNbLights = 0;
      }
      else
        out << "vsLightGEN";
 
      if ((mPass->getVertexColourTracking() & Ogre::TVC_AMBIENT) || (mPass->getVertexColourTracking() == Ogre::TVC_DIFFUSE))
      {
        mUseVertexColor = true;
        out << "VCOLOR";
      }
 
      Ogre::Pass::TextureUnitStates units = mPass->getTextureUnitStates();
      for (unsigned int i = 0; i < units.size(); i++)
      {
        Ogre::TextureUnitState* pTex = units[i];
        ShaderMapType uType = SPass::GetTextureUnitType(pTex);
 
        Ogre::TextureUnitState::EffectMap effects = pTex->getEffects();
        Ogre::TextureUnitState::EffectMap::const_iterator effectEnd = effects.end();
 
        bool animatedUv = false;
        if (!effects.empty() && ((effects.find(Ogre::TextureUnitState::ET_ROTATE) != effectEnd) ||
           (effects.find(Ogre::TextureUnitState::ET_TRANSFORM) != effectEnd) ||
           (effects.find(Ogre::TextureUnitState::ET_USCROLL) != effectEnd) ||
           (effects.find(Ogre::TextureUnitState::ET_VSCROLL) != effectEnd) ||
           (effects.find(Ogre::TextureUnitState::ET_UVSCROLL) != effectEnd)))
        {
          animatedUv = true;
        }
 
        if ((pTex->getTextureUScroll() != 0.0f) || (pTex->getTextureVScroll() != 0.0f) ||
           (pTex->getTextureUScale() != 1.0f) || (pTex->getTextureVScale() != 1.0f) ||
           (pTex->getTextureRotate().valueRadians() != 0.0f))
        {
          animatedUv = true;
        }
 
        bool envMap = false;
        if (!effects.empty() && (effects.find(Ogre::TextureUnitState::ET_ENVIRONMENT_MAP) != effectEnd))
          envMap = true;
 
        if (!(mConfig & MAP_AMBIENT) && (uType == MAP_AMBIENT))
        {
          mConfig |= MAP_AMBIENT;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_AMBIENT);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_NORMAL) && (uType == MAP_NORMAL))
        {
          mConfig |= MAP_NORMAL;
          out << i;
          out << "NORM";
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_NORMAL);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_EMISSIVE) && (uType == MAP_EMISSIVE))
        {
          mConfig |= MAP_EMISSIVE;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_EMISSIVE);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_REFMASK) && (uType == MAP_REFMASK))
        {
          mConfig |= MAP_REFMASK;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_REFMASK);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_REFLECTION) && (uType == MAP_REFLECTION))
        {
          mConfig |= MAP_REFLECTION;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_REFLECTION);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_OPACITY) && (uType == MAP_OPACITY))
        {
          mConfig |= MAP_OPACITY;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_OPACITY);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_SPECULAR) && (uType == MAP_SPECULAR))
        {
          mConfig |= MAP_SPECULAR;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_SPECULAR);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_SHININESS) && (uType == MAP_SHININESS))
        {
          mConfig |= MAP_SHININESS;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_SHININESS);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_ROUGHNESS) && (uType == MAP_ROUGHNESS))
        {
          mConfig |= MAP_ROUGHNESS;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_ROUGHNESS);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_DIFFUSE)) // only one
        {
          mConfig |= MAP_DIFFUSE;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_DIFFUSE);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else //dummy
        {
          mConfig |= MAP_DUMMY;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mAnimatedUv.push_back(animatedUv);
          mTexTypes.push_back(MAP_DUMMY);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
      }
 
      mSortedTexUnits = mTexUnits;
      std::sort(mSortedTexUnits.begin(), mSortedTexUnits.end());
      mSortedTexUnits.erase(std::unique(mSortedTexUnits.begin(), mSortedTexUnits.end()), mSortedTexUnits.end());
 
      for (unsigned int i = 0; i < mSortedTexUnits.size(); i++)
      {
        out << mSortedTexUnits[i];
        bool iscube = false;
        for (unsigned int j = 0; j < mTexUnits.size(); j++)
        {
          if (mTexUnits[j] == mSortedTexUnits[i])
          {
            if (mCubeUv[j])
            {
              out << "C";
              iscube = true;
            }
 
            if (mAnimatedUv[j])
            {
              out << j;
              out << "A";
            }
          }
        }
        mSortedCubeUv.push_back(iscube);
      }
 
      break;
    }
 
    case ShaderGeneratorFP:
    {
      if (!mPass->getLightingEnabled())
      {
        out << "fpNoLightGEN";
        mNotLight = true;
        mNbLights = 0;
      }
      else
        out << "fpLightGEN";
 
      if (mIgnoreSlicePlane)
        out << "NOSLP";
 
      if ((mPass->getVertexColourTracking() & Ogre::TVC_AMBIENT) || (mPass->getVertexColourTracking() == Ogre::TVC_DIFFUSE))
      {
        mUseVertexColor = true;
        out << "VCOLOR";
      }
 
      if (mUseAlphaRejection)
        out << "REJECT";
 
      bool isMask = false;
      Ogre::Pass::TextureUnitStates units = mPass->getTextureUnitStates();
      for (unsigned int i = 0; i < units.size(); i++)
      {
        Ogre::TextureUnitState* pTex = units[i];
        ShaderMapType uType = SPass::GetTextureUnitType(pTex);
        Ogre::String tex_filename = pTex->getTextureName();
        Ogre::StringUtil::toLowerCase(tex_filename);
 
        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;
 
        if (!(mConfig & MAP_AMBIENT) && (uType == MAP_AMBIENT))
        {
          mConfig |= MAP_AMBIENT;
          out << i;
          out << "AMB";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_AMBIENT);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_NORMAL) && (uType == MAP_NORMAL))
        {
          mConfig |= MAP_NORMAL;
          out << i;
          out << "NORM";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_NORMAL);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_EMISSIVE) && (uType == MAP_EMISSIVE))
        {
          out << i;
          out << "EMI";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_EMISSIVE;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_EMISSIVE);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_REFMASK) && (uType == MAP_REFMASK))
        {
          out << i;
          out << "REFMASK";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_REFMASK;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_REFMASK);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_REFLECTION) && (uType == MAP_REFLECTION))
        {
          out << i;
          out << "REF";
 
          mRefTexCoef = pTex->getColourBlendMode().factor;
          if (mRefTexCoef == 0.0f)
            mRefTexCoef = 1.0f; //default
 
          if ((tex_filename.find("fresn") != Ogre::String::npos))
          {
            out << "Fresnel";
            mConfig |= MAP_FRESNEL;
          }
 
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_REFLECTION;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_REFLECTION);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_OPACITY) && (uType == MAP_OPACITY))
        {
          out << i;
          out << "OPAC";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_OPACITY;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_OPACITY);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_SPECULAR) && (uType == MAP_SPECULAR))
        {
          out << i;
          out << "SPEC";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_SPECULAR;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_SPECULAR);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_SHININESS) && (uType == MAP_SHININESS))
        {
          out << i;
          out << "SHIN";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_SHININESS;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_SHININESS);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_ROUGHNESS) && (uType == MAP_ROUGHNESS))
        {
          mConfig |= MAP_ROUGHNESS;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_ROUGHNESS);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else if (!(mConfig & MAP_DIFFUSE)) // only one
        {
          out << i;
          out << "DIFF";
          out << pTex->getTextureCoordSet();
          if (pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP)
            out << "C";
 
          mConfig |= MAP_DIFFUSE;
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_DIFFUSE);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
        else //dummy
        {
          mConfig |= MAP_DUMMY;
 
          mTexUnits.push_back(pTex->getTextureCoordSet());
          mTexTypes.push_back(MAP_DUMMY);
          mCubeUv.push_back(pTex->getTextureType() == Ogre::TEX_TYPE_CUBE_MAP);
        }
      }
 
      if ((mConfig & MAP_FRESNEL) && (mConfig & MAP_NORMAL))
      {
        mNbLights = 4;
      }
 
      if (mNbLights > 0)
      {
        out << "L";
        out << mNbLights;
      }
 
      mSortedTexUnits = mTexUnits;
      std::sort(mSortedTexUnits.begin(), mSortedTexUnits.end());
      mSortedTexUnits.erase(std::unique(mSortedTexUnits.begin(), mSortedTexUnits.end()), mSortedTexUnits.end());
 
      for (unsigned int i = 0; i < mSortedTexUnits.size(); i++)
      {
        bool iscube = false;
        for (unsigned int j = 0; j < mTexUnits.size() && !iscube; j++)
        {
          if (mTexUnits[j] == mSortedTexUnits[i] && mCubeUv[j])
          {
            iscube = true;
          }
        }
        mSortedCubeUv.push_back(iscube);
      }
 
      break;
    }
  }
  mShaderName = out.str();
}
 
std::string SShaderGenerator::GetShaderName()
{
  return mShaderName;
}
 
bool SShaderGenerator::IsUvAnimated(int uvindex)
{
  for (unsigned int i = 0; i < mTexUnits.size(); i++)
  {
    if ((mTexUnits[i] == uvindex) && mAnimatedUv[i])
      return true;
  }
 
  return false;
}
 
bool SShaderGenerator::IsAlphaRejected()
{
  return mUseAlphaRejection;
}
 
void SShaderGenerator::ComputeShaderCode()
{
 
}
 
std::string SShaderGenerator::GetUniformParams()
{
  return "";
}
 
std::string SShaderGenerator::GetProgram()
{
  return "";
}
 
void SShaderGenerator::ApplyShader()
{
  if (mType == ShaderType::ShaderGeneratorRTSS)
  {
    SRoot::getSingletonPtr()->InvalidateGeneratedMaterial(mTechnique->getParent());
 
    //Ogre::SceneManager* sceneManager = shaderGen->getActiveSceneManager();
    //if (!sceneManager)
    //  return;
    //
    //shaderGen->validateMaterial(Ogre::MSN_SHADERGEN, *mTechnique->getParent());
  }
}
 
}