EffectManager.h

#pragma once

#include "AssetManager.h"
#include "effect_file.h"
#include "LightManager.h"

namespace ParaEngine
{
    class CBaseObject;
    class CShadowMap;
    class CGlowEffect;
    class IScene;
    class WaveEffect;
    
    class EffectManager: public AssetManager<CEffectFile>
    {
    public:
        EffectManager();
        ~EffectManager();

        CEffectFile* GetEffectByHandle(int nHandle);

        int GetEffectHandle(CEffectFile* effectFile);

        CEffectFile* GetEffectByName(const string& sName);

        CEffectFile* MapHandleToEffect(int nHandle, CEffectFile* pNewEffect);

        virtual bool DeleteEntity(AssetEntity* entity);
        virtual void InitDeviceObjects();
        virtual void DeleteDeviceObjects();
        virtual void RestoreDeviceObjects();
        virtual void InvalidateDeviceObjects();
        virtual void RendererRecreated();

        void Cleanup();

        CShadowMap* GetShadowMap();
        CGlowEffect* GetGlowEffect();

        bool BeginEffect(int nHandle, CEffectFile** pOutEffect = NULL);
        void EndEffect();
        CEffectFile* CheckLoadEffect(int nHandle);

        enum VERTEX_DECLARATION
        {
            S0_POS_TEX0, // all data in stream 0: position and tex0
            S0_POS_NORM_TEX0, // all data in stream 0: position, normal and tex0
            S0_POS_NORM_TEX0_INSTANCED, // all data in stream 0: position, normal and tex0, stream1:instanced data
            S0_POS_TEX0_COLOR, // all data in stream 0: position, tex0 and color
            S0_POS_NORM_TEX0_COLOR, // all data in stream 0: position, normal, tex0 and color
            S0_S1_S2_OCEAN_FFT, // for FFT ocean
            S0_S1_S2_S3_OCEAN_FFT, // for FFT ocean with terrain height field
            S0_POS_NORM_TEX0_TEX1, // all data in stream 0: position, normal tex0 and tex1
            S0_POS_TEX0_TEX1, // all data in stream 0: position, tex0 and tex1
            S0_S1_OCEAN_CLOUD, // stream 0: position; stream 1, height field
            S0_POS_COLOR, // all data in stream 0: position, and color
            S0_POS2_COLOR,  // all data in stream 0: homogeneous coordinates, and color
            S0_POS_NORM_COLOR, // all data in stream 0: position, normal, and color
            S0_POS_NORM_TEX0_COLOR0_COLOR1, // all data in stream 0: position, normal, tex0,color0 and color1
            S0_POS, // all data in stream 0: position
            MAX_DECLARATIONS_NUM,
        };


        VertexDeclarationPtr GetVertexDeclaration(int nIndex);
        HRESULT SetVertexDeclaration(int nIndex);

        void SetDefaultEffectMapping(int nLevel);
        int GetDefaultEffectMapping();

        enum EffectTechniques
        {
            EFFECT_DEFAULT = 0, 
            EFFECT_GEN_SHADOWMAP,
            EFFECT_RENDER_WITH_SHADOWMAP,
            EFFECT_FIXED_FUNCTION,
        };
        void SetAllEffectsTechnique(EffectTechniques nTech);
        EffectTechniques GetCurrentEffectTechniqueType();


        int GetCurrentTechHandle();
        CEffectFile* GetCurrentEffectFile();

        //
        // The following functions set or retrieve global effect states which are shared by all effect files.
        // They are designed to look like the fixed pipeline programming interface of DirectX9
        //
        
        HRESULT SetMaterial(ParaMaterial *pMaterial);
        HRESULT SetLight(DWORD Index, const Para3DLight *pLight);
        HRESULT LightEnable(DWORD Index, BOOL Enable);
        HRESULT SetRenderState(D3DRENDERSTATETYPE State, DWORD Value);
        HRESULT SetTexture(DWORD Stage, DeviceTexturePtr_type pTexture);
        HRESULT SetSamplerState(int nStage, DWORD dwType, DWORD dwValue, bool bForceSet = false);
        HRESULT GetSamplerState(int nStage, DWORD dwType, DWORD* pValue, bool bForceGet = false);
        void SetDefaultSamplerState(int nStage, DWORD dwType, DWORD dwValue);
        DWORD GetDefaultSamplerState(int nStage, DWORD dwType);

        HRESULT SetTransform(D3DTRANSFORMSTATETYPE State, const Matrix4 *pMatrix);
        HRESULT GetTransform(D3DTRANSFORMSTATETYPE State,Matrix4 * pMatrix);

        const Matrix4& GetWorldTransform();
        const Matrix4& GetViewTransform();
        const Matrix4& GetProjTransform();

        void UpdateD3DPipelineTransform(bool pWorld, bool pView,bool pProjection);

        void EnableFog(bool bEnabled);

