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