PPEManager.c

Go to the documentation of this file.

 
class PPEManagerStatic
{
  static ref PPEManager m_Manager;
 
  static void CreateManagerStatic()
  {
    if (m_Manager)
    {
      Debug.Log("PPEManagerStatic | CreateManagerStatic - PPEManager already exists");
      return;
    }
 
    m_Manager = new PPEManager;
  }
 
  static void DestroyManagerStatic()
  {
    if (m_Manager)
    {
      m_Manager.Cleanup();
      delete m_Manager;
    }
  }
 
  static PPEManager GetPPEManager()
  {
    return m_Manager;
  }
}
 
class PPEManager extends Managed
{
  const int CAMERA_ID = 0;
 
  protected bool m_ManagerInitialized;
  protected ref map<int, ref PPEClassBase> m_PPEClassMap; //contains sorted postprocess classes, IDs in 'PostProcessEffectType' // <MaterialID,<material_class>>
  protected ref map<int, ref array<int>> m_PPEMaterialUpdateQueueMap; //multiple levels of update queues, to allow for multiple dependent updates during same frame (greedy?)
  protected ref array<int> m_UpdatedMaterials;
  protected ref array<ref PPERequesterBase> m_ExistingPostprocessRequests; //which requests are active overall. Does not have to be updating ATM!
  protected ref array<ref PPERequesterBase> m_UpdatingRequests; //which requests are currently updating and processing
 
  void PPEManager()
  {
    m_ManagerInitialized = false;
    PPERequesterBank.Init();
  }
 
  void Cleanup()
  {
    PPERequesterBank.Cleanup();
 
    if (m_ManagerInitialized)
    {
      m_PPEMaterialUpdateQueueMap.Clear();
      m_ExistingPostprocessRequests.Clear();
      m_UpdatingRequests.Clear();
      m_PPEClassMap.Clear();
    }
  }
 
  void Init()
  {
    //DbgPrnt("PPEDebug | PPEManager | m_ManagerInitialized: " + m_ManagerInitialized);
    if (!m_ManagerInitialized)
    {
      m_PPEMaterialUpdateQueueMap = new map<int, ref array<int>>;
      m_UpdatedMaterials = new array<int>;
      m_ExistingPostprocessRequests = new array<ref PPERequesterBase>;
      m_UpdatingRequests = new array<ref PPERequesterBase>;
      InitPPEManagerClassMap();
 
      GetGame().GetUpdateQueue(CALL_CATEGORY_GUI).Insert(this.Update); //can be safely and easily 'disabled' here
      m_ManagerInitialized = true;
    }
  }
 
  protected void InitPPEManagerClassMap()
  {
    if (m_PPEClassMap)
      delete m_PPEClassMap;
    m_PPEClassMap = new map<int, ref PPEClassBase>;
 
    RegisterPPEClass(new PPENone()); //dummy
    RegisterPPEClass(new PPEUnderWater());
    RegisterPPEClass(new PPESSAO());
    RegisterPPEClass(new PPEDepthOfField());
    RegisterPPEClass(new PPEHBAO());
    RegisterPPEClass(new PPERotBlur());
    RegisterPPEClass(new PPEGodRays());
    RegisterPPEClass(new PPERain());
    RegisterPPEClass(new PPEFilmGrain());
    RegisterPPEClass(new PPERadialBlur());
    RegisterPPEClass(new PPEChromAber());
    RegisterPPEClass(new PPEWetDistort());
    RegisterPPEClass(new PPEDynamicBlur());
    RegisterPPEClass(new PPEColorGrading());
    RegisterPPEClass(new PPEColors());
    RegisterPPEClass(new PPEGlow());
    RegisterPPEClass(new PPESMAA());
    RegisterPPEClass(new PPEFXAA());
    RegisterPPEClass(new PPEMedian());
    RegisterPPEClass(new PPESunMask());
    RegisterPPEClass(new PPEGaussFilter());
    RegisterPPEClass(new PPEExposureNative());
    RegisterPPEClass(new PPEEyeAccomodationNative());
    RegisterPPEClass(new PPEDOF());
    RegisterPPEClass(new PPELightIntensityParamsNative());
  }
 
  protected void RegisterPPEClass(PPEClassBase material_class)
  {
    m_PPEClassMap.Set(material_class.GetPostProcessEffectID(), material_class);
  }
 
