F:/My Projects/LSEngine/Modules/LSGraphicsLib/Src/Fnd/LSGFnd.h

#ifndef __LSG_FND_H__
#define __LSG_FND_H__

#include "../LSGGraphicsLib.h"
#include "LSGFndBase.h"

namespace lsg {

#ifdef LSG_OGL
        typedef COpenGl                                                                                         CBaseApi;
#elif defined( LSG_OGLES )
        typedef COpenGlEs                                                                                       CBaseApi;
#elif defined( LSG_DX9 )
        typedef CDirectX9                                                                                       CBaseApi;
#elif defined( LSG_DX10 )
        typedef CDirectX10                                                                                      CBaseApi;
#elif defined( LSG_DX11 )
        typedef CDirectX11                                                                                      CBaseApi;
#endif  // #ifdef LSG_OGL

        class CIndexBuffer;
        class CPostProcessor;
        class CRenderTargetManager;
        class CShader;
        class CVertexBuffer;

        class CFnd {
        public :
                // == Functions.
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // SCREEN
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSVOID LSE_FCALL                                              AssertError();

                static LSVOID LSE_CALL                                                                  ApplyDefaultStates();

                static LSE_INLINE LSVOID LSE_FCALL                                              Present();

                static LSE_INLINE const CFndBase::LSG_METRICS LSE_CALL  GetMetrics();

                static LSE_INLINE CRenderTargetManager * LSE_CALL               RenderTargetMan();

                static LSE_INLINE CPostProcessor * LSE_CALL                             PostProcessor();

                static LSE_INLINE LSVOID LSE_FCALL                                              Clear( LSUINT32 _ui32Mask );

                static LSE_INLINE LSVOID LSE_FCALL                                              ClearAll();

                static LSE_INLINE LSVOID LSE_CALL                                               SetClearColor( LSREAL _fR, LSREAL _fG, LSREAL _fB, LSREAL _fA );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetClearDepth( LSREAL _fValue );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetViewport( LSINT32 _i32X, LSINT32 _i32Y, LSINT32 _i32Width, LSINT32 _i32Height );

                static LSE_INLINE LSVOID LSE_CALL                                               SaveViewPort();

                static LSE_INLINE LSVOID LSE_CALL                                               RestoreViewPort();