        enum ClipPlaneState{
            ClipPlane_Disabled,
                ClipPlane_Enabled_WorldSpace,
                ClipPlane_Enabled_ClipSpace,
        };

        void EnableClipPlane(bool bEnable);

        void EnableClipPlaneImmediate(EffectManager::ClipPlaneState newState, int nIndex=0);
        bool IsClipPlaneEnabled();
        
        void SetClipPlane(DWORD Index,  const float * pPlane, bool bClipSpace);

        void applySurfaceMaterial(const ParaMaterial* pSurfaceMaterial, bool bUseGlobalAmbient = true);

        void applyLocalLightingData(const LightList* lights, int nLightNum);
        void applyLocalLightingData();
        
        void applyFogParameters();

        void applyObjectLocalLighting(CBaseObject* pObj);

        void EnableGlobalLighting(bool bEnable);
        bool IsGlobalLightingEnabled();

        void EnableLocalLighting(bool bEnable);
        bool IsLocalLightingEnabled();

        void  EnableUsingShadowMap(bool bEnable);
        bool IsUsingShadowMap();
        const Matrix4* GetTexViewProjMatrix();

        void EnableTextures(bool bEnable);
        bool AreTextureEnabled();

        void DisableD3DAlphaTesting(bool bDisable);

        bool IsD3DAlphaTestingDisabled();

        void DisableD3DCulling(bool bDisable);
        bool IsD3DCullingDisabled();

        void DisableZWrite(bool bDisable);
        bool IsZWriteDisabled();

        void EnableZWrite(bool bZWriteEnabled);

        void EnableD3DAlphaBlending(bool bEnable);

        void EnableZTest(bool bEnable, bool bForceSet = false);
        bool IsZTestEnabled();

        void SetCullingMode(DWORD dwCullMode);
        void SetCullingMode(bool bEnable);

        bool SetD3DFogState();

        bool IsUsingFullScreenGlow();

        void EnableFullScreenGlow( bool bEnable);

        inline bool IsReflectionRenderingEnabled(){return m_bEnableReflectionRendering;};
        inline void EnableReflectionRendering(bool bEnabled){m_bEnableReflectionRendering = bEnabled;};

        void SetGlowTechnique(int nTech);

        int GetGlowTechnique();
        
        void SetGlowness(const Vector4& Glowness);
        //change glowness type to vector4  --clayman 2011.7.19
        const Vector4& GetGlowness();

        WaveEffect* GetScreenWaveEffect();
        bool IsUsingScreenWaveEffect();
        void EnableScreenWaveEffect(bool enable);
        void SetScreenWaveTechnique(int nTech);
        int GetScreenWaveTechnique();
        
        void SetMaxLocalLightsNum(int nNum);

        int GetMaxLocalLightsNum();

        IScene * GetScene(){return m_pScene;}

        void SetScene(IScene * pScene){m_pScene = pScene;}

        bool IsCurrentEffectValid() { return m_bEffectValid; }

    private:
        // which scene object the effect manager is current serving
        IScene * m_pScene;

        ClipPlaneState GetClipPlaneState();
        bool BeginEffectFF(int nHandle);
        bool BeginEffectShader(int nHandle, CEffectFile** pOutEffect = NULL);

        map<int, CEffectFile*> m_HandleMap;
        int m_nCurrentEffect;
        CEffectFile* m_pCurrentEffect;

        bool m_bEffectValid;
        /*Matrix4 m_mWorld;
        Matrix4 m_mView;
        Matrix4 m_mProj;*/

        bool m_bEnableLocalLighting;
        bool m_bUseFog;
        bool m_bDisableD3DAlphaTesting;
        bool m_bDisableZWrite;
        bool m_bZEnable;
        bool m_bUsingShadowMap;
        bool m_bIsUsingFullScreenGlow;
        //-clayman 2011.7.18
        Vector4 m_colorGlowness;
        int m_nGlowTechnique;

        int m_screenWaveTechnique;

        int m_nMaxLocalLightsNum;
        
        bool m_bDisableD3DCulling;

        bool m_bEnableReflectionRendering;

        ClipPlaneState  m_ClipPlaneState;
        bool            m_bClipPlaneEnabled;
        static const int MaxClipPlanesNum = 3;
        Plane m_ClipPlaneWorldSpace[MaxClipPlanesNum];
        Plane m_ClipPlaneClipSpace[MaxClipPlanesNum];

        WaveEffect* m_pWaveEffect;
        bool m_enableScreenWaveEffect;

        int m_nEffectLevel;

        DWORD m_lastSamplerStates[8][16];
        DWORD m_defaultSamplerStates[8][16];
        
        VertexDeclarationPtr m_pVertexDeclarations[MAX_DECLARATIONS_NUM];
        int m_pVertexDeclarations_status[MAX_DECLARATIONS_NUM];

//#ifdef USE_DIRECTX_RENDERER
        CShadowMap* m_pShadowMap;
#ifdef USE_DIRECTX_RENDERER
        CGlowEffect* m_pGlowEffect;
#endif
    };
}