SO3DeferredShadowManager.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
#include <boost/lexical_cast.hpp>
#include "SO3Utils/SO3Exception.h"
#include "SO3Renderer/DeferredShading/SO3DeferredShadowManager.h"
 
 
template<> SO3::SDeferredShadowManager* Ogre::Singleton<SO3::SDeferredShadowManager>::msSingleton = 0;
 
namespace SO3
{
 
SDeferredShadowManager::SDeferredShadowManager()
{
        // Init textures ptr to zero
        shadowStandardTexture.reset();
        shadowCubicTexture.reset();
 
        // Init materials ptr to zero
        shadowStandardMaterial.reset();
        shadowCubicMaterial.reset();
 
        // Useful matrix for shadow texture projection
        PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE = Ogre::Matrix4(0.5,    0,    0,  0.5, 
                                                                0,   -0.5,    0,  0.5, 
                                                                0,      0,    1,    0,
                                                                0,      0,    0,    1);
 
        // Setting up shadow textures to medium quality values
        standardTextureSize = 1024;
        standardTexturePixelFormat = Ogre::PF_FLOAT16_R;
        standardTextureFsaa = 0;
        standardTextureNeedRebuild = true;
        cubicTextureSize = 512;
        cubicTexturePixelFormat = Ogre::PF_FLOAT16_R;
        cubicTextureFsaa = 0;
        cubicTextureNeedRebuild = true;
 
        // Setting up names
        deferredShadowStandardTextureName  = std::string(SO3_DEFERRED_SHADOWS_SCHEME_NAME) + std::string(SO3_DEFERRED_SHADOWS_STANDARD_BASE_NAME) + std::string(SO3_DEFERRED_SHADOWS_TEXTURE_NAME);
        deferredShadowStandardCameraName   = std::string(SO3_DEFERRED_SHADOWS_SCHEME_NAME) + std::string(SO3_DEFERRED_SHADOWS_STANDARD_BASE_NAME) + std::string(SO3_DEFERRED_SHADOWS_CAMERA_NAME);
        deferredShadowStandardMaterialName = std::string(SO3_DEFERRED_SHADOWS_SCHEME_NAME) + std::string(SO3_DEFERRED_SHADOWS_STANDARD_BASE_NAME) + std::string(SO3_DEFERRED_SHADOWS_MATERIAL_NAME);
        deferredShadowCubicTextureName     = std::string(SO3_DEFERRED_SHADOWS_SCHEME_NAME) + std::string(SO3_DEFERRED_SHADOWS_CUBIC_BASE_NAME) + std::string(SO3_DEFERRED_SHADOWS_TEXTURE_NAME);
        deferredShadowCubicCameraName      = std::string(SO3_DEFERRED_SHADOWS_SCHEME_NAME) + std::string(SO3_DEFERRED_SHADOWS_CUBIC_BASE_NAME) + std::string(SO3_DEFERRED_SHADOWS_CAMERA_NAME);
        deferredShadowCubicMaterialName    = std::string(SO3_DEFERRED_SHADOWS_SCHEME_NAME) + std::string(SO3_DEFERRED_SHADOWS_CUBIC_BASE_NAME) + std::string(SO3_DEFERRED_SHADOWS_MATERIAL_NAME);
 
  // Define some camera setup
  spotShadowCameraSetup = new Ogre::DefaultShadowCameraSetup();
  pointShadowCameraSetup = new Ogre::DefaultShadowCameraSetup();
  directionalShadowCameraSetup = new Ogre::DefaultShadowCameraSetup();
  /*directionalShadowCameraSetup = new Ogre::LiSPSMShadowCameraSetup();
 
  // Further configuration for non-default camera setup.
  static_cast<Ogre::LiSPSMShadowCameraSetup*>(directionalShadowCameraSetup)->setOptimalAdjustFactor(5);*/
 
        // Hook up the shadow handlers.
        Ogre::MaterialManager::getSingleton().addListener(this, SO3_DEFERRED_SHADOWS_SCHEME_NAME);
}
 
SDeferredShadowManager::~SDeferredShadowManager()
{
        Ogre::MaterialManager::getSingleton().removeListener(this, SO3_DEFERRED_SHADOWS_SCHEME_NAME);
        DestroyShadowStandardTexture();
        DestroyShadowCubicTexture();
 
  // Remove camera setup
  SO3_SAFE_DELETE(spotShadowCameraSetup);
  SO3_SAFE_DELETE(pointShadowCameraSetup);
  SO3_SAFE_DELETE(directionalShadowCameraSetup);
}
 
SDeferredShadowManager* SDeferredShadowManager::getSingletonPtr()
{
        return msSingleton;
}
 
SDeferredShadowManager& SDeferredShadowManager::getSingleton()
{
        assert(msSingleton);
        return (*msSingleton);
}
 
void SDeferredShadowManager::RegisterSceneManager(Ogre::SceneManager* targetScene)
{
        OgreSceneManagerList::iterator ogreSceneManagerSearched = ogreSceneManagerList.find(targetScene);
        if (ogreSceneManagerSearched != ogreSceneManagerList.end())
    SO3_EXCEPT(SExceptionItemIdentity, "Trying to register an already registered scene manager!", "SDeferredShadowManager::RegisterSceneManager", true);
        else
        {
                // TODO Store the original shadow parameters, for restoring while unregistering
                // Configure deferred shadows
                targetScene->setShadowTechnique(Ogre::SHADOWTYPE_NONE);
 
                // Create shadow standard texture camera. Camera names are handled by each scene, so no worries about duplicate items
                Ogre::Camera* ogreStandardShadowCamera = targetScene->createCamera(deferredShadowStandardCameraName);
                ogreStandardShadowCamera->setAspectRatio(1);
                standardTextureCameraByScene.insert(StandardTextureCameraByScene::value_type(targetScene, ogreStandardShadowCamera));
 
                // Create shadow cubic texture cameras.
                std::vector<Ogre::Camera*> ogreCubicCameras;
                for(int cpt = 0; cpt < 6; cpt++)
                {
                        Ogre::Camera* ogreCubicShadowCamera = targetScene->createCamera(deferredShadowCubicCameraName + boost::lexical_cast<std::string, int>(cpt));
                        // Store a reference to the camera for fast access.
                        ogreCubicCameras.push_back(ogreCubicShadowCamera);
                }
                cubicTextureCamerasByScene.insert(CubicTextureCamerasByScene::value_type(targetScene, ogreCubicCameras));
 
                // Add target scenemanager to our list
                ogreSceneManagerList.insert(targetScene);
        }
}
 
void SDeferredShadowManager::UnregisterSceneManager(Ogre::SceneManager* existingScene)
{
        OgreSceneManagerList::iterator ogreSceneManagerSearched = ogreSceneManagerList.find(existingScene);
        if (ogreSceneManagerSearched == ogreSceneManagerList.end())
                SO3_EXCEPT(SExceptionItemNotFound, "Trying to unregister a scene manager that is not registered!", "SDeferredShadowManager::UnregisterSceneManager", true);
        else
        {
                // Destroy shadow standard texture camera.
                StandardTextureCameraByScene::iterator iCamera = standardTextureCameraByScene.find(existingScene);
                Ogre::Camera* ogreStandardShadowCamera = iCamera->second;
                standardTextureCameraByScene.erase(iCamera);
                existingScene->destroyCamera(ogreStandardShadowCamera);
 
                // TODO Destroy shadow cubic texture cameras.
                CubicTextureCamerasByScene::iterator iCameras = cubicTextureCamerasByScene.find(existingScene);
                for(int cpt = 0; cpt < 6; cpt++)
                {
                        Ogre::Camera* ogreCubicShadowCamera = iCameras->second.at(cpt);
                        existingScene->destroyCamera(ogreCubicShadowCamera);
                }
                iCameras->second.clear();
                cubicTextureCamerasByScene.erase(iCameras);
 
                // TODO Restore shadow parameters
                // Remove from our list
                ogreSceneManagerList.erase(ogreSceneManagerSearched);
        }
}
 
void SDeferredShadowManager::SetShadowTextureSize(unsigned short size)
{
        SetShadowStandardTextureSize(size);
        SetShadowCubicTextureSize(size);
}
 
void SDeferredShadowManager::SetShadowTexturePixelFormat(Ogre::PixelFormat fmt)
{
        SetShadowStandardTexturePixelFormat(fmt);
        SetShadowCubicTexturePixelFormat(fmt);
}
 
void SDeferredShadowManager::SetShadowTextureFSAA(unsigned short fsaa)
{
        SetShadowStandardTextureFSAA(fsaa);
        SetShadowCubicTextureFSAA(fsaa);
}
 
void SDeferredShadowManager::SetShadowStandardTextureSize(unsigned short size)
{
        if(standardTextureSize != size)
                standardTextureNeedRebuild = true;
 
        standardTextureSize = size;
}
 
void SDeferredShadowManager::SetShadowStandardTexturePixelFormat(Ogre::PixelFormat fmt)
{
        if(standardTexturePixelFormat != fmt)
                standardTextureNeedRebuild = true;
 
        standardTexturePixelFormat = fmt;
}
 
void SDeferredShadowManager::SetShadowStandardTextureFSAA(unsigned short fsaa)
{
        if(standardTextureFsaa != fsaa)
                standardTextureNeedRebuild = true;
 
        standardTextureFsaa = fsaa;
}
 
void SDeferredShadowManager::SetShadowCubicTextureSize(unsigned short size)
{
        if(cubicTextureSize != size)
                cubicTextureNeedRebuild = true;
 
        cubicTextureSize = size;
}
 
void SDeferredShadowManager::SetShadowCubicTexturePixelFormat(Ogre::PixelFormat fmt)
{
        if(cubicTexturePixelFormat != fmt)
                cubicTextureNeedRebuild = true;
        
        cubicTexturePixelFormat = fmt;
}
 
void SDeferredShadowManager::SetShadowCubicTextureFSAA(unsigned short fsaa)
{
        if(cubicTextureFsaa != fsaa)
                cubicTextureNeedRebuild = true;
        
        cubicTextureFsaa = fsaa;
}
 
void SDeferredShadowManager::CreateShadowStandardTexture()
{
        // Delete existing texture if needed
        DestroyShadowStandardTexture();
 
        // Create the RTT texture
        shadowStandardTexture = Ogre::TextureManager::getSingleton().createManual(deferredShadowStandardTextureName,
                                                                                                                                                          Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, 
                                                                                                                                                          Ogre::TEX_TYPE_2D, 
                                                                                                                                                          standardTextureSize,
                                                                                                                                                          standardTextureSize,
                                                                                                                                                          0,
                                                                                                                                                          standardTexturePixelFormat,
                                                                                                                                                          Ogre::TU_RENDERTARGET,
                                                                                                                                                          0,
                                                                                                                                                          false,
                                                                                                                                                          standardTextureFsaa);
        // Ensure texture loaded
        shadowStandardTexture->load();
 
        // Create Material used for rendering this shadow
        shadowStandardMaterial = Ogre::MaterialManager::getSingleton().create(deferredShadowStandardMaterialName, Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
 
        // Configure the material
        Ogre::Pass* ogreShadowPass = shadowStandardMaterial->getTechnique(0)->getPass(0);
        ogreShadowPass->removeAllTextureUnitStates();
        Ogre::TextureUnitState* texUnit = ogreShadowPass->createTextureUnitState(deferredShadowStandardTextureName);
        texUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_BORDER);
        texUnit->setTextureBorderColour(Ogre::ColourValue::White);
        shadowStandardMaterial->touch();
 
        // All done
        standardTextureNeedRebuild = false;
}
 
void SDeferredShadowManager::CreateShadowCubicTexture()
{
        // Delete existing texture if needed
        DestroyShadowCubicTexture();
 
        // Create the RTT cubic texture
        shadowCubicTexture = Ogre::TextureManager::getSingleton().createManual(deferredShadowCubicTextureName,
                                                                                                                                                   Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME,
                                                                                                                                                   Ogre::TEX_TYPE_CUBE_MAP, 
                                                                                                                                                   cubicTextureSize,
                                                                                                                                                   cubicTextureSize,
                                                                                                                                                   0,
                                                                                                                                                   cubicTexturePixelFormat,
                                                                                                                                                   Ogre::TU_RENDERTARGET,
                                                                                                                                                   0,
                                                                                                                                                   false,
                                                                                                                                                   cubicTextureFsaa);
        // Ensure texture loaded
        shadowCubicTexture->load();
 
        // Create Material used for rendering this shadow
        shadowCubicMaterial = Ogre::MaterialManager::getSingleton().create(deferredShadowCubicMaterialName, Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
 
        // Configure the material
        Ogre::Pass* ogreShadowPass = shadowCubicMaterial->getTechnique(0)->getPass(0);
        ogreShadowPass->removeAllTextureUnitStates();
        Ogre::TextureUnitState* texUnit = ogreShadowPass->createTextureUnitState(deferredShadowCubicTextureName);
//      texUnit->setCubicTexture(&shadowCubicTexture, true);
        texUnit->setCubicTextureName(shadowCubicTexture->getName(), true);
        texUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_BORDER);
        texUnit->setTextureBorderColour(Ogre::ColourValue::White);
        shadowCubicMaterial->touch();
 
        // All done
        cubicTextureNeedRebuild = false;
}
 
void SDeferredShadowManager::DestroyShadowStandardTexture()
{
        // Check if there's an existing texture for this scene manager
        if(shadowStandardTexture)
        {
                // Delete the viewport
                Ogre::RenderTarget* ogreShadowRenderTarget = shadowStandardTexture->getBuffer()->getRenderTarget();
                Ogre::Viewport* ogreShadowViewport = ogreShadowRenderTarget->getViewport(0);
                if(ogreShadowViewport->getCamera() != 0)
                        ogreShadowViewport->setCamera(0);
                ogreShadowRenderTarget->removeViewport(0);
                // ogreShadowRenderTarget->setDepthBufferPool(1);
 
                // Delete the material
                Ogre::MaterialManager::getSingleton().remove(shadowStandardMaterial->getHandle());
                shadowStandardMaterial.reset();
 
                // Finally release the texture
                Ogre::TextureManager::getSingleton().remove(shadowStandardTexture->getHandle());
                shadowStandardTexture.reset();
                standardTextureNeedRebuild = true;
        }
}
 
void SDeferredShadowManager::DestroyShadowCubicTexture()
{
        // Check if there's an existing texture for this scene manager
        if(shadowCubicTexture)
        {
                // Delete the viewports
                for(int cpt = 0; cpt < 6; cpt++)
                {
                        Ogre::RenderTarget* ogreShadowRenderTarget = shadowCubicTexture->getBuffer(cpt)->getRenderTarget();
                        Ogre::Viewport* ogreShadowViewport = ogreShadowRenderTarget->getViewport(0);
                        if(ogreShadowViewport->getCamera() != 0)
                                ogreShadowViewport->setCamera(0);
                        ogreShadowRenderTarget->removeViewport(0);
                        // ogreShadowRenderTarget->setDepthBufferPool(1);
                }
 
                // Delete the material
                Ogre::MaterialManager::getSingleton().remove(shadowCubicMaterial->getHandle());
                shadowCubicMaterial.reset();
 
                // Finally release the texture
                Ogre::TextureManager::getSingleton().remove(shadowCubicTexture->getHandle());
                shadowCubicTexture.reset();
                cubicTextureNeedRebuild = true;
        }
}
 
Ogre::TexturePtr& SDeferredShadowManager::PrepareShadowTexture(Ogre::Camera* ogreCamera, Ogre::Viewport* ogreViewport, const Ogre::Light* light, Ogre::Pass* ogrePass)
{
        // You must have verify that light casts shadows before calling this function!
        Ogre::SceneManager* ogreTargetScene = ogreCamera->getSceneManager();
        OgreSceneManagerList::iterator ogreSceneManagerSearched = ogreSceneManagerList.find(ogreTargetScene);
        if (ogreSceneManagerSearched == ogreSceneManagerList.end())
    SO3_EXCEPT(SExceptionItemNotFound, "Can not prepare shadow texture for the scenemanager \""+ ogreTargetScene->getName() +"\", as it seems that it does not use deferred rendering!", "SDeferredShadowManager::PrepareShadowTexture", true);
 
        // Pause current rendering
        Ogre::SceneManager::RenderContext* context = ogreTargetScene->_pauseRendering();
 
        // Prepare 2D texture or Cubic texture?
        if(light->getType() == Ogre::Light::LT_POINT)
                PrepareShadowCubicTextureImpl(ogreTargetScene, ogreCamera, ogreViewport, light);
        else
                PrepareShadowTextureImpl(ogreTargetScene, ogreCamera, ogreViewport, light);
 
        // Resume rendering
        ogreTargetScene->_resumeRendering(context);
 
        // VERY IMPORTANT! 
        // Set auto_param ACT_TEXTURE_VIEWPROJ_MATRIX, it's not bounded correctly when we do not use Ogre's internal shadows.
        // As a drawback, this parameter must not be bounded as a auto_param in the program!
        Ogre::Camera* ogreShadowCamera = 0;
        if(light->getType() == Ogre::Light::LT_POINT)
                ogreShadowCamera = cubicTextureCamerasByScene.find(ogreTargetScene)->second.front();
        else
                ogreShadowCamera = standardTextureCameraByScene.find(ogreTargetScene)->second;
 
        assert(ogreShadowCamera != 0);
        Ogre::GpuProgramParametersSharedPtr params = ogrePass->getFragmentProgramParameters();
        Ogre::Matrix4 textureProjectionMatrix = PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE * ogreShadowCamera->getProjectionMatrixWithRSDepth() * ogreShadowCamera->getViewMatrix();
        if (params->_findNamedConstantDefinition("shadowViewProjMat"))
                params->setNamedConstant("shadowViewProjMat", textureProjectionMatrix);
 
        // Return the prepared texture
        if(light->getType() == Ogre::Light::LT_POINT)
                return shadowCubicTexture;
        else
                return shadowStandardTexture;
}
 
void SDeferredShadowManager::PrepareShadowTextureImpl(Ogre::SceneManager* ogreTargetScene, Ogre::Camera* ogreCamera, Ogre::Viewport* ogreViewport, const Ogre::Light* ogreLight)
{
        // First, check if we need to create the texture
        if(standardTextureNeedRebuild)
                CreateShadowStandardTexture();
 
        // Get the scene shadow standard texture camera
        StandardTextureCameraByScene::iterator iCamera = standardTextureCameraByScene.find(ogreTargetScene);
        Ogre::Camera* ogreShadowCamera = iCamera->second;
 
        // Check rtt viewport
        Ogre::RenderTarget* ogreShadowRTT = shadowStandardTexture->getBuffer()->getRenderTarget();
        Ogre::Viewport* ogreShadowViewport = 0;
        if(ogreShadowRTT->getNumViewports() == 0)
        {
                ogreShadowViewport = ogreShadowRTT->addViewport(ogreShadowCamera);
                ogreShadowViewport->setClearEveryFrame(true);
                ogreShadowViewport->setOverlaysEnabled(false);
                ogreShadowViewport->setMaterialScheme(SO3_DEFERRED_SHADOWS_SCHEME_NAME);
                ogreShadowRTT->setAutoUpdated(false);
        }
        else
                ogreShadowViewport = ogreShadowRTT->getViewport(0);
 
        // Be sure that the viewport is bind to the correct camera
        assert(ogreShadowViewport != 0);
        ogreShadowViewport->setCamera(ogreShadowCamera);
 
        // Associate main view camera as LOD camera
        ogreShadowCamera->setLodCamera(ogreCamera);
        ogreShadowCamera->setDirection(ogreLight->getDerivedDirection());
        if (ogreLight->getType() == Ogre::Light::LT_SPOTLIGHT)
  {
                ogreShadowCamera->setPosition(ogreLight->getDerivedPosition());
    spotShadowCameraSetup->getShadowCamera(ogreTargetScene, ogreCamera, ogreViewport, ogreLight, ogreShadowCamera, 0);
  }
  else
  {
    directionalShadowCameraSetup->getShadowCamera(ogreTargetScene, ogreCamera, ogreViewport, ogreLight, ogreShadowCamera, 0);
  }
 
        // Further config on the material
        shadowStandardMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setProjectiveTexturing(true, ogreShadowCamera);
 
        // Setup background colour
        ogreShadowViewport->setBackgroundColour(Ogre::ColourValue::White);
        
        // Update target
        ogreShadowRTT->update();
}
 
void SDeferredShadowManager::PrepareShadowCubicTextureImpl(Ogre::SceneManager* ogreTargetScene, Ogre::Camera* ogreCamera, Ogre::Viewport* ogreViewport, const Ogre::Light* ogreLight)
{
        // First, check if we need to create the texture
        if(cubicTextureNeedRebuild)
                CreateShadowCubicTexture();
 
        // Get the list of all the cubic camera for this scene
        std::vector<Ogre::Camera*> ogreCubicCameras = cubicTextureCamerasByScene.find(ogreTargetScene)->second;
 
        // Iterate Rtts
        for(int cpt = 0; cpt < 6; cpt++)
        {
                // Get the scene shadow cubic texture camera
                Ogre::Camera* ogreShadowCamera = ogreCubicCameras.at(cpt);
 
                // Check rtt viewport
    Ogre::RenderTarget* ogreShadowRTT = shadowCubicTexture->getBuffer(cpt)->getRenderTarget();
                Ogre::Viewport* ogreShadowViewport = 0;
                if(ogreShadowRTT->getNumViewports() == 0)
                {
                        ogreShadowViewport = ogreShadowRTT->addViewport(ogreShadowCamera);
                        ogreShadowViewport->setClearEveryFrame(true);
                        ogreShadowViewport->setOverlaysEnabled(false);
                        ogreShadowViewport->setMaterialScheme(SO3_DEFERRED_SHADOWS_SCHEME_NAME);
                        ogreShadowRTT->setAutoUpdated(false);
                }
                else
                        ogreShadowViewport = ogreShadowRTT->getViewport(0);
 
                // Be sure that the viewport is bind to the correct camera
                assert(ogreShadowViewport != 0);
                ogreShadowViewport->setCamera(ogreShadowCamera);
                        
                // Get the shadow camera setup
    pointShadowCameraSetup->getShadowCamera(ogreTargetScene, ogreCamera, ogreViewport, ogreLight, ogreShadowCamera, 0);
 
    // Override some stuff of the camera setup
    ogreShadowCamera->setProjectionType(Ogre::PT_PERSPECTIVE);
    ogreShadowCamera->setAspectRatio(1);
                ogreShadowCamera->setFOVy(Ogre::Degree(90));
 
    // Associate main view camera as LOD camera
                ogreShadowCamera->setLodCamera(ogreCamera);
 
    // Set position (after getShadowCameraSetup()!)
                ogreShadowCamera->setPosition(ogreLight->getDerivedPosition());
 
    // Set orientation (after getShadowCameraSetup()!), face the good cube face
    ogreShadowCamera->setOrientation(Ogre::Quaternion::IDENTITY);
                switch(cpt)
                {
                case 0:
                        ogreShadowCamera->yaw(Ogre::Degree(-90));
                        break;
                case 1:
                        ogreShadowCamera->yaw(Ogre::Degree(90));
                        break;
                case 2:
                        ogreShadowCamera->pitch(Ogre::Degree(90));
                        break;
                case 3:
                        ogreShadowCamera->pitch(Ogre::Degree(-90));
                        break;
                case 5:
                        ogreShadowCamera->yaw(Ogre::Degree(180));
                        break;
                }
 
                // Further config on the material
    shadowCubicMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setProjectiveTexturing(true, ogreShadowCamera);
 
                // Setup background colour
                ogreShadowViewport->setBackgroundColour(Ogre::ColourValue::White);
        
                // Update target
                ogreShadowRTT->update();
        }
}
 
Ogre::Technique* SDeferredShadowManager::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
{
  Ogre::Material::TechniqueIterator schemeTechniqueIt = originalMaterial->getTechniqueIterator();
  while(schemeTechniqueIt.hasMoreElements())
  {
    Ogre::Technique* schemeTechnique = schemeTechniqueIt.getNext();
    if(schemeTechnique->getSchemeName() == schemeName)
      return schemeTechnique;
  }
 
        Ogre::Technique* shadowTechnique = 0;
        if(schemeName == SO3_DEFERRED_SHADOWS_SCHEME_NAME)
        {
                // Get a reference to the original technique
                Ogre::MaterialManager& ogreMaterialManager = Ogre::MaterialManager::getSingleton();
                ogreMaterialManager.setActiveScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME);
                Ogre::Technique* originalTechnique = originalMaterial->getBestTechnique(lodIndex, rend);
 
                // Get a reference to the template shadow caster material
                Ogre::MaterialPtr shadowCasterMaterial = Ogre::MaterialManager::getSingleton().getByName(SO3_DEFERRED_SHADOW_CASTER_NAME);
                if (!shadowCasterMaterial)
      SO3_EXCEPT(SExceptionItemNotFound, "Cannot locate the shadow caster material named \"" + std::string(SO3_DEFERRED_SHADOW_CASTER_NAME) + "'", "SDeferredShadowManager::handleSchemeNotFound", true);
                
                // Make sure it's loaded
                if(!shadowCasterMaterial->isLoaded())
                        shadowCasterMaterial->load();
 
                // Store a reference to the shadow caster technique used by the default scheme
                Ogre::Technique* shadowCasterTechnique = shadowCasterMaterial->getBestTechnique();
 
                // Now, get back to the deferred shadow scheme
                ogreMaterialManager.setActiveScheme(SO3_DEFERRED_SHADOWS_SCHEME_NAME);
 
                // Create a new empty gbuffer technique on the existing material.
                shadowTechnique = originalMaterial->createTechnique();
                shadowTechnique->removeAllPasses();
                shadowTechnique->setSchemeName(SO3_DEFERRED_SHADOWS_SCHEME_NAME);
 
                // Iterate throught the original material passes. 
                for (unsigned short i=0; i<originalTechnique->getNumPasses(); i++)
                {
                        Ogre::Pass* originalPass = originalTechnique->getPass(i);
                        Ogre::Pass* shadowPass = shadowTechnique->createPass();
 
                        // Special case alpha-blended passes
                        if((originalPass->getSourceBlendFactor() == Ogre::SBF_SOURCE_ALPHA)
                         &&(originalPass->getDestBlendFactor() == Ogre::SBF_ONE_MINUS_SOURCE_ALPHA)
                         ||(originalPass->getAlphaRejectFunction() != Ogre::CMPF_ALWAYS_PASS))
                        {
                                // Code from Ogre::SceneManager::deriveShadowCasterPass
                                // Alpha blended passes must retain their transparency
                                shadowPass->setAlphaRejectSettings(originalPass->getAlphaRejectFunction(), originalPass->getAlphaRejectValue());
                                shadowPass->setSceneBlending(originalPass->getSourceBlendFactor(), originalPass->getDestBlendFactor());
                                shadowPass->getParent()->getParent()->setTransparencyCastsShadows(true);
 
                                // So we allow the texture units, but override the colour functions
                                // Copy texture state, shift up one since 0 is shadow texture
                                unsigned short origPassTUCount = originalPass->getNumTextureUnitStates();
                                for (unsigned short t = 0; t < origPassTUCount; ++t)
                                {
                                        // copy base state
                                        Ogre::TextureUnitState* shadowTextureUnit = originalPass->createTextureUnitState();
                                        (*shadowTextureUnit) = *(originalPass->getTextureUnitState(t));
                                        
                                        // override colour function. I use additive shadows, so set it to black. With non-additive shadow technique it should be the shadow colour.
                                        shadowTextureUnit->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, Ogre::ColourValue::Black);
                                }
                        }
                        else
                        {
                                // reset
                                shadowPass->setSceneBlending(Ogre::SBT_REPLACE);
                                shadowPass->setAlphaRejectFunction(Ogre::CMPF_ALWAYS_PASS);
                        }
 
                        // Propagate culling modes
                        shadowPass->setCullingMode(originalPass->getCullingMode());
                        shadowPass->setManualCullingMode(originalPass->getManualCullingMode());
                
                        // Set our shadow caster programs
                        Ogre::Pass* shadowCasterDefaultPass = shadowCasterTechnique->getPass(0);
                        
                        // Start with vertex program
                        if(shadowCasterDefaultPass->hasVertexProgram())
                        {
                                shadowPass->setVertexProgram(shadowCasterDefaultPass->getVertexProgramName(), false);
                                const Ogre::GpuProgramPtr& shadowPassVertexProgram = shadowPass->getVertexProgram();
                                if (!shadowPassVertexProgram->isLoaded())
                                        shadowPassVertexProgram->load();
                                
                                // Copy params
                                shadowPass->setVertexProgramParameters(shadowCasterDefaultPass->getVertexProgramParameters());
                        }
 
                        // Continue with fragment program
                        if(shadowCasterDefaultPass->hasFragmentProgram())
                        {
                                shadowPass->setFragmentProgram(shadowCasterDefaultPass->getFragmentProgramName(), false);
                                const Ogre::GpuProgramPtr& shadowPassFragmentProgram = shadowPass->getVertexProgram();
                                if (!shadowPassFragmentProgram->isLoaded())
                                        shadowPassFragmentProgram->load();
 
                                // Copy params
                                shadowPass->setFragmentProgramParameters(shadowCasterDefaultPass->getFragmentProgramParameters());
                        }
 
                        // handle the case where there is no fixed pipeline support
                        shadowPass->getParent()->getParent()->compile();
                        shadowPass = shadowPass->getParent()->getParent()->getBestTechnique()->getPass(0);
 
                        // All done, process the next pass.
                }
        }
        return shadowTechnique;
}
 
}