effect_file_OpenGL.h

#pragma once
#include "effect_file.h"
#include "ParameterBlock.h"
#include "gleffects.h"
#include <unordered_map>

namespace GLWrapper{
    class GLProgram;
    struct Uniform;
}

namespace ParaEngine
{
    

    class CEffectFileOpenGL : public CEffectFileBase
    {
    public:
        CEffectFileOpenGL(const char* filename);
        CEffectFileOpenGL(const AssetKey& key);

        void Init();

        virtual  ~CEffectFileOpenGL();

        virtual HRESULT RendererRecreated();
        
    public:
        static void EnableTextures(bool bEnable);
        static bool AreTextureEnabled();

        int totalPasses()const;

        void EnableSunLight(bool bEnableSunLight);
        void applySurfaceMaterial(const ParaMaterial* pSurfaceMaterial, bool bUseGlobalAmbient = true);
        void applyCameraMatrices();
        void applyWorldMatrices();
        void applyFogParameters(bool bEnableFog, const Vector4* fogParam, const LinearColor* fogColor);
        void applyGlobalLightingData(CSunLight& sunlight);

        bool setParameter(eParameterHandles index, const void* data, int32 size = D3DX_DEFAULT);
        bool setParameter(eParameterHandles index, const Vector2* data);
        bool setParameter(eParameterHandles index, const Vector3* data);
        bool setParameter(eParameterHandles index, const Vector4* data);

        bool setBool(eParameterHandles index, BOOL bBoolean);
        bool setInt(eParameterHandles index, int nValue);
        bool setFloat(eParameterHandles index, float fValue);

        HRESULT SetRawValue(const char* hParameter, const void* pData, uint32 ByteOffset, uint32 Bytes);
        bool SetBool(const char* hParameter, BOOL bBoolean);
        bool SetInt(const char* hParameter, int nValue);
        bool SetFloat(const char* hParameter, float fValue);
        bool SetVector2(const char* hParameter, const Vector2& vValue);
        bool SetVector3(const char* hParameter, const Vector3& vValue);
        bool SetVector4(const char* hParameter, const Vector4& vValue);
        bool SetMatrix(const char* hParameter, const Matrix4& data);

        bool isParameterUsed(eParameterHandles index);
        bool setMatrix(eParameterHandles index, const Matrix4* data);
        bool isMatrixUsed(eParameterHandles index);

        bool setTexture(int index, TextureEntity* data);
        bool setTexture(int index, DeviceTexturePtr_type pTex);

        bool SetBoolean(int nIndex, bool value);

        bool begin(bool bApplyParam = true, DWORD flag = 0);
        bool BeginPass(int pass, bool bForceBegin = false);
        void CommitChanges();
        void EndPass(bool bForceEnd = false);
        void end(bool bForceEnd = false);

        virtual HRESULT InitDeviceObjects();

        bool LoadBuildinShader();

        virtual HRESULT DeleteDeviceObjects();
        void releaseEffect(int nTech = -1, int nPass = -1);

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

        bool EnableEnvironmentMapping(bool bEnable);
        bool EnableReflectionMapping(bool bEnable, float fSurfaceHeight = 0.f);

        void SetReflectFactor(float fFactor);
        void EnableNormalMap(bool bEnable);

        void EnableLightMap(bool bEnable);

        void EnableAlphaBlending(bool bAlphaBlending);
        void EnableAlphaTesting(bool bAlphaTesting);
    

        bool SetFirstValidTechniqueByCategory(TechniqueCategory nCat);
        bool SetTechniqueByIndex(int nIndex);
        const TechniqueDesc* GetCurrentTechniqueDesc();

    public:
        bool setParameter(GLWrapper::Uniform* uniform, const void* data, int32 size = D3DX_DEFAULT);

        GLWrapper::GLProgram* GetGLProgram(int nTech, int nPass, bool bCreateIfNotExist = false);
        
        bool initWithByteArrays(const char* vShaderByteArray, const char* fShaderByteArray, int nTech = 0, int nPass = 0);

        bool initWithFilenames(const std::string& vShaderFilename, const std::string& fShaderFilename, int nTech = 0, int nPass = 0);

        bool link(int nTech = 0, int nPass = 0);
        bool use(int nTech = -1, int nPass = -1);
        void updateUniforms(int nTech = -1, int nPass = -1);
        
        GLWrapper::Uniform* GetUniformByID(eParameterHandles id);
        GLWrapper::Uniform* GetUniform(const std::string& sName);
        
        template <typename ValueType>
        void AddParamChange(const std::string& sName, const ValueType& value)
        {
            for (uint32 i = 0; i < m_pendingChangesCount; ++i)
            {
                if (m_pendingChanges[i].GetName() == sName)
                {
                    m_pendingChanges[i] = value;
                    return;
                }
            }
            ++ m_pendingChangesCount;
            if (m_pendingChanges.size() < m_pendingChangesCount)
                m_pendingChanges.resize(m_pendingChangesCount + 4);
            m_pendingChanges[m_pendingChangesCount - 1].SetName(sName);
            m_pendingChanges[m_pendingChangesCount - 1] = value;
        }

        void SetShadowMapSize(int nsize);

    protected:
        bool MappingEffectUniforms();
        bool GeneratePasses();

    protected:
        std::unordered_map<uint32, std::string> m_ID2Names;
        GLEffectsTree* m_Effect;

        struct TechniqueDescGL : public TechniqueDesc
        {
            std::vector<GLWrapper::GLProgram*> mPasses;
        };
        std::vector<TechniqueDescGL> mTechniques;
        int mTechniqueIndex;
        int m_nActivePassIndex;
        bool m_bIsBegin;
        std::string m_filename;
        
        std::vector<CParameter> m_pendingChanges;
        uint32 m_pendingChangesCount;
    };

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