Файл PPERequestPlatformsBase.c

См. исходные тексты.

Структуры данных
class	PPERequesterBase

Функции
class PPERequesterBase	GetCategoryMask ()
	mask for mass-handling methods like 'StopAllEffects'
void	PPERequesterBase (int requester_IDX)
void	SetRequesterUpdating (bool state)
	Has to be set for the requester to be handled.
void	Start (Param par=null)
void	Stop (Param par=null)
bool	IsRequesterRunning ()
void	SetRequesterIDX (int idx)
	automatically assigned by PPERequesterBank
int	GetRequesterIDX ()
	Returns requester index.
void	SetTargetValueBool (int mat_id, int param_idx, bool val, int priority_layer, int operator=PPOperators.SET)
void	SetTargetValueBoolDefault (int mat_id, int param_idx)
void	SetTargetValueInt (int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator=PPOperators.SET)
void	SetTargetValueIntDefault (int mat_id, int param_idx)
void	SetTargetValueFloat (int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator=PPOperators.ADD_RELATIVE)
void	SetTargetValueFloatDefault (int mat_id, int param_idx)
void	SetTargetValueColor (int mat_id, int param_idx, ref array< float > val, int priority_layer, int operator=PPOperators.ADD_RELATIVE)
void	SetTargetValueColorDefault (int mat_id, int param_idx)
void	QueueValuesSend ()
	Sets this requester to update in the manager.
PPERequestParamDataBase	GetRequestData (int mat_id, int param_idx, int type)
	returns request data for specific parameter, or creates one if one does not exist in this request yet (singletons)
PPERequestParamDataBase	PrepareData (int mat_id, int param_idx, int type)
map< int, ref map< int, ref PPERequestParamDataBase > >	GetActiveRequestStructure ()
void	ClearRequesterData ()
void	SendCurrentValueData (PPERequestParamDataBase data)
void	OnUpdate (float delta)
void	OnStart (Param par=null)
void	OnStop (Param par=null)
	automatically resets all material parameters of this requester to defaults
float	RelativizeValue (float value, int var_type, int mat_id, int param_id, bool relative)
	converts all values used to relative values (if not relative already)
void	SetDefaultValuesAll ()
	Sets all requested values to default, ignoring them in further calculations.
void	DbgPrnt (string text)

Переменные
bool	m_IsRunning
bool	m_ValuesSent
int	m_IDX
bool	m_Valid = false
ref map< int, ref map< int, ref PPERequestParamDataBase > >	m_RequestDataStructure

Функции

ClearRequesterData()

void ClearRequesterData ( )

protected

DbgPrnt()

void DbgPrnt ( string text )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

GetActiveRequestStructure()

map< int, ref map< int, ref PPERequestParamDataBase > > GetActiveRequestStructure ( )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

GetCategoryMask()

int GetCategoryMask

(

)

mask for mass-handling methods like 'StopAllEffects'

    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }

GetRequestData()

PPERequestParamDataBase GetRequestData ( int mat_id, int param_idx, int type )

protected

returns request data for specific parameter, or creates one if one does not exist in this request yet (singletons)

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

GetRequesterIDX()

int GetRequesterIDX ( )

protected

Returns requester index.

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

IsRequesterRunning()

bool IsRequesterRunning ( )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

OnStart()

void OnStart ( Param par = null )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в TimerBase::Run().

OnStop()

void OnStop ( Param par = null )

protected

automatically resets all material parameters of this requester to defaults

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

OnUpdate()

void OnUpdate ( float delta )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

PPERequesterBase()

void PPERequesterBase ( int requester_IDX )

protected

    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

PrepareData()

PPERequestParamDataBase PrepareData ( int mat_id, int param_idx, int type )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

QueueValuesSend()

void QueueValuesSend ( )

protected

Sets this requester to update in the manager.

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

RelativizeValue()

float RelativizeValue ( float value, int var_type, int mat_id, int param_id, bool relative )

protected

converts all values used to relative values (if not relative already)

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

SendCurrentValueData()

void SendCurrentValueData ( PPERequestParamDataBase data )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

SetDefaultValuesAll()

void SetDefaultValuesAll ( )

protected

Sets all requested values to default, ignoring them in further calculations.

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

SetRequesterIDX()

void SetRequesterIDX ( int idx )

protected

automatically assigned by PPERequesterBank

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

SetRequesterUpdating()

void SetRequesterUpdating ( bool state )

protected

