SO3DeferredShading.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3Utils/SO3Exception.h"
#include "SO3Renderer/DeferredShading/SO3DeferredShading.h"
#include "SO3Renderer/DeferredShading/SO3GBufferSchemeHandler.h"
#include "SO3Renderer/DeferredShading/SO3NoGBufferSchemeHandler.h"
#include "SO3Renderer/DeferredShading/SO3DeferredLightCompositionPass.h"
#include "SO3Renderer/DeferredShading/SO3SSAOLogic.h"
#include "SO3Renderer/DeferredShading/SO3GBufferLow.h"
#include "SO3Renderer/DeferredShading/SO3GBufferHigh.h"
#include "SO3Renderer/SO3ViewPort.h"
 
template<> SO3::SDeferredShading* Ogre::Singleton<SO3::SDeferredShading>::msSingleton = 0;
 
namespace SO3
{
 
//Also change in SO3_Deferred.compositor "SO3/Deferred/GBuffer"
const Ogre::uint8 SDeferredShading::PRE_GBUFFER_RENDER_QUEUE = Ogre::RENDER_QUEUE_2;
const Ogre::uint8 SDeferredShading::POST_GBUFFER_RENDER_QUEUE = Ogre::RENDER_QUEUE_8;
 
SDeferredShading::SDeferredShading()
{
  #if SO3_ENABLE_DEFERRED_CUSTOM_SHADOWS == 1
          deferredShadowManager = new SDeferredShadowManager();
  #else
    deferredShadowManager = 0;
  #endif
  currentGBuffer = 0;
  newViewportAdded = false;
  gBufferSchemeHandler = 0;
  noGBufferSchemeHandler = 0;
  ssaoCompositorLogic = 0;
  deferredLightCompositionPass = 0;
 
  gbufferMaterialGenerator = new SGBufferMaterialGenerator();
  deferredLightManager = new SDeferredLightManager();
  compositorGBuffer = new SDeferredCompositorGBuffer();
  compositorLighting = new SDeferredCompositorLighting();
  compositorShowDepth = new SDeferredCompositorShowDepth();
  compositorShowDiffuse = new SDeferredCompositorShowDiffuse();
  compositorShowEmissive = new SDeferredCompositorShowEmissive();
  compositorShowMaterialID = new SDeferredCompositorShowMaterialID();
  compositorShowNormal = new SDeferredCompositorShowNormal();
  compositorShowSpecular = new SDeferredCompositorShowSpecular();
  compositorShowVelocity = new SDeferredCompositorShowVelocity();
  compositorSSAO = new SDeferredCompositorSSAO();
  compositorSSAA = new SDeferredCompositorSSAA();
  compositorNFAA = new SDeferredCompositorNFAA();
 
  currentMode = SO3_DEFERRED_SHOWLIT;
  SetMode(currentMode);
}
 
SDeferredShading::~SDeferredShading()
{
  UnregisterAllViewports();
        SAFE_DELETE(deferredShadowManager);
 
  // Remove GBuffer scheme listener.
  if(gBufferSchemeHandler)
  {
    Ogre::MaterialManager::getSingleton().removeListener(gBufferSchemeHandler);
    SO3_SAFE_DELETE(gBufferSchemeHandler);
  }
 
  // Remove NoGBuffer scheme listener.
  if(noGBufferSchemeHandler)
  {
    Ogre::MaterialManager::getSingleton().removeListener(noGBufferSchemeHandler);
    SO3_SAFE_DELETE(noGBufferSchemeHandler);
  }
 
  // UnHook the compositor logic.
  Ogre::CompositorManager& compMan = Ogre::CompositorManager::getSingleton();
  if(ssaoCompositorLogic)
  {
    compMan.unregisterCompositorLogic("SSAOLogic");
    SO3_SAFE_DELETE(ssaoCompositorLogic);
  }
 
  // UnHook light composition pass.
  /*if(deferredLightCompositionPass)
  {
    TODO!
    compMan.unregisterCustomCompositionPass("DeferredLight", deferredLightCompositionPass);
    SO3_SAFE_DELETE(deferredLightCompositionPass);
  }*/
 
  //
  SO3_SAFE_DELETE(compositorGBuffer);
  SO3_SAFE_DELETE(compositorLighting);
  SO3_SAFE_DELETE(compositorShowDepth);
  SO3_SAFE_DELETE(compositorShowDiffuse);
  SO3_SAFE_DELETE(compositorShowEmissive);
  SO3_SAFE_DELETE(compositorShowMaterialID);
  SO3_SAFE_DELETE(compositorShowNormal);
  SO3_SAFE_DELETE(compositorShowSpecular);
  SO3_SAFE_DELETE(compositorShowVelocity);
  SO3_SAFE_DELETE(compositorSSAO);
  SO3_SAFE_DELETE(compositorSSAA);
  SO3_SAFE_DELETE(compositorNFAA);
  SO3_SAFE_DELETE(deferredLightManager);
  SO3_SAFE_DELETE(gbufferMaterialGenerator);
 
  //
  AvailableGBufferMap::iterator iGBuffer = availableGBufferMap.begin();
  while(iGBuffer != availableGBufferMap.end())
  {
    SO3_SAFE_DELETE(iGBuffer->second);
    iGBuffer++;
  }
  availableGBufferMap.clear();
}
 
SDeferredShading* SDeferredShading::getSingletonPtr()
{
  return msSingleton;
}
 
SDeferredShading& SDeferredShading::getSingleton()
{
  assert(msSingleton);
  return (*msSingleton);
}
 
void SDeferredShading::RegisterViewport(SViewPort* targetViewport)
{
  OgreViewportList::iterator ogreViewportSearched = ogreViewportList.find(targetViewport);
  if (ogreViewportSearched != ogreViewportList.end())
    SO3_EXCEPT(SExceptionItemIdentity, "Trying to register an already registered viewport!", "SDeferredShading::RegisterViewport", true);
  else
  {
    Ogre::CompositorManager& compMan = Ogre::CompositorManager::getSingleton();
    static bool firstTime = true;
    if (firstTime)
    {
      // Check graphic card capabilities. We do this here cause we have to be certain that a render window exists before checking capabilities
      Ogre::RenderSystem* ogreRenderSystem = Ogre::Root::getSingleton().getRenderSystem();
      const Ogre::RenderSystemCapabilities* ogreCapabilities = ogreRenderSystem ->getCapabilities();
 
      // Checking fragment and vertex programs availibility
      if (!ogreCapabilities->hasCapability(Ogre::RSC_VERTEX_PROGRAM) || !(ogreCapabilities->hasCapability(Ogre::RSC_FRAGMENT_PROGRAM)))
        SO3_EXCEPT(SExceptionUnimplemented, "Your card does not support vertex and fragment programs!", "SDeferredShading::SDeferredShading", true);
 
      // Checking MRT availibility for 2 MRT Gbuffer
      if (ogreCapabilities->getNumMultiRenderTargets()<2)
        SO3_EXCEPT(SExceptionUnimplemented, "Your card does not support at least two simultaneous render targets!",  "SDeferredShading::SDeferredShading", true);
 
      // Generate GBuffer_Low
      currentGBuffer = new SGBufferLow();
      availableGBufferMap.insert(AvailableGBufferMap::value_type(currentGBuffer->GetName(), currentGBuffer));
 
      // Checking MRT availibility for 4 MRT Gbuffer
      if (ogreCapabilities->getNumMultiRenderTargets()<4)
      {
        Ogre::LogManager::getSingleton().logMessage("Your card does not support at least four simultaneous render targets, high resolution deferred will not be available!");
      }
      else
      {
        // Generate GBuffer_High, select it if available
        currentGBuffer = new SGBufferHigh();
        availableGBufferMap.insert(AvailableGBufferMap::value_type(currentGBuffer->GetName(), currentGBuffer));
      }
 
      // Hook up the scheme handlers.
      gBufferSchemeHandler = new SGBufferSchemeHandler(gbufferMaterialGenerator);
      noGBufferSchemeHandler = new SNoGBufferSchemeHandler();
      Ogre::MaterialManager::getSingleton().addListener(gBufferSchemeHandler, "GBuffer");
      Ogre::MaterialManager::getSingleton().addListener(noGBufferSchemeHandler, "NoGBuffer");
 
      // Hook up the compositor logic.
      ssaoCompositorLogic = new SSsaoLogic();
      compMan.registerCompositorLogic("SSAOLogic", ssaoCompositorLogic);
      deferredLightCompositionPass = new SDeferredLightCompositionPass();
      compMan.registerCustomCompositionPass("DeferredLight", deferredLightCompositionPass);
 
      firstTime = false;
    }
 
    // Create our viewport gbuffer filters instance
    GBufferFilters* viewportGBufferFilters = new GBufferFilters();
 
    // Create the main GBuffer compositor
    Ogre::Viewport* ogreTargetViewport = targetViewport->GetOgreViewPortPointer();
    viewportGBufferFilters->gBufferInstance = compMan.addCompositor(ogreTargetViewport, compositorGBuffer->GetCompositor(currentGBuffer)->getName(), 0);
    //viewportGBufferFilters->gBufferInstance->getTechnique()->getTargetPass(0)->getPass(0)->setClearColour(targetViewport->getBackgroundColour());
 
    // Create filters
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWLIT]        = compMan.addCompositor(ogreTargetViewport, compositorLighting->GetCompositor(currentGBuffer)->getName(), 1);
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWCOLOUR]     = compMan.addCompositor(ogreTargetViewport, compositorShowDiffuse->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWNORMALS]    = compMan.addCompositor(ogreTargetViewport, compositorShowNormal->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWDEPTH]      = compMan.addCompositor(ogreTargetViewport, compositorShowDepth->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWSPECULAR]   = compMan.addCompositor(ogreTargetViewport, compositorShowSpecular->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWEMISSIVE]   = compMan.addCompositor(ogreTargetViewport, compositorShowEmissive->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWVELOCITY]   = compMan.addCompositor(ogreTargetViewport, compositorShowVelocity->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->gBufferCompositors[SO3_DEFERRED_SHOWMATERIALID] = compMan.addCompositor(ogreTargetViewport, compositorShowMaterialID->GetCompositor(currentGBuffer)->getName());
 
    // Create ssao compositor
    viewportGBufferFilters->ssaoCompositor = compMan.addCompositor(ogreTargetViewport, compositorSSAO->GetCompositor(currentGBuffer)->getName(), 2);
 
    // Create AA compositors
    viewportGBufferFilters->antiAliasingCompositors[SO3_DEFERRED_SSAA - 1] = compMan.addCompositor(ogreTargetViewport, compositorSSAA->GetCompositor(currentGBuffer)->getName());
    viewportGBufferFilters->antiAliasingCompositors[SO3_DEFERRED_NFAA - 1] = compMan.addCompositor(ogreTargetViewport, compositorNFAA->GetCompositor(currentGBuffer)->getName());
 
    // Add to our list
    ogreViewportList.insert(OgreViewportList::value_type(targetViewport, viewportGBufferFilters));
 
    // Activate GBuffer
    viewportGBufferFilters->gBufferInstance->setEnabled(true);
 
    // Force synchro.
    newViewportAdded = true;
    SetMode(currentMode);
  }
}
 
