PPEMatClassesBase.c

Go to the documentation of this file.

 
class PPEClassBase
{
  protected PPEManager m_Manager;
  protected string m_MaterialPath = "";
  protected Material m_Material;
 
  protected ref map<int, ref array<int>> m_ParameterUpdateQueueMap;
  protected ref array<int> m_ParameterRemovalQueue;
  protected ref array<int> m_UpdatedParameters;
 
  protected ref map<int, ref PPEMatClassParameterCommandData> m_MaterialParamMapStructure; //<param_idx, <ParamData>>
 
  void PPEClassBase(string mat_path_override = "")
  {
    Init(mat_path_override);
    CreateMaterial();
    CreateDataStructure();
    RegisterMaterialParameters();
  }
 
  protected void Init(string mat_path_override = "")
  {
    if (mat_path_override != "")
      m_MaterialPath = mat_path_override;
    else
      m_MaterialPath = GetDefaultMaterialPath();
    m_Manager = PPEManagerStatic.GetPPEManager();
  }
 
  protected void CreateMaterial()
  {
    if (m_MaterialPath != "")
      m_Material = GetGame().GetWorld().GetMaterial(m_MaterialPath);
  }
 
  Material GetMaterial()
  {
    return m_Material;
  }
 
  //do not override!
  protected void CreateDataStructure()
  {
    m_MaterialParamMapStructure = new map<int, ref PPEMatClassParameterCommandData>;
    //m_ParameterUpdateQueue = new array<int>;
    m_ParameterUpdateQueueMap = new map<int, ref array<int>>;
    m_ParameterRemovalQueue = new array<int>;
    m_UpdatedParameters = new array<int>;
  }
 
  protected void RegisterMaterialParameters();
 
