SO3HdrHandler.cpp

Go to the documentation of this file.

 
#include "SO3Renderer/SO3HdrHandler.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Utils/SO3Exception.h"
#include "SO3Renderer/SO3ViewPort.h"
 
namespace SO3
{
 
bool SHdrHandler::compositorCreated = false;
// global since the compositor logic can not be per SHdrHandler
float SHdrHandler::mBlurAmount = 0.2f;
float SHdrHandler::mEffectAmount = 0.3f;
float SHdrHandler::mGamma = 1.0f;
 
void SHdrHandler::Reset()
{
  compositorCreated = false;
}
 
SHdrHandler::SHdrHandler()
{
}
 
SHdrHandler::SHdrHandler(SViewPort* targetViewportInstance)
{
  // Initialize
  inputCompositorInstance = 0;
  isEnable = false;
  targetViewport = targetViewportInstance;
  targetViewportScheme = targetViewport->GetOgreViewPortPointer()->getMaterialScheme();
 
  // Generate compositor
  ogreCompositorManager = Ogre::CompositorManager::getSingletonPtr();
 
  //test if shaders are supported by the card
  const Ogre::RenderSystemCapabilities* caps = SRoot::getSingleton().GetOgreRenderSystem()->getCapabilities();    
  isSupported = caps && caps->hasCapability(Ogre::RSC_VERTEX_PROGRAM) &&
                caps->hasCapability(Ogre::RSC_FRAGMENT_PROGRAM) &&
                caps->hasCapability(Ogre::RSC_NON_POWER_OF_2_TEXTURES) &&
                !caps->hasCapability(Ogre::RSC_MRT_SAME_BIT_DEPTHS) &&
                (caps->isShaderProfileSupported("ps_3_0") || caps->isShaderProfileSupported("ps_4_0") || (caps->isShaderProfileSupported("arbfp1")) || (caps->isShaderProfileSupported("glsles")) || (caps->isShaderProfileSupported("glsl300es")));
 
  if (isSupported)
  {
    CreateCompositors();
 
    //HDR must be first on chain
    inputCompositorInstance = ogreCompositorManager->addCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr");
 
    // Get clear pass, and change the clear colour to automatic mode
    if(inputCompositorInstance)
    {
      inputCompositorInstance->getTechnique()->getTargetPass(1)->getPasses()[0]->setAutomaticColour(true);
    }
  }
}
 
SHdrHandler::~SHdrHandler()
{
  if (isSupported)
  {
    // Force disable
    SetEnable(false);
 
    // Release compositor
    if (inputCompositorInstance)
    {
      ogreCompositorManager->removeCompositor(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr");
      inputCompositorInstance = 0;
    }
 
    Ogre::CompositorChain* compositorChain = ogreCompositorManager->getCompositorChain(targetViewport->GetOgreViewPortPointer());
    if(compositorChain)
      if(compositorChain->getCompositorInstances().empty())
        ogreCompositorManager->removeCompositorChain(targetViewport->GetOgreViewPortPointer());
 
    ogreCompositorManager = 0;
  }
}
 
bool SHdrHandler::GetEnable()
{
  return isEnable;
}
 
void SHdrHandler::SetEnable(bool enable)
{
  if (isSupported)
  {
    if(enable != isEnable)
    {
      isEnable = enable;
      // Enable base compositor
      if (!targetViewport->UpdateStereoCompositorState(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr", isEnable))
        ogreCompositorManager->setCompositorEnabled(targetViewport->GetOgreViewPortPointer(), std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr", isEnable);
    }
  }
}
 
 
void SHdrHandler::SetBlurAmount(float amount)
{
  mBlurAmount = amount;
}
 
void SHdrHandler::SetEffectAmount(float amount)
{
  mEffectAmount = amount;
}
 
void SHdrHandler::SetGamma(float gamma)
{
  mGamma = gamma;
}
 
void SHdrHandler::CreateCompositors()
{
  // Generate Ogre's resources for HDR
  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);
 
    // Generate a compositor that will render the scene (without transparent objects), and will old a texture to the blurred SSAO
    GenerateHdrCompositor();
 
    // Everything was created.
    compositorCreated = true;
  }
}
 
void SHdrHandler::GenerateHdrCompositor()
{
  // Create compositor
  Ogre::CompositorPtr hdrCompositor = ogreCompositorManager->create(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr", SO3_INTERNAL_RESOURCE_GROUP);
 
  // Create the technique
  Ogre::CompositionTechnique* hdrCompositionTechnique = hdrCompositor->createTechnique();
  hdrCompositionTechnique->setCompositorLogicName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Logic");
 
  Ogre::PixelFormat rttformat = Ogre::PF_BYTE_RGB;
  SRoot::getSingleton().GetRttPixelFormat(rttformat);
 
  Ogre::PixelFormatList pixelFormatList;
  pixelFormatList.push_back(rttformat);
 
  // Create a texture that will hold the previous render
  Ogre::CompositionTechnique::TextureDefinition* previousTexture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/Previous");
  previousTexture->width = 0;
  previousTexture->height = 0;
  previousTexture->formatList = pixelFormatList;
 
  Ogre::CompositionTargetPass* compositionTargetPrevious = hdrCompositionTechnique->createTargetPass();
  compositionTargetPrevious->setShadowsEnabled(false);
  compositionTargetPrevious->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/Previous");
  compositionTargetPrevious->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
 
  SRoot::getSingleton().GetRttPixelFormat(rttformat, false, false);
  pixelFormatList.clear();
  pixelFormatList.push_back(rttformat);
  
  // Create a texture for luminance evaluation
  Ogre::CompositionTechnique::TextureDefinition* lum4Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum4");
  lum4Texture->width = 128;
  lum4Texture->height = 128;
  lum4Texture->formatList = pixelFormatList;
 
  Ogre::CompositionTechnique::TextureDefinition* lum3Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum3");
  lum3Texture->width = 64;
  lum3Texture->height = 64;
  lum3Texture->formatList = pixelFormatList;
 
  Ogre::CompositionTechnique::TextureDefinition* lum2Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum2");
  lum2Texture->width = 16;
  lum2Texture->height = 16;
  lum2Texture->formatList = pixelFormatList;
 
  Ogre::CompositionTechnique::TextureDefinition* lum1Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum1");
  lum1Texture->width = 4;
  lum1Texture->height = 4;
  lum1Texture->formatList = pixelFormatList;
 
  Ogre::CompositionTechnique::TextureDefinition* lum0Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum0");
  lum0Texture->width = 1;
  lum0Texture->height = 1;
  lum0Texture->formatList = pixelFormatList;
 
  // lum4
  Ogre::CompositionTargetPass* compositionTargetLum4 = hdrCompositionTechnique->createTargetPass();
  compositionTargetLum4->setShadowsEnabled(false);
  compositionTargetLum4->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum4");
  compositionTargetLum4->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetLum4QuadPass = compositionTargetLum4->createPass();
  compositionTargetLum4QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetLum4QuadPass->setMaterialName("Ogre/Compositor/HDR/Downsample2x2Luminence");
  compositionTargetLum4QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/Previous");
  compositionTargetLum4QuadPass->setIdentifier(994);
 
  // lum3
  Ogre::CompositionTargetPass* compositionTargetLum3 = hdrCompositionTechnique->createTargetPass();
  compositionTargetLum3->setShadowsEnabled(false);
  compositionTargetLum3->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum3");
  compositionTargetLum3->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetLum3QuadPass = compositionTargetLum3->createPass();
  compositionTargetLum3QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetLum3QuadPass->setMaterialName("Ogre/Compositor/HDR/Downsample3x3");
  compositionTargetLum3QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum4");
  compositionTargetLum3QuadPass->setIdentifier(993);
 
  // lum2
  Ogre::CompositionTargetPass* compositionTargetLum2 = hdrCompositionTechnique->createTargetPass();
  compositionTargetLum2->setShadowsEnabled(false);
  compositionTargetLum2->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum2");
  compositionTargetLum2->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetLum2QuadPass = compositionTargetLum2->createPass();
  compositionTargetLum2QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetLum2QuadPass->setMaterialName("Ogre/Compositor/HDR/Downsample3x3");
  compositionTargetLum2QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum3");
  compositionTargetLum2QuadPass->setIdentifier(992);
 
  // lum1
  Ogre::CompositionTargetPass* compositionTargetLum1 = hdrCompositionTechnique->createTargetPass();
  compositionTargetLum1->setShadowsEnabled(false);
  compositionTargetLum1->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum1");
  compositionTargetLum1->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetLum1QuadPass = compositionTargetLum1->createPass();
  compositionTargetLum1QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetLum1QuadPass->setMaterialName("Ogre/Compositor/HDR/Downsample3x3");
  compositionTargetLum1QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum2");
  compositionTargetLum1QuadPass->setIdentifier(991);
  
  // lum0
  Ogre::CompositionTargetPass* compositionTargetLum0 = hdrCompositionTechnique->createTargetPass();
  compositionTargetLum0->setShadowsEnabled(false);
  compositionTargetLum0->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum0");
  compositionTargetLum0->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetLum0QuadPass = compositionTargetLum0->createPass();
  compositionTargetLum0QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetLum0QuadPass->setMaterialName("Ogre/Compositor/HDR/FinalLuminance");
  compositionTargetLum0QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/lum1");
  compositionTargetLum1QuadPass->setIdentifier(990);
 
  // adated luminance
  Ogre::CompositionTechnique::TextureDefinition* adaptLastlumTexture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptLastLum");
  adaptLastlumTexture->width = 1;
  adaptLastlumTexture->height = 1;
  adaptLastlumTexture->formatList = pixelFormatList;
 
  Ogre::CompositionTechnique::TextureDefinition* adaptedlumTexture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptedLum");
  adaptedlumTexture->width = 1;
  adaptedlumTexture->height = 1;
  adaptedlumTexture->formatList = pixelFormatList;
 
  Ogre::CompositionTargetPass* compositionTargetAdaptLastLum = hdrCompositionTechnique->createTargetPass();
  compositionTargetAdaptLastLum->setShadowsEnabled(false);
  compositionTargetAdaptLastLum->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptLastLum");
  compositionTargetAdaptLastLum->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetAdaptLastLumQuadPass = compositionTargetAdaptLastLum->createPass();
  compositionTargetAdaptLastLumQuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetAdaptLastLumQuadPass->setMaterialName("Ogre/Compositor/HDR/Copy");
  compositionTargetAdaptLastLumQuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptedLum");
 
  Ogre::CompositionTargetPass* compositionTargetAdaptedLum = hdrCompositionTechnique->createTargetPass();
  compositionTargetAdaptedLum->setShadowsEnabled(false);
  compositionTargetAdaptedLum->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptedLum");
  compositionTargetAdaptedLum->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetAdaptedLumQuadPass = compositionTargetAdaptedLum->createPass();
  compositionTargetAdaptedLumQuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetAdaptedLumQuadPass->setMaterialName("Ogre/Compositor/HDR/AdaptLuminance");
  compositionTargetAdaptedLumQuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/lum0");
  compositionTargetAdaptedLumQuadPass->setInput(1, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptLastLum");
  
  // key for tone mapping
  Ogre::CompositionTechnique::TextureDefinition* keyTexture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/key");
  keyTexture->width = 1;
  keyTexture->height = 1;
  keyTexture->formatList = pixelFormatList;
 
  Ogre::CompositionTargetPass* compositionTargetKey = hdrCompositionTechnique->createTargetPass();
  compositionTargetKey->setShadowsEnabled(false);
  compositionTargetKey->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/key");
  compositionTargetKey->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetKeyQuadPass = compositionTargetKey->createPass();
  compositionTargetKeyQuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetKeyQuadPass->setMaterialName("Ogre/Compositor/HDR/AutoKey");
  compositionTargetKeyQuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/lum0");
  SRoot::getSingleton().GetRttPixelFormat(rttformat);
  pixelFormatList.clear();
  pixelFormatList.push_back(rttformat);
 
  // bright pass
  Ogre::CompositionTechnique::TextureDefinition* brightPassTexture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/brightpass");
  brightPassTexture->width = 128;
  brightPassTexture->height = 128;
  brightPassTexture->formatList = pixelFormatList;
 
  Ogre::CompositionTargetPass* compositionTargetBrightPass = hdrCompositionTechnique->createTargetPass();
  compositionTargetBrightPass->setShadowsEnabled(false);
  compositionTargetBrightPass->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/brightpass");
  compositionTargetBrightPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetBrightQuadPass = compositionTargetBrightPass->createPass();
  compositionTargetBrightQuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetBrightQuadPass->setMaterialName("Ogre/Compositor/HDR/Brightpass");
  compositionTargetBrightQuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/Previous");
  compositionTargetBrightQuadPass->setInput(1, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/adaptedLum");
  compositionTargetBrightQuadPass->setInput(2, std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/Hdr/Input/Texture/key");
  compositionTargetBrightQuadPass->setIdentifier(800);
 
  //Bloom filter targets
  Ogre::CompositionTechnique::TextureDefinition* bloom0Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom0");
  bloom0Texture->width = 128;
  bloom0Texture->height = 128;
  bloom0Texture->formatList = pixelFormatList;
 
  Ogre::CompositionTechnique::TextureDefinition* bloom1Texture = hdrCompositionTechnique->createTextureDefinition(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom1");
  bloom1Texture->width = 128;
  bloom1Texture->height = 128;
  bloom1Texture->formatList = pixelFormatList;
 
  // Bloom1 pass
  Ogre::CompositionTargetPass* compositionTargetBloom1 = hdrCompositionTechnique->createTargetPass();
  compositionTargetBloom1->setShadowsEnabled(false);
  compositionTargetBloom1->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom1");
  compositionTargetBloom1->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetBloom1QuadPass = compositionTargetBloom1->createPass();
  compositionTargetBloom1QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetBloom1QuadPass->setMaterialName("Ogre/Compositor/HDR/GaussianBloom");
  compositionTargetBloom1QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/brightpass");
  compositionTargetBloom1QuadPass->setIdentifier(701);
  
  // Bloom0 pass
  Ogre::CompositionTargetPass* compositionTargetBloom0 = hdrCompositionTechnique->createTargetPass();
  compositionTargetBloom0->setShadowsEnabled(false);
  compositionTargetBloom0->setOutputName(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom0");
  compositionTargetBloom0->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionTargetBloom0QuadPass = compositionTargetBloom0->createPass();
  compositionTargetBloom0QuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
  compositionTargetBloom0QuadPass->setMaterialName("Ogre/Compositor/HDR/GaussianBloom");
  compositionTargetBloom0QuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom1");
  compositionTargetBloom0QuadPass->setIdentifier(700);
  
  // Create the out target
  Ogre::CompositionTargetPass* compositionOutTarget = hdrCompositionTechnique->getOutputTargetPass();
  compositionOutTarget->setShadowsEnabled(false);
  compositionOutTarget->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  Ogre::CompositionPass* compositionOutTargetQuadPass = compositionOutTarget->createPass();
  compositionOutTargetQuadPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
 
  compositionOutTargetQuadPass->setIdentifier(1000);
  compositionOutTargetQuadPass->setMaterialName("Ogre/Compositor/HDR/ToneMapping");
  compositionOutTargetQuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/Previous");
  compositionOutTargetQuadPass->setInput(1, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom0");
  compositionOutTargetQuadPass->setInput(2, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/adaptedLum");
  compositionOutTargetQuadPass->setInput(3, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/key");
 
  //debug  
  //compositionOutTargetQuadPass->setMaterialName("Ogre/Compositor/HDR/Copy");
  //compositionOutTargetQuadPass->setInput(0, std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/brightpass");
  
 
  //register the compositor
  Ogre::CompositorManager& compMgr = Ogre::CompositorManager::getSingleton();
        compMgr.registerCompositorLogic(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Logic", new SHdrLogic);
}
 
//SHdrLogic
Ogre::CompositorInstance::Listener* SHdrLogic::createListener(Ogre::CompositorInstance* instance)
{
        SHdrListener* listener = new SHdrListener();
  listener->notifyCompositor(instance);
        return listener;
}
 
//SHdrListener
SHdrListener::SHdrListener()
{
}
 
SHdrListener::~SHdrListener()
{
}
 
void SHdrListener::notifyCompositor(Ogre::CompositorInstance* instance)
{
        // Get some RTT dimensions for later calculations
        Ogre::CompositionTechnique::TextureDefinitions defList = instance->getTechnique()->getTextureDefinitions();
  Ogre::CompositionTechnique::TextureDefinitions::const_iterator defIter;
  for (defIter = defList.begin(); defIter != defList.end(); ++defIter)
        {
                Ogre::CompositionTechnique::TextureDefinition* def = *defIter;
 
                if(def->name == (std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Hdr/Input/Texture/bloom0"))
                {
                        mBloomSize = (int)def->width; // should be square
                        // Calculate gaussian texture offsets & weights
                        float deviation = 5.0f;
                        float texelSize = 1.0f / (float)mBloomSize;
 
                        // central sample, no offset
                        mBloomTexOffsetsHorz[0][0] = 0.0f;
                        mBloomTexOffsetsHorz[0][1] = 0.0f;
                        mBloomTexOffsetsVert[0][0] = 0.0f;
                        mBloomTexOffsetsVert[0][1] = 0.0f;
                        mBloomTexWeights[0][0] = mBloomTexWeights[0][1] =       mBloomTexWeights[0][2] = Ogre::Math::gaussianDistribution(0, 0, deviation);
                        mBloomTexWeights[0][3] = 1.0f;
 
                        // 'pre' samples
                        for(int i = 1; i < 8; ++i)
                        {
                                mBloomTexWeights[i][0] = mBloomTexWeights[i][1] =       mBloomTexWeights[i][2] = 1.25f * Ogre::Math::gaussianDistribution((float)i, 0, deviation);
                                mBloomTexWeights[i][3] = 1.0f;
                                mBloomTexOffsetsHorz[i][0] = i * texelSize;
                                mBloomTexOffsetsHorz[i][1] = 0.0f;
                                mBloomTexOffsetsVert[i][0] = 0.0f;
                                mBloomTexOffsetsVert[i][1] = i * texelSize;
                        }
                        // 'post' samples
                        for(int i = 8; i < 15; ++i)
                        {
                                mBloomTexWeights[i][0] = mBloomTexWeights[i][1] =       mBloomTexWeights[i][2] = mBloomTexWeights[i - 7][0];
                                mBloomTexWeights[i][3] = 1.0f;
 
                                mBloomTexOffsetsHorz[i][0] = -mBloomTexOffsetsHorz[i - 7][0];
                                mBloomTexOffsetsHorz[i][1] = 0.0f;
                                mBloomTexOffsetsVert[i][0] = 0.0f;
                                mBloomTexOffsetsVert[i][1] = -mBloomTexOffsetsVert[i - 7][1];
                        }
                }
        }
}
 
void SHdrListener::notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
        // Prepare the fragment params offsets
        switch(pass_id)
        {
  case 993: // rt_lum3
  case 992: // rt_lum2
  case 991: // rt_lum1
  case 990: // rt_lum0
    break;
  case 800: // rt_brightpass
    break;
        case 701: // rt_bloom1
                {
                        // horizontal bloom
                        mat->load();
                        Ogre::GpuProgramParametersSharedPtr fparams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
                        fparams->setNamedConstant("sampleOffsets", mBloomTexOffsetsHorz[0], 15);
                        fparams->setNamedConstant("sampleWeights", mBloomTexWeights[0], 15);
 
                        break;
                }
        case 700: // rt_bloom0
                {
                        // vertical bloom
                        mat->load();
                        Ogre::GpuProgramParametersSharedPtr fparams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
                        fparams->setNamedConstant("sampleOffsets", mBloomTexOffsetsVert[0], 15);
                        fparams->setNamedConstant("sampleWeights", mBloomTexWeights[0], 15);
 
                        break;
                }
  default:
    break;
        }
}
 
void SHdrListener::notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
  if (pass_id == 1000 && mat->getSupportedTechniques().size() > 0)
  {
    Ogre::GpuProgramParametersSharedPtr toneShaderParams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
    if (toneShaderParams)
    {
      if (toneShaderParams->_findNamedConstantDefinition("blurAmount"))
        toneShaderParams->setNamedConstant("blurAmount", SHdrHandler::mBlurAmount);
 
      if (toneShaderParams->_findNamedConstantDefinition("effectAmount"))
        toneShaderParams->setNamedConstant("effectAmount",SHdrHandler::mEffectAmount);
 
      if (toneShaderParams->_findNamedConstantDefinition("gamma"))
        toneShaderParams->setNamedConstant("gamma", SHdrHandler::mGamma);
    }
  }
}
 
}