  void SendMaterialValueData(PPERequestParamDataBase data)
  {
    //DbgPrnt("DataVerification | m_ColorTarget | SendMaterialValueData: " + PPERequestParamDataColor.Cast(data).m_ColorTarget[0] + "/" + PPERequestParamDataColor.Cast(data).m_ColorTarget[1] + "/" + PPERequestParamDataColor.Cast(data).m_ColorTarget[2] + "/" + PPERequestParamDataColor.Cast(data).m_ColorTarget[3]);
    PPEClassBase mat_class = m_PPEClassMap.Get(data.GetMaterialID());
    mat_class.InsertParamValueData(data);
    SetMaterialParamUpdating(data.GetMaterialID(), data.GetParameterID(), PPEConstants.DEPENDENCY_ORDER_BASE);
  }
 
  void SetMaterialParamUpdating(int material_id, int parameter_id, int order)
  {
    if (order > PPEConstants.DEPENDENCY_ORDER_HIGHEST)
    {
      //DbgPrnt("PPEDebug | PPEManager - SetMaterialParamUpdating | Order higher than max, ignoring! | mat/par/ord: " + material_id + "/" + parameter_id + "/" + order);
      return;
    }
 
    PPEClassBase mat_class = m_PPEClassMap.Get(material_id);
 
    //DbgPrnt("PPEDebug | PPEManager - SetMaterialParamUpdating | mat/par: " + material_id + "/" + parameter_id);
    //insert material into queue
    if (!m_PPEMaterialUpdateQueueMap.Contains(order))
      m_PPEMaterialUpdateQueueMap.Set(order, new array<int>);
 
    int found = m_PPEMaterialUpdateQueueMap.Get(order).Find(material_id);
    if (found == -1)
      m_PPEMaterialUpdateQueueMap.Get(order).Insert(material_id);
 
    mat_class.SetParameterUpdating(order, parameter_id);
  }
 
  void RemoveMaterialUpdating(int material_id, int order = 0)
  {
    if (m_PPEMaterialUpdateQueueMap.Contains(order))
    {
      m_PPEMaterialUpdateQueueMap.Get(order).RemoveItem(material_id);
 
      if (m_PPEMaterialUpdateQueueMap.Get(order).Count() == 0)
        m_PPEMaterialUpdateQueueMap.Remove(order);
    }
  }
 
  protected void ClearMaterialUpdating()
  {
    m_PPEMaterialUpdateQueueMap.Clear();
  }
 
  void SetRequestActive(PPERequesterBase request, bool active)
  {
    int found = m_ExistingPostprocessRequests.Find(request);
    if (active && found == -1)
      m_ExistingPostprocessRequests.Insert(request);
    else if (!active && found > -1) //should always be found in this case, redundant?
    {
      //RemoveActiveRequestFromMaterials(request);
 
      m_ExistingPostprocessRequests.Remove(found);
    }
  }
 
  void SetRequestUpdating(PPERequesterBase request, bool active)
  {
    if (!m_UpdatingRequests)
    {
      Debug.Log("PPEManager | SetRequestUpdating | !m_UpdatingRequests");
      return;
    }
 
    int idx = m_UpdatingRequests.Find(request);
 
    if (active && idx == -1)
      m_UpdatingRequests.Insert(request);
    else if (!active && idx > -1)
      m_UpdatingRequests.Remove(idx);
  }
 
  // Just a getter
  bool GetExistingRequester(typename req, out PPERequesterBase ret)
  {
    int idx = m_ExistingPostprocessRequests.Find(PPERequesterBank.GetRequester(req));
    if (idx > -1)
    {
      ret = m_ExistingPostprocessRequests.Get(idx);
      return true;
    }
    return false;
  }
 
  bool IsAnyRequesterRunning(array<typename> requesters)
  {
    foreach (typename requesterType : requesters)
    {
      PPERequesterBase ppeRequester;
      GetExistingRequester(requesterType, ppeRequester);
      if (ppeRequester && ppeRequester.IsRequesterRunning())
        return true;
    }
 
    return false;
  }
 
  protected void RemoveActiveRequestFromMaterials(PPERequesterBase req)
  {
    int count = req.GetActiveRequestStructure().Count();
    int mat_id;
    for (int i = 0; i < count; i++)
    {
      mat_id = req.GetActiveRequestStructure().GetKey(i);
      PPEClassBase mat_class = m_PPEClassMap.Get(mat_id);
      mat_class.RemoveRequest(req.GetRequesterIDX());
    }
  }
 
