ParameterBlock.h

#pragma once

#include <string>
#include <vector>
#include <list>

namespace ParaEngine
{
    using namespace std;
    struct TextureEntity;
    class CEffectFile;

    class CParameter
    {
    public:
        typedef TextureEntity* LPTextureEntity;

        enum PARAMETER_TYPE{
            PARAM_UNKNOWN,
            PARAM_INT,
            PARAM_FLOAT, 
            PARAM_BOOLEAN,
            PARAM_VECTOR2,
            PARAM_VECTOR3,
            PARAM_VECTOR4,
            PARAM_MATRIX,
            PARAM_RAWBYTES,
            PARAM_TEXTURE_ENTITY,
            PARAM_LAST,
        };

        CParameter() : m_type(PARAM_UNKNOWN){};
        CParameter(const string& sName):m_sName(sName), m_type(PARAM_UNKNOWN){};
        ~CParameter(){};

        string m_sName;
        vector<char> m_data;
        PARAMETER_TYPE m_type;

        const string& GetTypeAsString();
        PARAMETER_TYPE SetTypeByString(const char* sType);
        bool SetValueByString(const char* value, int nType = -1);

        string GetValueByString();

        const string& GetName() const {return m_sName;};
        void SetName(const string& sName) {m_sName = sName;};

        char* GetRawData() { return &(m_data[0]); };

        int GetRawDataLength() { return (int)(m_data.size());};

        void SetRawData(const char* data, int nSize){m_data.resize(nSize); memcpy(&(m_data[0]), data, nSize);};

        operator int() {return *((int*)GetRawData());};
        operator bool();
        operator DWORD() {return *((DWORD*)GetRawData());};
        operator float() {return *((float*)GetRawData());};
        operator Vector2() {return *((Vector2*)GetRawData());};
        operator Vector3() {return *((Vector3*)GetRawData());};
        operator Vector4() {return *((Vector4*)GetRawData());};
        operator Matrix4() {return *((Matrix4*)GetRawData());};
        operator LPTextureEntity() {return *((LPTextureEntity*)GetRawData());};

        //CParameter& operator =(const CParameter& r){m_data = r.m_data;};
        CParameter& operator =(const int& r) { m_type=PARAM_INT; m_data.resize(sizeof(int)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};
        CParameter& operator =(const bool& r) { m_type=PARAM_BOOLEAN;m_data.resize(sizeof(BOOL)); BOOL p = r; memcpy(GetRawData(), &p, (int)m_data.size()); return *this;};
        CParameter& operator =(const float& r) { m_type=PARAM_FLOAT;m_data.resize(sizeof(float)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};

        CParameter& operator =(const Vector2& r) { m_type=PARAM_VECTOR2;m_data.resize(sizeof(Vector2)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};
        CParameter& operator =(const Vector3& r) { m_type=PARAM_VECTOR3;m_data.resize(sizeof(Vector3)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};
        CParameter& operator =(const Vector4& r) { m_type=PARAM_VECTOR4;m_data.resize(sizeof(Vector4)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};
        CParameter& operator =(const Matrix4& r) { m_type=PARAM_MATRIX;m_data.resize(sizeof(Matrix4)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};
        CParameter& operator =(const LPTextureEntity& r) { m_type=PARAM_TEXTURE_ENTITY;m_data.resize(sizeof(LPTextureEntity)); memcpy(GetRawData(), &r, (int)m_data.size()); return *this;};

    };

    class CParameterBlock
    {
    public:
        typedef map <string, CParameter>::iterator ParamIterator;
        map <string, CParameter> m_params;

        ParamIterator BeginIter() { return m_params.begin();};
        ParamIterator EndIter() { return m_params.end();};
        bool IsEmpty() { return m_params.empty();};

        template <class t>
        void SetParameter(const string& sName, const t& value)
        {
            map <string, CParameter>::iterator it = m_params.find(sName);
            if(it!=m_params.end())
            {
                it->second = value;
            }
            else
            {
                CParameter p(sName);
                p = value;
                m_params[sName] = p;
            }
        }

        bool AddParameter(const CParameter& p);

        CParameter* GetParameter(const string& sName)
        {
            map <string, CParameter>::iterator it = m_params.find(sName);
            if(it!=m_params.end())
            {
                return &(it->second);
            }
            else
            {
                return NULL;
            }
        }

        void SetParamByStringValue(const char* sParamName, const char* sValue_);

        // clear all parameters
        void Clear()
        {
            m_params.clear();
        }

        bool ApplyToEffect( CEffectFile* pEffectFile );
    };

    class CApplyObjectLevelParamBlock
    {
    private:
        CApplyObjectLevelParamBlock(){};
    public:
        CApplyObjectLevelParamBlock(CParameterBlock* pBlock);
        ~CApplyObjectLevelParamBlock();

        CParameterBlock* GetParamsBlock();
    private:
        CParameterBlock* m_pBlock;
        bool m_bLastZEnabled;
    };
}