void SDeferredShading::UnregisterViewport(SViewPort* existingViewport)
{
  OgreViewportList::iterator ogreViewportSearched = ogreViewportList.find(existingViewport);
  if (ogreViewportSearched != ogreViewportList.end())
  //  SO3_EXCEPT(SExceptionItemNotFound, "Trying to unregister a viewport that is not registered!", "SDeferredShading::UnregisterViewport", true);
  //else
  {
    Ogre::Viewport* ogreTargetViewport = existingViewport->GetOgreViewPortPointer();
    Ogre::CompositorChain* chain = Ogre::CompositorManager::getSingleton().getCompositorChain(ogreTargetViewport);
 
    for(int i=0; i<SO3_DEFERRED_COUNT; ++i)
      chain->_removeInstance(ogreViewportSearched->second->gBufferCompositors[i]);
 
    for(int i=0; i<SO3_DEFERRED_AA_COUNT; ++i)
      chain->_removeInstance(ogreViewportSearched->second->antiAliasingCompositors[i]);
 
    chain->_removeInstance(ogreViewportSearched->second->ssaoCompositor);
    chain->_removeInstance(ogreViewportSearched->second->gBufferInstance);
 
    chain->_markDirty();
 
    if(chain->getNumCompositors() == 0)
      Ogre::CompositorManager::getSingleton().removeCompositorChain(ogreTargetViewport);
 
    // TODO verify that our filter struct is empty
    // Delete our filter struct
    SO3_SAFE_DELETE(ogreViewportSearched->second);
 
    // Remove from our list
    ogreViewportList.erase(ogreViewportSearched);
  }
}
 
