SO3SsaoHandler.cpp

Go to the documentation of this file.

 
#include "SO3Renderer/SO3SsaoHandler.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Utils/SO3Exception.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Material/SO3Technique.h"
#include "SO3Material/SO3Material.h"
 
namespace SO3
{
 
  bool SSsaoHandler::compositorCreated = false;
  SSsaoHandler::SsaoTechniqueParametersByTechnique SSsaoHandler::ssaoTechniquesParameters;
 
  void SSsaoHandler::Reset()
  {
    compositorCreated = false;
    ssaoTechniquesParameters.clear();
  }
 
  SSsaoHandler::SSsaoHandler()
  {
  }
 
  SSsaoHandler::SSsaoHandler(SViewPort* targetViewportInstance)
  {
    // Initialize viewport
    isEnable = false;
    targetViewport = targetViewportInstance;
    targetViewportScheme = targetViewport->GetOgreViewPortPointer()->getMaterialScheme();
    inputCompositorInstance = 0;
    ogreCompositorManager = Ogre::CompositorManager::getSingletonPtr();
    ogreProgramManager = Ogre::GpuProgramManager::getSingletonPtr();
    ogreMaterialManager = Ogre::MaterialManager::getSingletonPtr();
    mSupportGbuffer = true;
 
    //test if shaders are supported by the card
    const Ogre::RenderSystemCapabilities* caps = SRoot::getSingleton().GetOgreRenderSystem()->getCapabilities();
    Ogre::PixelFormat rttformat = Ogre::PF_BYTE_BGRA;
    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_4_0") || caps->isShaderProfileSupported("ps_3_0") || caps->isShaderProfileSupported("arbfp1") || caps->isShaderProfileSupported("glsles") || caps->isShaderProfileSupported("glsl300es"));
    if (isSupported)
    {
      // Generate compositor
      CreateCompositors();
 
      /* Setup compositors. This is a relatively complex chain:
         -> "/Ssao/Input" stores RGB color texture and occlusion texture. Do not deactivate it!
         -> "/Ssao/GBuffer" namespace holds compositors that fill a basic GBuffer, depending what the Ssao method needs to render. Only one compositor of this namespace must be activated at a time.
         -> "/Ssao/Method" namespace holds ssao methods implementations. Only one compositor of this namespace must be activated at a time.
         -> "/Ssao/Filter" namespace holds compositors that will blur the occlusion texture filled by a SSAO method. Zero or one compositor of this namespace should be activated at a time
         -> "/Ssao/Output" namespace holds compositors that will render result to buffer. Only one compositor of this namespace must be activated at a time (Merging or one of Debug).
         -> "/Ssao/Output/Debug" namespace holds compositors that will render debug visualizations to buffer. Merging compositor must be deactivated if one of those compositor is activated.
      */
 
      inputCompositorInstance = ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input");
      if (mSupportGbuffer)
        normalCompositorInstance = ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
 
      ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek");
 
      if (mSupportGbuffer)
        ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric");
 
      if (mSupportGbuffer)
        ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading");
 
      ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging");
      ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box");
      ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart");
 
      if (mSupportGbuffer)
        ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2");
 
      ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug");           // Compositor chain should stop here if this compositor is activated.
      ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth");    // Compositor chain should stop here if this compositor is activated.
 
      if (mSupportGbuffer)
      {
        ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2");   // Compositor chain should stop here if this compositor is activated.
        ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal");   // Compositor chain should stop here if this compositor is activated.
        ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position"); // Compositor chain should stop here if this compositor is activated.
      }
 
      // Init ssao
      currentSsaoGbufferLayout = static_cast<SsaoGBufferLayout>(-1);
      currentSsaoTechnique = static_cast<SsaoTechnique>(-1);
      currentSsaoFilter = static_cast<SsaoFilter>(-1);
      currentSsaoDebugMode = static_cast<SsaoDebugMode>(-1);
      SetTechnique(SO3_SSAO_TECHNIQUE_CRYTEK);
      SetFilter(SO3_SSAO_FILTER_BOX);
      SetDebugMode(SO3_SSAO_DEBUG_MODE_NONE);
    }
  }
 
  SSsaoHandler::~SSsaoHandler()
  {
    if (isSupported)
    {
      // Force disable
      SetEnable(false);
 
      // Release compositor
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position");
      
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal");
      
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2");
 
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth");
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug");
 
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2");
 
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart");
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box");
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging");
 
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading");
 
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric");
 
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek");
 
      if (mSupportGbuffer)
        ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
 
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input");
 
      inputCompositorInstance = 0;
 
      Ogre::CompositorChain* compositorChain = ogreCompositorManager->getCompositorChain(targetViewport->GetOgreViewPortPointer());
      if (compositorChain)
        if (compositorChain->getCompositorInstances().empty())
          ogreCompositorManager->removeCompositorChain(targetViewport->GetOgreViewPortPointer());
 
      ogreCompositorManager = 0;
    }
  }
 
  bool SSsaoHandler::GetEnable()
  {
    return isEnable;
  }
 
