GetOnScreenPosition()

void ActionTargetsCursor::GetOnScreenPosition ( out float x, out float y )

inlineprotected

kept for backward compatibility

Get memory LOD from p3d

save selection from memory lod

cache current object and the widget world pos

doors/handles

single vertex in selection

multiple vertices in selection

cache current object and the widget world pos

do not store component index for doors/handles

ladders handling

cache current object and the widget world pos

do not store component index for ladders

См. определение в файле ActionTargetsCursor.c строка 471

    {
        const float     DEFAULT_HANDLE_OFFSET   = 0.2;
        const string    CE_CENTER_COMP_NAME     = "ce_center";
        const string    MEM_LOD_NAME            = LOD.NAME_MEMORY; 
        
        int compIdx;
        float pivotOffset = 0.0;
        float memOffset   = 0.0;
        string compName;
 
        bool isTargetForced = false;
        
        vector worldPos;
        vector modelPos;
 
        LOD lod;
 
        array<Selection> memSelections  = new array<Selection>();
        array<string> components = new array<string>; // for components with multiple selection
        
        Object object;
 
        if (m_Target)
        {
            object = m_Target.GetObject();
            compIdx  = m_Target.GetComponentIndex();
 
            if (m_Target.GetCursorHitPos() == vector.Zero)
                isTargetForced = true;
        }
        else
        {
            return;
        }
 
        if (object)
        {
            if (!isTargetForced)
            {
                compName = object.GetActionComponentName(compIdx);
                object.GetActionComponentNameList(compIdx, components);
 
                if (!object.IsInventoryItem() && (object.HasFixedActionTargetCursorPosition() || object.GetActionComponentNameList(compIdx, components) == 0))
                {
                    m_FixedOnPosition = true;
                    return;
                }
                
                pivotOffset = object.ConfigGetFloat("actionTargetPivotOffsetY");
                memOffset   = object.ConfigGetFloat("actionTargetMemOffsetY");
    
                lod = object.GetLODByName(MEM_LOD_NAME);
                if (lod != null)
                {
                    lod.GetSelections(memSelections);
                    
                    // items with CE_Center mem point
                    if (MiscGameplayFunctions.IsComponentInSelection(memSelections, CE_CENTER_COMP_NAME))
                    {
                        for (int i2 = 0; i2 < memSelections.Count(); ++i2)
                        {
                            if (memSelections[i2].GetName() == CE_CENTER_COMP_NAME && memSelections[i2].GetVertexCount() == 1)
                            {
                                m_FixedOnPosition = false;
                                modelPos = object.GetSelectionPositionMS(CE_CENTER_COMP_NAME);
                                worldPos = object.ModelToWorld(modelPos);
                                if (memOffset != 0.0)
                                {
                                    worldPos[1] = worldPos[1] + memOffset;
                                }
                                else
                                {
                                    worldPos[1] = worldPos[1] + DEFAULT_HANDLE_OFFSET;
                                }
                            }
                        }

                        m_CachedObject.Store(object, worldPos, compIdx);
                    } 
                    else if (!compName.Contains("ladder") && IsComponentInSelection(memSelections, compName))
                    {
                        for (int i1 = 0; i1 < memSelections.Count(); ++i1)
                        {
                            if (memSelections[i1].GetName() == compName && memSelections[i1].GetVertexCount() == 1)
                            {
                                modelPos = object.GetSelectionPositionMS(compName);
                                worldPos = object.ModelToWorld(modelPos);
 
                                m_FixedOnPosition = false;
                                if (object.GetType() == "Fence" || object.GetType() == "Watchttower" || object.GetType() == "GardenPlot")
                                    m_FixedOnPosition = true;
                                
                                if (memOffset != 0.0)
                                {
                                    worldPos[1] = worldPos[1] + memOffset;
                                }
                                else
                                {
                                    worldPos[1] = worldPos[1] + DEFAULT_HANDLE_OFFSET;
                                }
                            }

                            if (memSelections[i1].GetName() == compName && memSelections[i1].GetVertexCount() > 1)
                            {
                                for (int j = 0; j < components.Count(); ++j)
                                {
                                    if (IsComponentInSelection(memSelections, components[j]))
                                    {
                                        modelPos = object.GetSelectionPositionMS(components[j]);
                                        worldPos = object.ModelToWorld(modelPos);
 
                                        m_FixedOnPosition = false;
                                        if (memOffset != 0.0)
                                        {
                                            worldPos[1] = worldPos[1] + memOffset;
                                        }
                                        else
                                        {
                                            worldPos[1] = worldPos[1] + DEFAULT_HANDLE_OFFSET;
                                        }
                                    }
                                }
                            }
                        }
                        
                        m_CachedObject.Store(object, worldPos, -1); 
                    }
                    else if (compName.Contains("ladder") && IsComponentInSelection(memSelections, compName))
                    {
                        vector ladderHandlePointLS, ladderHandlePointWS;
                        vector closestHandlePos;
                        float lastDistance = 0;
    
                        for (int i3 = 0; i3 < memSelections.Count(); ++i3)
                        {
                            if (memSelections[i3].GetName() == compName && memSelections[i3].GetVertexCount() > 1)
                            {
                                ladderHandlePointLS = memSelections[i3].GetVertexPosition(lod, 0);
                                ladderHandlePointWS = object.ModelToWorld(ladderHandlePointLS);
                                closestHandlePos = ladderHandlePointWS;
                                lastDistance = Math.AbsFloat(vector.DistanceSq(ladderHandlePointWS, m_Player.GetPosition()));
    
                                for (int k = 1; k < memSelections[i3].GetVertexCount(); ++k)
                                {
                                    ladderHandlePointLS = memSelections[i3].GetVertexPosition(lod, k);
                                    ladderHandlePointWS = object.ModelToWorld(ladderHandlePointLS);
                                    
                                    if (lastDistance > Math.AbsFloat(vector.DistanceSq(ladderHandlePointWS, m_Player.GetPosition())))
                                    {
                                        lastDistance = Math.AbsFloat(vector.DistanceSq(ladderHandlePointWS, m_Player.GetPosition()));
                                        closestHandlePos = ladderHandlePointWS;
                                    }
                                }
 
                                m_FixedOnPosition = false;
                                worldPos = closestHandlePos;                        
                                if (memOffset != 0.0)
                                {
                                    worldPos[1] = worldPos[1] + memOffset;
                                }
                                else
                                {
                                    worldPos[1] = worldPos[1] + DEFAULT_HANDLE_OFFSET;
                                }
                            }
                        }

                        m_CachedObject.Store(object, worldPos, -1); 
                    }
                    else
                    {
                        m_FixedOnPosition = true;
                    }
                }
                else
                {
                    m_FixedOnPosition = true;
                }
            }
            else
            {
                m_FixedOnPosition = true;
            }
 
            vector pos = TransformToScreenPos(worldPos);
 
            x = pos[0];
            y = pos[1];
        }
 
        worldPos = vector.Zero;
        isTargetForced = false;

Перекрестные ссылки Math::AbsFloat(), string::Contains(), vector::DistanceSq(), GetName(), LOD::GetSelections(), GetType(), HasFixedActionTargetCursorPosition(), IsComponentInSelection(), m_CachedObject, m_FixedOnPosition, m_Player, m_Target, LOD::NAME_MEMORY, TransformToScreenPos(), x, y и vector::Zero.

Используется в BuildFloatingCursor().