PPERequestPlatformsBase.c File Reference

Go to the source code of this file.

Classes
class	PPERequesterBase

Functions
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)

Variables
bool	m_IsRunning
bool	m_ValuesSent
int	m_IDX
bool	m_Valid = false
ref map< int, ref map< int, ref PPERequestParamDataBase > >	m_RequestDataStructure

Function Documentation

ClearRequesterData()

void GetCategoryMask::ClearRequesterData ( )

protected

Definition at line 749 of file PPERequestPlatformsBase.c.

DbgPrnt()

void GetCategoryMask::DbgPrnt ( string text )

protected

Definition at line 849 of file PPERequestPlatformsBase.c.

{
  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 > > GetCategoryMask::GetActiveRequestStructure ( )

protected

Definition at line 744 of file PPERequestPlatformsBase.c.

{
  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'

Definition at line 1 of file PPERequestPlatformsBase.c.

  {
    return PPERequesterCategory.GAMEPLAY_EFFECTS;
  }

GetRequestData()

PPERequestParamDataBase GetCategoryMask::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)

Definition at line 690 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::GetRequesterIDX ( )

protected

Returns requester index.

Definition at line 494 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::IsRequesterRunning ( )

protected

Definition at line 482 of file PPERequestPlatformsBase.c.

{
  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

Definition at line 779 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Referenced by TimerBase::Run(), and Start().

OnStop()

void GetCategoryMask::OnStop ( Param par = null )

protected

automatically resets all material parameters of this requester to defaults

Definition at line 785 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::OnUpdate ( float delta )

protected

Definition at line 761 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::PPERequesterBase ( int requester_IDX )

protected

Definition at line 441 of file PPERequestPlatformsBase.c.

  {
    return PPERequesterCategory.MENU_EFFECTS;
  }
}

PrepareData()

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

protected

Definition at line 719 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::QueueValuesSend ( )

protected

Sets this requester to update in the manager.

Definition at line 682 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::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)

Definition at line 793 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::SendCurrentValueData ( PPERequestParamDataBase data )

protected

Definition at line 754 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::SetDefaultValuesAll ( )

protected

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

Definition at line 813 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::SetRequesterIDX ( int idx )

protected

automatically assigned by PPERequesterBank

Definition at line 488 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::SetRequesterUpdating ( bool state )

protected

Has to be set for the requester to be handled.

Definition at line 452 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

SetTargetValueBool()

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

protected

Definition at line 507 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Referenced by PPERequester_GameplayBase::SetValuesIronsights().

SetTargetValueBoolDefault()

void GetCategoryMask::SetTargetValueBoolDefault ( int mat_id, int param_idx )

protected

Definition at line 529 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Referenced by PPERequester_GameplayBase::SetValuesOptics().

SetTargetValueColor()

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

protected

Definition at line 626 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Referenced by PPERequester_GameplayBase::OnStart(), PPERequester_GameplayBase::OnUpdate(), PPERequester_GameplayBase::SetFlashbangIntensity(), PPERequester_GameplayBase::SetHitIntensity(), PPERequester_GameplayBase::SetNVMode(), and PPERequester_MenuBase::SetVignetteIntensity().

SetTargetValueColorDefault()

void GetCategoryMask::SetTargetValueColorDefault ( int mat_id, int param_idx )

protected

Definition at line 650 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::SetTargetValueFloat ( int mat_id, int param_idx, bool relative, float val, int priority_layer, int operator = PPOperators.ADD_RELATIVE )

protected

Definition at line 584 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Referenced by PPERequester_GameplayBase::OnStart(), PPERequester_MenuBase::OnStart(), PPERequester_GameplayBase::OnUpdate(), PPERequester_GameplayBase::SetBloodLossLevel(), PPERequester_MenuBase::SetBlurIntensity(), PPERequester_GameplayBase::SetEyeAccommodation(), PPERequester_GameplayBase::SetFeverIntensity(), PPERequester_GameplayBase::SetFlashbangIntensity(), PPERequester_GameplayBase::SetHitIntensity(), PPERequester_GameplayBase::SetNVMode(), PPERequester_GameplayBase::SetRadialBlur(), PPERequester_GameplayBase::SetValuesIronsights(), PPERequester_GameplayBase::SetValuesOptics(), and PPERequester_MenuBase::SetVignetteIntensity().

SetTargetValueFloatDefault()

void GetCategoryMask::SetTargetValueFloatDefault ( int mat_id, int param_idx )

protected

Definition at line 607 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Referenced by PPERequester_GameplayBase::SetNVMode(), and PPERequester_GameplayBase::SetValuesIronsights().

SetTargetValueInt()

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

protected

Definition at line 546 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::SetTargetValueIntDefault ( int mat_id, int param_idx )

protected

Definition at line 567 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::Start ( Param par = null )

protected

Definition at line 467 of file PPERequestPlatformsBase.c.

{
  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 GetCategoryMask::Stop ( Param par = null )

protected

Definition at line 473 of file PPERequestPlatformsBase.c.

{
  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;
  }
}

Variable Documentation

m_IDX

int m_IDX

protected

Definition at line 435 of file PPERequestPlatformsBase.c.

m_IsRunning

bool m_IsRunning

protected

Definition at line 433 of file PPERequestPlatformsBase.c.

Referenced by PPERequester_GameplayBase::OnStart(), PPERequester_GameplayBase::OnUpdate(), PPERequester_GameplayBase::SetUndergroundExposureCoef(), Managed::StartRunningDrops(), Managed::StopIndicator(), and Managed::Update().

m_RequestDataStructure

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

protected

Definition at line 439 of file PPERequestPlatformsBase.c.

m_Valid

bool m_Valid = false

protected

Definition at line 437 of file PPERequestPlatformsBase.c.

m_ValuesSent

bool m_ValuesSent

protected

Definition at line 434 of file PPERequestPlatformsBase.c.