void SDeferredShading::UnregisterAllViewports()
{
  // Copy our internal viewport list cause it'll be modified.
  OgreViewportList ogreViewportListCopy = ogreViewportList;
  OgreViewportList::iterator iOgreViewportListCopy = ogreViewportListCopy.begin();
  while (iOgreViewportListCopy != ogreViewportListCopy.end())
  {
    UnregisterViewport(iOgreViewportListCopy->first);
    iOgreViewportListCopy++;
  }
}
 
void SDeferredShading::SetMode(DeferredShadingMode mode)
{
  assert(0 <= mode && mode < SO3_DEFERRED_COUNT);
 
  // prevent duplicate setups
  if ((currentMode == mode) && (!newViewportAdded))
    return;
 
  // For each viewport
  newViewportAdded = false;
  OgreViewportList::iterator iOgreViewportList = ogreViewportList.begin();
  while (iOgreViewportList != ogreViewportList.end())
  {
    for(int i=0; i<SO3_DEFERRED_COUNT; ++i)
    {
      if(i == mode)
      {
        iOgreViewportList->second->gBufferCompositors[i]->setEnabled(true);
      }
      else
      {
        iOgreViewportList->second->gBufferCompositors[i]->setEnabled(false);
      }
    }
 
    // Activate ssao
    if(iOgreViewportList->first->GetSSAOEnable())
      iOgreViewportList->second->ssaoCompositor->setEnabled(mode == SO3_DEFERRED_SHOWLIT);
 
    iOgreViewportList++;
  }
  currentMode = mode;
}
 
