SO3ShaderGeneratorCG.cpp

Go to the documentation of this file.

 
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include <sstream>
 
#include "SO3Renderer/SO3Root.h"
#include "SO3Material/SO3ShaderGeneratorCG.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
 
namespace SO3
{
 
SShaderGeneratorCG::SShaderGeneratorCG(Ogre::Technique* technique, Ogre::Pass* pass, ShaderType type, bool ignoreSlicePlane) : SShaderGenerator(technique, pass, type, ignoreSlicePlane)
{
 
}
 
SShaderGeneratorCG::~SShaderGeneratorCG()
{
 
}
 
void SShaderGeneratorCG::ComputeShaderCode()
{
  if (mType == ShaderGeneratorVP)
    BuildVertexShader();
  else
    BuildFragmentShader();
}
 
void SShaderGeneratorCG::BuildVertexShader()
{
  // generate the shader
  mSource << "void " << GetShaderName() << "(float4 position    : POSITION,\n";
  mSource << "\tfloat3 normal : NORMAL,\n";
  if( (mConfig & MAP_NORMAL) && !mNotLight)
    mSource << "\tfloat3 tangent : TANGENT,\n";
 
  if (mUseVertexColor)
    mSource << "\tfloat4 iColor : COLOR,\n";
 
  for (unsigned int i = 0; i < mSortedTexUnits.size(); i++)
  {
    if (mSortedCubeUv[i])
      mSource << "\tfloat3 uv";
    else
      mSource << "\tfloat2 uv";
 
    mSource << mSortedTexUnits[i] << " : TEXCOORD" << mSortedTexUnits[i] << ",\n";
  }
 
  int texCoord = 0;
  mSource << "\tout float4 oPos : POSITION,\n";
  mSource << "\tout float4 oNorm : TEXCOORD" << texCoord++ << ",\n";
 
  if ((mConfig & MAP_NORMAL) && !mNotLight)
  {
    mSource << "\tout float3 oTang : TEXCOORD" << texCoord++ << ",\n";
    mSource << "\tout float3 oBinormal : TEXCOORD" << texCoord++ << ",\n";
  }
 
  if (mUseVertexColor)
    mSource << "\tout float4 oColor : TEXCOORD" << texCoord++ << ",\n";
 
  mSource << "\tout float4 oWp : TEXCOORD" << texCoord++ << ",\n";
 
  int lastAvailableTexCoord = texCoord;
  int lastUvIndex = -1;
 
  for (unsigned int i = 0; i < mSortedTexUnits.size() && (texCoord < 16); i++)
  {
    if (mSortedCubeUv[i])
      mSource << "\tout float3 oUv";
    else
      mSource << "\tout float2 oUv";
 
    mSource << mSortedTexUnits[i] << " : TEXCOORD" << texCoord++ << ",\n";
    lastUvIndex = mSortedTexUnits[i];
  }
 
  if (texCoord > 8)
    mHighProfile = true;
 
  mSource << "\tuniform float4x4 wMat,\n";
 
  if (!(mConfig & MAP_NORMAL) || mNotLight)
    mSource << "\tuniform float4x4 witMat,\n";
 
  mSource << "\tuniform float4x4 wvpMat";
 
  for (unsigned int i = 0; i < mSortedTexUnits.size(); i++)
  {
    if (IsUvAnimated(mSortedTexUnits[i]))
      mSource << ",\n\tuniform float4x4 texMat" << mSortedTexUnits[i];
  }
 
  mSource << "\n)\n";
  mSource << "{\n";
 
  mSource << "\toWp = mul(wMat, position);\n";
  mSource << "\toPos = mul(wvpMat, position);\n";
 
  // for fog
  mSource << "\toWp.w = oPos.z;\n";
  mSource << "\toNorm.w = oPos.w;\n";
 
  texCoord = lastAvailableTexCoord;
  lastUvIndex = -1;
  for (unsigned int i = 0; i < mSortedTexUnits.size() && (texCoord < 16); i++)
  {
    bool aUV = IsUvAnimated(mSortedTexUnits[i]);
 
    if (!aUV)
      mSource << "\toUv" << mSortedTexUnits[i] << " = uv" << mSortedTexUnits[i] << ";\n";
    else
      mSource << "\toUv" << mSortedTexUnits[i] << " = mul(texMat" << mSortedTexUnits[i] << ", float4(" << "uv" << mSortedTexUnits[i] << ", 0.0, 1.0)).xy;\n";
 
    lastUvIndex = mSortedTexUnits[i];
    texCoord++;
  }
 
  if (texCoord > 8)
    mHighProfile = true;
 
  if ((mConfig & MAP_NORMAL) && !mNotLight)
  {
    mSource << "\toTang = tangent;\n";
    mSource << "\toBinormal = cross(tangent, normal);\n";
    mSource << "\toNorm.xyz = normal;\n";
  }
  else
  {
    mSource << "\toNorm.xyz = normalize(mul((float3x3)witMat, normal));\n";
  }
 
  if (mUseVertexColor)
    mSource << "\toColor = iColor;\n";
 
  mSource << "}\n";
}
 
void SShaderGeneratorCG::BuildFragmentShader()
{
  int texCoord = 0;
 
  // generate the shader
  mSource << "float4 " << GetShaderName() << "(float4 position  : POSITION,\n";
  mSource << "\tfloat4 norm : TEXCOORD" << texCoord++ << ",\n";
 
  if ((mConfig & MAP_NORMAL) && !mNotLight)
  {
    mSource << "\tfloat3 tangent : TEXCOORD" << texCoord++ << ",\n";
    mSource << "\tfloat3 binormal : TEXCOORD" << texCoord++ << ",\n";
  }
 
  if (mUseVertexColor)
    mSource << "\tfloat4 iColor : TEXCOORD" << texCoord++ << ",\n";
 
  mSource << "\tfloat4 wp : TEXCOORD" << texCoord++ << ",\n";
 
  int lastUvIndex = -1;
  for (unsigned int i = 0; i < mSortedTexUnits.size() && (texCoord < 16); i++)
  {
    if (mSortedCubeUv[i])
      mSource << "\tfloat3 uv" << mSortedTexUnits[i] << " : TEXCOORD" << texCoord++ << ",\n";
    else
      mSource << "\tfloat2 uv" << mSortedTexUnits[i] << " : TEXCOORD" << texCoord++ << ",\n";
    
    lastUvIndex = mSortedTexUnits[i];
  }
 
  if (texCoord > 8)
    mHighProfile = true;
 
  if (!mIgnoreSlicePlane)
    mSource << "\tuniform float4 slicePlane,\n";
 
  if (!mNotLight)
  {
    //mSource << "\tuniform float4x4 wMat,\n";
    mSource << "\tuniform float4 ambient,\n";
 
    mSource << "\tuniform float4 lightDif[" << mNbLights << "],\n";
    mSource << "\tuniform float4 lightPos[" << mNbLights << "],\n";
    mSource << "\tuniform float4 lightAtt[" << mNbLights << "],\n";
    //mSource << "\tuniform float3 lightSpec[" << mNbLights << "],\n";
    mSource << "\tuniform float4 spotlightParams[" << mNbLights << "],\n";
    mSource << "\tuniform float4 spotlightDir[" << mNbLights << "],\n";
  }
  
  if (!mNotLight || mConfig & MAP_REFLECTION)
    mSource << "\tuniform float3 camPos,\n";
 
  mSource << "\tuniform float4 fogParams,\n";
  mSource << "\tuniform float4 fogColor";
 
  if (!mNotLight)
  {
    if (!mUseVertexColor)
    {
      mSource << ",\n\tuniform float4 matAmb";
      mSource << ",\n\tuniform float4 matDif";
    }
 
    mSource << ",\n\tuniform float4 matEmissive";
    mSource << ",\n\tuniform float4 matSpec";
    mSource << ",\n\tuniform float matShininess";
  }
 
  if ((mConfig & MAP_NORMAL) && !mNotLight)
  {
    mSource << ",\n\tuniform float4x4 iTWMat";
    //mSource << ",\n\tuniform float normalMul";
  }
 
  if (mConfig & MAP_REFLECTION)
  {
    mSource << ",\n\tuniform float reflectivity";
 
    if (mConfig & MAP_FRESNEL)
    {
      mSource << ",\n\tuniform float fresnelMul";
      mSource << ",\n\tuniform float fresnelPow";
    }
  }
 
  int samplerId = 0;
  int ambUv = 0;
  int diffUv = 0;
  int specUv = 0;
  int normUv = 0;
  int illUv = 0;
  int refMskUv = 0;
 
  bool bAmbCube = false;
  bool bDiffCube = false;
  bool bSpecCube = false;
  bool bNormCube = false;
  bool bRefCube = false;
  bool bIllCube = false;
  bool bRefMskCube = false;
 
  for (unsigned int i = 0; i < mTexTypes.size(); i++)
  {
    switch (mTexTypes[i])
    {
      //could be a light map
    case MAP_AMBIENT:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE ambMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D ambMap : register(s" << samplerId << ")";
      ambUv = mTexUnits[i];
      bAmbCube = mCubeUv[i];
      break;
 
    case MAP_DIFFUSE:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE diffuseMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D diffuseMap : register(s" << samplerId << ")";
      diffUv = mTexUnits[i];
      bDiffCube = mCubeUv[i];
      break;
 
    case MAP_SPECULAR:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE specMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D specMap : register(s" << samplerId << ")";
      specUv = mTexUnits[i];
      bSpecCube = mCubeUv[i];
      break;
 
    case MAP_NORMAL:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE normalMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D normalMap : register(s" << samplerId << ")";
      normUv = mTexUnits[i];
      bNormCube = mCubeUv[i];
      break;
 
    case MAP_EMISSIVE:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE illMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D illMap : register(s" << samplerId << ")";
      illUv = mTexUnits[i];
      bIllCube = mCubeUv[i];
      break;
 
    case MAP_REFLECTION:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE reflectMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D reflectMap : register(s" << samplerId << ")";
      bRefCube = mCubeUv[i];
      break;
 
    case MAP_REFMASK:
      if (mCubeUv[i])
        mSource << ",\n\tuniform samplerCUBE reflectMskMap : register(s" << samplerId << ")";
      else
        mSource << ",\n\tuniform sampler2D reflectMskMap : register(s" << samplerId << ")";
      bRefMskCube = mCubeUv[i];
      break;
    }
    samplerId++;
  }
 
  mSource << "): COLOR0\n";
  mSource << "{\n";
 
  if (!mIgnoreSlicePlane)
  {
    mSource << "\tif((slicePlane.x + slicePlane.y + slicePlane.z) != 0.0)\n";
    mSource << "\t\tclip((slicePlane.x * wp.x + slicePlane.y * wp.y + slicePlane.z * wp.z + slicePlane.w > 0.0) ? -1.0 : 1.0);\n";
  }
  
  //Fog
  mSource << "\tfloat fog = 1.0;\n";
  mSource << "\t if (fogParams.x == 0.0)\n";
  mSource << "\t{\n";
  mSource << "\tif (fogParams.w > 0.0)\n";
  mSource << "\t\tfog = (fogParams.z - wp.w) * fogParams.w;\n";
  mSource << "\t}\n";
  mSource << "\telse\n";
  mSource << "\t\tfog = exp2(-fogParams.x * abs(norm.w));\n";
  mSource << "\tfog = clamp(fog, 0.0, 1.0);\n";
 
  if (!(mConfig & MAP_REFLECTION))
    mSource << "\tif (fog == 0.0) return fogColor;\n";
 
  if ((mConfig & MAP_NORMAL) && !mNotLight)
  {
    if (bNormCube)
      mSource << "\tfloat3 normalTex = texCUBE(normalMap, uv" << normUv << ").rgb;\n";
    else
      mSource << "\tfloat3 normalTex = tex2D(normalMap, uv" << normUv << ".xy).rgb;\n";
 
//    mSource << "\ttangent *= normalMul;\n";
//    mSource << "\tbinormal *= normalMul;\n";
    mSource << "\tfloat3x3 tbn = float3x3(tangent, binormal, norm.xyz);\n";
 
    mSource << "\tfloat3 normal = mul(transpose(tbn), (normalTex.xyz -0.5) * 2); // to object space\n";
    mSource << "\tnormal = normalize(mul((float3x3)iTWMat, normal));\n";
  }
  else
  {
    mSource << "\tfloat3 normal = normalize(norm.xyz);\n";
  }
 
  if (!mNotLight || mConfig & MAP_REFLECTION)
    mSource << "\tfloat3 camDir = normalize(camPos - wp.xyz);\n";
 
  if (!mNotLight)
  {
    mSource << "\tfloat3 diffuseLight = float3(0.0, 0.0, 0.0);\n";
    mSource << "\tfloat3 specularLight = float3(0.0, 0.0, 0.0);\n";
    mSource << "\tfloat shincontrib = 0.0;\n";
    mSource << "\tfloat shinlt = 0.0;\n";
    mSource << "\tfloat spot = 0.0;\n";
    mSource << "\thalf ila = 0;\n";
    mSource << "\thalf la = 0;\n";
    mSource << "\tfloat3 ld = float3(0.0, 0.0, 0.0);\n";
    mSource << "\tfloat lc = 0.0;\n";
    mSource << "\thalf lightDist = 0;\n\n";
 
    mSource << "\tfor (int i = 0; i < " << mNbLights <<"; i++)\n";
    mSource << "\t{\n";
    // direction
    mSource << "\tld = normalize(lightPos[i].xyz - (lightPos[i].w * wp.xyz));\n";
 
    mSource << "\t// attenuation\n";
    mSource << "\tlightDist = length(lightPos[i].xyz - wp.xyz) / (lightAtt[i].r / lightAtt[i].r);\n";
    mSource << "\tla = 1;\n";
    mSource << "\tif(lightAtt[i].a > 0.0)\n";
    mSource << "\t{\n";
    mSource << "\t\tila = lightDist * lightDist; // quadratic falloff\n";
    mSource << "\t\tla = 1.0 / (lightAtt[i].g + lightAtt[i].b * lightDist + lightAtt[i].a * ila);\n";
    mSource << "\t}\n";
 
    mSource << "\t// calculate the spotlight effect\n";
    mSource << "\tspot = ((spotlightParams[i].w == 0.0) ? 1.0 : // if so, then it's not a spot light\n";
    mSource << "\t   saturate((dot(-normalize(spotlightDir[i].xyz - (spotlightDir[i].w * wp.xyz)), ld) - spotlightParams[i].y) / (spotlightParams[i].x - spotlightParams[i].y)));\n";
 
    mSource << "\tlc = max(dot(normal, ld), 0.0) * spot * la;\n";
    mSource << "\tshinlt = pow(max(dot(normal, normalize(ld + camDir)), 0.0), matShininess + 0.1) * lc;\n";
 
    mSource << "\tspecularLight += lightDif[i].rgb * float3(shinlt, shinlt, shinlt);\n";
    mSource << "\tdiffuseLight += lightDif[i].rgb * float3(lc, lc, lc);\n";
    mSource << "\tshincontrib += shinlt;\n";
 
    mSource << "\t}\n";
   
    if (!mUseVertexColor)
    {
      mSource << "\tfloat3 ambientColor = ambient.rgb * matAmb.rgb;\n";
      mSource << "\tfloat3 diffuseContrib = matDif.rgb;\n";
    }
    else
    {
      mSource << "\tfloat3 ambientColor = ambient.rgb * iColor.rgb;\n";
      mSource << "\tfloat3 diffuseContrib = iColor.rgb;\n";
    }
 
    if (!(mConfig & MAP_EMISSIVE))
    {
      mSource << "\tambientColor = max(matEmissive.rgb, ambientColor);\n";
    }
  }
  else
  {
    if (!mUseVertexColor)
      mSource << "\tfloat4 ambientColor = float4(1.0, 1.0, 1.0, 1.0);\n";
    else
      mSource << "\tfloat4 ambientColor = iColor;\n";
  }
  if (mConfig & MAP_AMBIENT)
  {
    if (bAmbCube)
      mSource << "\tfloat4 ambTex = texCUBE(ambMap, uv" << ambUv << ");\n";
    else
      mSource << "\tfloat4 ambTex = tex2D(ambMap, uv" << ambUv << ".xy);\n";
 
    if (mUseAlphaRejection)
      mSource << "\tif (ambTex.a < 0.05) discard;\n";
 
    if (!mNotLight)
      mSource << "\tambientColor *= ambTex.rgb;\n";
    else
      mSource << "\tambientColor *= ambTex;\n";
  }
 
  if (mConfig & MAP_DIFFUSE)
  {
    if (bDiffCube)
      mSource << "\tfloat4 diffuseTex = texCUBE(diffuseMap, uv" << diffUv << ");\n";
    else
      mSource << "\tfloat4 diffuseTex = tex2D(diffuseMap, uv" << diffUv << ".xy);\n";
 
    if (mUseAlphaRejection)
      mSource << "\tif (diffuseTex.a < 0.05) discard;\n";
 
    if (!mNotLight)
    {
      mSource << "\tambientColor *= diffuseTex.rgb;\n";
      mSource << "\tdiffuseContrib *= diffuseTex.rgb;\n";
    }
    else
    {
      mSource << "\tambientColor *= diffuseTex;\n";
    }
  }
 
  if (mConfig & MAP_EMISSIVE)
  {
    if (bIllCube)
      mSource << "\tfloat3 illTex = texCUBE(illMap, uv" << illUv << ").rgb;\n";
    else
      mSource << "\tfloat3 illTex = tex2D(illMap, uv" << illUv << ".xy).rgb;\n";
 
    if (!mNotLight)
    {
      mSource << "\tambientColor = max(ambientColor, matEmissive.rgb * illTex);\n";
    }
    else
    {
      mSource << "\tambientColor += float4(illTex, 0.0);\n";
    }
  }
 
  if (!mNotLight)
    mSource << "\tfloat4 specularContrib = float4(specularLight, 1.0) * matSpec;\n";
 
  if ((mConfig & MAP_SPECULAR) && !mNotLight)
  {
    if (bSpecCube)
      mSource << "\tfloat4 specTex = texCUBE(specMap, uv" << specUv << ");\n";
    else
      mSource << "\tfloat4 specTex = tex2D(specMap, uv" << specUv << ".xy);\n";
 
    mSource << "\tspecularContrib.rgb *= specTex.rgb;\n";
  }
 
  //if(bAmbient)
  //mSource << "\tspecularContrib.rgb *= ambTex.rgb;\n";
 
  if (!mNotLight)
  {
    mSource << "\tfloat3 light0C = clamp(ambientColor + (diffuseLight * diffuseContrib) + specularContrib.rgb, 0.0, 1.0);\n";
 
    if (!mUseVertexColor)
      mSource << "\tfloat alpha = clamp(matDif.a + (specularContrib.a * shincontrib * matDif.a), 0.0, 1.0);\n";
    else
      mSource << "\tfloat alpha = clamp(iColor.a + (specularContrib.a * shincontrib * iColor.a), 0.0, 1.0);\n";
 
    if (mConfig & MAP_DIFFUSE)
      mSource << "\talpha *= diffuseTex.a;\n";
    else if (mConfig & MAP_AMBIENT)
      mSource << "\talpha *= ambTex.a;\n";
  }
 
  if (mConfig & MAP_REFLECTION)
  {
    mSource << "\tfloat3 refVec = -reflect(camDir, normal);\n";
    if (bRefCube)
    {
      mSource << "\trefVec.z = -refVec.z;\n";
      mSource << "\tfloat4 reflecTex = texCUBE(reflectMap, refVec);\n";
    }
    else
    {
      mSource << "\tfloat mref = 2.0 * sqrt((refVec.x * refVec.x) + (refVec.y * refVec.y) + (refVec.z * refVec.z));\n";
      mSource << "\tfloat2 pref = float2(0.5 + refVec.x / mref, 0.5 - refVec.y / mref);\n";
      mSource << "\tfloat4 reflecTex = tex2D(reflectMap, pref);\n";
    }
 
    if (mConfig & MAP_FRESNEL && !mNotLight)
    {
      mSource << "\tfloat fresnel = fresnelMul * reflectivity * pow(1 + dot(-camDir, normal), fresnelPow - (reflectivity * fresnelMul));\n";
      mSource << "\tfloat4 reflecVal = clamp(reflecTex * fresnel, 0.0, 1.0);\n";
      mSource << "\tfloat3 reflectColor = reflecVal.rgb * (1.0 - light0C);\n";
    }
    else //metal style
    {
      mSource << "\tfloat3 reflectColor = reflecTex.rgb * reflectivity;\n";
    }
 
    //mask
    if (mConfig & MAP_REFMASK)
    {
      if (bRefMskCube)
        mSource << "\tfloat3 refTexMsk = texCUBE(reflectMskMap, uv" << refMskUv << ").rgb;\n";
      else
        mSource << "\tfloat3 refTexMsk = tex2D(reflectMskMap, uv" << refMskUv << ".xy).rgb;\n";
 
      mSource << "\treflectColor *= refTexMsk;\n";
    }
 
    if (!mNotLight)
    {
      mSource << "\treturn float4((fog * (light0C + reflectColor)) + fogColor.xyz * (1.0 - fog), alpha);\n";
    }
    else
    {
      mSource << "\treturn float4((fog * (ambientColor.rgb + reflectColor)) + fogColor.xyz * (1.0 - fog), ambientColor.a);\n";
    }
  }
  else
  {
    if (!mNotLight)
      mSource << "\treturn float4((fog * light0C) + (fogColor.xyz * (1.0 - fog)), alpha);\n";
    else
      mSource << "\treturn float4((fog * ambientColor.rgb) + (fogColor.xyz * (1.0 - fog)), ambientColor.a);\n";
  }
 
  mSource << "}\n";
}
 
std::string SShaderGeneratorCG::GetUniformParams()
{
  std::stringstream out;
 
  if (mType == ShaderGeneratorVP)
  {
    out << "\t\t\tvertex_program_ref " << GetShaderName() << "\n";
    out << "\t\t\t{\n";
 
    for (unsigned int i = 0; i < mSortedTexUnits.size(); i++)
    {
      if (IsUvAnimated(mSortedTexUnits[i]))
        out << "\t\t\t\tparam_named_auto " << "texMat" << mSortedTexUnits[i] << " texture_matrix " << mSortedTexUnits[i] << "\n";
    }
 
    out << "\t\t\t}\n";
  }
  else
  {
    out << "\t\t\tfragment_program_ref " << GetShaderName() << "\n";
    out << "\t\t\t{\n";
 
/*    if ((mConfig & MAP_NORMAL) && !mNotLight)
    {
      //TODO where could I get that kind of value ?
      out << "\t\t\t\tparam_named normalMul float " << 1.0f << "\n";
    }
*/
    if (mConfig & MAP_REFLECTION)
    {
      //TODO where could I get that kind of value ?
      out << "\t\t\t\tparam_named reflectivity float " << 0.8f << "\n";
      if (mConfig & MAP_FRESNEL)
      {
        out << "\t\t\t\tparam_named fresnelMul float " << 0.8f << "\n";
        out << "\t\t\t\tparam_named fresnelPow float " << ((mPass->getShininess() / 255.0f) * 2.0f) << "\n";
      }
    }
 
    out << "\t\t\t}\n";
  }
  mParams = out.str();
  return mParams;
}
 
std::string SShaderGeneratorCG::GetProgram()
{
  std::stringstream out;
 
  if (mType == ShaderGeneratorVP)
  {
    out << "vertex_program " << GetShaderName() << "_CG cg\n";
    out << "{\n";
 
    out << "\tsource " << GetShaderName() << ".cg\n";
    if (mHighProfile)
      out << "\tprofiles vs_4_0 vs_4_0_level_9_1 vs_4_0_level_9_3 vs_3_0 arbvp2\n";
    else
      out << "\tprofiles vs_4_0 vs_4_0_level_9_1 vs_4_0_level_9_3 vs_3_0 arbvp1\n";
    out << "\tentry_point " << GetShaderName() << "\n";
 
    out << "\tdefault_params\n";
    out << "\t{\n";
    out << "\t\tparam_named_auto wMat world_matrix\n";
 
    if (!(mConfig & MAP_NORMAL) || mNotLight)
      out << "\t\tparam_named_auto witMat inverse_transpose_world_matrix\n";
 
    out << "\t\tparam_named_auto wvpMat worldviewproj_matrix\n";
 
    out << "\t}\n";
    out << "}\n";
  }
  else
  {
    //CG
    out << "fragment_program " << GetShaderName() << "_CG cg\n";
    out << "{\n";
 
    out << "\tsource " << GetShaderName() << ".cg\n";
    if (mHighProfile)
      out << "\tprofiles ps_4_0 ps_3_x arbfp1\n";
    else
      out << "\tprofiles ps_4_0 ps_3_0 arbfp1\n";
    out << "\tentry_point " << GetShaderName() << "\n";
 
    out << "\tdefault_params\n";
    out << "\t{\n";
 
    out << "\t\tparam_named_auto fogParams fog_params\n";
    out << "\t\tparam_named_auto fogColor fog_colour\n";
 
    if (!mNotLight)
    {
      //out << "\t\tparam_named_auto wMat world_matrix\n";
      out << "\t\tparam_named_auto ambient ambient_light_colour\n";
 
      out << "\t\tparam_named_auto lightDif light_diffuse_colour_array " << mNbLights << "\n";
      out << "\t\tparam_named_auto lightPos light_position_array " << mNbLights << "\n";
      out << "\t\tparam_named_auto lightAtt light_attenuation_array " << mNbLights << "\n";
      //out << "\t\tparam_named_auto lightSpec light_specular_colour_array " << mNbLights << "\n";
      out << "\t\tparam_named_auto spotlightParams spotlight_params_array " << mNbLights << "\n";
      out << "\t\tparam_named_auto spotlightDir light_direction_array " << mNbLights << "\n";
 
      out << "\t\tparam_named_auto camPos camera_position\n";
 
      if (!mUseVertexColor)
      {
        out << "\t\tparam_named_auto matAmb surface_ambient_colour\n";
        out << "\t\tparam_named_auto matDif surface_diffuse_colour\n";
      }
 
      out << "\t\tparam_named_auto matEmissive surface_emissive_colour\n";
      out << "\t\tparam_named_auto matSpec surface_specular_colour\n";
      out << "\t\tparam_named_auto matShininess surface_shininess\n";
    }
    else
    {
      if (mConfig & MAP_REFLECTION)
        out << "\t\tparam_named_auto camPos camera_position\n";
    }
 
    if ((mConfig & MAP_NORMAL) && !mNotLight)
    {
      out << "\t\tparam_named_auto iTWMat inverse_transpose_world_matrix\n";
      //out << "\t\tparam_named normalMul float 1\n";
    }
 
    if (mConfig & MAP_REFLECTION)
    {
      out << "\t\tparam_named reflectivity float 0.8\n";
 
      if (mConfig & MAP_FRESNEL)
      {
        out << "\t\tparam_named fresnelMul float 1.0\n";
        out << "\t\tparam_named fresnelPow float 1.0\n";
      }
    }
 
    out << "\t}\n";
    out << "}\n";
  }
  mProgram = out.str();
  return mProgram;
}
 
void SShaderGeneratorCG::ApplyShader()
{
  if (mType == ShaderGeneratorVP)
  {
    //Try to get the shader if it exist already    
    Ogre::GpuProgramPtr shaderPtr = Ogre::GpuProgramManager::getSingletonPtr()->getByName(GetShaderName(), Ogre::RGN_DEFAULT);
 
    // otherwise we load it
    if (!shaderPtr)
    {
      ComputeShaderCode();
      shaderPtr = Ogre::GpuProgramManager::getSingletonPtr()->create(GetShaderName(),
        Ogre::RGN_DEFAULT,
        Ogre::GPT_VERTEX_PROGRAM,
        "cg");
 
      shaderPtr->setSource(mSource.str());
      shaderPtr->setParameter("entry_point", GetShaderName());
 
      if (mHighProfile)
        shaderPtr->setParameter("profiles", "vs_4_0 vs_4_0_level_9_1 vs_4_0_level_9_3 vs_3_0 arbvp2");
      else
        shaderPtr->setParameter("profiles", "vs_4_0 vs_4_0_level_9_1 vs_4_0_level_9_3 vs_3_0 arbvp1");
 
      // Set auto param binding
      Ogre::GpuProgramParametersSharedPtr vpParams = shaderPtr->getDefaultParameters();
 
      vpParams->setNamedAutoConstant("wMat", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
 
      if (!(mConfig & MAP_NORMAL) || mNotLight)
        vpParams->setNamedAutoConstant("witMat", Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLD_MATRIX);
 
      vpParams->setNamedAutoConstant("wvpMat", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
 
      // All defined, load!
      shaderPtr->load();
 
      mGeneratedShaders.push_back(shaderPtr);
    }
 
    if (shaderPtr->hasCompileError())
    {
      shaderPtr.reset();
      mPass->setVertexProgram("");
      return;
    }
 
    mPass->setVertexProgram(GetShaderName());
    Ogre::GpuProgramParametersSharedPtr passParams = mPass->getVertexProgramParameters();
 
    // on pass
    for (unsigned int i = 0; i < mSortedTexUnits.size(); i++)
    {
      std::stringstream pname;
 
      if (IsUvAnimated(mSortedTexUnits[i]))
      {
        pname << "texMat" << mSortedTexUnits[i];
        passParams->setNamedAutoConstant(pname.str(), Ogre::GpuProgramParameters::ACT_TEXTURE_MATRIX, mSortedTexUnits[i]);
      }
    }
  }
  else
  {
    //Try to get the shader if it exist already    
    Ogre::GpuProgramPtr shaderPtr = Ogre::GpuProgramManager::getSingletonPtr()->getByName(GetShaderName(), Ogre::RGN_DEFAULT);
 
    // otherwise we load it
    if (!shaderPtr)
    {
      ComputeShaderCode();
      shaderPtr = Ogre::GpuProgramManager::getSingletonPtr()->create(GetShaderName(),
        Ogre::RGN_DEFAULT,
        Ogre::GPT_FRAGMENT_PROGRAM,
        "cg");
 
      shaderPtr->setSource(mSource.str());
      shaderPtr->setParameter("entry_point", GetShaderName());
      if (mHighProfile)
        shaderPtr->setParameter("profiles", "ps_4_0 ps_4_0_level_9_1 ps_4_0_level_9_3 ps_3_x arbfp1");
      else
        shaderPtr->setParameter("profiles", "ps_4_0 ps_4_0_level_9_1 ps_4_0_level_9_3 ps_3_0 arbfp1");
 
      // Set auto param binding
      Ogre::GpuProgramParametersSharedPtr vpParams = shaderPtr->getDefaultParameters();
 
      if (!mIgnoreSlicePlane)
        vpParams->addSharedParameters("SO3SlicePlaneParams");
 
      vpParams->setNamedAutoConstant("fogParams", Ogre::GpuProgramParameters::ACT_FOG_PARAMS);
      vpParams->setNamedAutoConstant("fogColor", Ogre::GpuProgramParameters::ACT_FOG_COLOUR);
      
      //common
      if (!mNotLight || mConfig & MAP_REFLECTION)
        vpParams->setNamedAutoConstant("camPos", Ogre::GpuProgramParameters::ACT_CAMERA_POSITION);
 
      if (!mNotLight)
      {
        //vpParams->setNamedAutoConstant("wMat", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
        vpParams->setNamedAutoConstant("ambient", Ogre::GpuProgramParameters::ACT_AMBIENT_LIGHT_COLOUR);
 
        if (!mUseVertexColor)
        {
          vpParams->setNamedAutoConstant("matAmb", Ogre::GpuProgramParameters::ACT_SURFACE_AMBIENT_COLOUR);
          vpParams->setNamedAutoConstant("matDif", Ogre::GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
        }
        
        vpParams->setNamedAutoConstant("matEmissive", Ogre::GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
        vpParams->setNamedAutoConstant("matSpec", Ogre::GpuProgramParameters::ACT_SURFACE_SPECULAR_COLOUR);
        vpParams->setNamedAutoConstant("matShininess", Ogre::GpuProgramParameters::ACT_SURFACE_SHININESS);
 
        vpParams->setNamedAutoConstant("lightDif", Ogre::GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR_ARRAY, mNbLights);
        vpParams->setNamedAutoConstant("lightPos", Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_ARRAY, mNbLights);
        vpParams->setNamedAutoConstant("lightAtt", Ogre::GpuProgramParameters::ACT_LIGHT_ATTENUATION_ARRAY, mNbLights);
        //vpParams->setNamedAutoConstant("lightSpec", Ogre::GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR_ARRAY, mNbLights);
        vpParams->setNamedAutoConstant("spotlightParams", Ogre::GpuProgramParameters::ACT_SPOTLIGHT_PARAMS_ARRAY, mNbLights);
        vpParams->setNamedAutoConstant("spotlightDir", Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_ARRAY, mNbLights);
      }
 
      if ((mConfig & MAP_NORMAL) && !mNotLight)
      {
        vpParams->setNamedAutoConstant("iTWMat", Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLD_MATRIX);
        //vpParams->setNamedConstant("normalMul", 1.0f);
      }
 
      if (mConfig & MAP_REFLECTION)
      {
        vpParams->setNamedConstant("reflectivity", 1.0f);
 
        if (mConfig & MAP_FRESNEL)
        {
          vpParams->setNamedConstant("fresnelMul", 1.0f);
          vpParams->setNamedConstant("fresnelPow", 1.0f);
        }
      }
 
      // All defined, load!
      shaderPtr->load();
 
      mGeneratedShaders.push_back(shaderPtr);
    }
 
    if (shaderPtr->hasCompileError())
    {
      shaderPtr.reset();
      mPass->setFragmentProgram("");
      return;
    }
 
    mPass->setFragmentProgram(GetShaderName());
    Ogre::GpuProgramParametersSharedPtr passParams = mPass->getFragmentProgramParameters();
 
    // on pass
    /*if ((mConfig & MAP_NORMAL) && !mNotLight)
    {
      passParams->setNamedConstant("normalMul", 1.0f);
    }*/
 
    if (mConfig & MAP_REFLECTION)
    {
      passParams->setNamedConstant("reflectivity", mRefTexCoef);
 
      if (mConfig & MAP_FRESNEL)
      {
        passParams->setNamedConstant("fresnelMul", mRefTexCoef * 1.5f);
        passParams->setNamedConstant("fresnelPow", ((mPass->getShininess() / 255.0f) * (mRefTexCoef * 10.0f)));
      }
    }
  }
}
 
}