SO3DeferredShading.h

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
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3_DEFERRED_SHADING_H__
#define __SO3_DEFERRED_SHADING_H__
 
 
#include "SO3DeferredShadowManager.h"
#include "SO3GBuffer.h"
#include "SO3DeferredCompositorGBuffer.h"
#include "SO3DeferredCompositorLighting.h"
#include "SO3DeferredCompositorShowDepth.h"
#include "SO3DeferredCompositorShowDiffuse.h"
#include "SO3DeferredCompositorShowEmissive.h"
#include "SO3DeferredCompositorShowMaterialID.h"
#include "SO3DeferredCompositorShowNormal.h"
#include "SO3DeferredCompositorShowSpecular.h"
#include "SO3DeferredCompositorShowVelocity.h"
#include "SO3DeferredCompositorSSAO.h"
#include "SO3DeferredCompositorSSAA.h"
#include "SO3DeferredCompositorNFAA.h"
#include "SO3DeferredLightManager.h"
#include "SO3GBufferMaterialGenerator.h"
#include "OgreCompositorInstance.h"
#include "OgreSceneManager.h"
#include "OgreSceneNode.h"
#include "OgreMaterial.h"
#include "OgreRenderTargetListener.h"
 
namespace SO3
{
 
class SDeferredShading : public Ogre::Singleton<SDeferredShading>
{
public:
  enum DeferredShadingMode
  {
    SO3_DEFERRED_SHOWLIT        = 0, 
    SO3_DEFERRED_SHOWCOLOUR     = 1, 
    SO3_DEFERRED_SHOWNORMALS    = 2, 
    SO3_DEFERRED_SHOWDEPTH      = 3, 
    SO3_DEFERRED_SHOWSPECULAR   = 4, 
    SO3_DEFERRED_SHOWEMISSIVE   = 5, 
    SO3_DEFERRED_SHOWVELOCITY   = 6, 
    SO3_DEFERRED_SHOWMATERIALID = 7,
    SO3_DEFERRED_COUNT          = 8
        };
 
  // References about most of the techniques listed here can be found here: http://iryoku.com/aacourse/
  enum DeferredShadingAntiAliasingMode
  {
    SO3_DEFERRED_AA_NONE        = 0, // No AA
    SO3_DEFERRED_SSAA           = 1, // Warning, SSAA means Screen Space AA, not Super Sampling AA (although it a super sampling derivated technique!).
    SO3_DEFERRED_NFAA           = 2, // Normal Filter AA.
    // SO3_DEFERRED_FXAA -> http://timothylottes.blogspot.com/2011/07/fxaa-311-released.html
    SO3_DEFERRED_AA_COUNT       = 2
  };
 
protected:
  typedef Ogre::CompositorInstance* GBufferCompositors[SO3_DEFERRED_COUNT];
  typedef Ogre::CompositorInstance* AntiAliasingCompositors[SO3_DEFERRED_AA_COUNT];
  struct GBufferFilters
  {
    Ogre::CompositorInstance* gBufferInstance;
    GBufferCompositors gBufferCompositors;
    Ogre::CompositorInstance* ssaoCompositor;
    AntiAliasingCompositors antiAliasingCompositors;
  };
 
  typedef std::map<SViewPort*, GBufferFilters*> OgreViewportList;
  OgreViewportList ogreViewportList;
  DeferredShadingMode currentMode;
private:
  bool newViewportAdded;
  SDeferredShadowManager* deferredShadowManager;
  SGBuffer* currentGBuffer;
  typedef std::map<std::string, SGBuffer*> AvailableGBufferMap;
  AvailableGBufferMap availableGBufferMap;
  SDeferredCompositorGBuffer* compositorGBuffer;
  SDeferredCompositorLighting* compositorLighting;
  SDeferredCompositorShowDepth* compositorShowDepth;
  SDeferredCompositorShowDiffuse* compositorShowDiffuse;
  SDeferredCompositorShowEmissive* compositorShowEmissive;
  SDeferredCompositorShowMaterialID* compositorShowMaterialID;
  SDeferredCompositorShowNormal* compositorShowNormal;
  SDeferredCompositorShowSpecular* compositorShowSpecular;
  SDeferredCompositorShowVelocity* compositorShowVelocity;
  SDeferredCompositorSSAO* compositorSSAO;
  SDeferredCompositorSSAA* compositorSSAA;
  SDeferredCompositorNFAA* compositorNFAA;
  SDeferredLightManager* deferredLightManager;
  Ogre::MaterialManager::Listener* gBufferSchemeHandler;
  Ogre::MaterialManager::Listener* noGBufferSchemeHandler;
  Ogre::CompositorLogic* ssaoCompositorLogic;
  Ogre::CustomCompositionPass* deferredLightCompositionPass;
  SGBufferMaterialGenerator* gbufferMaterialGenerator;
 
public:
  SDeferredShading();
        
  ~SDeferredShading();
 
  static SDeferredShading& getSingleton();
 
  static SDeferredShading* getSingletonPtr();
 
  static const Ogre::uint8 PRE_GBUFFER_RENDER_QUEUE;
        
  static const Ogre::uint8 POST_GBUFFER_RENDER_QUEUE;
          
  void RegisterViewport(SViewPort* targetViewport);
                
  void UnregisterViewport(SViewPort* existingViewport);
 
  void UnregisterAllViewports();
 
  void SetSSAO(SViewPort* existingViewport, bool ssao);
 
  void SetAntiAliasing(SViewPort* existingViewport, DeferredShadingAntiAliasingMode newMode);
 
  void SetMode(DeferredShadingMode mode);
 
  DeferredShadingMode GetMode() const;
 
  SGBuffer* GetGBuffer();
 
  SGBufferMaterialGenerator* GetGBufferMaterialGenerator();
protected:
private:
};
 
}
 
#endif