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 = g_Game.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);
    }
};