SO3ShadowCSM.cpp

Go to the documentation of this file.

 
#include "SO3Renderer/SO3ShadowCSM.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Material/SO3Material.h"
#include "SO3Renderer/SO3Root.h"
 
  // GPU constants
namespace Ogre
{
  //Singleton instance
  template<> SO3::CSMGpuConstants* Ogre::Singleton<SO3::CSMGpuConstants>::msSingleton = 0;
}
 
namespace SO3
{
  bool SShadowCSM::CheckSystemCompatibility()
  {
#ifdef RPI
    return false;
#endif
 
    //test if shaders are supported by the card
    const Ogre::RenderSystemCapabilities* caps = SRoot::getSingleton().GetOgreRenderSystem()->getCapabilities();
 
    bool isSupported = true;
    Ogre::PixelFormat rttformat;
 
    bool pfsupport = SRoot::getSingleton().GetRttPixelFormat(rttformat, false, true);
 
    isSupported = pfsupport && caps && caps->hasCapability(Ogre::RSC_VERTEX_PROGRAM) &&
      caps->hasCapability(Ogre::RSC_FRAGMENT_PROGRAM) &&
      caps->hasCapability(Ogre::RSC_NON_POWER_OF_2_TEXTURES) &&
      (caps->isShaderProfileSupported("ps_3_0") || caps->isShaderProfileSupported("ps_4_0") || (caps->isShaderProfileSupported("arbfp1")) || (caps->isShaderProfileSupported("glsles")) || (caps->isShaderProfileSupported("glsl300es")));
 
    if (isSupported)
      Ogre::LogManager::getSingleton().logMessage("[SShadowCSM] is supported!");
    else
      Ogre::LogManager::getSingleton().logMessage("[SShadowCSM] is not supported!");
 
    return isSupported;
  }
 
  SShadowCSM::SShadowCSM() : SShadow(0, "", SShadowManager::SO3_SHADOWS_CSM)
  {
  }
 
  SShadowCSM::SShadowCSM(SShadowManager* sManager) : SShadow(sManager, "CSM", SShadowManager::SO3_SHADOWS_CSM)
  {
    //clear shadow textures
    ogreScene->setShadowTechnique(static_cast <Ogre::ShadowTechnique> (Ogre::SHADOWDETAILTYPE_TEXTURE | Ogre::SHADOWDETAILTYPE_INTEGRATED | shadowManager->GetLightingTechnique()));
 
    unsigned short quality = sManager->GetShadowQuality();
    unsigned int textureCount = (quality <= SShadowManager::SO3_SHADOWS_QUALITY_MEDIUM) ? 2 : (quality == SShadowManager::SO3_SHADOWS_QUALITY_HIGH) ? 3 : 4;
    ogreScene->setShadowCasterRenderBackFaces(true);
    ogreScene->setShadowTextureSelfShadow(false);
    ogreScene->setShadowTextureCount(textureCount);
    ogreScene->setShadowDirLightTextureOffset(0.1f);
    ogreScene->setShadowTextureFadeStart(mFadeStart);
    ogreScene->setShadowTextureFadeEnd(mFadeEnd);
 
    try
    {
      Ogre::MaterialPtr mcaster = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowCaster");
      Ogre::MaterialPtr emptyMat;
      ogreScene->setShadowTextureCasterMaterial(mcaster);
      ogreScene->setShadowTextureReceiverMaterial(emptyMat);
    }
    catch (Ogre::Exception &e) 
    {
      //can fail here is a material texture is missing
      std::string error = e.what();
    }
 
    ogreScene->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, textureCount);
    ogreScene->setShadowTextureCountPerLightType(Ogre::Light::LT_SPOTLIGHT, 0);
    ogreScene->setShadowTextureCountPerLightType(Ogre::Light::LT_POINT, 0);
 
    //get best format on device
    SRoot::getSingleton().GetRttPixelFormat(mRttFormat, false, true);
 
    ogreScene->setShadowTextureConfig(0, quality, quality, mRttFormat);
    ogreScene->setShadowTextureConfig(1, quality, quality, mRttFormat);
 
