SO3SsaoHandler.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_SSAO_HANDLER_H__
#define __SO3_SSAO_HANDLER_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
 
namespace SO3
{
 
class SSsaoHandler : public Ogre::MaterialManager::Listener //, Ogre::RenderTargetListener
{
public:
  enum SsaoTechnique
  {
    SO3_SSAO_TECHNIQUE_NONE = -1,
    SO3_SSAO_TECHNIQUE_CRYTEK = 0,
    SO3_SSAO_TECHNIQUE_HEMISPHERIC = 1,
    SO3_SSAO_TECHNIQUE_CREASE_SHADING = 2,
    SO3_SSAO_TECHNIQUE_MAX = 3
  };
  enum SsaoFilter
  {
    SO3_SSAO_FILTER_NONE,
    SO3_SSAO_FILTER_BOX,
    SO3_SSAO_FILTER_BOX_SMART,
    SO3_SSAO_FILTER_MAX
  };
  enum SsaoDebugMode
  {
    SO3_SSAO_DEBUG_MODE_NONE,
    SO3_SSAO_DEBUG_MODE_DEPTH,
    SO3_SSAO_DEBUG_MODE_NORMAL,
    SO3_SSAO_DEBUG_MODE_POSITION,
    SO3_SSAO_DEBUG_MODE_SSAO_ONLY,
    SO3_SSAO_DEBUG_MODE_MAX
  };
  typedef std::pair<float, float> SsaoTechniqueParameterRange;
  struct SsaoTechniqueParameter
  {
    const std::string displayName;
    const SsaoTechniqueParameterRange range;
    float value;
    SsaoTechniqueParameter(const std::string& parameterDisplayName, const SsaoTechniqueParameterRange& parameterRange, const float& parameterValue) : displayName(parameterDisplayName),
                                                                                                                                                      range(parameterRange)
    {
      value = parameterValue;
    }
  };
  typedef std::map<std::string, SsaoTechniqueParameter> SsaoTechniqueParameters;
 
  static void Reset();
protected:
private:
  enum SsaoGBufferLayout
  {
    SO3_SSAO_GBUFFER_NONE,
    SO3_SSAO_GBUFFER_DEPTH_ONLY,
    SO3_SSAO_GBUFFER_NORMAL_POSITION,
    SO3_SSAO_GBUFFER_MAX
  };
 
  static bool compositorCreated;
  bool isEnable;
  bool isSupported;
  SViewPort* targetViewport;
  Ogre::String targetViewportScheme;
  Ogre::CompositorManager* ogreCompositorManager;
  Ogre::MaterialManager* ogreMaterialManager;
  Ogre::GpuProgramManager* ogreProgramManager;
 
  Ogre::CompositorInstance* inputCompositorInstance;
  Ogre::CompositorInstance* normalCompositorInstance;
  Ogre::MaterialPtr normalPositionMaterial;
  Ogre::MaterialPtr normalPositionAlphaRejectionMaterial;
  Ogre::MaterialPtr normalPositionMaterialTransparent;
  Ogre::MaterialPtr crytekSsaoMaterial;
  Ogre::MaterialPtr hemisphericSsaoMaterial;
  Ogre::MaterialPtr creaseShadingSsaoMaterial;
  Ogre::GpuProgramPtr ssaoRenderQuadVp;
  Ogre::GpuProgramPtr ssaoDepthDebugCompositorFp;
  Ogre::GpuProgramPtr normalPositionGeneratorVp;
  Ogre::GpuProgramPtr normalPositionGeneratorFp;
  Ogre::GpuProgramPtr normalPositionAlphaRejectionGeneratorVp;
  Ogre::GpuProgramPtr normalPositionAlphaRejectionGeneratorFp;
  Ogre::GpuProgramPtr ssaoNormalDebugCompositorFp;
  Ogre::GpuProgramPtr ssaoPositionDebugCompositorFp;
  Ogre::GpuProgramPtr ssaoDepth2DebugCompositorFp;
  Ogre::GpuProgramPtr ssaoCrytekCompositorFp;
  Ogre::GpuProgramPtr ssaoHemiCompositorFp;
  Ogre::GpuProgramPtr ssaoCreaseCompositorFp;
  Ogre::GpuProgramPtr filterBoxCompositorFp;
  Ogre::GpuProgramPtr filterBoxSmartCompositorFp;
  Ogre::GpuProgramPtr filterBoxSmart2CompositorFp;
  Ogre::GpuProgramPtr ssaoDebugCompositorFp;
  Ogre::GpuProgramPtr ssaoMergingCompositorFp;
  
  SsaoGBufferLayout currentSsaoGbufferLayout;
  SsaoTechnique currentSsaoTechnique;
  SsaoFilter currentSsaoFilter;
  SsaoDebugMode currentSsaoDebugMode;
  typedef std::map<SsaoTechnique, SsaoTechniqueParameters> SsaoTechniqueParametersByTechnique;
  static SsaoTechniqueParametersByTechnique ssaoTechniquesParameters;
  bool mSupportGbuffer;
 
public:
  SSsaoHandler(SViewPort* targetViewportInstance);
 
  ~SSsaoHandler();
 
  bool GetEnable();
 
  void SetEnable(bool enable);
 
  SsaoTechnique GetTechnique();
 
  void SetTechnique(SsaoTechnique newTechnique);
 
  SsaoFilter GetFilter();
 
  void SetFilter(const SsaoFilter& newFilter);
 
  SsaoDebugMode GetDebugMode();
 
  void SetDebugMode(const SsaoDebugMode& newDebugMode);
 
  float GetTechniqueParameterValue(const SsaoTechnique& technique, const std::string& parameterName) const;
 
  void SetTechniqueParameterValue(const SsaoTechnique& technique, const std::string& parameterName, const float& parameterValue);
 
  SsaoTechniqueParameters GetTechniqueParameters(const SsaoTechnique& technique) const;
 
  void SetTechniqueParameters(const SsaoTechnique& technique, const SsaoTechniqueParameters& parameters);
 
  virtual Ogre::Technique* handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend);
 
  /*
  virtual void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
  virtual void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
  */
private:
  SSsaoHandler();
 
  Ogre::GpuProgramPtr createGpuProgram(const Ogre::String &Name, const bool& fragment, const Ogre::String& Data);
 
  void GenerateRenderQuadVertexShader();
 
  void CreateCompositors();
 
  void GenerateSsaoCompositor();
 
  void GenerateDepthDebugCompositor();
 
  void GenerateNormalPositionCompositor();
 
  void GenerateNormalDebugCompositor();
 
  void GenerateViewPositionDebugCompositor();
 
  void GenerateDepthDebugCompositor2();
 
  void GenerateSsaoCrytekCompositor();
 
  void GenerateSsaoHemisphericCompositor();
 
  void GenerateSsaoCreaseShadingCompositor();
 
  void GenerateFilterBoxCompositor();
 
  void GenerateFilterBoxSmartCompositor();
 
  void GenerateFilterBoxSmartCompositor2();
 
  void GenerateSsaoDebugCompositor();
 
  void GenerateMergingCompositor();
 
  SsaoGBufferLayout GetGBufferLayout(const SsaoTechnique& technique);
};
 
}
 
#endif