  protected void RequestsCleanup()
  {
  }
 
  void InsertUpdatedMaterial(int mat_id)
  {
    if (m_UpdatedMaterials.Find(mat_id) == -1)
      m_UpdatedMaterials.Insert(mat_id);
  }
 
  //---------//
  //PROCESSING
  //---------//
  protected void ProcessRequesterUpdates(float timeslice)
  {
    PPERequesterBase req;
    for (int i = 0; i < m_UpdatingRequests.Count(); i++)
    {
      //DbgPrnt("PPEDebug | ProcessRequesterUpdates | m_UpdatingRequests[i]: " + m_UpdatingRequests[i]);
      req = m_UpdatingRequests.Get(i);
      if (req)
        req.OnUpdate(timeslice);
    }
  }
 
  protected void ProcessMaterialUpdates(float timeslice)
  {
    for (int i = 0; i < m_PPEMaterialUpdateQueueMap.Count(); i++) //orders (levels?)
    {
      //DbgPrnt("PPEDebug | ProcessMaterialUpdates | GetKey " + i + ": " + m_PPEMaterialUpdateQueueMap.GetKey(i));
      //DbgPrnt("PPEDebug | ProcessMaterialUpdates | GetElement - count " + i + ": " + m_PPEMaterialUpdateQueueMap.GetElement(i).Count());
 
      for (int j = 0; j < m_PPEMaterialUpdateQueueMap.GetElement(i).Count(); j++)
      {
        PPEClassBase mat_class = m_PPEClassMap.Get(m_PPEMaterialUpdateQueueMap.GetElement(i).Get(j));
        mat_class.OnUpdate(timeslice, i);
      }
    }
  }
 
  protected void ProcessApplyValueChanges()
  {
    int material_id;
    for (int i = 0; i < m_UpdatedMaterials.Count(); i++)
    {
      material_id = m_UpdatedMaterials.Get(i);
      PPEClassBase mat_class = m_PPEClassMap.Get(material_id);
      mat_class.ApplyValueChanges();
    }
 
    m_UpdatedMaterials.Clear();
    ClearMaterialUpdating();
  }
 
  void Update(float timeslice)
  {
    if (!m_ManagerInitialized)
      return;
 
    ProcessRequesterUpdates(timeslice);
    ProcessMaterialUpdates(timeslice);
    ProcessApplyValueChanges();
    RequestsCleanup(); //unused
  }
 
  Param GetPostProcessDefaultValues(int material, int parameter)
  {
    PPEClassBase mat_class = m_PPEClassMap.Get(material);
    return mat_class.GetParameterCommandData(parameter).GetDefaultValues();
  }
 
  Param GetPostProcessCurrentValues(int material, int parameter)
  {
    PPEClassBase mat_class = m_PPEClassMap.Get(material);
    return mat_class.GetParameterCommandData(parameter).GetCurrentValues();
  }
 
  //TODO - certain C++ events may change the actual material path with a graphics option changes. Reflect this on script-side!
  //Currently only SSAY/HBAO affected...welp.
  void ChangePPEMaterial(PostProcessPrioritiesCamera priority, PostProcessEffectType type, string path, bool scriptside_only)
  {
    if (m_PPEClassMap.Contains(type))
    {
      PPEClassBase mat_class = m_PPEClassMap.Get(type);
      typename name = mat_class.Type();
      PPEClassBase postprocess_capsule = PPEClassBase.Cast(name.Spawn());
      postprocess_capsule.ChangeMaterialPathUsed(path);
 
      if (postprocess_capsule.GetMaterial() == 0x0)
      {
        Debug.Log("PPEManager | Invalid material path " + path + " used for " + name);
        return;
      }
 
      //m_PPEClassMap.Remove(type);
      m_PPEClassMap.Set(type, postprocess_capsule);
    }
 
    //can be sent script-side only to adapt to c++ options changes
    if (!scriptside_only)
      SetCameraPostProcessEffect(CAMERA_ID, priority, type, path);
  }
 
  void StopAllEffects(int mask = 0)
  {
    if (m_ExistingPostprocessRequests)
    {
      foreach (PPERequesterBase requester : m_ExistingPostprocessRequests)
      {
        if (requester.GetCategoryMask() & mask)
          requester.Stop();
      }
    }
  }
 
  void DbgPrnt(string text)
  {
    //Debug.Log(""+text);
  }
};