  void SSsaoHandler::SetEnable(bool enable)
  {
    if (isSupported)
    {
      if (enable != isEnable)
      {
        isEnable = enable;
        if (enable)
        {
          if (mSupportGbuffer)
            ogreMaterialManager->addListener(this, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
 
          // Enable base compositor
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", true);
 
          // Activate SSAO
          SsaoTechnique techniqueToRestore = currentSsaoTechnique;
          SsaoDebugMode debugModeToRestore = currentSsaoDebugMode;
          SsaoFilter filterToRestore = currentSsaoFilter;
          currentSsaoGbufferLayout = static_cast<SsaoGBufferLayout>(-1);
          currentSsaoTechnique = static_cast<SsaoTechnique>(-1);
          currentSsaoFilter = static_cast<SsaoFilter>(-1);
          currentSsaoDebugMode = static_cast<SsaoDebugMode>(-1);
          isEnable = enable;
          SetTechnique(techniqueToRestore);
          SetDebugMode(debugModeToRestore);
          SetFilter(filterToRestore);
        }
        else
        {
          // Remove gbuffer material scheme listener
          if (mSupportGbuffer)
            ogreMaterialManager->removeListener(this, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
 
          // Stop others compositors
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", false);
 
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", false);
 
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", false);
 
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", false);
 
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", false);
 
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", false);
 
          if (mSupportGbuffer && !targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", false);
 
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", false);
        }
      }
    }
  }
 
  SSsaoHandler::SsaoTechnique SSsaoHandler::GetTechnique()
  {
    return currentSsaoTechnique;
  }
 
  void SSsaoHandler::SetTechnique(SsaoTechnique newTechnique)
  {
    //Force crytek when not supported
    if ((newTechnique != SO3_SSAO_TECHNIQUE_NONE) && (!mSupportGbuffer && ((newTechnique == SO3_SSAO_TECHNIQUE_HEMISPHERIC) || (newTechnique == SO3_SSAO_TECHNIQUE_CREASE_SHADING))))
      newTechnique = SO3_SSAO_TECHNIQUE_CRYTEK;
 
    if (isSupported && (newTechnique < SO3_SSAO_TECHNIQUE_MAX) && (newTechnique != currentSsaoTechnique))
    {
      if (isEnable)
      {
        // Disable current technique
        switch (currentSsaoTechnique)
        {
        case SO3_SSAO_TECHNIQUE_NONE:
          break;
        case SO3_SSAO_TECHNIQUE_CRYTEK:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", false);
          break;
        case SO3_SSAO_TECHNIQUE_HEMISPHERIC:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", false);
          break;
        case SO3_SSAO_TECHNIQUE_CREASE_SHADING:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", false);
          break;
        }
 
        // Check if we need to switch GBuffer
        SsaoGBufferLayout newLayout = GetGBufferLayout(newTechnique);
        if (currentSsaoGbufferLayout != newLayout)
        {
          // Store and reset debug mode before switching gbuffer layout.
          SsaoDebugMode debugModeToRestore = currentSsaoDebugMode;
          SetDebugMode(SO3_SSAO_DEBUG_MODE_NONE);
 
          // Store and reset filter before switching gbuffer layout.
          SsaoFilter filterToRestore = currentSsaoFilter;
          SetFilter(SO3_SSAO_FILTER_NONE);
 
          // Disable old GBuffer layout
          switch (currentSsaoGbufferLayout)
          {
          case SO3_SSAO_GBUFFER_DEPTH_ONLY:
            break;
          case SO3_SSAO_GBUFFER_NORMAL_POSITION:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", false))
            {
              //normalCompositorInstance->getRenderTarget(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture")->removeListener(this);
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", false);
            }
            break;
          }
 
          // Enable new GBuffer layout
          switch (newLayout)
          {
          case SO3_SSAO_GBUFFER_DEPTH_ONLY:
            break;
          case SO3_SSAO_GBUFFER_NORMAL_POSITION:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", true))
            {
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", true);
              //normalCompositorInstance->getRenderTarget(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture")->addListener(this);
            }
            break;
          }
          currentSsaoGbufferLayout = newLayout;
 
          // Restore debug mode after switching gbuffer layout.
          SetDebugMode(debugModeToRestore);
 
          // Restore filter after switching gbuffer layout.
          SetFilter(filterToRestore);
        }
 
        // Enable new technique
        switch (newTechnique)
        {
        case SO3_SSAO_TECHNIQUE_NONE:
          break;
        case SO3_SSAO_TECHNIQUE_CRYTEK:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", true);
          break;
        case SO3_SSAO_TECHNIQUE_HEMISPHERIC:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", true);
          break;
        case SO3_SSAO_TECHNIQUE_CREASE_SHADING:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", true);
          break;
        }
      }
      currentSsaoTechnique = newTechnique;
    }
  }
 
  SSsaoHandler::SsaoFilter SSsaoHandler::GetFilter()
  {
    return currentSsaoFilter;
  }
 
  void SSsaoHandler::SetFilter(const SsaoFilter& newFilter)
  {
    if (isSupported && (newFilter < SO3_SSAO_FILTER_MAX) && (newFilter != currentSsaoFilter))
    {
      if (isEnable)
      {
        // Disable current filter
        switch (currentSsaoFilter)
        {
        case SO3_SSAO_FILTER_NONE:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", false);
          break;
        case SO3_SSAO_FILTER_BOX:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", false);
          break;
        case SO3_SSAO_FILTER_BOX_SMART:
        {
          switch (currentSsaoGbufferLayout)
          {
          case SO3_SSAO_GBUFFER_DEPTH_ONLY:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", false))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", false);
            break;
          case SO3_SSAO_GBUFFER_NORMAL_POSITION:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", false))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", false);
            break;
          }
          break;
        }
        }
 
        // Enable new filter
        switch (newFilter)
        {
        case SO3_SSAO_FILTER_NONE:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", true);
          break;
        case SO3_SSAO_FILTER_BOX:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", true);
          break;
        case SO3_SSAO_FILTER_BOX_SMART:
        {
          switch (currentSsaoGbufferLayout)
          {
          case SO3_SSAO_GBUFFER_DEPTH_ONLY:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", true))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", true);
            break;
          case SO3_SSAO_GBUFFER_NORMAL_POSITION:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", true))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", true);
            break;
          }
          break;
        }
        }
      }
      currentSsaoFilter = newFilter;
    }
  }
 
  SSsaoHandler::SsaoDebugMode SSsaoHandler::GetDebugMode()
  {
    return currentSsaoDebugMode;
  }
 
  void SSsaoHandler::SetDebugMode(const SsaoDebugMode& newDebugMode)
  {
    if ((newDebugMode < SO3_SSAO_DEBUG_MODE_MAX) && (newDebugMode != currentSsaoDebugMode))
    {
      if (isEnable)
      {
        // Disable current mode
        switch (currentSsaoDebugMode)
        {
        case SO3_SSAO_DEBUG_MODE_NONE:
          //if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Ssao/Output/Merging", false))
          //  ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Ssao/Output/Merging", false);
          break;
        case SO3_SSAO_DEBUG_MODE_DEPTH:
        {
          switch (currentSsaoGbufferLayout)
          {
          case SO3_SSAO_GBUFFER_DEPTH_ONLY:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", false))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", false);
            break;
          case SO3_SSAO_GBUFFER_NORMAL_POSITION:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", false))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", false);
            break;
          }
          break;
        }
        case SO3_SSAO_DEBUG_MODE_NORMAL:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", false);
          break;
        case SO3_SSAO_DEBUG_MODE_POSITION:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", false);
          break;
        case SO3_SSAO_DEBUG_MODE_SSAO_ONLY:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", false))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", false);
          break;
        }
 
        // Enable new mode
        switch (newDebugMode)
        {
        case SO3_SSAO_DEBUG_MODE_NONE:
          //if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Ssao/Output/Merging", true))
          //  ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Ssao/Output/Merging", true);
          break;
        case SO3_SSAO_DEBUG_MODE_DEPTH:
        {
          switch (currentSsaoGbufferLayout)
          {
          case SO3_SSAO_GBUFFER_DEPTH_ONLY:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", true))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", true);
            break;
          case SO3_SSAO_GBUFFER_NORMAL_POSITION:
            if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", true))
              ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", true);
            break;
          }
          break;
        }
        case SO3_SSAO_DEBUG_MODE_NORMAL:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", true);
          break;
        case SO3_SSAO_DEBUG_MODE_POSITION:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", true);
          break;
        case SO3_SSAO_DEBUG_MODE_SSAO_ONLY:
          if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", true))
            ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", true);
          break;
        }
      }
      currentSsaoDebugMode = newDebugMode;
    }
  }
 
  void SSsaoHandler::CreateCompositors()
  {
    // Generate Ogre's resources for SSAO
    if (!compositorCreated)
    {
      Ogre::StringVector resourceGroups = Ogre::ResourceGroupManager::getSingletonPtr()->getResourceGroups();
      if (std::find(resourceGroups.begin(), resourceGroups.end(), SO3_INTERNAL_RESOURCE_GROUP) == resourceGroups.end())
        Ogre::ResourceGroupManager::getSingletonPtr()->createResourceGroup(SO3_INTERNAL_RESOURCE_GROUP);
 
      // Shared vertex shader.
      GenerateRenderQuadVertexShader();
 
      // Generate a compositor that will render the scene (without transparent objects), and will old a texture to the blurred SSAO
      GenerateSsaoCompositor();
 
      // Generate depth texture debug visualization compositor
      GenerateDepthDebugCompositor();
 
      // Generate ssao compositor that will use Crytek SSAO method
      GenerateSsaoCrytekCompositor();
 
      try
      {
        // Generate normal / view space position generator compositor
        GenerateNormalPositionCompositor();
 
        // Generate normal texture debug visualization compositor
        GenerateNormalDebugCompositor();
 
        // Generate view space position texture debug visualization compositor
        GenerateViewPositionDebugCompositor();
 
        // Generate depth texture debug visualization compositor, but for the normal/position compositor.
        GenerateDepthDebugCompositor2();
 
        // Generate ssao compositor that will use Hemispheric SSAO method
        GenerateSsaoHemisphericCompositor();
 
        // Generate ssao compositor that will use Crease Shading SSAO method
        GenerateSsaoCreaseShadingCompositor();
 
        // Generate ssao post filter that will use a more advanced 'smart box' method, but for the normal/position compositor.
        GenerateFilterBoxSmartCompositor2();
      }
      catch (Ogre::Exception &)
      {
        mSupportGbuffer = false;
      }
 
      // Generate ssao post filter that will use a basic 'box' method
      GenerateFilterBoxCompositor();
 
      // Generate ssao post filter that will use a more advanced 'smart box' method
      GenerateFilterBoxSmartCompositor();
 
      // Generate ssao texture debug visualization compositor
      GenerateSsaoDebugCompositor();
 
      // Merge solids with occlusion, and renders transparents objects on top.
      GenerateMergingCompositor();
 
      // Everything was created.
      compositorCreated = true;
    }
    else
    {
      normalPositionMaterial = ogreMaterialManager->getByName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Material/Solid", SO3_INTERNAL_RESOURCE_GROUP);
      normalPositionMaterialTransparent = ogreMaterialManager->getByName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Material/Transparent", SO3_INTERNAL_RESOURCE_GROUP);
      crytekSsaoMaterial = ogreMaterialManager->getByName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek/Material", SO3_INTERNAL_RESOURCE_GROUP);
      hemisphericSsaoMaterial = ogreMaterialManager->getByName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric/Material", SO3_INTERNAL_RESOURCE_GROUP);
      creaseShadingSsaoMaterial = ogreMaterialManager->getByName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading/Material", SO3_INTERNAL_RESOURCE_GROUP);
    }
  }
 
  Ogre::Technique* SSsaoHandler::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
  {
    //look if we didn't add the technique in a previous handleSchemeNotFound call
    std::vector<Ogre::Technique*> techs = originalMaterial->getTechniques();
    for (unsigned int i = 0; i < techs.size(); i++)
    {
      Ogre::Technique* schemeTechnique = techs[i];
      if (schemeTechnique->getSchemeName() == schemeName)
        return schemeTechnique;
    }
 
    // Change to the normal scheme, get the technique we should have without ssao, and get back to ssao scheme
    Ogre::String targetScheme = schemeName;
    ogreMaterialManager->setActiveScheme(targetViewportScheme);
    Ogre::Technique* ogreTechnique = originalMaterial->getBestTechnique();
    ogreMaterialManager->setActiveScheme(targetScheme);
 
    bool hasOverlay = false;
    Ogre::Any bindedSTechnique = ogreTechnique->getUserObjectBindings().getUserAny("STechnique");
    if (bindedSTechnique.has_value())
    {
      STechnique* matTechnique = Ogre::any_cast<STechnique*> (bindedSTechnique);
      hasOverlay = (matTechnique->GetParentMaterial()->GetAssociatedWidget() == 0) ? false : true;
    }
 
    bool forcePointsRender = false;
    Ogre::Real pointSize = 1.0f;
 
    if ((originalMaterial->getNumTechniques() > 0) && (originalMaterial->getTechnique(0)->getNumPasses() > 0) && (!originalMaterial->getTechnique(0)->getPass(0)->getPolygonModeOverrideable()) && (originalMaterial->getTechnique(0)->getPass(0)->getPolygonMode() == Ogre::PM_POINTS))
    {
      forcePointsRender = true;
      pointSize = originalMaterial->getTechnique(0)->getPass(0)->getPointSize();
    }
 
    //look for SSAO scheme and use it for the test if exist
    techs = originalMaterial->getSupportedTechniques();
    for (unsigned int i = 0; i < techs.size(); i++)
    {
      Ogre::Technique* tech = techs[i];
      if (tech->getSchemeName() == "SSAO")
      {
        ogreTechnique = tech;
        break;
      }
    }
 
    //new technique
    Ogre::Technique* nTech = originalMaterial->createTechnique();
 
    // If the technique is transparent, then ignore for rendering in depth texture
    if (ogreTechnique && !hasOverlay && (!originalMaterial->getReceiveShadows() || (ogreTechnique->isTransparent() && (!ogreTechnique->isDepthWriteEnabled() || !ogreTechnique->isDepthCheckEnabled())) || ogreTechnique->hasColourWriteDisabled()))
    {
      if (targetScheme == (std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition"))
      {
        nTech->setSchemeName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
        Ogre::Technique* btech = normalPositionMaterialTransparent->getTechnique(0);
        *nTech = *btech;
      }
    }
    else
    {
      //look to alpha rejection pass > 120
      Ogre::TexturePtr alphaTex;
      Ogre::Pass* alphaPass = 0;
 
      if (ogreTechnique != 0)
      {
        bool goodTexFound = false;
        unsigned short nbPass = ogreTechnique->getNumPasses();
        for (unsigned short i = 0; i < nbPass && !goodTexFound; i++)
        {
          Ogre::Pass* pass = ogreTechnique->getPass(i);
          if (pass && (pass->getIlluminationStage() != Ogre::IS_DECAL) && (hasOverlay || (Ogre::Real(pass->getAlphaRejectValue()) > 120.0f)))
          {
            unsigned short nbTex = pass->getNumTextureUnitStates();
            for (unsigned short t = 0; t < nbTex && !goodTexFound; t++)
            {
              Ogre::TextureUnitState* ustate = pass->getTextureUnitState(t);
              Ogre::TexturePtr texptr = ustate->_getTexturePtr();
              // this is a candidate
              if (texptr && texptr->hasAlpha() && (texptr->getTextureType() == Ogre::TEX_TYPE_2D))
              {
                alphaTex = texptr;
                alphaPass = pass;
 
                //now look if we get more chance to have a good one
                //a texture with alpha in ambient pass should have the needed alpha
                if (pass->getIlluminationStage() == Ogre::IS_AMBIENT)
                  goodTexFound = true;
              }
            }
          }
        }
      }
 
      if (alphaTex)
      {
        if (targetScheme == (std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition"))
        {
          Ogre::Technique* btech = normalPositionAlphaRejectionMaterial->getTechnique(0);
          nTech->setName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/AlphaRejection");
          nTech->setSchemeName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
          *nTech = *btech;
 
          Ogre::Pass* bpass = btech->getPass(0);
          Ogre::Pass* nPass = nTech->getPass(0);
          *nPass = *bpass;
          nPass->setCullingMode(alphaPass->getCullingMode());
          nPass->getTextureUnitState(0)->setTexture(alphaTex);
        }
      }
      else
      {
        if (targetScheme == (std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition"))
        {
          nTech->setSchemeName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
          Ogre::Technique* btech = normalPositionMaterial->getTechnique(0);
          *nTech = *btech;
        }
      }
    }
 
    if (nTech && nTech->getNumPasses() > 0)
    {
      if (forcePointsRender)
      {
        nTech->getPass(0)->setPolygonMode(Ogre::PM_POINTS);
        nTech->getPass(0)->setPointSize(pointSize);
      }
      else
      {
        nTech->getPass(0)->setPolygonMode(Ogre::PM_SOLID);
      }
    }
    return nTech;
  }
 
  Ogre::GpuProgramPtr SSsaoHandler::createGpuProgram(const Ogre::String &Name, const bool& fragment, const Ogre::String& Data)
  {
    Ogre::GpuProgramPtr HLGpuProgram;
    Ogre::String rendererName = Ogre::Root::getSingleton().getRenderSystem()->getName();
    bool isGlslang = (rendererName == "Vulkan Rendering Subsystem") ? true : false;
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem" || rendererName == "Vulkan Rendering Subsystem") ? false : true;
    Ogre::String language = ((rendererName == "OpenGL ES 2.x Rendering Subsystem") || (rendererName == "Metal Rendering Subsystem")) ? "glsles" : (rendererName == "Vulkan Rendering Subsystem") ? "glslang" : isGlSL ? "glsl" : "hlsl";
 
    if (Ogre::GpuProgramManager::getSingletonPtr()->getByName(Name, std::string(SO3_INTERNAL_RESOURCE_GROUP)))
      return HLGpuProgram;
 
    HLGpuProgram = Ogre::GpuProgramManager::getSingletonPtr()->create(Name, std::string(SO3_INTERNAL_RESOURCE_GROUP), (!fragment) ? Ogre::GPT_VERTEX_PROGRAM : Ogre::GPT_FRAGMENT_PROGRAM, language);
 
    //HLGpuProgram->setSource((isGlSL) ? "#version 150\n" + Data : Data);
    HLGpuProgram->setSource(Data);
 
    if (!isGlSL && !isGlslang)
    {
      if (!fragment)
        HLGpuProgram->setParameter("target", "vs_3_0 vs_2_a");
      else
        HLGpuProgram->setParameter("target", "ps_3_0 ps_2_a");
    }
 
    return HLGpuProgram;
  }
 
  void SSsaoHandler::GenerateRenderQuadVertexShader()
  {
    Ogre::StringStream VertexProgramData;
    // Create an unified vp for render fullscreen quad.
    VertexProgramData << "#ifdef GL_ES" << std::endl;
    VertexProgramData << "    precision highp int;" << std::endl;
    VertexProgramData << "    precision highp float;" << std::endl;
    VertexProgramData << "#endif" << std::endl;
 
    VertexProgramData << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    VertexProgramData << "OGRE_UNIFORMS(" << std::endl;
    VertexProgramData << "uniform mat4 cWorldViewProj;" << std::endl;
    VertexProgramData << ")" << std::endl;
 
    VertexProgramData << "MAIN_PARAMETERS" << std::endl;
    VertexProgramData << "IN(vec4 vertex, POSITION)" << std::endl;
    VertexProgramData << "IN(vec2 uv0, TEXCOORD0)" << std::endl;
    VertexProgramData << "OUT(vec2 oUv, TEXCOORD0)" << std::endl;
 
    VertexProgramData << "MAIN_DECLARATION" << std::endl;
    VertexProgramData << "{" << std::endl;
    VertexProgramData << " gl_Position = mul(cWorldViewProj, vertex);" << std::endl;
    VertexProgramData << " vec2 inPos = sign(vertex.xy);" << std::endl;
    //VertexProgramData << " oUv = (vec2(inPos.x, -inPos.y) + vec2_splat(1.0)) * vec2_splat(0.5);" << std::endl;
    VertexProgramData << " oUv = uv0;" << std::endl;
    VertexProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoRenderQuadVp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP", false, VertexProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr ssaoRenderQuadVpParams = ssaoRenderQuadVp->getDefaultParameters();
    ssaoRenderQuadVpParams->setNamedAutoConstant("cWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
 
    // All defined, load!
    ssaoRenderQuadVp->load();
  }
 
  void SSsaoHandler::GenerateSsaoCompositor()
  {
    // Create compositor
    Ogre::CompositorPtr ssaoCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoCompositionTechnique = ssaoCompositor->createTechnique();
 
    Ogre::PixelFormat rttformat = Ogre::PF_BYTE_RGBA;
    SRoot::getSingleton().GetRttPixelFormat(rttformat, true);
 
    Ogre::PixelFormatList pixelFormatList;
    pixelFormatList.push_back(rttformat);
 
    Ogre::PixelFormatList pixelFormatListMRT;
    pixelFormatListMRT.push_back(rttformat);
 
    if (Ogre::TextureManager::getSingleton().isFormatSupported(Ogre::TEX_TYPE_2D, Ogre::PF_DEPTH32, Ogre::TU_RENDERTARGET))
      pixelFormatListMRT.push_back(Ogre::PF_DEPTH32);
    else
      pixelFormatListMRT.push_back(Ogre::PF_DEPTH16);
 
    // Create a texture that will hold the previous render with depth
    Ogre::CompositionTechnique::TextureDefinition* previousTexture = ssaoCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous");
    previousTexture->width = 0;
    previousTexture->height = 0;
    previousTexture->formatList = pixelFormatListMRT;
    previousTexture->scope = Ogre::CompositionTechnique::TS_CHAIN;
 
    // Create a texture that will hold blurred SSAO
    Ogre::CompositionTechnique::TextureDefinition* occlusionTexture = ssaoCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    occlusionTexture->width = 0;
    occlusionTexture->height = 0;
    occlusionTexture->formatList = pixelFormatList;
    occlusionTexture->scope = Ogre::CompositionTechnique::TS_CHAIN;
 
    // Create the target that will get previous render
    Ogre::CompositionTargetPass* compositionTargetPrevious = ssaoCompositionTechnique->createTargetPass();
    compositionTargetPrevious->setShadowsEnabled(false);
    compositionTargetPrevious->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous");
    compositionTargetPrevious->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
 
    // Create the target that will hold blurred ssao
    Ogre::CompositionTargetPass* compositionTargetOcclusion = ssaoCompositionTechnique->createTargetPass();
    compositionTargetOcclusion->setShadowsEnabled(false);
    compositionTargetOcclusion->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    compositionTargetOcclusion->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Just create a "clear" pass on the target, it will be filled by a specific SSAO method compositor, and then blurred with a filter
    Ogre::CompositionPass* compositionTargetOcclusionClearPass = compositionTargetOcclusion->createPass();
    compositionTargetOcclusionClearPass->setType(Ogre::CompositionPass::PT_CLEAR);
  }
 
  void SSsaoHandler::GenerateDepthDebugCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneDepthSampler, 0);" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << "  float depth = texture2D(sSceneDepthSampler, oUv).r;" << std::endl;
    FragmentProgramData << "  gl_FragColor = vec4(vec3_splat(depth), 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoDepthDebugCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth/Compositor_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr FP_Parameters = ssaoDepthDebugCompositorFp->getDefaultParameters();
    if (isGlSL)
      FP_Parameters->setNamedConstant("sSceneDepthSampler", 0);
 
    // All defined, load!
    ssaoDepthDebugCompositorFp->load();
 
    // Create material for depth debug compositor.
    Ogre::MaterialPtr ssaoDepthDebugMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoDepthDebugMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState(); // Will be filled with depth texture
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 1);
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoDepthDebugCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr ssaoDepthDebugCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoDepthDebugCompositionTechnique = ssaoDepthDebugCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* ssaoDepthDebugOutputCompositionTargetPass = ssaoDepthDebugCompositionTechnique->getOutputTargetPass();
    ssaoDepthDebugOutputCompositionTargetPass->setShadowsEnabled(false);
    ssaoDepthDebugOutputCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the depth rendering pass
    Ogre::CompositionPass* ssaoDepthDebugOutputRenderDepthCompositionPass = ssaoDepthDebugOutputCompositionTargetPass->createPass();
    ssaoDepthDebugOutputRenderDepthCompositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    ssaoDepthDebugOutputRenderDepthCompositionPass->setMaterial(ssaoDepthDebugMaterial);
  }
 
  void SSsaoHandler::GenerateNormalPositionCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    // Create an unified vp for depth generator.
    Ogre::StringStream VertexProgramData;
    // Create an unified vp for render fullscreen quad.
    VertexProgramData << programHeader.str();
 
    VertexProgramData << "OGRE_UNIFORMS(" << std::endl;
    VertexProgramData << "uniform mat4 cWorldViewProj;" << std::endl;
    VertexProgramData << "uniform mat4 cWorldView;" << std::endl;
    VertexProgramData << "uniform mat4 cWorldPos;" << std::endl;
    VertexProgramData << ")" << std::endl;
 
    VertexProgramData << "MAIN_PARAMETERS" << std::endl;
    VertexProgramData << "IN(vec4 vertex, POSITION)" << std::endl;
    VertexProgramData << "IN(vec3 normal, NORMAL)" << std::endl;
    VertexProgramData << "OUT(vec3 oViewPos, TEXCOORD0)" << std::endl;
    VertexProgramData << "OUT(vec3 oNormal, TEXCOORD1)" << std::endl;
    VertexProgramData << "OUT(vec4 oWp, TEXCOORD2)" << std::endl;
 
    VertexProgramData << "MAIN_DECLARATION" << std::endl;
    VertexProgramData << "{" << std::endl;
    VertexProgramData << " gl_Position = mul(cWorldViewProj, vertex);" << std::endl;
    VertexProgramData << " oViewPos = mul(cWorldView, vertex).xyz;" << std::endl;
    VertexProgramData << " oWp = mul(cWorldPos, vertex);" << std::endl;
    VertexProgramData << " oNormal = mul(cWorldView, vec4(normal.xyz, 0.0)).xyz;" << std::endl;
    VertexProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    normalPositionGeneratorVp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/NormalPositionGenerator_VP", false, VertexProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr normalPositionGeneratorVpParams = normalPositionGeneratorVp->getDefaultParameters();
    normalPositionGeneratorVpParams->setNamedAutoConstant("cWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
    normalPositionGeneratorVpParams->setNamedAutoConstant("cWorldView", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
    normalPositionGeneratorVpParams->setNamedAutoConstant("cWorldPos", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
 
    // All defined, load!
    normalPositionGeneratorVp->load();
 
    // Create an unified fp for normalPosition generator.
    Ogre::StringStream FragmentProgramData;
    // Need to enable the draw buffers extension
    FragmentProgramData << "#if defined(OGRE_GLSL) || defined(OGRE_GLSLES)" << std::endl;
    FragmentProgramData << "#extension GL_ARB_draw_buffers : enable" << std::endl;
    FragmentProgramData << "#endif" << std::endl;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 slicePlane;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec3 oViewPos, TEXCOORD0)" << std::endl;
    FragmentProgramData << "IN(vec3 oNormal, TEXCOORD1)" << std::endl;
    FragmentProgramData << "IN(vec4 oWp, TEXCOORD2)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION_DATA" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << "  if (((slicePlane.x + slicePlane.y + slicePlane.z) != 0.0) && (slicePlane.x * oWp.x + slicePlane.y * oWp.y + slicePlane.z * oWp.z + slicePlane.w > 0.0))" << std::endl;
    FragmentProgramData << "    discard;" << std::endl;
    FragmentProgramData << "  gl_FragColor0 = vec4(normalize(oNormal), 0.0);" << std::endl;
    FragmentProgramData << "  gl_FragColor1 = vec4(oViewPos, 0.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    normalPositionGeneratorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "NormalPositionGenerator_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr normalPositionGeneratorFpParams = normalPositionGeneratorFp->getDefaultParameters();
    normalPositionGeneratorFpParams->addSharedParameters("SO3SlicePlaneParams");
 
    // All defined, load!
    normalPositionGeneratorFp->load();
 
    // Create depth material for handleSchemeNotFound
    normalPositionMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Material/Solid", SO3_INTERNAL_RESOURCE_GROUP);
    normalPositionMaterial->getTechnique(0)->setSchemeName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
    normalPositionMaterial->getTechnique(0)->setLightingEnabled(false);
    normalPositionMaterial->getTechnique(0)->getPass(0)->setName("SO3/SSAO/NORMAPPASS");
    normalPositionMaterial->getTechnique(0)->getPass(0)->setVertexProgram(normalPositionGeneratorVp->getName());
    normalPositionMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(normalPositionGeneratorFp->getName());
    normalPositionMaterial->load();
 
    // Create depth transparent material for handleSchemeNotFound
    normalPositionMaterialTransparent = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Material/Transparent", SO3_INTERNAL_RESOURCE_GROUP);
    normalPositionMaterialTransparent->getTechnique(0)->setSchemeName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
    normalPositionMaterialTransparent->getTechnique(0)->setColourWriteEnabled(false);
    normalPositionMaterialTransparent->getTechnique(0)->setDepthCheckEnabled(false);
    normalPositionMaterialTransparent->getTechnique(0)->setDepthWriteEnabled(false);
    normalPositionMaterialTransparent->getTechnique(0)->getPass(0)->setName("SO3/SSAO/TRANSPARENT/NORMALPASS");
    normalPositionMaterialTransparent->getTechnique(0)->getPass(0)->setVertexProgram("SO3/Internal/Default_nolight_vp");
    normalPositionMaterialTransparent->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/Internal/Default_fp");
    normalPositionMaterialTransparent->load();
 
    // Create an unified vp for normalPosition with alpha rejection generator.
    VertexProgramData.str("");
    VertexProgramData.clear();
    // Create an unified vp for render fullscreen quad.
    VertexProgramData << programHeader.str();
 
    VertexProgramData << "OGRE_UNIFORMS(" << std::endl;
    VertexProgramData << "uniform mat4 cWorldViewProj;" << std::endl;
    VertexProgramData << "uniform mat4 cWorldView;" << std::endl;
    VertexProgramData << "uniform mat4 cWorldPos;" << std::endl;
    VertexProgramData << ")" << std::endl;
 
    VertexProgramData << "MAIN_PARAMETERS" << std::endl;
    VertexProgramData << "IN(vec4 vertex, POSITION)" << std::endl;
    VertexProgramData << "IN(vec3 normal, NORMAL)" << std::endl;
    VertexProgramData << "IN(vec2 uv0, TEXCOORD0)" << std::endl;
    VertexProgramData << "OUT(vec3 oViewPos, TEXCOORD0)" << std::endl;
    VertexProgramData << "OUT(vec3 oNormal, TEXCOORD1)" << std::endl;
    VertexProgramData << "OUT(vec2 oUv, TEXCOORD2)" << std::endl;
    VertexProgramData << "OUT(vec4 oWp, TEXCOORD3)" << std::endl;
 
    VertexProgramData << "MAIN_DECLARATION" << std::endl;
    VertexProgramData << "{" << std::endl;
    VertexProgramData << "  gl_Position = mul(cWorldViewProj, vertex);" << std::endl;
    VertexProgramData << "  oViewPos = mul(cWorldView, vertex).xyz;" << std::endl;
    VertexProgramData << "  oWp = mul(cWorldPos, vertex);" << std::endl;
    VertexProgramData << "  oNormal = mul(cWorldView, vec4(normal.xyz, 0.0)).xyz;" << std::endl;
    VertexProgramData << "  oUv = uv0;" << std::endl;
    VertexProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    normalPositionAlphaRejectionGeneratorVp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/normalPositionAlphaRejectionGenerator_VP", false, VertexProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr normalPositionAlphaRejectionGeneratorVpParams = normalPositionAlphaRejectionGeneratorVp->getDefaultParameters();
    normalPositionAlphaRejectionGeneratorVpParams->setNamedAutoConstant("cWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
    normalPositionAlphaRejectionGeneratorVpParams->setNamedAutoConstant("cWorldView", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
    normalPositionAlphaRejectionGeneratorVpParams->setNamedAutoConstant("cWorldPos", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
 
    // All defined, load!
    normalPositionAlphaRejectionGeneratorVp->load();
 
    // Create an unified fp for normalPosition with alpha rejection generator.
    FragmentProgramData.str("");
    FragmentProgramData.clear();
    // Need to enable the draw buffers extension
    FragmentProgramData << "#if defined(OGRE_GLSL) || defined(OGRE_GLSLES)" << std::endl;
    FragmentProgramData << "#extension GL_ARB_draw_buffers : enable" << std::endl;
    FragmentProgramData << "#endif" << std::endl;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sAlpha, 0);" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 slicePlane;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec3 oViewPos, TEXCOORD0)" << std::endl;
    FragmentProgramData << "IN(vec3 oNormal, TEXCOORD1)" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD2)" << std::endl;
    FragmentProgramData << "IN(vec4 oWp, TEXCOORD3)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION_DATA" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << "  if (((slicePlane.x + slicePlane.y + slicePlane.z) != 0.0) && (slicePlane.x * oWp.x + slicePlane.y * oWp.y + slicePlane.z * oWp.z + slicePlane.w > 0.0))" << std::endl;
    FragmentProgramData << "    discard;" << std::endl;
    FragmentProgramData << "  float alpha = texture2D(sAlpha, oUv).a;" << std::endl;
    FragmentProgramData << "  if (alpha < 0.47)" << std::endl;    // same as OGRE pass directive "alpha_rejection greater 120"
    FragmentProgramData << "    discard;" << std::endl;
    FragmentProgramData << "  gl_FragColor0 = vec4(normalize(oNormal), 0.0);" << std::endl;
    FragmentProgramData << "  gl_FragColor1 = vec4(oViewPos, 0.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    normalPositionAlphaRejectionGeneratorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "NormalPositionAlphaGenerator_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr normalPositionAlphaRejectionGeneratorFpParams = normalPositionAlphaRejectionGeneratorFp->getDefaultParameters();
    normalPositionAlphaRejectionGeneratorFpParams->addSharedParameters("SO3SlicePlaneParams");
 
    if (isGlSL)
      normalPositionAlphaRejectionGeneratorFpParams->setNamedConstant("sAlpha", 0);
 
    // All defined, load!
    normalPositionAlphaRejectionGeneratorFp->load();
 
    // Create depth material for handleSchemeNotFound
    normalPositionAlphaRejectionMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Material/Solid/AlphaRejection", SO3_INTERNAL_RESOURCE_GROUP);
    normalPositionAlphaRejectionMaterial->getTechnique(0)->setSchemeName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
    normalPositionAlphaRejectionMaterial->getTechnique(0)->setLightingEnabled(false);
    normalPositionAlphaRejectionMaterial->getTechnique(0)->getPass(0)->setVertexProgram(normalPositionAlphaRejectionGeneratorVp->getName());
    normalPositionAlphaRejectionMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(normalPositionAlphaRejectionGeneratorFp->getName());
    normalPositionAlphaRejectionMaterial->getTechnique(0)->getPass(0)->createTextureUnitState();
 
    // Create compositor
    Ogre::CompositorPtr normalPositionCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* normalPositionCompositionTechnique = normalPositionCompositor->createTechnique();
 
    // Create a temporary texture that will hold 'late' (no sky nor water) solid objects normalPosition (from camera pov). It shall be used by next compositors in the chain.
    Ogre::CompositionTechnique::TextureDefinition* normalTexture = normalPositionCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture");
    normalTexture->width = 0;
    normalTexture->height = 0;
    normalTexture->heightFactor = 0.75f;
    normalTexture->widthFactor = 0.75f;
 
    Ogre::PixelFormat rttformat = Ogre::PF_FLOAT32_RGB;
    SRoot::getSingleton().GetRttPixelFormat(rttformat, false, true);
 
    Ogre::PixelFormatList pixelFormatList;
    pixelFormatList.push_back(rttformat);
    pixelFormatList.push_back(rttformat);
 
    normalTexture->formatList = pixelFormatList;
    normalTexture->scope = Ogre::CompositionTechnique::TS_CHAIN;
 
    // Create the target that will render normalPosition. Set a special material scheme.
    Ogre::CompositionTargetPass* normalPositionCompositionTargetPass = normalPositionCompositionTechnique->createTargetPass();
    normalPositionCompositionTargetPass->setShadowsEnabled(false);
    normalPositionCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
    normalPositionCompositionTargetPass->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture");
    normalPositionCompositionTargetPass->setMaterialScheme(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition");
 
    // Create a "clear" pass on the normalPosition target
    Ogre::CompositionPass* normalPositionCompositionPassClear = normalPositionCompositionTargetPass->createPass();
    normalPositionCompositionPassClear->setType(Ogre::CompositionPass::PT_CLEAR);
    //normalPositionCompositionPassClear->setClearBuffers(Ogre::FBT_COLOUR | Ogre::FBT_DEPTH | Ogre::FBT_STENCIL);
    //normalPositionCompositionPassClear->setClearDepth(1.0f);
    normalPositionCompositionPassClear->setClearColour(Ogre::ColourValue(0, 0, 0, 1));
 
    // Create the render normalPosition pass. Rendering this will call handleSchemeNotFound on objects.
    Ogre::CompositionPass* normalPositionCompositionPassRenderScene = normalPositionCompositionTargetPass->createPass();
    normalPositionCompositionPassRenderScene->setType(Ogre::CompositionPass::PT_RENDERSCENE);
    normalPositionCompositionPassRenderScene->setFirstRenderQueue(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_1);
    normalPositionCompositionPassRenderScene->setLastRenderQueue(Ogre::RENDER_QUEUE_8);
  }
 
  void SSsaoHandler::GenerateNormalDebugCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for visualizing normal texture.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sNormalSampler, 0);" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << "  vec3 normal = texture2D(sNormalSampler, oUv).xyz;" << std::endl;
    FragmentProgramData << "  gl_FragColor = vec4(normal / vec3_splat(2.0) + vec3_splat(0.5), 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoNormalDebugCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal/Compositor_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr FP_Parameters = ssaoNormalDebugCompositorFp->getDefaultParameters();
    if (isGlSL)
      FP_Parameters->setNamedConstant("sNormalSampler", 0);
 
    // All defined, load!
    ssaoNormalDebugCompositorFp->load();
 
    // Create material for normal debug compositor.
    Ogre::MaterialPtr ssaoNormalDebugMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoNormalDebugMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
 
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 0);
 
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoNormalDebugCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr ssaoNormalDebugCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Normal", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoNormalDebugCompositionTechnique = ssaoNormalDebugCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* ssaoNormalDebugOutputCompositionTargetPass = ssaoNormalDebugCompositionTechnique->getOutputTargetPass();
    ssaoNormalDebugOutputCompositionTargetPass->setShadowsEnabled(false);
    ssaoNormalDebugOutputCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the normal rendering pass
    Ogre::CompositionPass* ssaoNormalDebugOutputRenderNormalCompositionPass = ssaoNormalDebugOutputCompositionTargetPass->createPass();
    ssaoNormalDebugOutputRenderNormalCompositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    ssaoNormalDebugOutputRenderNormalCompositionPass->setMaterial(ssaoNormalDebugMaterial);
  }
 
  void SSsaoHandler::GenerateViewPositionDebugCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for visualizing position texture.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sPositionSampler, 0);" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << "  vec4 position = vec4(texture2D(sPositionSampler, oUv).xyz, 1.0);" << std::endl;
    FragmentProgramData << "  gl_FragColor = position * vec4(0.1, 0.1, -0.01, 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoPositionDebugCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position/Compositor_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr FP_Parameters = ssaoPositionDebugCompositorFp->getDefaultParameters();
    if (isGlSL)
      FP_Parameters->setNamedConstant("sPositionSampler", 0);
 
    // All defined, load!
    ssaoPositionDebugCompositorFp->load();
 
    // Create material for position debug compositor.
    Ogre::MaterialPtr ssaoPositionDebugMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoPositionDebugMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
 
    Ogre::TextureUnitState* ogreTextureUnit0 = ogrePass->createTextureUnitState(); // Will be filled with depth texture
    ogreTextureUnit0->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit0->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit0->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit0->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 1);
 
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoPositionDebugCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr ssaoPositionDebugCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Position", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoPositionDebugCompositionTechnique = ssaoPositionDebugCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* ssaoPositionDebugOutputCompositionTargetPass = ssaoPositionDebugCompositionTechnique->getOutputTargetPass();
    ssaoPositionDebugOutputCompositionTargetPass->setShadowsEnabled(false);
    ssaoPositionDebugOutputCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the position rendering pass
    Ogre::CompositionPass* ssaoPositionDebugOutputRenderPositionCompositionPass = ssaoPositionDebugOutputCompositionTargetPass->createPass();
    ssaoPositionDebugOutputRenderPositionCompositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    ssaoPositionDebugOutputRenderPositionCompositionPass->setMaterial(ssaoPositionDebugMaterial);
  }
 
  void SSsaoHandler::GenerateDepthDebugCompositor2()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for visualizing depth texture.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneNormalPosDepthSampler, 0);" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform float cFarClipDistance;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << "  float farClip = cFarClipDistance <= 0.0 ? 100.0 : cFarClipDistance;" << std::endl; // hack for infinite farclip
    FragmentProgramData << "  float depth = texture2D(sSceneNormalPosDepthSampler, oUv).a / farClip;" << std::endl; // Inverse depth
    FragmentProgramData << "  if(depth < 0.0)" << std::endl;
    FragmentProgramData << "    depth = -depth;" << std::endl;
    FragmentProgramData << "  gl_FragColor = vec4(vec3_splat(pow(depth, 0.3)), 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoDepth2DebugCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2/Compositor_FP", true, FragmentProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr ssaoDepth2DebugCompositorFpParams = ssaoDepth2DebugCompositorFp->getDefaultParameters();
    ssaoDepth2DebugCompositorFpParams->setNamedAutoConstant("cFarClipDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
 
    if (isGlSL)
      ssaoDepth2DebugCompositorFpParams->setNamedConstant("sSceneNormalPosDepthSampler", 0);
 
    // All defined, load!
    ssaoDepth2DebugCompositorFp->load();
 
    // Create material for depth debug compositor.
    Ogre::MaterialPtr ssaoDepth2DebugMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoDepth2DebugMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState(); // Will be filled with depth texture
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 1);
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoDepth2DebugCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr ssaoDepth2DebugCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Depth2", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoDepth2DebugCompositionTechnique = ssaoDepth2DebugCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* ssaoDepth2DebugOutputCompositionTargetPass = ssaoDepth2DebugCompositionTechnique->getOutputTargetPass();
    ssaoDepth2DebugOutputCompositionTargetPass->setShadowsEnabled(false);
    ssaoDepth2DebugOutputCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the depth rendering pass
    Ogre::CompositionPass* ssaoDepth2DebugOutputRenderDepthCompositionPass = ssaoDepth2DebugOutputCompositionTargetPass->createPass();
    ssaoDepth2DebugOutputRenderDepthCompositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    ssaoDepth2DebugOutputRenderDepthCompositionPass->setMaterial(ssaoDepth2DebugMaterial);
  }
 
  void SSsaoHandler::GenerateSsaoCrytekCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for SSAO.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneDepthSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sRotSampler4x4, 1);" << std::endl;
 
    FragmentProgramData << "#define NSAMPLES 32" << std::endl; // number of samples
    FragmentProgramData << "#define NSAMPLESDIV 4" << std::endl;
    FragmentProgramData << "#define NSAMPLESINV 0.03125" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 cViewportSize;" << std::endl;
    FragmentProgramData << "uniform float cFov;" << std::endl;
    FragmentProgramData << "uniform float farClipDistance;" << std::endl;
    FragmentProgramData << "uniform float nearClipDistance;" << std::endl;
    FragmentProgramData << "uniform float cSampleInScreenspace;" << std::endl;
    FragmentProgramData << "uniform float cSampleLengthScreenSpace;" << std::endl;
    FragmentProgramData << "uniform float cSampleLengthWorldSpace;" << std::endl;
    FragmentProgramData << "uniform float cOffsetScale;" << std::endl;
    FragmentProgramData << "uniform float cDefaultAccessibility;" << std::endl;
    FragmentProgramData << "uniform float cEdgeHighlight;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " float highlight = 2.0 - cEdgeHighlight;" << std::endl;
    FragmentProgramData << " float clipDepth = farClipDistance - nearClipDistance;" << std::endl;                         // compute the distance between the clipping planes to convert [0, 1] depth to world space units
    FragmentProgramData << " float fragmentWorldDepth = texture2D(sSceneDepthSampler, oUv).r;" << std::endl; // get the depth of the current pixel and convert into world space unit [0, inf]
    FragmentProgramData << " fragmentWorldDepth *= clipDepth;" << std::endl;
    FragmentProgramData << " vec2 rotationTC = oUv * cViewportSize.xy / vec2_splat(4.0);" << std::endl;                             // get rotation vector, rotation is tiled every 4 screen pixels
    FragmentProgramData << " vec3 rotationVector = vec3_splat(2.0) * texture2D(sRotSampler4x4, rotationTC).xyz - vec3_splat(1.0);" << std::endl;             // [-1, 1]x[-1. 1]x[-1. 1]
    FragmentProgramData << " float rUV = 0.0;" << std::endl;                                                                     // radius of influence in screen space
    FragmentProgramData << " float r = 0.0;" << std::endl;                                                                       // radius of influence in world space
    FragmentProgramData << " if (cSampleInScreenspace == 1.0)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  rUV = cSampleLengthScreenSpace;" << std::endl;
    FragmentProgramData << "  r = tan(rUV * cFov) * fragmentWorldDepth;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " else" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  rUV = atan(cSampleLengthWorldSpace / fragmentWorldDepth) / cFov;" << std::endl;                  // the radius of influence projected into screen space
    FragmentProgramData << "  r = cSampleLengthWorldSpace;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " float sampleLength = cOffsetScale;" << std::endl;                                                 // the offset for the first sample
    FragmentProgramData << " float sampleLengthStep = pow((rUV / sampleLength), NSAMPLESINV);" << std::endl;
    FragmentProgramData << " float accessibility = 0.0;" << std::endl;                                                           // sample the sphere and accumulate accessibility
    FragmentProgramData << " for (int i = 0; i < NSAMPLESDIV; i++)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  for (int x = -1; x <= 1; x += 2)" << std::endl;
    FragmentProgramData << "  for (int y = -1; y <= 1; y += 2)" << std::endl;
    FragmentProgramData << "  for (int z = -1; z <= 1; z += 2)" << std::endl;
    FragmentProgramData << "  {" << std::endl;
    FragmentProgramData << "   vec3 offset = normalize(vec3(float(x), float(y), float(z))) * vec3_splat(sampleLength);" << std::endl;                                                            //generate offset vector
    FragmentProgramData << "   sampleLength *= sampleLengthStep;" << std::endl;                                                                                             // update sample length
    FragmentProgramData << "   vec3 rotatedOffset = reflect(offset, rotationVector);" << std::endl;                                                                         // reflect offset vector by random rotation sample (i.e. rotating it) 
    FragmentProgramData << "   vec2 sampleTC = oUv + rotatedOffset.xy * vec2_splat(rUV);" << std::endl;
    FragmentProgramData << "   float sampleWorldDepth = texture2D(sSceneDepthSampler, sampleTC).r * clipDepth;" << std::endl;                                    // read scene depth at sampling point and convert into world space units (m or whatever).
    FragmentProgramData << "   float fRangeIsInvalid = saturate((fragmentWorldDepth - sampleWorldDepth) / r);" << std::endl;                                                // check if depths of both pixels are close enough and sampling point should affect our center pixel
    FragmentProgramData << "   accessibility += mix(sampleWorldDepth > (fragmentWorldDepth + rotatedOffset.z * r) ? 1.0 : 0.0, cDefaultAccessibility, fRangeIsInvalid);" << std::endl; // accumulate accessibility, use default value of 0.5 if right computations are not possible
    FragmentProgramData << "  }" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " accessibility /= float(NSAMPLES);" << std::endl;                                                       // get average value
    FragmentProgramData << " accessibility *= highlight;" << std::endl;                                                   // normalize, remove edge highlighting
    FragmentProgramData << " gl_FragColor = vec4(vec3_splat(accessibility), 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoCrytekCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek/Compositor_FP", true, FragmentProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr ssaoCompositorFpParams = ssaoCrytekCompositorFp->getDefaultParameters();
    ssaoCompositorFpParams->setNamedAutoConstant("cViewportSize", Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE);
    ssaoCompositorFpParams->setNamedAutoConstant("nearClipDistance", Ogre::GpuProgramParameters::ACT_NEAR_CLIP_DISTANCE);
    ssaoCompositorFpParams->setNamedAutoConstant("farClipDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
    ssaoCompositorFpParams->setNamedAutoConstant("cFov", Ogre::GpuProgramParameters::ACT_FOV);
    ssaoCompositorFpParams->setNamedConstant("cSampleInScreenspace", 1.0f);
    ssaoCompositorFpParams->setNamedConstant("cSampleLengthScreenSpace", 0.25f);
    ssaoCompositorFpParams->setNamedConstant("cSampleLengthWorldSpace", 2.0f);
    ssaoCompositorFpParams->setNamedConstant("cOffsetScale", 0.001f);
    ssaoCompositorFpParams->setNamedConstant("cDefaultAccessibility", 0.5f);
    ssaoCompositorFpParams->setNamedConstant("cEdgeHighlight", 0.05f);
 
    if (isGlSL)
    {
      ssaoCompositorFpParams->setNamedConstant("sSceneDepthSampler", 0);
      ssaoCompositorFpParams->setNamedConstant("sRotSampler4x4", 1);
    }
 
    // All defined, load!
    ssaoCrytekCompositorFp->load();
 
    // Create SSAO material for compositor.
    crytekSsaoMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = crytekSsaoMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
 
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 1);
 
    ogreTextureUnit = ogrePass->createTextureUnitState("regularSphereJittered4.png");
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
 
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoCrytekCompositorFp->getName());
 
    // Configure technique parameters.
    SsaoTechniqueParameters crytekTechniqueParameters;
    crytekTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleInScreenspace", SsaoTechniqueParameter("Sample in screen space", SsaoTechniqueParameterRange(0.0f, 1.0f), 1.0f)));
    crytekTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleLengthScreenSpace", SsaoTechniqueParameter("Screen space length (%)", SsaoTechniqueParameterRange(0.00001f, 1.0f), 0.25f)));
    crytekTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleLengthWorldSpace", SsaoTechniqueParameter("World space length (units)", SsaoTechniqueParameterRange(0.00001f, 10.0f), 2.0f)));
    crytekTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cOffsetScale", SsaoTechniqueParameter("Offset scale (% of sample length)", SsaoTechniqueParameterRange(0.00001f, 1.0f), 0.001f)));
    crytekTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cDefaultAccessibility", SsaoTechniqueParameter("Default accessibility", SsaoTechniqueParameterRange(0.0f, 1.0f), 0.5f)));
    crytekTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cEdgeHighlight", SsaoTechniqueParameter("Edge highlight factor", SsaoTechniqueParameterRange(0.0f, 1.0f), 0.05f)));
    ssaoTechniquesParameters.insert(SsaoTechniqueParametersByTechnique::value_type(SO3_SSAO_TECHNIQUE_CRYTEK, crytekTechniqueParameters));
 
    // Set SSAO default configuration
    SetTechniqueParameters(SO3_SSAO_TECHNIQUE_CRYTEK, crytekTechniqueParameters);
 
    // Create compositor
    Ogre::CompositorPtr ssaoCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Crytek", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoCompositionTechnique = ssaoCompositor->createTechnique();
 
    // Create a reference to the occlusion temporary texture
    Ogre::CompositionTechnique::TextureDefinition* occlusionTexture = ssaoCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    occlusionTexture->width = 0;
    occlusionTexture->height = 0;
    occlusionTexture->refCompName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input";
    occlusionTexture->refTexName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion";
 
    // Render in first compositor occlusion texture
    Ogre::CompositionTargetPass* compositionTargetPass = ssaoCompositionTechnique->createTargetPass();
    compositionTargetPass->setShadowsEnabled(false);
    compositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
    compositionTargetPass->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
 
    // Create the SSAO rendering pass
    Ogre::CompositionPass* compositionTargetPassRenderSsaoPass = compositionTargetPass->createPass();
    compositionTargetPassRenderSsaoPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    compositionTargetPassRenderSsaoPass->setMaterial(crytekSsaoMaterial);
  }
 
  void SSsaoHandler::GenerateSsaoHemisphericCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for SSAO.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneNormalSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sScenePositionSampler, 1);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sRand, 2);" << std::endl;
 
    FragmentProgramData << "#define INTERLEAVED 4.0" << std::endl;
    FragmentProgramData << "#define MSAMPLES 4.0" << std::endl;
    FragmentProgramData << "#define NSAMPLES 4.0" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 cViewportSize;" << std::endl;
    FragmentProgramData << "uniform float cFov;" << std::endl;
    FragmentProgramData << "uniform float cSampleInScreenspace;" << std::endl;
    FragmentProgramData << "uniform float nearClipDistance;" << std::endl;
    FragmentProgramData << "uniform float cSampleLengthScreenSpace;" << std::endl;
    FragmentProgramData << "uniform float cSampleLengthWorldSpace;" << std::endl;
    FragmentProgramData << "uniform float cSampleLengthExponent;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " float numSamples = MSAMPLES * NSAMPLES;" << std::endl;
    FragmentProgramData << " vec2 interleaveOffset = oUv * cViewportSize.xy / vec2_splat(INTERLEAVED);" << std::endl;
    FragmentProgramData << " vec3 fragmentPosition = texture2D(sScenePositionSampler, oUv).xyz;" << std::endl;                                       // the current fragment in view space
    FragmentProgramData << " vec3 fragmentNormal = texture2D(sSceneNormalSampler, oUv).xyz;" << std::endl;                                           // the fragment normal
    FragmentProgramData << " float rUV = 0.0;" << std::endl;                                                                                              // radius of influence in screen space
    FragmentProgramData << " float r = 0.0;" << std::endl;                                                                                                // radius of influence in world space
    FragmentProgramData << " if (cSampleInScreenspace == 1.0)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  rUV = cSampleLengthScreenSpace;" << std::endl;
    FragmentProgramData << "  r = tan(rUV * cFov) * -fragmentPosition.z;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " else" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  rUV = atan(cSampleLengthWorldSpace / -fragmentPosition.z) / cFov;" << std::endl;                     // the radius of influence projected into screen space
    FragmentProgramData << "  r = cSampleLengthWorldSpace;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " if (rUV < (cViewportSize.z))" << std::endl;                                                          // abort if the projected radius of influence is smaller than 1 fragment
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);" << std::endl;
    FragmentProgramData << "  return;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " float accessibility = 0.0;" << std::endl;                                                              // accessibility of the fragment
    FragmentProgramData << " vec3 viewVector = vec3(0.0, 0.0, 1.0);" << std::endl;                                            // the constant view vector in view space
    FragmentProgramData << " vec3 reflector = normalize(fragmentNormal + viewVector) * vec3(-1.0, 1.0, 1.0);" << std::endl;   // the reflection vector to align the hemisphere with the fragment normal somehow the x component must be flipped...???
    FragmentProgramData << " float count = 0.0;" << std::endl;
    FragmentProgramData << " float sampleLength;" << std::endl;
    FragmentProgramData << " for (float i = 0.0; i < MSAMPLES; i++)" << std::endl;
    FragmentProgramData << " for (float j = 0.0; j < NSAMPLES; j++)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  count ++;" << std::endl;
    FragmentProgramData << "  vec2 randomTC = interleaveOffset + vec2(i/(INTERLEAVED * MSAMPLES), j/(INTERLEAVED * NSAMPLES));" << std::endl;
    FragmentProgramData << "  vec3 randomVector = (texture2D(sRand, randomTC).rgb * vec3_splat(2.0)) - vec3_splat(1.0);" << std::endl;                                                // unpack to [-1, 1]x[-1, 1]x[1, 1]
    FragmentProgramData << "  sampleLength = pow(count/numSamples, cSampleLengthExponent);" << std::endl;
    FragmentProgramData << "  vec3 sampleVector = reflect(randomVector, reflector) * vec3_splat(sampleLength);" << std::endl;
    FragmentProgramData << "  vec2 sampleTC = oUv + sampleVector.xy * vec2_splat(rUV);" << std::endl;
    FragmentProgramData << "  vec3 samplePosition = texture2D(sScenePositionSampler, sampleTC).xyz;" << std::endl;                                                                                                  // solid geometry
    FragmentProgramData << "  if (samplePosition.z < (fragmentPosition.z - sampleVector.z))" << std::endl;                                      // thin air
    FragmentProgramData << "   accessibility++;" << std::endl;
    FragmentProgramData << "  else" << std::endl;                                                                                                   // solid geometry
    FragmentProgramData << "   accessibility += length(fragmentPosition - samplePosition) > r;" << std::endl;                                       // out of reach, i.e. false occluder                                    // out of reach, i.e. false occluder
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " accessibility /= numSamples;" << std::endl;
    FragmentProgramData << " gl_FragColor = vec4(vec3_splat(accessibility), 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoHemiCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric/Compositor_FP", true, FragmentProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr ssaoCompositorFpParams = ssaoHemiCompositorFp->getDefaultParameters();
    ssaoCompositorFpParams->setNamedAutoConstant("cViewportSize", Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE);
    ssaoCompositorFpParams->setNamedAutoConstant("cFov", Ogre::GpuProgramParameters::ACT_FOV);
 
    ssaoCompositorFpParams->setNamedConstant("cSampleInScreenspace", 1.0f);
    ssaoCompositorFpParams->setNamedConstant("cSampleLengthScreenSpace", 0.04f);
    ssaoCompositorFpParams->setNamedConstant("cSampleLengthWorldSpace", 2.0f);
    ssaoCompositorFpParams->setNamedConstant("cSampleLengthExponent", 1.0f);
 
    if (isGlSL)
    {
      ssaoCompositorFpParams->setNamedConstant("sSceneNormalSampler", 0);
      ssaoCompositorFpParams->setNamedConstant("sScenePositionSampler", 1);
      ssaoCompositorFpParams->setNamedConstant("sRand", 2);
    }
 
    // All defined, load!
    ssaoHemiCompositorFp->load();
 
    // Create SSAO material for compositor.
    hemisphericSsaoMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = hemisphericSsaoMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
 
    Ogre::TextureUnitState* ogreTextureUnit0 = ogrePass->createTextureUnitState(); // Will be filled with depth texture
    ogreTextureUnit0->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit0->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit0->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit0->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 0);
 
    Ogre::TextureUnitState* ogreTextureUnit1 = ogrePass->createTextureUnitState(); // Will be filled with depth texture
    ogreTextureUnit1->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit1->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit1->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit1->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 1);
 
    Ogre::TextureUnitState* ogreTextureUnit2 = ogrePass->createTextureUnitState("importance4InterleavedSphereHemisphere8x4.png");
    ogreTextureUnit2->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
    ogreTextureUnit2->setTextureFiltering(Ogre::TFO_NONE);
 
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoHemiCompositorFp->getName());
 
    // Configure technique parameters.
    SsaoTechniqueParameters hemisphericTechniqueParameters;
    hemisphericTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleInScreenspace", SsaoTechniqueParameter("Sample in screen space", SsaoTechniqueParameterRange(0.0f, 1.0f), 1.0f)));
    hemisphericTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleLengthScreenSpace", SsaoTechniqueParameter("Screen space length (%)", SsaoTechniqueParameterRange(0.00001f, 0.999f), 0.04f)));
    hemisphericTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleLengthWorldSpace", SsaoTechniqueParameter("World space length (units)", SsaoTechniqueParameterRange(0.00001f, 100.0f), 2.0f)));
    hemisphericTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cSampleLengthExponent", SsaoTechniqueParameter("Sample length exponent", SsaoTechniqueParameterRange(0.0f, 1.0f), 1.0f)));
    ssaoTechniquesParameters.insert(SsaoTechniqueParametersByTechnique::value_type(SO3_SSAO_TECHNIQUE_HEMISPHERIC, hemisphericTechniqueParameters));
 
    // Set SSAO default configuration
    SetTechniqueParameters(SO3_SSAO_TECHNIQUE_HEMISPHERIC, hemisphericTechniqueParameters);
 
    // Create compositor
    Ogre::CompositorPtr ssaoCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/Hemispheric", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoCompositionTechnique = ssaoCompositor->createTechnique();
 
    // Create a reference to the occlusion temporary texture
    Ogre::CompositionTechnique::TextureDefinition* occlusionTexture = ssaoCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    occlusionTexture->width = 0;
    occlusionTexture->height = 0;
    occlusionTexture->refCompName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input";
    occlusionTexture->refTexName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion";
 
    // Render in first compositor occlusion texture
    Ogre::CompositionTargetPass* compositionTargetPass = ssaoCompositionTechnique->createTargetPass();
    compositionTargetPass->setShadowsEnabled(false);
    compositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
    compositionTargetPass->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
 
    // Create the SSAO rendering pass
    Ogre::CompositionPass* compositionTargetPassRenderSsaoPass = compositionTargetPass->createPass();
    compositionTargetPassRenderSsaoPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    compositionTargetPassRenderSsaoPass->setMaterial(hemisphericSsaoMaterial);
  }
 
  void SSsaoHandler::GenerateSsaoCreaseShadingCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for SSAO.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneNormalSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sScenePositionSampler, 1);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sRandom, 2);" << std::endl;
 
    FragmentProgramData << "#define INTERLEAVED 4.0" << std::endl;
    FragmentProgramData << "#define MSAMPLES 4.0" << std::endl;
    FragmentProgramData << "#define NSAMPLES 4.0" << std::endl;
    FragmentProgramData << "#define STIPPLESIZE 11.0" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 cViewportSize;" << std::endl;
    FragmentProgramData << "uniform float cRange;" << std::endl;
    FragmentProgramData << "uniform float cBias;" << std::endl;
    FragmentProgramData << "uniform float cAverager;" << std::endl;
    FragmentProgramData << "uniform float cMinimumCrease;" << std::endl;
    FragmentProgramData << "uniform float cKernelSize;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " vec3 fragmentPosition = texture2D(sScenePositionSampler, oUv).xyz;" << std::endl;                                       // get the view space position of the fragment
    FragmentProgramData << " vec3 fragmentNormal = texture2D(sSceneNormalSampler, oUv).xyz;" << std::endl;                       // get the normal of the fragment
    FragmentProgramData << " float totalGI = 0.0;" << std::endl;
    FragmentProgramData << " for (float i = 0.0; i < (STIPPLESIZE + 1.0) / 2.0; i++)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  vec2 diagonalStart = vec2(-(STIPPLESIZE - 1.0) / 2.0, 0.0) + i;" << std::endl;
    FragmentProgramData << "  for(float j = 0.0; j < (STIPPLESIZE + 1.0) / 2.0; j++)" << std::endl;
    FragmentProgramData << "  {" << std::endl;
    FragmentProgramData << "   vec2 sampleOffset = diagonalStart + vec2(j, -j);" << std::endl;
    FragmentProgramData << "   vec2 sampleUV = oUv + (sampleOffset * cViewportSize.zw * vec2_splat(cKernelSize));" << std::endl;
    FragmentProgramData << "   vec3 samplePos = texture2D(sScenePositionSampler, sampleUV).xyz;" << std::endl;
    FragmentProgramData << "   vec3 toCenter = samplePos - fragmentPosition;" << std::endl;
    FragmentProgramData << "   float distance = length(toCenter);" << std::endl;
    FragmentProgramData << "   toCenter = normalize(toCenter);" << std::endl;
    FragmentProgramData << "   float centerContrib = saturate((dot(toCenter, fragmentNormal) - cMinimumCrease) * cBias);" << std::endl;
    FragmentProgramData << "   float rangeAttenuation = 1.0 - saturate(distance / cRange);" << std::endl;
    FragmentProgramData << "   totalGI += centerContrib * rangeAttenuation;" << std::endl;
    FragmentProgramData << "  }" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " totalGI /= cAverager;" << std::endl;
    FragmentProgramData << " gl_FragColor = vec4_splat(1.0) - vec4(vec3_splat(totalGI), 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
 
    // Load the program in Ogre
    ssaoCreaseCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading/Compositor_FP", true, FragmentProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr ssaoCompositorFpParams = ssaoCreaseCompositorFp->getDefaultParameters();
    ssaoCompositorFpParams->setNamedAutoConstant("cViewportSize", Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE);
    ssaoCompositorFpParams->setNamedConstant("cMinimumCrease", 0.2f);
    ssaoCompositorFpParams->setNamedConstant("cRange", 1.0f);
    ssaoCompositorFpParams->setNamedConstant("cBias", 1.0f);
    ssaoCompositorFpParams->setNamedConstant("cAverager", 24.0f);
    ssaoCompositorFpParams->setNamedConstant("cKernelSize", 3.0f);
 
    if (isGlSL)
    {
      ssaoCompositorFpParams->setNamedConstant("sSceneNormalSampler", 0);
      ssaoCompositorFpParams->setNamedConstant("sScenePositionSampler", 1);
      ssaoCompositorFpParams->setNamedConstant("sRandom", 2);
    }
 
    // All defined, load!
    ssaoCreaseCompositorFp->load();
 
    // Create SSAO material for compositor.
    creaseShadingSsaoMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = creaseShadingSsaoMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
 
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 0);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 1);
 
    ogreTextureUnit = ogrePass->createTextureUnitState("rand1x32.png");
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
 
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoCreaseCompositorFp->getName());
 
    // Configure technique parameters.
    SsaoTechniqueParameters creaseShadingTechniqueParameters;
    creaseShadingTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cMinimumCrease", SsaoTechniqueParameter("Minimum crease", SsaoTechniqueParameterRange(0.0f, 1.0f), 0.2f)));
    creaseShadingTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cRange", SsaoTechniqueParameter("Crease range", SsaoTechniqueParameterRange(0.0f, 10.0f), 1.0f)));
    creaseShadingTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cBias", SsaoTechniqueParameter("Bias", SsaoTechniqueParameterRange(0.0f, 10.0f), 1.0f)));
    creaseShadingTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cAverager", SsaoTechniqueParameter("Avenger", SsaoTechniqueParameterRange(1.0f, 1000.0f), 24.0f)));
    creaseShadingTechniqueParameters.insert(SsaoTechniqueParameters::value_type("cKernelSize", SsaoTechniqueParameter("Kernel size bias", SsaoTechniqueParameterRange(0.1f, 10.0f), 3.0f)));
    ssaoTechniquesParameters.insert(SsaoTechniqueParametersByTechnique::value_type(SO3_SSAO_TECHNIQUE_CREASE_SHADING, creaseShadingTechniqueParameters));
 
    // Set SSAO default configuration
    SetTechniqueParameters(SO3_SSAO_TECHNIQUE_CREASE_SHADING, creaseShadingTechniqueParameters);
 
    // Create compositor
    Ogre::CompositorPtr ssaoCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Method/CreaseShading", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoCompositionTechnique = ssaoCompositor->createTechnique();
 
    // Create a reference to the occlusion temporary texture
    Ogre::CompositionTechnique::TextureDefinition* occlusionTexture = ssaoCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    occlusionTexture->width = 0;
    occlusionTexture->height = 0;
    occlusionTexture->refCompName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input";
    occlusionTexture->refTexName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion";
 
    // Render in first compositor occlusion texture
    Ogre::CompositionTargetPass* compositionTargetPass = ssaoCompositionTechnique->createTargetPass();
    compositionTargetPass->setShadowsEnabled(false);
    compositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
    compositionTargetPass->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
 
    // Create the SSAO rendering pass
    Ogre::CompositionPass* compositionTargetPassRenderSsaoPass = compositionTargetPass->createPass();
    compositionTargetPassRenderSsaoPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    compositionTargetPassRenderSsaoPass->setMaterial(creaseShadingSsaoMaterial);
  }
 
  void SSsaoHandler::GenerateFilterBoxCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for merging scene render with blurred ssao.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneSolidSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sSceneOcclusion, 1);" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 screenSize;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " float occ = 0.0;" << std::endl;
    FragmentProgramData << " for (int x = -2; x < 3; x++)" << std::endl;
    FragmentProgramData << " for (int y = -2; y < 3; y++)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  occ += texture2D(sSceneOcclusion, vec2(oUv.x + float(x) * screenSize.z, oUv.y + float(y) * screenSize.w)).x;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " occ /= 25.0;" << std::endl;
    FragmentProgramData << " vec4 color = texture2D(sSceneSolidSampler, oUv);" << std::endl;
    FragmentProgramData << " gl_FragColor = vec4(color.r * occ, color.g * occ, color.b * occ, color.a);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    filterBoxCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr FP_Parameters = filterBoxCompositorFp->getDefaultParameters();
    FP_Parameters->setNamedAutoConstant("screenSize", Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE);
    if (isGlSL)
    {
      FP_Parameters->setNamedConstant("sSceneSolidSampler", 0);
      FP_Parameters->setNamedConstant("sSceneOcclusion", 1);
    }
 
    // All defined, load!
    filterBoxCompositorFp->load();
 
    // Create merging material for compositor.
    Ogre::MaterialPtr ssaoMergingMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoMergingMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 0);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(filterBoxCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr filterBoxCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/Box", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* filterBoxCompositionTechnique = filterBoxCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* filterBoxCompositionTargetPass = filterBoxCompositionTechnique->getOutputTargetPass();
    filterBoxCompositionTargetPass->setShadowsEnabled(false);
    filterBoxCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the SSAO rendering pass
    Ogre::CompositionPass* filterBoxCompositionPassRenderBlur = filterBoxCompositionTargetPass->createPass();
    filterBoxCompositionPassRenderBlur->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    filterBoxCompositionPassRenderBlur->setMaterial(ssaoMergingMaterial);
  }
 
  void SSsaoHandler::GenerateFilterBoxSmartCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for ssao post filter.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneSolidSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sSceneDepthSampler, 1);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sSceneOcclusion, 2);" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 screenSize;" << std::endl;
    FragmentProgramData << "uniform float farClipDistance;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " float fragmentDepth = texture2D(sSceneDepthSampler, oUv).r;" << std::endl;
    FragmentProgramData << " float occ = 0.0;" << std::endl;
    FragmentProgramData << " float weight = 0.0;" << std::endl;
    FragmentProgramData << " for (int x = -2; x < 3; x++)" << std::endl;
    FragmentProgramData << " for (int y = -2; y < 3; y++)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  float sampleDepth = texture2D(sSceneDepthSampler, vec2(oUv.x + float(x) * screenSize.z, oUv.y + float(y) * screenSize.w)).x;" << std::endl;
    FragmentProgramData << "  float dist = abs(fragmentDepth - sampleDepth) * farClipDistance + 0.5;" << std::endl;
    FragmentProgramData << "  float sampleWeight = 1.0 / (pow(dist, 1.0) + 1.0);" << std::endl;
    FragmentProgramData << "  occ += sampleWeight * texture2D(sSceneOcclusion, vec2(oUv.x + float(x) * screenSize.z, oUv.y + float(y) * screenSize.w)).x;" << std::endl;
    FragmentProgramData << "  weight += sampleWeight;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " occ /= weight;" << std::endl;
    FragmentProgramData << " vec4 color = texture2D(sSceneSolidSampler, oUv);" << std::endl;
    FragmentProgramData << " gl_FragColor = vec4(color.r * occ, color.g * occ, color.b * occ, color.a);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    filterBoxSmartCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart_FP", true, FragmentProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr filterBoxSmartCompositorFpParams = filterBoxSmartCompositorFp->getDefaultParameters();
    filterBoxSmartCompositorFpParams->setNamedAutoConstant("screenSize", Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE);
    filterBoxSmartCompositorFpParams->setNamedAutoConstant("farClipDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
 
    if (isGlSL)
    {
      filterBoxSmartCompositorFpParams->setNamedConstant("sSceneSolidSampler", 0);
      filterBoxSmartCompositorFpParams->setNamedConstant("sSceneDepthSampler", 1);
      filterBoxSmartCompositorFpParams->setNamedConstant("sSceneOcclusion", 2);
    }
 
    // All defined, load!
    filterBoxSmartCompositorFp->load();
 
    // Create blur material for compositor.
    Ogre::MaterialPtr filterBoxSmartMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = filterBoxSmartMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 0);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 1);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(filterBoxSmartCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr filterBoxSmartCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* filterBoxSmartCompositionTechnique = filterBoxSmartCompositor->createTechnique();
 
    // Create a reference to the occlusion temporary texture
    Ogre::CompositionTechnique::TextureDefinition* occlusionTexture = filterBoxSmartCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    occlusionTexture->width = 0;
    occlusionTexture->height = 0;
    occlusionTexture->refCompName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input";
    occlusionTexture->refTexName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion";
 
    // Render in first compositor occlusion texture
    Ogre::CompositionTargetPass* filterBoxSmartCompositionTargetPass = filterBoxSmartCompositionTechnique->getOutputTargetPass();
    filterBoxSmartCompositionTargetPass->setShadowsEnabled(false);
    filterBoxSmartCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the Blur rendering pass
    Ogre::CompositionPass* filterBoxSmartCompositionPassRenderBlur = filterBoxSmartCompositionTargetPass->createPass();
    filterBoxSmartCompositionPassRenderBlur->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    filterBoxSmartCompositionPassRenderBlur->setMaterial(filterBoxSmartMaterial);
  }
 
  void SSsaoHandler::GenerateFilterBoxSmartCompositor2()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for ssao post filter.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneSolidSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sSceneDepthSampler, 1);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sSceneOcclusion, 2);" << std::endl;
 
    FragmentProgramData << "OGRE_UNIFORMS(" << std::endl;
    FragmentProgramData << "uniform vec4 screenSize;" << std::endl;
    FragmentProgramData << "uniform float farClipDistance;" << std::endl;
    FragmentProgramData << ")" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " float fragmentDepth = texture2D(sSceneDepthSampler, oUv).w / farClipDistance;" << std::endl;
    FragmentProgramData << " float occ = 0.0;" << std::endl;
    FragmentProgramData << " float weight = 0.0;" << std::endl;
    FragmentProgramData << " for (float x = -2.0; x < 3.0; x++)" << std::endl;
    FragmentProgramData << " for (float y = -2.0; y < 3.0; y++)" << std::endl;
    FragmentProgramData << " {" << std::endl;
    FragmentProgramData << "  float sampleDepth = texture2D(sSceneDepthSampler, vec2(oUv.x + float(x) * screenSize.z, oUv.y + float(y) * screenSize.w)).x / farClipDistance;" << std::endl;
    FragmentProgramData << "  float dist = abs(fragmentDepth - sampleDepth) * farClipDistance + 0.5;" << std::endl;
    FragmentProgramData << "  float sampleWeight = 1.0 / (pow(dist, 1.0) + 1.0);" << std::endl;
    FragmentProgramData << "  occ += sampleWeight * texture2D(sSceneOcclusion, vec2(oUv.x + float(x) * screenSize.z, oUv.y + float(y) * screenSize.w)).x;" << std::endl;
    FragmentProgramData << "  weight += sampleWeight;" << std::endl;
    FragmentProgramData << " }" << std::endl;
    FragmentProgramData << " occ /= weight;" << std::endl;
    FragmentProgramData << " vec4 color = texture2D(sSceneSolidSampler, oUv);" << std::endl;
    FragmentProgramData << " gl_FragColor = vec4(color.r * occ, color.g * occ, color.b * occ, color.a);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    filterBoxSmart2CompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2_FP", true, FragmentProgramData.str());
 
    // Set auto param binding
    Ogre::GpuProgramParametersSharedPtr filterBoxSmart2CompositorFpParams = filterBoxSmart2CompositorFp->getDefaultParameters();
    filterBoxSmart2CompositorFpParams->setNamedAutoConstant("screenSize", Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE);
    filterBoxSmart2CompositorFpParams->setNamedAutoConstant("farClipDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
 
    if (isGlSL)
    {
      filterBoxSmart2CompositorFpParams->setNamedConstant("sSceneSolidSampler", 0);
      filterBoxSmart2CompositorFpParams->setNamedConstant("sSceneDepthSampler", 1);
      filterBoxSmart2CompositorFpParams->setNamedConstant("sSceneOcclusion", 2);
    }
 
    // All defined, load!
    filterBoxSmart2CompositorFp->load();
 
    // Create blur material for compositor.
    Ogre::MaterialPtr filterBoxSmart2Material = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = filterBoxSmart2Material->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 0);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/GBuffer/NormalPosition/Texture", 1);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(filterBoxSmart2CompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr filterBoxSmart2Compositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Filter/BoxSmart2", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* filterBoxSmart2CompositionTechnique = filterBoxSmart2Compositor->createTechnique();
 
    // Create a reference to the occlusion temporary texture
    Ogre::CompositionTechnique::TextureDefinition* occlusionTexture = filterBoxSmart2CompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    occlusionTexture->width = 0;
    occlusionTexture->height = 0;
    occlusionTexture->refCompName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input";
    occlusionTexture->refTexName = std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion";
 
    // Render in first compositor occlusion texture
    Ogre::CompositionTargetPass* filterBoxSmart2CompositionTargetPass = filterBoxSmart2CompositionTechnique->getOutputTargetPass();
    filterBoxSmart2CompositionTargetPass->setShadowsEnabled(false);
    filterBoxSmart2CompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the Blur rendering pass
    Ogre::CompositionPass* filterBoxSmart2CompositionPassRenderBlur = filterBoxSmart2CompositionTargetPass->createPass();
    filterBoxSmart2CompositionPassRenderBlur->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    filterBoxSmart2CompositionPassRenderBlur->setMaterial(filterBoxSmart2Material);
  }
 
  void SSsaoHandler::GenerateSsaoDebugCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for visualizing depth texture.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneOcclusion, 0);" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    FragmentProgramData << " gl_FragColor = vec4(texture2D(sSceneOcclusion, oUv).xyz, 1.0);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoDebugCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Compositor_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr FP_Parameters = ssaoDebugCompositorFp->getDefaultParameters();
    if (isGlSL)
      FP_Parameters->setNamedConstant("sSceneOcclusion", 0);
 
    // All defined, load!
    ssaoDebugCompositorFp->load();
 
    // Create merging material for compositor.
    Ogre::MaterialPtr ssaoDebugMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoDebugMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState(); // Will be filled with occlusion texture
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoDebugCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr ssaoDebugCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Debug", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoDebugCompositionTechnique = ssaoDebugCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* ssaoDebugOutputCompositionTargetPass = ssaoDebugCompositionTechnique->getOutputTargetPass();
    ssaoDebugOutputCompositionTargetPass->setShadowsEnabled(false);
    ssaoDebugOutputCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the ssao debug rendering pass
    Ogre::CompositionPass* ssaoDebugOutputRenderDepthCompositionPass = ssaoDebugOutputCompositionTargetPass->createPass();
    ssaoDebugOutputRenderDepthCompositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    ssaoDebugOutputRenderDepthCompositionPass->setMaterial(ssaoDebugMaterial);
  }
 
  void SSsaoHandler::GenerateMergingCompositor()
  {
    Ogre::String rendererName = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getName();
    bool isGlSL = (rendererName == "Direct3D9 Rendering Subsystem" || rendererName == "Direct3D11 Rendering Subsystem") ? false : true;
 
    // Create an unified fp for merging scene render with blurred ssao.
    Ogre::StringStream programHeader;
    programHeader << "#ifdef GL_ES" << std::endl;
    programHeader << "    precision highp int;" << std::endl;
    programHeader << "    precision highp float;" << std::endl;
    programHeader << "#endif" << std::endl;
 
    programHeader << "#define USE_OGRE_FROM_FUTURE\n#include <OgreUnifiedShader.h>" << std::endl;
 
    Ogre::StringStream FragmentProgramData;
    FragmentProgramData << programHeader.str();
 
    FragmentProgramData << "SAMPLER2D(sSceneSolidSampler, 0);" << std::endl;
    FragmentProgramData << "SAMPLER2D(sSceneOcclusion, 1);" << std::endl;
 
    FragmentProgramData << "MAIN_PARAMETERS" << std::endl;
    FragmentProgramData << "IN(vec2 oUv, TEXCOORD0)" << std::endl;
 
    FragmentProgramData << "MAIN_DECLARATION" << std::endl;
    FragmentProgramData << "{" << std::endl;
    //FragmentProgramData << "  gl_FragColor = vec4(oUv.x, oUv.y, oUv.x * oUv.y, 1.0);" << std::endl;
    FragmentProgramData << "  float occ = texture2D(sSceneOcclusion, oUv).x;" << std::endl;
    FragmentProgramData << "  vec4 color = texture2D(sSceneSolidSampler, oUv);" << std::endl;
    FragmentProgramData << "  gl_FragColor = vec4(color.r * occ, color.g * occ, color.b * occ, color.a);" << std::endl;
    FragmentProgramData << "}" << std::endl;
 
    // Load the program in Ogre
    ssaoMergingCompositorFp = createGpuProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging/Compositor_FP", true, FragmentProgramData.str());
 
    Ogre::GpuProgramParametersSharedPtr FP_Parameters = ssaoMergingCompositorFp->getDefaultParameters();
    if (isGlSL)
    {
      FP_Parameters->setNamedConstant("sSceneSolidSampler", 0);
      FP_Parameters->setNamedConstant("sSceneOcclusion", 1);
    }
 
    // All defined, load!
    ssaoMergingCompositorFp->load();
 
    // Create merging material for compositor.
    Ogre::MaterialPtr ssaoMergingMaterial = ogreMaterialManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging/Material", SO3_INTERNAL_RESOURCE_GROUP);
    Ogre::Pass* ogrePass = ssaoMergingMaterial->getTechnique(0)->getPass(0);
    ogrePass->setDepthCheckEnabled(false);
    Ogre::TextureUnitState* ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Previous", 0);
 
    ogreTextureUnit = ogrePass->createTextureUnitState();
    ogreTextureUnit->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    ogreTextureUnit->setTextureFiltering(Ogre::TFO_NONE);
    ogreTextureUnit->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    ogreTextureUnit->setCompositorReference(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input", std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Input/Texture/Occlusion");
    ogrePass->setVertexProgram(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/RenderQuad_VP");
    ogrePass->setFragmentProgram(ssaoMergingCompositorFp->getName());
 
    // Create compositor
    Ogre::CompositorPtr ssaoMergingCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Ssao/Output/Merging", SO3_INTERNAL_RESOURCE_GROUP);
 
    // Create the technique
    Ogre::CompositionTechnique* ssaoMergingCompositionTechnique = ssaoMergingCompositor->createTechnique();
 
    // Render as output
    Ogre::CompositionTargetPass* ssaoMergingOutputCompositionTargetPass = ssaoMergingCompositionTechnique->getOutputTargetPass();
    ssaoMergingOutputCompositionTargetPass->setShadowsEnabled(false);
    ssaoMergingOutputCompositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
    // Create the SSAO rendering pass
    Ogre::CompositionPass* ssaoMergingOutputMergeCompositionPass = ssaoMergingOutputCompositionTargetPass->createPass();
    ssaoMergingOutputMergeCompositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
    ssaoMergingOutputMergeCompositionPass->setMaterial(ssaoMergingMaterial);
  }
 
  SSsaoHandler::SsaoGBufferLayout SSsaoHandler::GetGBufferLayout(const SSsaoHandler::SsaoTechnique& technique)
  {
    SsaoGBufferLayout techniqueGBufferLayout = SO3_SSAO_GBUFFER_NONE;
    if (technique < SO3_SSAO_TECHNIQUE_MAX)
    {
      switch (technique)
      {
      case SO3_SSAO_TECHNIQUE_NONE:
        techniqueGBufferLayout = SO3_SSAO_GBUFFER_NONE;
        break;
      case SO3_SSAO_TECHNIQUE_CRYTEK:
        techniqueGBufferLayout = SO3_SSAO_GBUFFER_DEPTH_ONLY;
        break;
      case SO3_SSAO_TECHNIQUE_HEMISPHERIC:
        techniqueGBufferLayout = SO3_SSAO_GBUFFER_NORMAL_POSITION;
        break;
      case SO3_SSAO_TECHNIQUE_CREASE_SHADING:
        techniqueGBufferLayout = SO3_SSAO_GBUFFER_NORMAL_POSITION;
        break;
      }
    }
    return techniqueGBufferLayout;
  }
 
  float SSsaoHandler::GetTechniqueParameterValue(const SSsaoHandler::SsaoTechnique& technique, const std::string& parameterName) const
  {
    // Get parameters for that technique
    SsaoTechniqueParametersByTechnique::iterator iSsaoTechniquesParameters = ssaoTechniquesParameters.find(technique);
    if (iSsaoTechniquesParameters != ssaoTechniquesParameters.end())
    {
      // Search technique parameter
      SsaoTechniqueParameters::iterator iTechniqueParameters = iSsaoTechniquesParameters->second.find(parameterName);
      if (iTechniqueParameters != iSsaoTechniquesParameters->second.end())
      {
        // Get this parameter value
        return iTechniqueParameters->second.value;
      }
      else
        SO3_EXCEPT(SExceptionInvalidParameters, "No parameter named " + parameterName + " for this SSAO technique, cannot retrieve parameter!", "SSsaoHandler::GetTechniqueParameterValue", true);
    }
    else
      SO3_EXCEPT(SExceptionInvalidParameters, "No such SSAO technique, or no parameters for this SSAO technique, cannot retrieve parameters!", "SSsaoHandler::GetTechniqueParameterValue", true);
 
    // Not reachable, but happy compiler
    return 0.0f;
  }
 
  void SSsaoHandler::SetTechniqueParameterValue(const SSsaoHandler::SsaoTechnique& technique, const std::string& parameterName, const float& parameterValue)
  {
    if (isSupported)
    {
      // Get technique material pass
      Ogre::Pass* ogrePass = 0;
      switch (technique)
      {
      case SO3_SSAO_TECHNIQUE_CRYTEK:
        ogrePass = crytekSsaoMaterial->getTechnique(0)->getPass(0);
        break;
      case SO3_SSAO_TECHNIQUE_HEMISPHERIC:
        if (mSupportGbuffer)
          ogrePass = hemisphericSsaoMaterial->getTechnique(0)->getPass(0);
        break;
      case SO3_SSAO_TECHNIQUE_CREASE_SHADING:
        if (mSupportGbuffer)
          ogrePass = creaseShadingSsaoMaterial->getTechnique(0)->getPass(0);
        break;
      }
 
      if (ogrePass != 0)
      {
        // Get parameter ptr from shader
        Ogre::GpuProgramParametersSharedPtr ssaoShaderParams = ogrePass->getFragmentProgramParameters();
 
        // Get parameters for that technique
        SsaoTechniqueParametersByTechnique::iterator iSsaoTechniquesParameters = ssaoTechniquesParameters.find(technique);
        if (iSsaoTechniquesParameters != ssaoTechniquesParameters.end())
        {
          // Search technique parameter
          SsaoTechniqueParameters::iterator iTechniqueParameters = iSsaoTechniquesParameters->second.find(parameterName);
          if (iTechniqueParameters != iSsaoTechniquesParameters->second.end())
          {
            // Check that value is in range
            if ((iTechniqueParameters->second.range.first <= parameterValue) && (iTechniqueParameters->second.range.second >= parameterValue))
            {
              // Set the param to the new value.
              ssaoShaderParams->setNamedConstant(parameterName, parameterValue);
 
              // Store this parameter
              iTechniqueParameters->second.value = parameterValue;
 
              // If SSAO is enabled, and the technique is the current technique, we need to disable and re-enable compositor in order to take the parameter in count (Ogre bug?)
              if ((isEnable) && (technique == currentSsaoTechnique))
                Ogre::CompositorManager::getSingleton().getCompositorChain(targetViewport->GetOgreViewPortPointer())->_markDirty();
            }
            else
              SO3_EXCEPT(SExceptionInvalidParameters, "New value for parameter " + parameterName + " is out of range, cannot set parameter!", "SSsaoHandler::SeTechniqueParameterValue", true);
          }
          else
            SO3_EXCEPT(SExceptionInvalidParameters, "No parameter named " + parameterName + " for this SSAO technique, cannot set parameter!", "SSsaoHandler::SeTechniqueParameterValue", true);
        }
        else
          SO3_EXCEPT(SExceptionInvalidParameters, "No parameters for this SSAO technique, cannot set parameters!", "SSsaoHandler::SeTechniqueParameterValue", true);
      }
      else
        SO3_EXCEPT(SExceptionInvalidParameters, "No such SSAO technique, cannot set parameters!", "SSsaoHandler::SeTechniqueParameterValue", true);
    }
    else
      SO3_EXCEPT(SExceptionInvalidParameters, "SSAO technique, not supported by the graphic card!", "SSsaoHandler::SeTechniqueParameterValue", true);
  }
 
  SSsaoHandler::SsaoTechniqueParameters SSsaoHandler::GetTechniqueParameters(const SSsaoHandler::SsaoTechnique& technique) const
  {
    // Get parameters for that technique
    SsaoTechniqueParametersByTechnique::iterator iSsaoTechniquesParameters = ssaoTechniquesParameters.find(technique);
    if (iSsaoTechniquesParameters != ssaoTechniquesParameters.end())
      return iSsaoTechniquesParameters->second;
    else
      SO3_EXCEPT(SExceptionInvalidParameters, "No such SSAO technique, or no parameters for this SSAO technique, cannot retrieve parameters!", "SSsaoHandler::GetTechniqueParameters", true);
 
    // Not reachable, but happy compiler
    return SsaoTechniqueParameters();
  }
 
  void SSsaoHandler::SetTechniqueParameters(const SSsaoHandler::SsaoTechnique& technique, const SSsaoHandler::SsaoTechniqueParameters& parameters)
  {
    if (isSupported)
    {
      // Get technique material pass
      Ogre::Pass* ogrePass = 0;
      switch (technique)
      {
      case SO3_SSAO_TECHNIQUE_CRYTEK:
        ogrePass = crytekSsaoMaterial->getTechnique(0)->getPass(0);
        break;
      case SO3_SSAO_TECHNIQUE_HEMISPHERIC:
        if (mSupportGbuffer)
          ogrePass = hemisphericSsaoMaterial->getTechnique(0)->getPass(0);
        break;
      case SO3_SSAO_TECHNIQUE_CREASE_SHADING:
        if (mSupportGbuffer)
          ogrePass = creaseShadingSsaoMaterial->getTechnique(0)->getPass(0);
        break;
      }
 
      if (ogrePass != 0)
      {
        // Get parameter ptr from shader
        Ogre::GpuProgramParametersSharedPtr ssaoShaderParams = ogrePass->getFragmentProgramParameters();
 
        // Get parameters for that technique
        float tempValue = 0.0f;
        SsaoTechniqueParametersByTechnique::iterator iSsaoTechniquesParameters = ssaoTechniquesParameters.find(technique);
        if (iSsaoTechniquesParameters != ssaoTechniquesParameters.end())
        {
          // Iterate through parameters
          SsaoTechniqueParameters::iterator iTechniqueParameters = iSsaoTechniquesParameters->second.begin();
          while (iTechniqueParameters != iSsaoTechniquesParameters->second.end())
          {
            // Get this parameter value in the list passed as arguments
            SsaoTechniqueParameters::const_iterator iNewParameter = parameters.find(iTechniqueParameters->first);
            if (iNewParameter != parameters.end())
            {
              // Check that value is in range
              tempValue = iNewParameter->second.value;
              if ((iTechniqueParameters->second.range.first <= tempValue) && (iTechniqueParameters->second.range.second >= tempValue))
              {
                // Set the param to the new value.
                ssaoShaderParams->setNamedConstant(iNewParameter->first, tempValue);
 
                // Store this parameter
                iTechniqueParameters->second.value = tempValue;
              }
              // Else warning in log?
            }
            // Else warning in log?
 
            // Next parameter to set
            iTechniqueParameters++;
          }
        }
        else
          SO3_EXCEPT(SExceptionInvalidParameters, "No parameters for this SSAO technique, cannot set parameters!", "SSsaoHandler::SeTechniqueParameters", true);
      }
      else
        SO3_EXCEPT(SExceptionInvalidParameters, "No such SSAO technique, cannot set parameters!", "SSsaoHandler::SeTechniqueParameters", true);
    }
    else
      SO3_EXCEPT(SExceptionInvalidParameters, "SSAO technique, not supported by the graphic card!", "SSsaoHandler::SeTechniqueParameters", true);
  }
 
  /*
  void SSsaoHandler::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
    //Disable octree update
    SCamera* cam = targetViewport->GetCamera();
    if (cam)
    {
      cam->GetParentScene()->GetOgreScenePointer()->setFindVisibleObjects(false);
      cam->GetParentScene()->GetOgreScenePointer()->setLateMaterialResolving(false);
    }
  }
 
  void SSsaoHandler::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
    //Enable octree update
    SCamera* cam = targetViewport->GetCamera();
    if (cam)
    {
      cam->GetParentScene()->GetOgreScenePointer()->setFindVisibleObjects(true);
      cam->GetParentScene()->GetOgreScenePointer()->setLateMaterialResolving(true);
    }
  }
  */
}