Has to be set for the requester to be handled.

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в PPERequester_GameplayBase::OnUpdate().

SetTargetValueBool()

void SetTargetValueBool ( int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в PPERequester_GameplayBase::SetValuesIronsights().

SetTargetValueBoolDefault()

void SetTargetValueBoolDefault ( int mat_id, int param_idx )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в PPERequester_GameplayBase::SetValuesOptics().

SetTargetValueColor()

void SetTargetValueColor ( int mat_id, int param_idx, ref array< float > val, int priority_layer, int operator = PPOperators.ADD_RELATIVE )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в PPERequester_GameplayBase::OnStart(), PPERequester_GameplayBase::OnUpdate(), PPERequester_GameplayBase::ProcessSimulation(), PPERequester_GameplayBase::SetEffectProgress(), PPERequester_GameplayBase::SetFlashbangIntensity(), PPERequester_GameplayBase::SetHitIntensity(), PPERequester_GameplayBase::SetNVMode() и PPERequester_MenuBase::SetVignetteIntensity().

SetTargetValueColorDefault()

void SetTargetValueColorDefault ( int mat_id, int param_idx )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

SetTargetValueFloat()

void SetTargetValueFloat ( int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в PPERequester_GameplayBase::OnStart(), PPERequester_MenuBase::OnStart(), PPERequester_GameplayBase::OnUpdate(), PPERequester_GameplayBase::ProcessSimulation(), PPERequester_GameplayBase::SetBloodLossLevel(), PPERequester_MenuBase::SetBlurIntensity(), PPERequester_GameplayBase::SetEffectProgress(), PPERequester_GameplayBase::SetEyeAccommodation(), PPERequester_GameplayBase::SetFeverIntensity(), PPERequester_GameplayBase::SetFlashbangIntensity(), PPERequester_GameplayBase::SetHitIntensity(), PPERequester_GameplayBase::SetNVMode(), PPERequester_GameplayBase::SetRadialBlur(), PPERequester_GameplayBase::SetValuesIronsights(), PPERequester_GameplayBase::SetValuesOptics() и PPERequester_MenuBase::SetVignetteIntensity().

SetTargetValueFloatDefault()

void SetTargetValueFloatDefault ( int mat_id, int param_idx )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Используется в PPERequester_GameplayBase::SetNVMode() и PPERequester_GameplayBase::SetValuesIronsights().

SetTargetValueInt()

void SetTargetValueInt ( int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

SetTargetValueIntDefault()

void SetTargetValueIntDefault ( int mat_id, int param_idx )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Start()

void Start ( Param par = null )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Stop()

void Stop ( Param par = null )

protected

{
    protected bool m_IsRunning; //helps determine if the requester has been stopped or not
    protected bool m_ValuesSent;
    protected int m_IDX;
    
    protected bool m_Valid = false;
    
    protected ref map<int,ref map<int,ref PPERequestParamDataBase>> m_RequestDataStructure; // <material<param_id,data>> // parameter data objects are singletons
    
    void PPERequesterBase(int requester_IDX)
    {
        m_Valid = PPERequesterBank.VerifyRequester(this);
        
        m_IDX = requester_IDX;
        m_ValuesSent = true;
        m_IsRunning = false;
        m_RequestDataStructure = new map<int,ref map<int,ref PPERequestParamDataBase>>;
    }
    
    void SetRequesterUpdating(bool state)
    {
        if (!m_Valid)
        {
            Debug.Log("" + this + " not valid!");
            return;
        }
        
        PPEManagerStatic.GetPPEManager().SetRequestUpdating(this,state);
        
        //TODO - separate into its own function?
        if (state)
            PPEManagerStatic.GetPPEManager().SetRequestActive(this,true);
    }
    
    void Start(Param par = null)
    {
        OnStart(par);
        m_IsRunning = true;
    }
    
    void Stop(Param par = null)
    {
        if (!m_RequestDataStructure || m_RequestDataStructure.Count() <= 0)
            return;
        
        OnStop(par);
        m_IsRunning = false;
    }
    
    bool IsRequesterRunning()
    {
        return m_IsRunning;
    }
    
    void SetRequesterIDX(int idx)
    {
        m_IDX = idx;
    }
    
    int GetRequesterIDX()
    {
        return m_IDX;
    }
    
    int GetCategoryMask()
    {
        return PPERequesterCategory.NONE;
    }
    
    //SETTERS//
    //vvvvvvv//
    protected void SetTargetValueBool(int mat_id, int param_idx, bool val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_BoolTarget = val;
        data.m_BoolLast = data.m_BoolCurrent;
        
        if (data.m_BoolTarget != data.m_BoolCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBool | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueBoolDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataBool data = PPERequestParamDataBool.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_BOOL));
        data.m_BoolLast = data.m_BoolCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueBoolDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueInt(int mat_id, int param_idx, bool relative, int val, int priority_layer, int operator = PPOperators.SET)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_IntTarget = val;
        data.m_IntLast = data.m_IntCurrent;
        if (data.m_IntTarget != data.m_IntCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueInt | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueIntDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataInt data = PPERequestParamDataInt.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_INT));
        data.m_IntLast = data.m_IntCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueIntDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloat(int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatTarget = RelativizeValue(val,PPEConstants.VAR_TYPE_FLOAT,mat_id,param_idx,relative);
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (data.m_FloatTarget != data.m_FloatCurrent || data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloat | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueFloatDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataFloat data = PPERequestParamDataFloat.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_FLOAT));
        data.m_FloatFormerTarget = data.m_FloatTarget;
        data.m_FloatLast = data.m_FloatCurrent;
        data.m_FloatStart = data.m_FloatCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueFloatDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColor(int mat_id, int param_idx, ref array<float> val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
        if ( !m_RequestDataStructure )
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.SetPriorityLayer(priority_layer);
        data.SetInteractionMask(operator);
        data.m_ColorFormerTarget = data.m_ColorTarget;
        
        data.m_ColorTarget.Copy(val);
        
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        //if (data.m_ColorTarget != data.m_ColorCurrent)
        {
            data.SetSettingDefaultValues(false);
            data.SetDataActive(true);
                    
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColor | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    protected void SetTargetValueColorDefault(int mat_id, int param_idx)
    {
        //TODO - running check and cleanup rework (elsewhere!)
        if ( !m_RequestDataStructure || !m_RequestDataStructure.Get(mat_id) || !m_RequestDataStructure.Get(mat_id).Get(param_idx))
            return;
        
        PPERequestParamDataColor data = PPERequestParamDataColor.Cast(GetRequestData(mat_id,param_idx,PPEConstants.VAR_TYPE_COLOR));
        data.m_ColorFormerTarget = data.m_ColorTarget;
        data.m_ColorLast = data.m_ColorCurrent;
        data.m_ColorStart = data.m_ColorCurrent;
        if (!data.IsSettingDefaultValues())
        {
            data.SetSettingDefaultValues(true);
            
            QueueValuesSend();
        }
        //DbgPrnt("PPEDebug | PPERequesterBase - SetTargetValueColorDefault | mat/par/req: " + mat_id + "/" + param_idx + "/" + m_IDX + " | data: " + data);
    }
    
    /*protected void SetTargetValueVector(int mat_id, int param_idx, bool relative, vector val, int priority_layer, int operator = PPOperators.ADD_RELATIVE)
    {
    }
    
    void SetTargetValueTexture(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    /*void SetTargetValueResource(int mat_id, int param_idx, string val, int priority_layer, int mask, bool override_priority = false)
    {
    }*/
    
    protected void QueueValuesSend()
    {
        m_ValuesSent = false;
        //m_IsRunning = true;
        SetRequesterUpdating(true);
    }
    
    PPERequestParamDataBase GetRequestData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        if ( m_RequestDataStructure.Get(mat_id) )
        {
            if (m_RequestDataStructure.Get(mat_id).Get(param_idx))
            {
                data = m_RequestDataStructure.Get(mat_id).Get(param_idx);
            }
            else
            {
                data = PrepareData(mat_id,param_idx,type);
                m_RequestDataStructure.Get(mat_id).Set(param_idx,data);
            }
        }
        else
        {
            data = PrepareData(mat_id,param_idx,type);
            map<int,ref PPERequestParamDataBase> temp_map = new map<int,ref PPERequestParamDataBase>;
            temp_map.Set(param_idx,data);
            m_RequestDataStructure.Set(mat_id, temp_map);
        }
        
        if (!data)
        {
            Error("GetRequestData | no data found in the structure");
        }
        
        data.m_Requester = this;
        
        return data;
    }
    
    protected PPERequestParamDataBase PrepareData(int mat_id, int param_idx, int type)
    {
        PPERequestParamDataBase data;
        switch (type)
        {
            case PPEConstants.VAR_TYPE_BOOL:
                data = new PPERequestParamDataBool(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_INT:
                data = new PPERequestParamDataInt(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_FLOAT:
                data = new PPERequestParamDataFloat(m_IDX, mat_id, param_idx);
            break;
            
            case PPEConstants.VAR_TYPE_COLOR:
                data = new PPERequestParamDataColor(m_IDX, mat_id, param_idx);
            break;
        }
        return data;
    }
    
    // unused?
    map<int,ref map<int,ref PPERequestParamDataBase>> GetActiveRequestStructure()
    {
        return m_RequestDataStructure;
    }
    
    protected void ClearRequesterData()
    {
        m_RequestDataStructure.Clear();
    }
    
    protected void SendCurrentValueData(PPERequestParamDataBase data)
    {
        PPEManagerStatic.GetPPEManager().SendMaterialValueData(data);
    }
    
    //EVENTS//
    //vvvvvv//
    void OnUpdate(float delta)
    {
        //DbgPrnt("PPEDebug | PPERequesterBase | OnUpdate");
        
        if ( !m_ValuesSent )
        {
            for (int i = 0; i < m_RequestDataStructure.Count(); i++)
            {
                for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
                {
                    SendCurrentValueData(m_RequestDataStructure.GetElement(i).GetElement(j)); //map<int,ref map<int,PPERequestParamDataBase>> //<material<param,data>>
                }
            }
            m_ValuesSent = true;
        }
        SetRequesterUpdating(false);
    }
    
    protected void OnStart(Param par = null)
    {
        SetRequesterUpdating(true);
    }
    
    protected void OnStop(Param par = null)
    {
        //DbgPrnt("PPEDebug | " + this + " | OnStop");
        SetRequesterUpdating(true);
        SetDefaultValuesAll();
    }
    
    protected float RelativizeValue(float value, int var_type, int mat_id, int param_id, bool relative)
    {
        float ret = value;
        if (!relative) //if not already relative...
        {
            switch (var_type)
            {
                case PPEConstants.VAR_TYPE_FLOAT:
                    PPETemplateDefFloat p_float = PPETemplateDefFloat.Cast(PPEManagerStatic.GetPPEManager().GetPostProcessDefaultValues(mat_id,param_id));
                    ret = Math.InverseLerp(p_float.param3, p_float.param4, ret);
                    ret = Math.Clamp(ret,0.0,1.0);
                break;
            }
        }
        //Print("RelativizeValue: " + ret);
        
        return ret;
    }
    
    protected void SetDefaultValuesAll()
    {
        //<material<param_id,data>>
        PPERequestParamDataBase req_data;
        
        for (int i = 0; i < m_RequestDataStructure.Count(); i++)
        {
            for (int j = 0; j < m_RequestDataStructure.GetElement(i).Count(); j++)
            {
                req_data = m_RequestDataStructure.GetElement(i).GetElement(j);
                
                if (!req_data.IsDataActive())
                    continue;
                
                switch (req_data.GetVarType())
                {
                    case PPEConstants.VAR_TYPE_BOOL:
                        SetTargetValueBoolDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_INT:
                        SetTargetValueIntDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_FLOAT:
                        SetTargetValueFloatDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                    
                    case PPEConstants.VAR_TYPE_COLOR:
                        SetTargetValueColorDefault(req_data.GetMaterialID(),req_data.GetParameterID());
                    break;
                }
            }
        }
    }
    
    void DbgPrnt(string text)
    {
        //Debug.Log(""+text);
    }
}
 
//                          Base requester platforms                                //
 
class PPERequester_GameplayBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.GAMEPLAY_EFFECTS;
    }
}
 
class PPERequester_MenuBase extends PPERequesterBase
{
    override int GetCategoryMask()
    {
        return PPERequesterCategory.MENU_EFFECTS;
    }
}

Переменные

m_IDX

int m_IDX

protected

m_IsRunning

bool m_IsRunning

protected

Используется в PPERequester_GameplayBase::OnStart(), PPERequester_GameplayBase::OnUpdate(), PPERequester_GameplayBase::SetUndergroundExposureCoef(), Managed::StartRunningDrops(), Managed::StopIndicator() и Managed::Update().

m_RequestDataStructure

ref map<int,ref map<int,ref PPERequestParamDataBase> > m_RequestDataStructure

protected

m_Valid

bool m_Valid = false

protected

m_ValuesSent

bool m_ValuesSent

protected