void SDeferredShading::SetSSAO(SViewPort* existingViewport, bool ssao)
{
  OgreViewportList::iterator iOgreViewportList = ogreViewportList.find(existingViewport);
  if (iOgreViewportList != ogreViewportList.end())
  {
    if (currentMode == SO3_DEFERRED_SHOWLIT)
    {
      iOgreViewportList->second->ssaoCompositor->setEnabled(ssao);
    }
  }
}
 
void SDeferredShading::SetAntiAliasing(SViewPort* existingViewport, SDeferredShading::DeferredShadingAntiAliasingMode newMode)
{
  OgreViewportList::iterator iOgreViewportList = ogreViewportList.find(existingViewport);
  if (iOgreViewportList != ogreViewportList.end())
  {
    for(int i=1; i<=SO3_DEFERRED_AA_COUNT; ++i)
    {
      if(i == newMode)
      {
        iOgreViewportList->second->antiAliasingCompositors[i - 1]->setEnabled(true);
      }
      else
      {
        iOgreViewportList->second->antiAliasingCompositors[i - 1]->setEnabled(false);
      }
    }
  }
}
 
SDeferredShading::DeferredShadingMode SDeferredShading::GetMode() const
{
        return currentMode;
}
 
SGBuffer* SDeferredShading::GetGBuffer()
{
  return currentGBuffer;
}
 
SGBufferMaterialGenerator* SDeferredShading::GetGBufferMaterialGenerator()
{
  return gbufferMaterialGenerator;
}
 
}