CachedInfosInstanced.c

См. документацию.

class InstancedAttachmentGroupDataBase //TODO: move!
{
    protected EntityAI m_Parent;
    
    void InstancedAttachmentGroupDataBase(EntityAI parent)
    {
        m_Parent = parent;
    }
    
    void Init();
}
 
class InstancedAttachmentGroupDataBuilding : InstancedAttachmentGroupDataBase
{
    protected ref map<string,ref AttachmentGroupProximityMetadata> m_AttGroupPositionData; 
    
    override void Init()
    {
        super.Init();
        
        TAttachmentGroupMap groupMap = m_Parent.GetTypeAttachmentGroupInfoHolder().GetAttachmentGroupMap();
        if (groupMap)
        {
            m_AttGroupPositionData = new map<string,ref AttachmentGroupProximityMetadata>();
            foreach (string groupName, ref TypeAttachmentGroupData groupData : groupMap)
            {
                bool createMetadata = false;
                AttachmentGroupPositionData posData;
                AttachmentGroupBoxData boxData;
                
                vector pos;
                float radius;
                if (CalculatePositionData(groupData.m_SelectionName,pos,radius))
                {
                    createMetadata = true;
                    posData = new AttachmentGroupPositionData(pos,radius);
                }
                
                vector min,max;
                if (CalculateBoxData(groupData.m_SelectionName,min,max))
                {
                    createMetadata = true;
                    boxData = new AttachmentGroupBoxData(min,max);
                }
                
                if (createMetadata)
                    m_AttGroupPositionData.Set(groupName,new AttachmentGroupProximityMetadata(posData,boxData));
            }
        }
    }
    
    protected bool CalculatePositionData(string namedSelection, out vector position, out float radius)
    {
        radius = 2.0; //UAMaxDistances.DEFAULT;
        
        if (m_Parent.MemoryPointExists(namedSelection)) //first look for mem point
        {
            position = m_Parent.ModelToWorld(m_Parent.GetMemoryPointPos(namedSelection));
            string memRadiusSelection = "" + namedSelection + "_radius";
            if (m_Parent.MemoryPointExists(memRadiusSelection)) //if using mem point, look for radius point too
            {
                vector radiusPoint = m_Parent.ModelToWorld(m_Parent.GetMemoryPointPos(memRadiusSelection));
                radius = vector.Distance(position,radiusPoint);
            }
            
            return true;
        }
        else //if not found, look for the named component center (building-specific solution, position possibly averaged from multiple components!)
        {
            TIntArray ost = new TIntArray();
            m_Parent.GetActionComponentsForSelectionName(m_Parent.GetViewGeometryLevel(),namedSelection,ost);
            
            if (ost.Count() == 0)
                return false;
            
            bool validPosFilled = false;
            vector tmpPos;
            foreach (int comp : ost)
            {
                if (!validPosFilled)
                {
                    tmpPos = m_Parent.ModelToWorld(m_Parent.GetActionComponentCenter(m_Parent.GetViewGeometryLevel(),comp));
                    validPosFilled = true;
                }
                else
                {
                    tmpPos = tmpPos + m_Parent.ModelToWorld(m_Parent.GetActionComponentCenter(m_Parent.GetViewGeometryLevel(),comp));
                }
            }
            
            position = tmpPos * (1 / ost.Count());
            return true;
        }
    }
    
    protected bool CalculateBoxData(string namedSelection, out vector min, out vector max)
    {
        string minSelection = "" + namedSelection + "_min";
        string maxSelection = "" + namedSelection + "_max";
        if (m_Parent.MemoryPointExists(minSelection) && m_Parent.MemoryPointExists(maxSelection))
        {
            min = m_Parent.ModelToWorld(m_Parent.GetMemoryPointPos(minSelection));
            max = m_Parent.ModelToWorld(m_Parent.GetMemoryPointPos(maxSelection));
            //sanitize minsmaxs
            vector.SanitizeMinsMaxs(min,max);
            return true;
        }
        
        return false;
    }
    
    map<string,ref AttachmentGroupProximityMetadata> GetAttGroupPositionMap()
    {
        return m_AttGroupPositionData;
    }
    
    bool GetValidAttGroupPosition(string groupName, out vector position, out float radius)
    {
        AttachmentGroupProximityMetadata metaData = m_AttGroupPositionData.Get(groupName);
        if (metaData)
            return metaData.GetValidRadialCheckData(position,radius);
        
        return false;
    }
    
    bool GetValidAttGroupBox(string groupName, out vector min, out vector max)
    {
        AttachmentGroupProximityMetadata metaData = m_AttGroupPositionData.Get(groupName);
        if (metaData)
            return metaData.GetValidBoxCheckData(min,max);
        
        return false;
    }
}

class AttachmentGroupProximityMetadata
{
    protected ref AttachmentGroupPositionData m_PositionData;
    protected ref AttachmentGroupBoxData m_BoxData;
    
    void AttachmentGroupProximityMetadata(AttachmentGroupPositionData posData, AttachmentGroupBoxData boxData)
    {
        m_PositionData = posData;
        m_BoxData = boxData;
    }
    
    bool GetValidRadialCheckData(out vector position, out float radius)
    {
        if (m_PositionData)
        {
            position = m_PositionData.m_Position;
            radius = m_PositionData.m_Radius;
            return true;
        }
        
        return false;
    }
    
    bool GetValidBoxCheckData(out vector min, out vector max)
    {
        if (m_BoxData)
        {
            min = m_BoxData.m_Min;
            max = m_BoxData.m_Max;
            return true;
        }
        
        return false;
    }
}
 
class AttachmentGroupPositionData
{
    vector m_Position;
    float m_Radius;
    
    void AttachmentGroupPositionData(vector pos, float radius)
    {
        m_Position = pos;
        m_Radius = radius;
    }
}
 
class AttachmentGroupBoxData
{
    vector m_Min;
    vector m_Max;
    
    void AttachmentGroupBoxData(vector min, vector max)
    {
        m_Min = min;
        m_Max = max;
    }
}