                static LSE_INLINE LSVOID LSE_CALL                                               SetFlipVertical( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetDepthTest( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetDepthFunc( LSG_DEPTH_TEST _dtFunc );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetDepthWrite( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetCulling( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetCullMode( LSG_CULL_MODES _cmMode );

                static LSE_INLINE LSG_CULL_MODES LSE_CALL                               GetCullMode();

                static LSE_INLINE LSG_CULL_MODES LSE_CALL                               GetReverseCullMode( LSG_CULL_MODES _cmMode );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetBlendEnabled( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetBlendFunc( LSG_BLEND_MODES _bmSrc, LSG_BLEND_MODES _bmDst );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetFillMode( LSG_FILL_MODES _fmMode );

                static LSE_INLINE LSBOOL LSE_FCALL                                              BeginRender();

                static LSE_INLINE LSVOID LSE_FCALL                                              EndRender();

                static LSE_INLINE LSVOID LSE_FCALL                                              SetScreenSize( LSUINT32 _ui32Width, LSUINT32 _ui32Height );

                static LSE_INLINE LSUINT32 LSE_CALL                                             GetScreenWidth();

                static LSE_INLINE LSUINT32 LSE_CALL                                             GetScreenHeight();



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // MATRICES
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSVOID LSE_FCALL                                              SetWorldMatrix( const CMatrix4x4 &_mMat );

                static LSE_INLINE const CMatrix4x4 & LSE_FCALL                  GetWorldMatrix();

                static LSE_INLINE LSVOID LSE_FCALL                                              SetViewMatrix( const CMatrix4x4 &_mMat );

                static LSE_INLINE const CMatrix4x4 & LSE_FCALL                  GetViewMatrix();

                static LSE_INLINE LSVOID LSE_FCALL                                              SetProjMatrix( const CMatrix4x4 &_mMat );

                static LSE_INLINE const CMatrix4x4 & LSE_FCALL                  GetProjMatrix();

                static LSE_INLINE CMatrix4x4 LSE_CALL                                   OffsetOrtho( LSREAL _fLeft, LSREAL _fRight,
                        LSREAL _fBottom, LSREAL _fTop, LSREAL _fNear, LSREAL _fFar );



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // MATERIALS
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSVOID LSE_FCALL                                              SetDiffuseMaterial( const CVector4 &_vColor );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetAmbientMaterial( const CVector4 &_vColor );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetEmissiveMaterial( const CVector4 &_vColor );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetSpecularMaterial( const CVector4 &_vColor );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetMaterialPower( LSREAL _fPower );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetRoughness( LSREAL _fValue );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetReflectivity( LSREAL _fValue );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetAnisotropy( LSREAL _fX, LSREAL _fY );



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // LIGHTS
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSVOID LSE_FCALL                                              DisableLight( LSUINT32 _ui32Slot );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetDirectionalLight( LSUINT32 _ui32Slot,
                        const CVector3 &_vDir, const CVector3 &_vDiffuse = CVector3( LSM_ONE, LSM_ONE, LSM_ONE ), const CVector3 &_vAmbient = CVector3( LSM_ZERO, LSM_ZERO, LSM_ZERO ), const CVector3 &_vSpecular = CVector3( LSM_ONE, LSM_ONE, LSM_ONE ) );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetHemisphereGroundColor( const CVector3 &_vColor );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetHemisphereSkyColor( const CVector3 &_vColor );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetHemisphereLighting( LSBOOL _bVal );

                static LSE_INLINE LSBOOL LSE_FCALL                                              GetHemisphereLighting();

                static LSE_INLINE LSBOOL LSE_FCALL                                              AnyLightsActive();

                static LSE_INLINE LSVOID LSE_FCALL                                              SetShadowMapActive( LSBOOL _bVal );

                static LSE_INLINE LSBOOL LSE_CALL                                               GetShadowMapActive();

                static LSE_INLINE const CMatrix4x4 & LSE_CALL                   GetShadowMapMatrix();

                static LSE_INLINE LSVOID LSE_CALL                                               SetShadowMapMatrix( const CMatrix4x4 &_mMat );

                static LSE_INLINE LSVOID LSE_CALL                                               SetShadowMapUVDepthFactors( LSREAL _fU, LSREAL _fV, LSREAL _fDepth );

                static LSE_INLINE LSVOID LSE_CALL                                               SetShadowMapCasterSize( LSREAL _fSize );

                static LSE_INLINE LSVOID LSE_CALL                                               SetGaussian( LSFLOAT _fVal );

                static LSE_INLINE LSFLOAT LSE_CALL                                              GetGaussian();

                static LSE_INLINE LSVOID LSE_CALL                                               SetExposure( LSFLOAT _fVal );

                static LSE_INLINE LSFLOAT LSE_CALL                                              GetExposure();

                static LSE_INLINE LSVOID LSE_CALL                                               SetBrightCutoff( LSFLOAT _fVal );

                static LSE_INLINE LSFLOAT LSE_CALL                                              GetBrightCutoff();

                static LSE_INLINE LSVOID LSE_CALL                                               SetTimeSinceLastRender( LSFLOAT _fVal );

                static LSE_INLINE LSFLOAT LSE_CALL                                              GetTimeSinceLastRender();



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // SHADERS
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSVOID LSE_FCALL                                              SetShader( CShader * _psShader );

                static LSE_INLINE CShader * LSE_FCALL                                   GetShader();

                static LSVOID LSE_FCALL                                                                 Render( LSUINT32 _ui32TotalPrimitives, const CIndexBuffer * _pibIndexBuffer = NULL );

                static LSE_INLINE LSVOID LSE_FCALL                                              SetMakeDepthCopy( LSBOOL _bVal );

                static LSE_INLINE LSBOOL LSE_CALL                                               GetMakeDepthCopy();

                static LSE_INLINE LSVOID LSE_FCALL                                              SetMakeNormalCopy( LSBOOL _bVal );

                static LSE_INLINE LSBOOL LSE_CALL                                               GetMakeNormalCopy();



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // METRICS
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSBOOL LSE_CALL                                               NonPo2();



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // STATISTICS
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSUINT64 LSE_CALL                                             GetTrianglesDrawn();

                static LSE_INLINE LSVOID LSE_CALL                                               ClearTriangles();



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // POST PROCESSING
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE CVertexBuffer * LSE_CALL                              GetPostProcVertBuf();

                static LSBOOL LSE_CALL                                                                  PreparePostProcess( LSUINT32 _ui32Width, LSUINT32 _ui32Height );


        protected :
                // == Members.
                static LSUINT64                                                                                 m_ui64TrianglesDrawn;
                

                // == Functions.
                static LSVOID LSE_CALL                                                                  ApplyLightsToCurrentShader();

        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
        LSE_INLINE LSVOID LSE_FCALL CFnd::AssertError() {
                CBaseApi::AssertError();
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::Present() {
                CBaseApi::Present();
        }

        LSE_INLINE const CFndBase::LSG_METRICS LSE_CALL CFnd::GetMetrics() {
                return CFndBase::m_mMetrics;
        }

        LSE_INLINE CRenderTargetManager * LSE_CALL CFnd::RenderTargetMan() {
                return CFndBase::m_prtmRenderTargetMan;
        }

        LSE_INLINE CPostProcessor * LSE_CALL CFnd::PostProcessor() {
                return CFndBase::m_pppPostProcessor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::Clear( LSUINT32 _ui32Mask ) {
                CBaseApi::Clear( _ui32Mask );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::ClearAll() {
                CBaseApi::ClearAll();
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetClearColor( LSREAL _fR, LSREAL _fG, LSREAL _fB, LSREAL _fA ) {
                CBaseApi::SetClearColor( _fR, _fG, _fB, _fA );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetClearDepth( LSREAL _fValue ) {
                CBaseApi::SetClearDepth( _fValue );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetViewport( LSINT32 _i32X, LSINT32 _i32Y, LSINT32 _i32Width, LSINT32 _i32Height ) {
                CFndBase::m_i32ViewportX = _i32X;
                CFndBase::m_i32ViewportY = _i32Y;
                CFndBase::m_i32ViewportWidth = _i32Width;
                CFndBase::m_i32ViewportHeight = _i32Height;
                CBaseApi::SetViewport( _i32X, _i32Y, _i32Width, _i32Height );
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SaveViewPort() {
                if ( CFndBase::m_ui32ViewStoreCount++ == 0UL ) {
                        CFndBase::m_i32LastViewportX = CFndBase::m_i32ViewportX;
                        CFndBase::m_i32LastViewportY = CFndBase::m_i32ViewportY;
                        CFndBase::m_i32LastViewportWidth = CFndBase::m_i32ViewportWidth;
                        CFndBase::m_i32LastViewportHeight = CFndBase::m_i32ViewportHeight;
                }
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::RestoreViewPort() {
                CFndBase::m_ui32ViewStoreCount = 0UL;
                SetViewport( CFndBase::m_i32LastViewportX, CFndBase::m_i32LastViewportY, CFndBase::m_i32LastViewportWidth, CFndBase::m_i32LastViewportHeight );
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetFlipVertical( LSBOOL _bVal ) {
                if ( CFndBase::m_bFlipRender == !_bVal ) {
                        CFndBase::m_bProjDirty = true;
                        CFndBase::m_bFlipRender = _bVal != false;
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetDepthTest( LSBOOL _bVal ) {
                CBaseApi::SetDepthTest( _bVal );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetDepthFunc( LSG_DEPTH_TEST _dtFunc ) {
                CBaseApi::SetDepthFunc( _dtFunc );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetDepthWrite( LSBOOL _bVal ) {
                CBaseApi::SetDepthWrite( _bVal );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetCulling( LSBOOL _bVal ) {
                CBaseApi::SetCulling( _bVal );
        }

        LSE_INLINE LSG_CULL_MODES LSE_CALL CFnd::GetCullMode() {
                return CBaseApi::GetCullMode();
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetCullMode( LSG_CULL_MODES _cmMode ) {
                CBaseApi::SetCullMode( _cmMode );
        }

        LSE_INLINE LSG_CULL_MODES LSE_CALL CFnd::GetReverseCullMode( LSG_CULL_MODES _cmMode ) {
                static const LSG_CULL_MODES cmModes[] = {
                        LSG_CM_CCW,
                        LSG_CM_CW
                };
                return cmModes[_cmMode];
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetBlendEnabled( LSBOOL _bVal ) {
                CBaseApi::SetBlendEnabled( _bVal );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetBlendFunc( LSG_BLEND_MODES _bmSrc, LSG_BLEND_MODES _bmDst ) {
                CBaseApi::SetBlendFunc( _bmSrc, _bmDst );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetFillMode( LSG_FILL_MODES _fmMode ) {
                if ( CFndBase::m_fmFillMode != _fmMode ) {
                        CFndBase::m_fmFillMode = _fmMode;
                        CBaseApi::SetFillMode( _fmMode );
                }
        }

        LSE_INLINE LSBOOL LSE_FCALL CFnd::BeginRender() {
                return CBaseApi::BeginRender();
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::EndRender() {
                CBaseApi::EndRender();
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetScreenSize( LSUINT32 _ui32Width, LSUINT32 _ui32Height ) {
                CFndBase::m_ui32ScreenWidth = _ui32Width;
                CFndBase::m_ui32ScreenHeight = _ui32Height;
#ifdef LSG_DX9
                CDirectX9::SetScreenSize( _ui32Width, _ui32Height );
#endif  // #ifdef LSG_DX9
        }

        LSE_INLINE LSUINT32 LSE_CALL CFnd::GetScreenWidth() {
                return CFndBase::m_ui32ScreenWidth;
        }

        LSE_INLINE LSUINT32 LSE_CALL CFnd::GetScreenHeight() {
                return CFndBase::m_ui32ScreenHeight;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetWorldMatrix( const CMatrix4x4 &_mMat ) {
                CFndBase::m_mWorldMatrix = _mMat;
                CFndBase::m_bWorldDirty = true;
        }

        LSE_INLINE const CMatrix4x4 & LSE_FCALL CFnd::GetWorldMatrix() {
                return CFndBase::m_mWorldMatrix;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetViewMatrix( const CMatrix4x4 &_mMat ) {
                CFndBase::m_mViewMatrix = _mMat;
                CFndBase::m_bViewDirty = true;
        }

        LSE_INLINE const CMatrix4x4 & LSE_FCALL CFnd::GetViewMatrix() {
                return CFndBase::m_mViewMatrix;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetProjMatrix( const CMatrix4x4 &_mMat ) {
                CFndBase::m_mProjMatrix = _mMat;
                CFndBase::m_bProjDirty = true;
        }

        LSE_INLINE const CMatrix4x4 & LSE_FCALL CFnd::GetProjMatrix() {
                return CFndBase::m_mProjMatrix;
        }

        LSE_INLINE CMatrix4x4 LSE_CALL CFnd::OffsetOrtho( LSREAL _fLeft, LSREAL _fRight,
                LSREAL _fBottom, LSREAL _fTop, LSREAL _fNear, LSREAL _fFar ) {
                return CBaseApi::OffsetOrtho( _fLeft, _fRight,
                        _fBottom, _fTop, _fNear, _fFar );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetDiffuseMaterial( const CVector4 &_vColor ) {
                CFndBase::m_vDiffuseMaterial = _vColor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetAmbientMaterial( const CVector4 &_vColor ) {
                CFndBase::m_vAmbientMaterial = _vColor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetEmissiveMaterial( const CVector4 &_vColor ) {
                CFndBase::m_vEmissiveMaterial = _vColor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetSpecularMaterial( const CVector4 &_vColor ) {
                CFndBase::m_vSpecularMaterial = _vColor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetMaterialPower( LSREAL _fPower ) {
                CFndBase::m_fPower = _fPower;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetRoughness( LSREAL _fValue ) {
                CFndBase::m_vRoughness.x = CStd::Max( _fValue, LSM_FLT_EPSILON );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetReflectivity( LSREAL _fValue ) {
                CFndBase::m_vRoughness.y = _fValue;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetAnisotropy( LSREAL _fX, LSREAL _fY ) {
                CFndBase::m_vAnisotropic.x = _fX;
                CFndBase::m_vAnisotropic.y = _fY;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::DisableLight( LSUINT32 _ui32Slot ) {
                assert( _ui32Slot < LSG_MAX_LIGHTS );
                CFndBase::m_lLights[_ui32Slot].ltType = LSG_LT_NONE;
                if ( _ui32Slot + 1UL == CFndBase::m_ui32MaxLight ) {
                        for ( LSUINT32 I = _ui32Slot; I--; ) {
                                if ( CFndBase::m_lLights[_ui32Slot].ltType != LSG_LT_NONE ) {
                                        CFndBase::m_ui32MaxLight = I + 1UL;
                                        return;
                                }
                        }
                        CFndBase::m_ui32MaxLight = 0UL;
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetDirectionalLight( LSUINT32 _ui32Slot,
                const CVector3 &_vDir, const CVector3 &_vDiffuse, const CVector3 &_vAmbient, const CVector3 &_vSpecular ) {
                assert( _ui32Slot < LSG_MAX_LIGHTS );
                CFndBase::m_lLights[_ui32Slot].ltType = LSG_LT_DIR;
                CFndBase::m_lLights[_ui32Slot].vDir = _vDir;
                CFndBase::m_lLights[_ui32Slot].vDir.Normalize();
                CFndBase::m_lLights[_ui32Slot].vDiffuse = _vDiffuse;
                CFndBase::m_lLights[_ui32Slot].vAmbient = _vAmbient;
                CFndBase::m_lLights[_ui32Slot].vSpecular = _vSpecular;
                CFndBase::m_ui32MaxLight = CStd::Max<LSUINT32>( CFndBase::m_ui32MaxLight, _ui32Slot + 1UL );
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetHemisphereGroundColor( const CVector3 &_vColor ) {
                CFndBase::m_vGroundColor = _vColor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetHemisphereSkyColor( const CVector3 &_vColor ) {
                CFndBase::m_vSkyColor = _vColor;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetHemisphereLighting( LSBOOL _bVal ) {
                CFndBase::m_bHemisphere = _bVal;
        }

        LSE_INLINE LSBOOL LSE_FCALL CFnd::GetHemisphereLighting() {
                return CFndBase::m_bHemisphere;
        }

        LSE_INLINE LSBOOL LSE_FCALL CFnd::AnyLightsActive() {
                return CFndBase::m_ui32MaxLight != 0UL;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetShadowMapActive( LSBOOL _bVal ) {
                CFndBase::m_bShadowMapActive = _bVal;
        }

        LSE_INLINE LSBOOL LSE_CALL CFnd::GetShadowMapActive() {
                return CFndBase::m_bShadowMapActive;
        }

        LSE_INLINE const CMatrix4x4 & LSE_CALL CFnd::GetShadowMapMatrix() {
                return CFndBase::m_mShadowMapMatrix;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetShadowMapMatrix( const CMatrix4x4 &_mMat ) {
                CFndBase::m_mShadowMapMatrix = _mMat;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetShadowMapUVDepthFactors( LSREAL _fU, LSREAL _fV, LSREAL _fDepth ) {
                CFndBase::m_vShadowMapUVDepth = CVector3( _fU, _fV, _fDepth );
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetShadowMapCasterSize( LSREAL _fSize ) {
                CFndBase::m_fShadowMapCasterSize = _fSize;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetGaussian( LSFLOAT _fVal ) {
                CFndBase::m_fGaussian = _fVal;
        }

        LSE_INLINE LSFLOAT LSE_CALL CFnd::GetGaussian() {
                return CFndBase::m_fGaussian;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetExposure( LSFLOAT _fVal ) {
                CFndBase::m_fExposure = _fVal;
        }

        LSE_INLINE LSFLOAT LSE_CALL CFnd::GetExposure() {
                return CFndBase::m_fExposure;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetBrightCutoff( LSFLOAT _fVal ) {
                CFndBase::m_fBrightCutoff = _fVal;
        }

        LSE_INLINE LSFLOAT LSE_CALL CFnd::GetBrightCutoff() {
                return CFndBase::m_fBrightCutoff;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::SetTimeSinceLastRender( LSFLOAT _fVal ) {
                CFndBase::m_fTimeSinceLastFrame = _fVal;
        }

        LSE_INLINE LSFLOAT LSE_CALL CFnd::GetTimeSinceLastRender() {
                return CFndBase::m_fTimeSinceLastFrame;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetShader( CShader * _psShader ) {
                CBaseApi::SetShader( _psShader );
        }

        LSE_INLINE CShader * LSE_FCALL CFnd::GetShader() {
                return CBaseApi::GetShader();
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetMakeDepthCopy( LSBOOL _bVal ) {
                if ( GetMetrics().ui32MaxRenderTargets > 1UL ) {
                        CFndBase::m_bMakeDepthCopy = _bVal;
                }
        }

        LSE_INLINE LSBOOL LSE_CALL CFnd::GetMakeDepthCopy() {
                return CFndBase::m_bMakeDepthCopy;
        }

        LSE_INLINE LSVOID LSE_FCALL CFnd::SetMakeNormalCopy( LSBOOL _bVal ) {
                if ( GetMetrics().ui32MaxRenderTargets > 1UL ) {
                        CFndBase::m_bMakeNormalCopy = _bVal;
                }
        }

        LSE_INLINE LSBOOL LSE_CALL CFnd::GetMakeNormalCopy() {
                return CFndBase::m_bMakeNormalCopy;
        }

        LSE_INLINE LSBOOL LSE_CALL CFnd::NonPo2() {
                return CBaseApi::NonPo2();
        }

        LSE_INLINE LSUINT64 LSE_CALL CFnd::GetTrianglesDrawn() {
                return m_ui64TrianglesDrawn;
        }

        LSE_INLINE LSVOID LSE_CALL CFnd::ClearTriangles() {
                m_ui64TrianglesDrawn = 0ULL;
        }

        LSE_INLINE CVertexBuffer * LSE_CALL CFnd::GetPostProcVertBuf() {
                return CFndBase::GetPostProcVertBuf();
        }

}       // namespace lsg

#endif  // __LSG_FND_H__