  protected void RegisterParameterScalarBool(int idx, string parameter_name, bool default_value)
  {
    PPETemplateDefBool p = new PPETemplateDefBool(parameter_name, default_value);
    PPEMatClassParameterBool parameter_data = new PPEMatClassParameterBool(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterScalarInt(int idx, string parameter_name, int default_value, int min, int max)
  {
    PPETemplateDefInt p = new PPETemplateDefInt(parameter_name, default_value, min, max);
 
    PPEMatClassParameterInt parameter_data = new PPEMatClassParameterInt(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterScalarFloat(int idx, string parameter_name, float default_value, float min, float max)
  {
    PPETemplateDefFloat p = new PPETemplateDefFloat(parameter_name, default_value, min, max);
 
    PPEMatClassParameterFloat parameter_data = new PPEMatClassParameterFloat(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterScalarFloatEx(int idx, string parameter_name, float default_value, float min, float max, typename type)
  {
    PPETemplateDefFloat p = new PPETemplateDefFloat(parameter_name, default_value, min, max);
 
    PPEMatClassParameterFloat parameter_data;
    bool boo = Class.CastTo(parameter_data, type.Spawn());
    //Print("RegisterParameterColorEx: " + boo );
    parameter_data.RegisterDefaults(p);
    parameter_data.SetMaterialIndex(GetPostProcessEffectID());
    parameter_data.SetParameterIndex(idx);
    parameter_data.SetParent(this);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterColor(int idx, string parameter_name, float r, float g, float b, float a)
  {
    PPETemplateDefColor p = new PPETemplateDefColor(parameter_name, r, g, b, a);
    PPEMatClassParameterColor parameter_data = new PPEMatClassParameterColor(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterColorEx(int idx, string parameter_name, float r, float g, float b, float a, typename type)
  {
    PPETemplateDefColor p = new PPETemplateDefColor(parameter_name, r, g, b, a);
    PPEMatClassParameterColor parameter_data;
    bool boo = Class.CastTo(parameter_data, type.Spawn());
    //Print("RegisterParameterColorEx: " + boo );
    parameter_data.RegisterDefaults(p);
    parameter_data.SetMaterialIndex(GetPostProcessEffectID());
    parameter_data.SetParameterIndex(idx);
    parameter_data.SetParent(this);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterVector(int idx, string parameter_name, array<float> default_values) //needs to be compatible with every type of vector (vector2 to vector4), hence array<float>...
  {
    PPETemplateDefVector p = new PPETemplateDefVector(parameter_name, default_values);
    PPEMatClassParameterVector parameter_data = new PPEMatClassParameterVector(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  //TEXTURE and RESOURCE types are not overridable during runtime..currently unused and unhandled
  protected void RegisterParameterTexture(int idx, string parameter_name, string default_path)
  {
    PPETemplateDefTexture p = new PPETemplateDefTexture(parameter_name, default_path);
    PPEMatClassParameterTexture parameter_data = new PPEMatClassParameterTexture(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  protected void RegisterParameterResource(int idx, string parameter_name, string default_path)
  {
    PPETemplateDefResource p = new PPETemplateDefResource(parameter_name, default_path);
    PPEMatClassParameterResource parameter_data = new PPEMatClassParameterResource(GetPostProcessEffectID(), idx, this);
    parameter_data.RegisterDefaults(p);
    m_MaterialParamMapStructure.Set(idx, parameter_data);
  }
 
  //------------------------------------------------------------------------------------
  void InsertParamValueData(PPERequestParamDataBase request_data)
  {
    PPEMatClassParameterCommandData param_data;
    bool exists = m_MaterialParamMapStructure.Find(request_data.GetParameterID(), param_data);
    if (!exists)
    {
      Error("PPEClassBase | InsertParamValueData | mat/par/req: " + GetPostProcessEffectID() + "/" + request_data.GetParameterID() + "/" + request_data.GetRequesterIDX() + " not registered in m_MaterialParamMapStructure!");
      return;
    }
 
    request_data.SetDataActive(true);
    request_data.SetUpdatingDataValues(true); //marks request data as updating
    param_data.InsertRequestData(request_data);//<request_ID, data>
 
    //DbgPrnt("PPEDebug | InsertParamValueData | mat/par/req: " + GetPostProcessEffectID() + "/" + request_data.GetParameterID() + "/" + request_data.GetRequesterIDX() + " | requester: " + request_data.m_Requester);
  }
 
  //TODO - rework
  void RemoveRequest(int req_idx)
  {
    /*for (int i = 0; i < m_ActiveMaterialRequestMap.Count(); i++)
      {
      ActiveParameterRequestsMap dbg = m_ActiveMaterialRequestMap.Get(i);
      //DbgPrnt("PPEDebug | dbg size: " + dbg.Count());
 
      if ( m_ActiveMaterialRequestMap.Get(i).Contains(req_idx) )
      {
        m_ActiveMaterialRequestMap.Get(i).Remove(req_idx);
 
        dbg = m_ActiveMaterialRequestMap.Get(i);
 
        if ( !m_ActiveMaterialRequestMap.Get(i) || m_ActiveMaterialRequestMap.Get(i).Count() < 1 )
        {
          if (m_ParameterUpdateQueue.IsValidIndex(i))
          {
            DbgPrnt("PPEDebug | PPEClassBase - RemoveRequest | Removing: " + i);
            DbgPrnt("PPEDebug | PPEClassBase - RemoveRequest | exit 4 - last request removal");
            m_ParameterRemovalQueue.Insert(m_ParameterUpdateQueue.Get(i));
          }
          else
            DbgPrnt("PPEDebug | PPEClassBase - RemoveRequest | Update queue no. " + i + " already removed!");
        }
      }
      //Adds to update one more time
      m_Manager.SetMaterialParamUpdating(GetPostProcessEffectID(),i);
      }*/
  }
 
  void OnUpdate(float timeslice, int order)
  {
    int parameter_idx = -1;
    //DbgPrnt("PPEDebug | PPEClassBase - OnUpdate | mat_id: " + GetPostProcessEffectID());
 
    if (m_ParameterUpdateQueueMap.Contains(order))
    {
      //Print(m_ParameterUpdateQueueMap.Get(order));
      for (int i = 0; i < m_ParameterUpdateQueueMap.Get(order).Count(); i++)
      {
        //DbgPrnt("PPEDebug | PPEClassBase - OnUpdate | parameter_idx: " + m_ParameterUpdateQueue.Get(i));
        Param p_values; //TODO - move to material classes?
        bool setting_defaults = false;
        parameter_idx = m_ParameterUpdateQueueMap.Get(order).Get(i);
        m_MaterialParamMapStructure.Get(parameter_idx).Update(timeslice, p_values, setting_defaults, order);
 
        InsertUpdatedParameter(parameter_idx);
      }
      m_Manager.InsertUpdatedMaterial(GetPostProcessEffectID());
 
      ParamUpdateQueueCleanup(order);
    }
    /*if ( !m_ParameterUpdateQueueMap.Contains(order) || m_ParameterUpdateQueueMap.Get(order).Count() < 1 )
      m_Manager.RemoveMaterialUpdating(GetPostProcessEffectID(),order); //stops material from updating when no parameters are.*/
  }
 
  void SetFinalParameterValue(int parameter_idx)
  {
    int var_type = GetParameterCommandData(parameter_idx).GetParameterVarType();
    Param values = GetParameterCommandData(parameter_idx).GetCurrentValues();
 
    switch (var_type)
    {
    case PPEConstants.VAR_TYPE_BOOL:
      bool value_var_bool = Param1<bool>.Cast(values).param1;
 
      m_Material.SetParamByIndex(parameter_idx, value_var_bool);
      //Print("DebugValues | PPEConstants.VAR_TYPE_BOOL | bool val: " + value_var_bool);
      break;
 
    case PPEConstants.VAR_TYPE_INT:
      int value_var_int = Param1<int>.Cast(values).param1;
 
      m_Material.SetParamByIndex(parameter_idx, value_var_int);
      //Print("DebugValues | PPEConstants.VAR_TYPE_BOOL | bool val: " + value_var_bool);
      break;
 
    case PPEConstants.VAR_TYPE_FLOAT:
      float value_var_float = Param1<float>.Cast(values).param1;
 
      m_Material.SetParamByIndex(parameter_idx, value_var_float);
      //Print("DebugValues | PPEConstants.VAR_TYPE_FLOAT | float val: " + value_var_float);
      break;
 
    case PPEConstants.VAR_TYPE_COLOR:
      float color[4] = {0, 0, 0, 0};
      color[0] = Param4<float, float, float, float>.Cast(values).param1;
      color[1] = Param4<float, float, float, float>.Cast(values).param2;
      color[2] = Param4<float, float, float, float>.Cast(values).param3;
      color[3] = Param4<float, float, float, float>.Cast(values).param4;
 
      m_Material.SetParamByIndex(parameter_idx, color);
      //Print("DebugValues | PPEConstants.VAR_TYPE_COLOR | color val:: " + color[0] + " " + color[1] + " " + color[2] + " " + color[3]);
      break;
    }
  }
 
  void ApplyValueChanges()
  {
    int parameter_id;
    for (int i = 0; i < m_UpdatedParameters.Count(); i++)
    {
      parameter_id = m_UpdatedParameters.Get(i);
      SetFinalParameterValue(parameter_id);
    }
 
    m_UpdatedParameters.Clear();
  }
 
  protected void InsertUpdatedParameter(int mat_id)
  {
    if (m_UpdatedParameters.Find(mat_id) == -1)
      m_UpdatedParameters.Insert(mat_id);
  }
 
  void ParamUpdateRemove(int parameter_idx)
  {
    if (m_ParameterRemovalQueue.Find(parameter_idx) == -1)
      m_ParameterRemovalQueue.Insert(parameter_idx);
  }
 
  void SetParameterUpdating(int order, int parameter_id)
  {
    if (!m_ParameterUpdateQueueMap.Contains(order))
      m_ParameterUpdateQueueMap.Set(order, new array<int>);
 
    if (m_ParameterUpdateQueueMap.Get(order).Find(parameter_id) == -1)
      m_ParameterUpdateQueueMap.Get(order).Insert(parameter_id);
  }
 
  protected void ParamUpdateQueueCleanup(int order)
  {
    //DbgPrnt("PPEDebug | PPEClassBase - ParamUpdateQueueCleanup | mat_id: " + GetPostProcessEffectID() + " | UpdateQueue count: " + m_ParameterUpdateQueue.Count());
    //DbgPrnt("PPEDebug | PPEClassBase - ParamUpdateQueueCleanup | mat_id: " + GetPostProcessEffectID() + " | RemovalQueue count: " + m_ParameterRemovalQueue.Count());
    for (int i = 0; i < m_ParameterUpdateQueueMap.Get(order).Count(); i++)
    {
      if (m_ParameterRemovalQueue.Find(m_ParameterUpdateQueueMap.Get(order).Get(i)) != -1)
      {
        //DbgPrnt("PPEDebug | PPEClassBase - ParamUpdateQueueCleanup | removing update of: " + m_ParameterUpdateQueue.Get(i));
        //m_ParameterUpdateQueue.RemoveItem(m_ParameterUpdateQueue.Get(i));
      }
    }
    m_ParameterUpdateQueueMap.Get(order).Clear();
  }
 
  string GetDefaultMaterialPath();
 
  void ChangeMaterialPathUsed(string path)
  {
    m_MaterialPath = path;
    m_Material = null;
    CreateMaterial();
  }
 
  string GetCurrentMaterialPath()
  {
    return m_MaterialPath;
  }
 
  int GetPostProcessEffectID()
  {
    return PostProcessEffectType.None;
  }
 
  /*int GetExceptionID()
    {
    return PPEExceptions.NONE;
    }*/
 
  PPEMatClassParameterCommandData GetParameterCommandData(int parameter_idx)
  {
    return m_MaterialParamMapStructure.Get(parameter_idx);
  }
 
#ifdef DEVELOPER
  //Debug//
  //-----//
  /*void DumpMap()
    {
    DbgPrnt("PPEClassDebug | m_ActiveMaterialRequestMap COUNT: " + m_ActiveMaterialRequestMap.Count());
    for (int i = 0; i < m_ActiveMaterialRequestMap.Count(); i++)
    {
      DbgPrnt("PPEClassDebug | m_ActiveRequest#: " + i);
      //ActiveMaterialRequests request = m_ActiveMaterialRequestMap.Get(i);
      DbgPrnt("PPEClassDebug | request: " + request);
      for (int j = 0; j < request.Count(); j++)
      {
        DbgPrnt("PPEClassDebug | request#: " + j);
        array<bool,float,int,int> values = request.Get(j);
        foreach (auto val : values)
        {
          DbgPrnt("PPEClassDebug | relative: " + val);
        }
      }
    }
    DbgPrnt("------------");
    }*/
#endif
 
  void DbgPrnt(string text)
  {
    //Debug.Log(""+text);
  }
};