effect_file_DirectX.h

#pragma once
#include "effect_file.h"

namespace ParaEngine
{
    class CEffectFileDirectX : public CEffectFileBase
    {
    public:
        CEffectFileDirectX(const char* filename);
        CEffectFileDirectX(const AssetKey& key);
        virtual  ~CEffectFileDirectX();

        // Operators...
        // Mutators...
        virtual HRESULT InitDeviceObjects();
        virtual HRESULT RestoreDeviceObjects();
        virtual HRESULT InvalidateDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();

        bool loadResource(); // load the resource from a file (or NULL to use the resource name)
        bool saveResource(const char* filename=0);  // save the resource to a file (or NULL to use the resource name)

        void SetFileName(const std::string& filename);

        bool begin(bool bApplyParam = true, DWORD flag=D3DXFX_DONOTSAVESTATE|D3DXFX_DONOTSAVESAMPLERSTATE|D3DXFX_DONOTSAVESHADERSTATE, bool bForceBegin = false);
        bool BeginPass(int pass,bool bForceBegin = false);
        void CommitChanges();
        void EndPass(bool bForceEnd = false);
        void end(bool bForceEnd = false);
        void EnableShareMode(bool bEnable);
        bool IsInShareMode();

        bool BeginSharePassMode(bool bApplyParam = true, DWORD flag=D3DXFX_DONOTSAVESTATE|D3DXFX_DONOTSAVESAMPLERSTATE|D3DXFX_DONOTSAVESHADERSTATE, bool bForceBegin = true);
    
        void EndSharePassMode();

        void OnSwitchInShader();

        void OnSwitchOutShader();

        struct TechniqueDescDX : public TechniqueDesc
        {
            D3DXHANDLE hTechnique;
            D3DXTECHNIQUE_DESC techniqueDesc;
        public:
            TechniqueDescDX(){
                memset(this, 0, sizeof(TechniqueDescDX));
            }
        };

        bool SetFirstValidTechniqueByCategory(TechniqueCategory nCat);
        bool SetTechniqueByIndex(int nIndex);
        const TechniqueDesc* GetCurrentTechniqueDesc();
        int GetCurrentTechniqueIndex();
    
        // Accessors...
        LPD3DXEFFECT effect()const;
        int totalPasses()const;

        bool isParameterUsed(eParameterHandles index)const;
        bool isMatrixUsed(eParameterHandles index)const;
        bool isTextureUsed(int index)const;
        bool isTextureMatrixUsed(int index)const;
        bool isShadowTextureUsed()const;

        bool setParameter(eParameterHandles index, const void* data, INT32 size=D3DX_DEFAULT)const;
        bool setBool(eParameterHandles index, BOOL bBoolean) const;
        bool setInt(eParameterHandles index, int nValue) const;
        bool setFloat(eParameterHandles index, float fValue) const;
        bool setMatrix(eParameterHandles index, const Matrix4* data)const;
        bool setMatrixArray(eParameterHandles index, const Matrix4* data, UINT32 count)const;
        bool setMatrixInArray(eParameterHandles index, UINT32 element, const Matrix4* data)const;
        bool setFloatArray(eParameterHandles index, const float* data, UINT32 count)const;
        bool setVectorArray(eParameterHandles index,const Vector4* pVector,UINT count)const;
        bool setFloatInArray(eParameterHandles index, UINT32 element, float data)const;
        bool setTexture(int index, TextureEntity* data);
        bool setTexture(int index, LPDIRECT3DTEXTURE9 pTex);
        bool setTextureInternal(int index, LPDIRECT3DTEXTURE9 pTex);
        bool setTextureMatrix(int index, const Matrix4* data)const;
        //bool setShadowTexture(const TextureEntity* data)const;
        void SetShadowMapSize(int nsize);
        void SetShadowRadius(float fRadius);

        void applySurfaceMaterial(const ParaMaterial* pSurfaceMaterial, bool bUseGlobalAmbient = true);
        void applyCameraMatrices();
        void applyWorldMatrices();
        void applyGlobalLightingData(CSunLight& sunlight);
        void applyLocalLightingData(const LightList* lights, int nLightNum);
        void applyFogParameters(bool bEnableFog, const Vector4* fogParam, const LinearColor* fogColor);
        void applyLayersNum(int nLayers);
        void applyTexWorldViewProj(const Matrix4* mat);

        // texture alpha operation attribute
        void EnableAlphaBlending(bool bAlphaBlending);
        void EnableAlphaTesting(bool bAlphaTesting);
        void EnableSunLight(bool bEnableSunLight);
        static void EnableTextures(bool bEnable);
        static bool AreTextureEnabled();
        void EnableShadowmap(int nShadowMethod);

        bool SetBoolean(int nIndex, bool value);

        bool EnableEnvironmentMapping(bool bEnable);
        bool EnableReflectionMapping(bool bEnable, float fSurfaceHeight=0.f);
    
        void SetReflectFactor(float fFactor);
        void EnableNormalMap(bool bEnable);

        void EnableLightMap(bool bEnable);

        LPD3DXEFFECT GetDXEffect() {return m_pEffect;};

        virtual CParameterBlock* GetParamBlock(bool bCreateIfNotExist = false);

        void LockTexture(int nIndex);
        void UnLockTexture(int nIndex);

        bool IsTextureLocked(int nIndex) const;

        D3DXHANDLE& GetTextureHandle(int nIndex);

        HRESULT SetRawValue(D3DXHANDLE hParameter, LPCVOID pData, UINT ByteOffset, UINT Bytes);
        bool SetBool(D3DXHANDLE hParameter, BOOL bBoolean);
        bool SetInt(D3DXHANDLE hParameter, int nValue);
        bool SetFloat(D3DXHANDLE hParameter, float fValue);
        bool SetVector2(D3DXHANDLE hParameter, const Vector2& vValue);
        bool SetVector3(D3DXHANDLE hParameter, const Vector3& vValue);
        bool SetVector4(D3DXHANDLE hParameter, const Vector4& vValue);
        bool SetMatrix(D3DXHANDLE hParameter, const Matrix4& data);
    private:
        // effect file name
        string m_filename;
        // Data Types & Constants...
        static bool s_bUseHalfPrecision; // set to TRUE to use half-precision floats in all shaders

        // Private Data...
        LPD3DXEFFECT m_pEffect;
        D3DXEFFECT_DESC m_EffectDesc;
        vector<TechniqueDescDX> m_techniques;
        vector<bool> m_LockedTextures;
        vector<void*> m_LastTextures;

        // the current technique index
        int m_nTechniqueIndex;
        bool m_bIsBegin;
        bool m_bSharedMode;
        static bool g_bTextureEnabled;

        CParameterBlock m_SharedParamBlock;
    
        D3DXHANDLE m_paramHandle[k_max_param_handles];

        // Private Functions...
        void parseParameters();
        void releaseEffect();
        int BeginWith(LPCSTR str, LPCSTR searchStr);
        bool GetNumber(LPCSTR str, int nBeginIndex, int* pOut);
    };

    // this is the actually class used externally. it does following:
    // typedef CEffectFileDirectX CEffectFile;
    class CEffectFile : public CEffectFileDirectX
    {
    public:
        CEffectFile(const char* filename) :CEffectFileDirectX(filename){};
        CEffectFile(const AssetKey& key) :CEffectFileDirectX(key){};
        virtual  ~CEffectFile(){};
    };
}