PPERequestPlatformsBase.c

Go to the documentation of this file.

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