SO3ShadowCSM.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 __SO3SHADOW_CSM_H__
#define __SO3SHADOW_CSM_H__
 
#include "SO3Renderer/SO3Shadow.h"
 
namespace SO3
{
 
/* CSM Camera Setup from Matthew Paul Reid sample code
   https://bitbucket.org/ScaleRender/ogrecascadedshadows/downloads
*/
class CSMGpuConstants : public Ogre::Singleton<CSMGpuConstants>
{
public:
        CSMGpuConstants();
  virtual ~CSMGpuConstants();
        void updateCascade(const Ogre::Camera &texCam, size_t index);
 
        static CSMGpuConstants& getSingleton();
 
        /*
        @copydoc Ogre::Singleton::getSingletonPtr
        */
        static CSMGpuConstants* getSingletonPtr();
private:
        Ogre::GpuSharedParametersPtr mParamsScaleBias;
        Ogre::GpuSharedParametersPtr mParamsShadowMatrix;
 
        Ogre::Matrix4 mFirstCascadeViewMatrix;
        Ogre::Real mFirstCascadeCamWidth;
        Ogre::Real mViewRange;
  Ogre::Matrix4 hack;
  size_t mCascadeCount;
};
 
class CSMGpuConstants;
 
class StableCSMShadowCameraSetup : public Ogre::LiSPSMShadowCameraSetup
{
public:
        typedef std::vector<Ogre::Real> SplitPointList;
 
public:
  StableCSMShadowCameraSetup(Ogre::SceneManager* ogreScene, CSMGpuConstants* constants);
        ~StableCSMShadowCameraSetup();
 
        void calculateSplitPoints(size_t cascadeCount, Ogre::Real firstSplitDist, Ogre::Real farDist, Ogre::Real lambda = 0.95);
 
        void setSplitPoints(const SplitPointList& newSplitPoints);
 
        void setSplitPadding(Ogre::Real pad) { mSplitPadding = pad; }
 
        Ogre::Real getSplitPadding() const { return mSplitPadding; }
        size_t getCascadeCount() const { return mCascadeCount; }
 
        virtual void getShadowCamera(const Ogre::SceneManager *sm, const Ogre::Camera *cam,
                const Ogre::Viewport *vp, const Ogre::Light *light, Ogre::Camera *texCam, size_t iteration) const;
 
        inline const SplitPointList& getSplitPoints() const
        { return mSplitPoints; }
 
protected:
        void getShadowCameraForCascade(const Ogre::SceneManager *sm, const Ogre::Camera *cam,
                const Ogre::Viewport *vp, const Ogre::Light *light, Ogre::Camera *texCam, size_t iteration,
                Ogre::Real nearSplit, Ogre::Real farSplit) const;
 
protected:
        size_t mCascadeCount;
        SplitPointList mSplitPoints;
        Ogre::Real mSplitPadding;
 
        mutable size_t mCurrentIteration;
 
private:
        CSMGpuConstants* mGpuConstants;
 
};
 
class SShadowViewportCSM : public SShadowViewport, Ogre::MaterialManager::Listener
{
public:
protected:
private:
  Ogre::TexturePtr mSpTexture;
  Ogre::RenderTexture* mSpRenderTexture;
  Ogre::Viewport* mSpViewport;
 
  Ogre::Overlay* mDebugOverlay;
  Ogre::OverlayContainer* mDebugOverlayPanel;
  Ogre::MaterialPtr mOverlayMaterial;
public:
  SShadowViewportCSM(Ogre::Viewport* viewport);
 
  ~SShadowViewportCSM();
 
  virtual void UpdateCamera(Ogre::Camera* cam);
 
  virtual Ogre::Technique* handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend);
protected:
private:
};
 
class SShadowCSM : public SShadow
{
public:
protected:
private:
 
public:
  static bool CheckSystemCompatibility();
 
  SShadowCSM(SShadowManager* sManager);
 
  ~SShadowCSM();
protected:
  virtual void UpdateShadowTechnique();
 
  virtual void UpdateShadowMaterial(Ogre::Technique* tech);
 
  virtual void RemoveMaterialPass(Ogre::Technique* tech);
 
  virtual bool IsShadowMaterialPass(Ogre::Pass* pass);
private:
  SShadowCSM();
 
  void CreateMaterialsPass();
 
  void CleanMaterials();
};
 
}
 
#endif