    if (textureCount >= 3)
      ogreScene->setShadowTextureConfig(2, (unsigned short)(quality * 0.75f), (unsigned short)(quality * 0.75f), mRttFormat);
    if (textureCount == 4)
      ogreScene->setShadowTextureConfig(3, quality / 2, quality / 2, mRttFormat);
    
    // camera setup
    StableCSMShadowCameraSetup* shadowCameraSetup = new StableCSMShadowCameraSetup(ogreScene, CSMGpuConstants::getSingletonPtr());
 
    float farClip = (ogreScene->getShadowFarDistance() + 1.0f);
    float lambda = 0.9999f; // lower lamdba means more uniform, higher lambda means more logarithmic
    shadowCameraSetup->calculateSplitPoints(textureCount, 1.01f, farClip, lambda);
    StableCSMShadowCameraSetup::SplitPointList points = shadowCameraSetup->getSplitPoints();
 
    // Apply settings
    shadowCameraSetup->setSplitPoints(points);
    shadowCameraSetup->setSplitPadding(0.5f);
 
    SetCameraSetup(Ogre::ShadowCameraSetupPtr(shadowCameraSetup));
    CreateMaterialsPass();
  }
 
  SShadowCSM::~SShadowCSM()
  {
    //reset to default
    Ogre::MaterialPtr emptyMat;
    ogreScene->setShadowTextureCasterMaterial(emptyMat);
    ogreScene->setShadowTextureReceiverMaterial(emptyMat);
 
    // before we clean the shadows textures
    CleanMaterials();
 
    ogreScene->setShadowTextureCount(1);
    ogreScene->setShadowTextureCountPerLightType(Ogre::Light::LT_SPOTLIGHT, 1);
    ogreScene->setShadowTextureCountPerLightType(Ogre::Light::LT_DIRECTIONAL, 1);
    ogreScene->setShadowTextureCountPerLightType(Ogre::Light::LT_POINT, 1);
    ogreScene->setShadowTexturePixelFormat(Ogre::PF_X8R8G8B8);
    ogreScene->setShadowCasterRenderBackFaces(false);
    ogreScene->setShadowTextureSelfShadow(true);
    ogreScene->setShadowTechnique(Ogre::SHADOWTYPE_NONE);
  }
 
  void SShadowCSM::UpdateShadowTechnique()
  {
    ogreScene->setShadowTechnique(static_cast <Ogre::ShadowTechnique> (Ogre::SHADOWDETAILTYPE_TEXTURE | Ogre::SHADOWDETAILTYPE_INTEGRATED | shadowManager->GetLightingTechnique()));
  }
 
  bool SShadowCSM::IsShadowMaterialPass(Ogre::Pass* pass)
  {
    if (pass->getName() == "CSM/PASS")
      return true;
 
    return false;
  }
 
  void SShadowCSM::RemoveMaterialPass(Ogre::Technique* tech)
  {
    if (!tech)
      return;
 
    //remove previous shadow pass
    Ogre::Technique::Passes passes = tech->getPasses();
    for (unsigned int i = 0; i < passes.size(); i++)
    {
      Ogre::Pass* pass = passes[i];
      if (pass->getName() == "CSM/PASS")
      {
        tech->removePass(i);
        break;
      }
    }
 
    tech->setShadowCasterMaterial("");
    tech->setShadowReceiverMaterial("");
  }
 
  void SShadowCSM::UpdateShadowMaterial(Ogre::Technique* tech)
  {
    if (!tech || (tech->getParent()->getName() == "Ogre/Debug/LinesMat") /*|| ((tech->getSchemeName() != Ogre::MSN_SHADERGEN) &&
      (tech->getSchemeName() != "Default") &&
      (tech->getSchemeName() != "basic_mat")) */)
      return;
 
    //remove previous pass
    RemoveMaterialPass(tech);
 
    // If the technique is transparent, then ignore for rendering
    if (tech->hasColourWriteDisabled() || (!tech->getParent()->getReceiveShadows()) || (tech->getSchemeName() == "SO3/LIGHTSHAFT"))
      return;
 
    Ogre::Technique::Passes opasses = tech->getPasses();
    Ogre::MaterialPtr baseMat;
 
    //look to alpha rejection pass > 120
    Ogre::TexturePtr alphaTex;
    Ogre::Pass* alphaPass = 0;
    Ogre::TextureUnitState* astate = 0;
 
    //search for alpha texture
    if (opasses.size() > 0)
    {
      Ogre::Pass* pass = opasses[0];
      if (pass && Ogre::Real(pass->getAlphaRejectValue()) > 120.0f)
      {
        unsigned short nbTex = pass->getNumTextureUnitStates();
        for (unsigned short t = 0; t < nbTex && !alphaTex; t++)
        {
          Ogre::TextureUnitState* ustate = pass->getTextureUnitState(t);
          Ogre::TexturePtr texptr = ustate->_getTexturePtr();
          if (texptr && texptr->hasAlpha() && (texptr->getTextureType() == Ogre::TEX_TYPE_2D))
          {
            alphaTex = texptr;
            astate = ustate;
            alphaPass = pass;
          }
        }
      }
    }
 
    size_t nbshadow = ogreScene->getShadowTextureConfigList().size();
    if (alphaTex)
      if (nbshadow <= 2)
        baseMat = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowReceiver2");
      else if (nbshadow == 3)
        baseMat = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowReceiver3");
      else
        baseMat = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowReceiver");
    else
      if (nbshadow <= 2)
        baseMat = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowReceiver2/basic");
      else if (nbshadow == 3)
        baseMat = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowReceiver3/basic");
      else
        baseMat = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowReceiver/basic");
 
    Ogre::Pass* basePass = baseMat->getTechnique(0)->getPass(0);
 
    Ogre::Pass* nPass = tech->createPass();
    *nPass = *basePass;
    nPass->setName("CSM/PASS");
    nPass->setIlluminationStage(Ogre::IS_DECAL);
    //nPass->setSceneBlending(Ogre::SBT_MODULATE);
    nPass->setLightingEnabled(false);
    nPass->setDepthBias(0.01f, 1.0f);
 
    Ogre::Pass* oPass = 0;
    if (alphaTex)
      oPass = alphaPass;
    else if (opasses.size() > 0)
      oPass = opasses[0];
 
    if (oPass && !oPass->getPolygonModeOverrideable() && (oPass->getPolygonMode() == Ogre::PM_POINTS))
    {
      nPass->setPolygonMode(Ogre::PM_POINTS);
      nPass->setPointSize(oPass->getPointSize());
    }
 
    nPass->setDiffuse(oPass->getDiffuse());
    nPass->setAmbient(oPass->getAmbient());
    nPass->setDepthWriteEnabled(false);
    nPass->setAlphaRejectSettings(oPass->getAlphaRejectFunction(), oPass->getAlphaRejectValue(), oPass->isAlphaToCoverageEnabled());
    
    if (!basePass->getTextureUnitState(nbshadow)->isLoaded())
      basePass->getTextureUnitState(nbshadow)->_load();
 
    // add the texture with alpha
    if (alphaTex)
    {
      Ogre::TextureUnitState* nTunitState = nPass->getTextureUnitState((nbshadow <= 2) ? 3 : (nbshadow == 3) ? 4 : 5);
      *nTunitState = *astate;
    }
 
    Ogre::MaterialPtr mcaster;
    if (!oPass->getDepthWriteEnabled() || alphaTex)
    {
      if (!alphaTex)
      {
        try
        {
          mcaster = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowCaster")->clone("SO3/CSM/ShadowCaster" + tech->getParent()->getName(), tech->getParent()->getGroup());
        }
        catch (Ogre::Exception&)
        {
          mcaster = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowCaster" + tech->getParent()->getName());
        }
      }
      else
      {
        try
        {
          mcaster = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowCaster/Alpha")->clone("SO3/CSM/ShadowCaster/Alpha" + tech->getParent()->getName(), tech->getParent()->getGroup());
        }
        catch (Ogre::Exception&)
        {
          mcaster = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowCaster/Alpha" + tech->getParent()->getName());
        }
      }
 
      if (!mcaster.isNull() && mcaster->getTechnique(0) != 0)
      {
        mcaster->getTechnique(0)->getPass(0)->setDiffuse(oPass->getDiffuse());
        mcaster->getTechnique(0)->getPass(0)->setAmbient(oPass->getAmbient());
        if (alphaTex)
        {
          if (mcaster->getTechnique(0)->getPass(0)->getNumTextureUnitStates() > 0)
            *(mcaster->getTechnique(0)->getPass(0)->getTextureUnitState(0)) = *astate;
          else
            *(mcaster->getTechnique(0)->getPass(0)->createTextureUnitState()) = *astate;
        }
        else if (mcaster->getTechnique(0)->getPass(0)->getNumTextureUnitStates() > 0)
          mcaster->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
      }
      tech->setShadowCasterMaterial(mcaster);
    }
    else
    {
      tech->setShadowCasterMaterial(mcaster);
    }
 
    tech->getParent()->reload();
 
    // set fogging
    Ogre::Real shadowEnd = ogreScene->getShadowFarDistance();
    //nPass->setFog(true, Ogre::FOG_LINEAR, Ogre::ColourValue::White, 0, shadowEnd * mFadeStart, shadowEnd * mFadeEnd);
    Ogre::Real dstart = shadowEnd * mFadeStart;
    Ogre::Real dend = shadowEnd * mFadeEnd;
    Ogre::GpuProgramParametersSharedPtr sparams = nPass->getFragmentProgramParameters();
    if (sparams)
    {
      sparams->setNamedConstant("fogParams", Ogre::Vector4(0.0f, dstart, dend, 1.0f / (dend - dstart)));
      //float fardist = ogreScene->getShadowFarDistance();
      //unsigned short quality = GetShadowManager()->GetShadowQuality();
      //float bias = (quality <= SShadowManager::SO3_SHADOWS_QUALITY_LOW) ? 0.1f : (quality <= SShadowManager::SO3_SHADOWS_QUALITY_MEDIUM) ? 0.05f : (quality > SShadowManager::SO3_SHADOWS_QUALITY_HIGH) ? 0.002f : 0.01f;
      //sparams->setNamedConstant("fixedDepthBias", Ogre::Vector4(bias / fardist, (bias * 1.5f) / fardist, (bias * 1.8f) / fardist, (bias * 2.0f) / fardist));
    }
  }
 
  void SShadowCSM::CreateMaterialsPass()
  {
    const SGroupMaterialMap groupmatmap = (*currentScene->GetMaterials());
    SGroupMaterialMap::const_iterator iGroupMaterialList = groupmatmap.begin();
    while (iGroupMaterialList != groupmatmap.end())
    {
      const SMaterialMap matmap = (*iGroupMaterialList->second);
      SMaterialMap::const_iterator iMaterialList = matmap.begin();
      while (iMaterialList != matmap.end())
      {
        Ogre::MaterialPtr material = iMaterialList->second->getOgreMaterialPointer();
        Ogre::Material::Techniques techniques = material->getTechniques();
        for (unsigned int t = 0; t < techniques.size(); t++)
        {
          UpdateShadowMaterial(techniques[t]);
        }
 
        iMaterialList++;
      }
      iGroupMaterialList++;
    }
  }
 
  void SShadowCSM::CleanMaterials()
  {
    // avoid a removed texture to be referenced in the shadow caster
    Ogre::MaterialPtr caster = Ogre::MaterialManager::getSingleton().getByName("SO3/CSM/ShadowCaster");
    if (caster && (caster->getNumTechniques() > 0) && (caster->getTechnique(0)->getNumPasses() > 0) && (caster->getTechnique(0)->getPass(0)->getNumTextureUnitStates() > 0))
    {
      caster->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
      caster->getTechnique(0)->getPass(0)->createTextureUnitState();
    }
 
    const SGroupMaterialMap groupmatmap = (*currentScene->GetMaterials());
    SGroupMaterialMap::const_iterator iGroupMaterialList = groupmatmap.begin();
    while (iGroupMaterialList != groupmatmap.end())
    {
      const SMaterialMap matmap = (*iGroupMaterialList->second);
      SMaterialMap::const_iterator iMaterialList = matmap.begin();
      while (iMaterialList != matmap.end())
      {
        Ogre::MaterialPtr material = iMaterialList->second->getOgreMaterialPointer();
        SRoot::getSingletonPtr()->RemoveGeneratedMaterial(material.get());
 
        Ogre::Material::Techniques techniques = material->getTechniques();
        for (unsigned int t = 0; t < techniques.size(); t++)
        {
          RemoveMaterialPass(techniques[t]);
          material->reload();
        }
 
        iMaterialList++;
      }
      iGroupMaterialList++;
    }
  }
 
  /* CSM Camera Setup from Matthew Paul Reid sample code
     https://bitbucket.org/ScaleRender/ogrecascadedshadows/downloads
  */
  StableCSMShadowCameraSetup::StableCSMShadowCameraSetup(Ogre::SceneManager* ogreScene, CSMGpuConstants* constants) :
    mSplitPadding(1.0f),
    mGpuConstants(constants)
  {
    calculateSplitPoints(3, 5.0f, ogreScene->getShadowFarDistance());
  }
  //---------------------------------------------------------------------
  StableCSMShadowCameraSetup::~StableCSMShadowCameraSetup()
  {
  }
  //---------------------------------------------------------------------
  void StableCSMShadowCameraSetup::calculateSplitPoints(size_t cascadeCount, Ogre::Real firstSplitDist, Ogre::Real farDist, Ogre::Real lambda)
  {
    if (cascadeCount < 2)
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cannot specify less than 2 cascades", "StableCSMShadowCameraSetup::calculateSplitPoints");
 
    mSplitPoints.resize(cascadeCount + 1);
    mCascadeCount = cascadeCount;
 
    mSplitPoints[0] = 0.0f;
    firstSplitDist = std::max(1.0f, firstSplitDist);
    farDist = (farDist * 2.0f) / (mCascadeCount + 1);
    for (size_t i = 1; i < mCascadeCount; i++)
    {
      Ogre::Real fraction = (Ogre::Real)i / (Ogre::Real)mCascadeCount;
      Ogre::Real splitPoint = firstSplitDist + lambda * Ogre::Math::Pow(farDist / firstSplitDist, fraction) +
        (1.0f - lambda) * (fraction * (farDist - firstSplitDist));
 
      mSplitPoints[i] = splitPoint;
    }
    mSplitPoints[mCascadeCount] = farDist;
  }
  //---------------------------------------------------------------------
  void StableCSMShadowCameraSetup::setSplitPoints(const SplitPointList& newSplitPoints)
  {
    if (newSplitPoints.size() < 3) // 3, not 2 since splits + 1 points
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cannot specify less than 2 splits", "StableCSMShadowCameraSetup::setSplitPoints");
    mCascadeCount = newSplitPoints.size() - 1;
    mSplitPoints = newSplitPoints;
  }
 
  //---------------------------------------------------------------------
  void StableCSMShadowCameraSetup::getShadowCamera(const Ogre::SceneManager *sm, const Ogre::Camera *cam,
    const Ogre::Viewport *vp, const Ogre::Light *light, Ogre::Camera *texCam, size_t iteration) const
  {
    texCam->setLodBias(0.25);
 
    // apply the right clip distance.
    Ogre::Real nearDist = mSplitPoints[iteration];
    Ogre::Real farDist = mSplitPoints[iteration + 1];
 
    // Add a padding factor to internal distances so that the connecting split point will not have bad artifacts.
    if (iteration > 0)
    {
      nearDist -= mSplitPadding;
    }
    if (iteration < mCascadeCount - 1)
    {
      farDist += mSplitPadding;
    }
 
    mCurrentIteration = iteration;
 
    getShadowCameraForCascade(sm, cam, vp, light, texCam, iteration, nearDist, farDist);
  }
 
  void StableCSMShadowCameraSetup::getShadowCameraForCascade(const Ogre::SceneManager *sm, const Ogre::Camera *cam,
    const Ogre::Viewport *vp, const Ogre::Light *light, Ogre::Camera *texCam, size_t iteration,
    Ogre::Real nearSplit, Ogre::Real farSplit) const
  {
    Ogre::Vector3 pos, dir;
    Ogre::Matrix3 rot;
 
    bool iscustom = cam->isCustomProjectionMatrixEnabled();
    Ogre::Radian nCamFov = cam->getFOVy();
    if (iscustom)
    {
      Ogre::Matrix4 projmat = cam->getProjectionMatrix();
      nCamFov = Ogre::Radian(Ogre::Math::ATan(1.0f / projmat[1][1]) * 2.0f);
    }
 
    // reset custom view / projection matrix in case already set
    texCam->setCustomViewMatrix(false);
    texCam->setCustomProjectionMatrix(false);
 
    // Directional lights
    if (light->getType() == Ogre::Light::LT_DIRECTIONAL)
    {
      // set up the shadow texture
      // Set ortho projection
      texCam->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
      // set easy FOV and near dist so that texture covers far dist
      texCam->setFOVy(Ogre::Degree(90));
 
      float nearClip = light->getShadowNearClipDistance();
      if (nearClip <= 0.0f)
        nearClip = cam->getNearClipDistance();
 
      float farClip = light->getShadowFarClipDistance();
      if (farClip <= 0.0f)
        farClip = cam->getFarClipDistance();
 
      texCam->setNearClipDistance(nearClip);
      texCam->setFarClipDistance(farClip);
 
      // Calculate texCam direction, which same as directional light direction
      dir = -light->getDerivedDirection();
      dir.normalise();
 
      //get light orientation
      Ogre::Vector3 up = Ogre::Vector3::UNIT_Y;
      // Check it's not coincident with dir
      if (Ogre::Math::Abs(up.dotProduct(dir)) >= 1.0f)
      {
        // Use camera up
        up = Ogre::Vector3::UNIT_Z;
      }
      rot = Ogre::Math::lookRotation(dir, up);
 
      // Find minimum enclosing sphere for view frustum
      // We do this in local space so that we don't have slight precision variation between frames
      float vertical = Ogre::Math::Tan(nCamFov * 0.5f);
      float horizontal = Ogre::Math::Tan(nCamFov * 0.5f);
 
      if (!iscustom)
        horizontal = horizontal * cam->getAspectRatio();
 
      Ogre::Vector3 topLeftFar;
      topLeftFar.x = horizontal * farSplit;
      topLeftFar.y = vertical * farSplit;
      topLeftFar.z = farSplit;
 
      Ogre::Vector3 bottomRightNear;
      bottomRightNear.z = nearSplit;
      bottomRightNear.x = horizontal * bottomRightNear.z;
      bottomRightNear.y = vertical * bottomRightNear.z;
 
      float dist = (topLeftFar.squaredLength() - bottomRightNear.squaredLength()) / (2 * (topLeftFar.z - bottomRightNear.z));
 
      if (dist > farSplit)
        dist = farSplit;
 
      Ogre::Vector3 localPos(0, 0, -dist); // we have now found the point along frustum center which is equi-distant to the opposing corner positions
 
      Ogre::Real diameter = topLeftFar.distance(-localPos) * 2.0f;
      pos = cam->getDerivedPosition() + cam->getDerivedOrientation() * localPos;
 
      diameter *= (Ogre::Real)1.01; // allow some boundary pixels for filtering etc. TODO - make this a user constant
      pos += dir * 0.5 * (farClip - nearClip); // pull light back so we can see the scene
 
      //calculate window size
      texCam->setOrthoWindowWidth(diameter);
 
      // Round local x/y position based on a world-space texel; this helps to reduce
      // jittering caused by the projection moving with the camera
      Ogre::Real worldTexelSize = texCam->getOrthoWindowWidth() / texCam->getViewport()->getActualWidth();
 
      //convert world space camera position into light space
      Ogre::Vector3 lightSpacePos = rot.transpose() * pos;
 
      //snap to nearest texel
      lightSpacePos.x -= fmod(lightSpacePos.x, worldTexelSize);
      lightSpacePos.y -= fmod(lightSpacePos.y, worldTexelSize);
 
      //convert back to world space
      pos = rot * lightSpacePos;
 
      // Finally set position
      texCam->getParentNode()->setPosition(pos);
      texCam->getParentNode()->setOrientation(rot);
    }
    /*
    else
    {
      float nearClip = nearSplit;
      float farClip = farSplit;
 
      if (nearClip <= 0.0f)
        nearClip = cam->getNearClipDistance();
 
      if (farClip <= 0.0f)
        farClip = cam->getFarClipDistance();
 
      texCam->setNearClipDistance(nearClip);
      texCam->setFarClipDistance(farClip);
 
      FocusedShadowCameraSetup::getShadowCamera(sm, cam, vp, light, texCam, iteration);
    }*/
 
          // set some GPU shader parameters
          mGpuConstants->updateCascade(*texCam, iteration);
  }
 
 
 
  // GPU constants
  CSMGpuConstants* CSMGpuConstants::getSingletonPtr()
  {
    if (!msSingleton)
      msSingleton = new CSMGpuConstants();
 
    return msSingleton;
  }
 
  CSMGpuConstants& CSMGpuConstants::getSingleton()
  {
    if (!msSingleton)
      msSingleton = new CSMGpuConstants();
 
    return (*msSingleton);
  }
 
  CSMGpuConstants::CSMGpuConstants()
  {
    mCascadeCount = 4;
    mParamsScaleBias = Ogre::GpuProgramManager::getSingletonPtr()->createSharedParameters("params_shadowMatrixScaleBias");
 
    for (size_t i = 1; i < mCascadeCount; i++)
    {
      mParamsScaleBias->addConstantDefinition("texMatrixScaleBias" + Ogre::StringConverter::toString(i), Ogre::GCT_FLOAT4);
    }
  }
 
 
  CSMGpuConstants::~CSMGpuConstants()
  {
    try
    {
      mParamsScaleBias = Ogre::GpuProgramManager::getSingletonPtr()->getSharedParameters("params_shadowMatrixScaleBias");
    }
    catch (Ogre::Exception&)
    {
    }
 
    if (mParamsScaleBias)
      mParamsScaleBias->removeAllConstantDefinitions();
  }
 
 
  void CSMGpuConstants::updateCascade(const Ogre::Camera &texCam, size_t index)
  {
    if (index == 0)
    {
      mFirstCascadeViewMatrix = texCam.getViewMatrix();
      mFirstCascadeCamWidth = texCam.getOrthoWindowWidth();
      mViewRange = texCam.getFarClipDistance() - texCam.getNearClipDistance();
    }
    else
    {
      Ogre::Matrix4 mat0 = mFirstCascadeViewMatrix;
      Ogre::Matrix4 mat1 = texCam.getViewMatrix();
 
      Ogre::Real offsetX = mat1[0][3] - mat0[0][3];
      Ogre::Real offsetY = mat1[1][3] - mat0[1][3];
      Ogre::Real offsetZ = mat1[2][3] - mat0[2][3];
 
      Ogre::Real width0 = mFirstCascadeCamWidth;
      Ogre::Real width1 = texCam.getOrthoWindowWidth();
 
      Ogre::Real oneOnWidth = 1.0f / width0;
      Ogre::Real offCenter = width1 / (2.0f * width0) - 0.5f;
 
      Ogre::RenderSystem* rs = Ogre::Root::getSingletonPtr()->getRenderSystem();
      float depthRange = Ogre::Math::Abs(rs->getMinimumDepthInputValue() - rs->getMaximumDepthInputValue());
 
      Ogre::Vector4 result;
      result.x = offsetX * oneOnWidth + offCenter;
      result.y = -offsetY * oneOnWidth + offCenter;
      result.z = -depthRange * offsetZ / mViewRange;
      result.w = width0 / width1;
 
      mParamsScaleBias->setNamedConstant("texMatrixScaleBias" + Ogre::StringConverter::toString(index), result);
    }
  }
 
}