Initial improvements to fix viewport icon selection and draw order (#6284)

* wip fixes for entity viewport icons displaying in the correct order and handling selection correctly Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * add additional comment about z value Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * move manual sorting and some small tidy-up Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * update comment Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * updates following initial round of PR feedback Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * additional changes to support tests for entity icon intersection Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * add support to enable/disable icons separately from helpers Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * final tests added and small tidy-up to display EntityId correctly Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * update some manipulator test framework calls after utility functions were moved Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * fix for implicit cast Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * move icon scale values to AZ_CVARS Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * fix failing tests caught in AR and update some naming conventions for tests Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * update naming convention for members of ProjectedViewportRay Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * update other references to ProjectedViewportRay Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * update more references to ProjectedViewportRay change Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com> * update menus for python tests Signed-off-by: Tom Hulton-Harrop <82228511+hultonha@users.noreply.github.com>
2021-12-16 09:35:23 +00:00
parent df8326a1b0
commit d065eb9498
56 changed files with 783 additions and 449 deletions
@@ -878,9 +878,6 @@ namespace AzToolsFramework
        /// Return the icon texture id (from internal IconManager) for a given entity icon path.
        /// This can be passed to DrawTextureLabel to draw an entity icon.
        virtual int GetIconTextureIdFromEntityIconPath(const AZStd::string& entityIconPath) = 0;
-
-        /// Returns if the Display Helpers option is toggled on in the Editor.
-        virtual bool DisplayHelpersVisible() = 0;
    };

    using EditorRequestBus = AZ::EBus<EditorRequests>;
@@ -89,8 +89,8 @@ namespace AzToolsFramework
        const float rayLength)
    {
        AZ_Assert(rayLength > 0.0f, "Invalid ray length passed to RefreshRayRequest");
-        rayRequest.m_startWorldPosition = viewportRay.origin;
-        rayRequest.m_endWorldPosition = viewportRay.origin + viewportRay.direction * rayLength;
+        rayRequest.m_startWorldPosition = viewportRay.m_origin;
+        rayRequest.m_endWorldPosition = viewportRay.m_origin + viewportRay.m_direction * rayLength;
    }

    AZ::Vector3 FindClosestPickIntersection(
@@ -15,7 +15,6 @@
 #include <AzFramework/Viewport/CameraState.h>
 #include <AzFramework/Viewport/ClickDetector.h>
 #include <AzFramework/Viewport/ViewportId.h>
-#include <AzFramework/Viewport/ViewportScreen.h>
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/Viewport/ViewportTypes.h>

@@ -151,13 +150,6 @@ namespace AzToolsFramework
            static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
        };

-        //! A ray projection, originating from a point and extending in a direction specified as a normal.
-        struct ProjectedViewportRay
-        {
-            AZ::Vector3 origin;
-            AZ::Vector3 direction;
-        };
-
        //! Requests that can be made to the viewport to query and modify its state.
        class ViewportInteractionRequests
        {
@@ -183,15 +175,6 @@ namespace AzToolsFramework
        //! Type to inherit to implement ViewportInteractionRequests.
        using ViewportInteractionRequestBus = AZ::EBus<ViewportInteractionRequests, ViewportEBusTraits>;

-        //! Utility function to return a viewport ray.
-        inline ProjectedViewportRay ViewportScreenToWorldRay(
-            const AzFramework::CameraState& cameraState, const AzFramework::ScreenPoint& screenPoint)
-        {
-            const AZ::Vector3 rayOrigin = AzFramework::ScreenToWorld(screenPoint, cameraState);
-            const AZ::Vector3 rayDirection = (rayOrigin - cameraState.m_position).GetNormalized();
-            return AzToolsFramework::ViewportInteraction::ProjectedViewportRay{ rayOrigin, rayDirection };
-        }
-
        //! Utility function to return a viewport ray using the ViewportInteractionRequestBus.
        inline ProjectedViewportRay ViewportScreenToWorldRay(
            const AzFramework::ViewportId viewportId, const AzFramework::ScreenPoint& screenPoint)
@@ -225,6 +208,10 @@ namespace AzToolsFramework
            virtual bool StickySelectEnabled() const = 0;
            //! Returns the default viewport camera position.
            virtual AZ::Vector3 DefaultEditorCameraPosition() const = 0;
+            //! Returns if icons are visible in the viewport.
+            virtual bool IconsVisible() const = 0;
+            //! Returns if viewport helpers (additional debug drawing) are visible in the viewport.
+            virtual bool HelpersVisible() const = 0;

        protected:
            ~ViewportSettingsRequests() = default;
@@ -20,6 +20,8 @@ namespace AzToolsFramework
    constexpr AZStd::string_view ScaleManipulatorBoxHalfExtentSetting = "/Amazon/Preferences/Editor/Manipulator/ScaleManipulatorBoxHalfExtent";
    constexpr AZStd::string_view RotationManipulatorRadiusSetting = "/Amazon/Preferences/Editor/Manipulator/RotationManipulatorRadius";
    constexpr AZStd::string_view ManipulatorViewBaseScaleSetting = "/Amazon/Preferences/Editor/Manipulator/ViewBaseScale";
+    constexpr AZStd::string_view IconsVisibleSetting = "/Amazon/Preferences/Editor/IconsVisible";
+    constexpr AZStd::string_view HelpersVisibleSetting = "/Amazon/Preferences/Editor/HelpersVisible";

    bool FlipManipulatorAxesTowardsView()
    {
@@ -120,4 +122,24 @@ namespace AzToolsFramework
    {
        SetRegistry(ManipulatorViewBaseScaleSetting, scale);
    }
+
+    bool IconsVisible()
+    {
+        return GetRegistry(IconsVisibleSetting, true);
+    }
+
+    void SetIconsVisible(const bool visible)
+    {
+        SetRegistry(IconsVisibleSetting, visible);
+    }
+
+    bool HelpersVisible()
+    {
+        return GetRegistry(HelpersVisibleSetting, true);
+    }
+
+    void SetHelpersVisible(const bool visible)
+    {
+        SetRegistry(HelpersVisibleSetting, visible);
+    }
 } // namespace AzToolsFramework
@@ -66,4 +66,10 @@ namespace AzToolsFramework

    float ManipulatorViewBaseScale();
    void SetManipulatorViewBaseScale(float scale);
+
+    bool IconsVisible();
+    void SetIconsVisible(bool visible);
+
+    bool HelpersVisible();
+    void SetHelpersVisible(bool visible);
 } // namespace AzToolsFramework
@@ -49,5 +49,22 @@ namespace AzToolsFramework
                ->Field("MouseEvent", &MouseInteractionEvent::m_mouseEvent)
                ->Field("WheelDelta", &MouseInteractionEvent::m_wheelDelta);
        }
+
+        MouseInteraction BuildMouseInteraction(
+            const MousePick& mousePick, const MouseButtons buttons, const InteractionId interactionId, const KeyboardModifiers modifiers)
+        {
+            MouseInteraction interaction;
+            interaction.m_mousePick = mousePick;
+            interaction.m_mouseButtons = buttons;
+            interaction.m_interactionId = interactionId;
+            interaction.m_keyboardModifiers = modifiers;
+            return interaction;
+        }
+
+        MouseInteractionEvent BuildMouseInteractionEvent(
+            const MouseInteraction& mouseInteraction, const MouseEvent event, const bool cursorCaptured /*= false*/)
+        {
+            return MouseInteractionEvent(mouseInteraction, event, cursorCaptured);
+        }
    } // namespace ViewportInteraction
 } // namespace AzToolsFramework
@@ -8,11 +8,11 @@

 #pragma once

-#include "AzFramework/Viewport/ScreenGeometry.h"
-
 #include <AzCore/Component/EntityId.h>
 #include <AzCore/Math/Vector2.h>
 #include <AzCore/Math/Vector3.h>
+#include <AzFramework/Viewport/CameraState.h>
+#include <AzFramework/Viewport/ViewportScreen.h>

 #include <QPoint>

@@ -20,7 +20,7 @@ namespace AZ
 {
    class ReflectContext;
    class SerializeContext;
-}
+} // namespace AZ

 namespace AzToolsFramework
 {
@@ -178,6 +178,12 @@ namespace AzToolsFramework
            //! @cond
            AZ_TYPE_INFO(MousePick, "{A69B9562-FC8C-4DE7-9137-0FF867B1513D}");
            MousePick() = default;
+            MousePick(const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection, const AzFramework::ScreenPoint& screenPoint)
+                : m_rayOrigin(rayOrigin)
+                , m_rayDirection(rayDirection)
+                , m_screenCoordinates(screenPoint)
+            {
+            }
            //! @endcond

            AZ::Vector3 m_rayOrigin = AZ::Vector3::CreateZero(); //!< World space.
@@ -249,6 +255,22 @@ namespace AzToolsFramework
            return mouseInteractionEvent.m_wheelDelta;
        }

+        //! A ray projection, originating from a point and extending in a direction specified as a normal.
+        struct ProjectedViewportRay
+        {
+            AZ::Vector3 m_origin;
+            AZ::Vector3 m_direction;
+        };
+
+        //! Utility function to return a viewport ray.
+        inline ProjectedViewportRay ViewportScreenToWorldRay(
+            const AzFramework::CameraState& cameraState, const AzFramework::ScreenPoint& screenPoint)
+        {
+            const AZ::Vector3 rayOrigin = AzFramework::ScreenToWorld(screenPoint, cameraState);
+            const AZ::Vector3 rayDirection = (rayOrigin - cameraState.m_position).GetNormalized();
+            return ProjectedViewportRay{ rayOrigin, rayDirection };
+        }
+
        //! Return QPoint from AzFramework::ScreenPoint.
        inline QPoint QPointFromScreenPoint(const AzFramework::ScreenPoint& screenPoint)
        {
@@ -301,6 +323,27 @@ namespace AzToolsFramework
            return mouseButtons;
        }

+        //! Build a mouse pick from the specified mouse position and camera state.
+        inline MousePick BuildMousePick(const AzFramework::CameraState& cameraState, const AzFramework::ScreenPoint& screenPoint)
+        {
+            const auto ray = ViewportScreenToWorldRay(cameraState, screenPoint);
+            return MousePick(ray.m_origin, ray.m_direction, screenPoint);
+        }
+
+        //! Create a mouse interaction from the specified pick, buttons, interaction id and keyboard modifiers.
+        MouseInteraction BuildMouseInteraction(
+            const MousePick& mousePick, MouseButtons buttons, InteractionId interactionId, KeyboardModifiers modifiers);
+
+        //! Create a mouse buttons from the specified mouse button.
+        inline MouseButtons BuildMouseButtons(const MouseButton button)
+        {
+            return MouseButtons(aznumeric_cast<AZ::u32>(button));
+        }
+
+        //! Create a mouse interaction event from the specified interaction and event.
+        MouseInteractionEvent BuildMouseInteractionEvent(
+            const MouseInteraction& mouseInteraction, MouseEvent event, bool cursorCaptured = false);
+
        //! Reflect all viewport related types.
        void ViewportInteractionReflect(AZ::ReflectContext* context);
    } // namespace ViewportInteraction
@@ -52,34 +52,45 @@ AZ_CVAR(
    AZ::ConsoleFunctorFlags::Null,
    "Use a lock icon when the cursor is over entities that cannot be interacted with");

+AZ_CVAR(float, ed_iconMinScale, 0.1f, nullptr, AZ::ConsoleFunctorFlags::Null, "Minimum scale for icons in the distance");
+AZ_CVAR(float, ed_iconMaxScale, 1.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "Maximum scale for icons near the camera");
+AZ_CVAR(float, ed_iconCloseDist, 3.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "Distance at which icons are at maximum scale");
+AZ_CVAR(float, ed_iconFarDist, 40.f, nullptr, AZ::ConsoleFunctorFlags::Null, "Distance at which icons are at minimum scale");
+
 namespace AzToolsFramework
 {
    AZ_CLASS_ALLOCATOR_IMPL(EditorHelpers, AZ::SystemAllocator, 0)

-    static const int s_iconSize = 36; // icon display size (in pixels)
-    static const float s_iconMinScale = 0.1f; // minimum scale for icons in the distance
-    static const float s_iconMaxScale = 1.0f; // maximum scale for icons near the camera
-    static const float s_iconCloseDist = 3.f; // distance at which icons are at maximum scale
-    static const float s_iconFarDist = 40.f; // distance at which icons are at minimum scale
+    static const int IconSize = 36; // icon display size (in pixels)

    // helper function to wrap EBus call to check if helpers are being displayed
-    // note: the ['?'] icon in the top right of the editor
-    static bool HelpersVisible()
+    static bool HelpersVisible(const AzFramework::ViewportId viewportId)
    {
        bool helpersVisible = false;
-        EditorRequestBus::BroadcastResult(helpersVisible, &EditorRequests::DisplayHelpersVisible);
+        ViewportInteraction::ViewportSettingsRequestBus::EventResult(
+            helpersVisible, viewportId, &ViewportInteraction::ViewportSettingsRequestBus::Events::HelpersVisible);
        return helpersVisible;
    }

-    // calculate the icon scale based on how far away it is (distanceSq) from a given point
-    // note: this is mostly likely distance from the camera
-    static float GetIconScale(const float distSq)
+    // helper function to wrap EBus call to check if icons are being displayed
+    static bool IconsVisible(const AzFramework::ViewportId viewportId)
    {
-        AZ_PROFILE_FUNCTION(AzToolsFramework);
+        bool iconsVisible = false;
+        ViewportInteraction::ViewportSettingsRequestBus::EventResult(
+            iconsVisible, viewportId, &ViewportInteraction::ViewportSettingsRequestBus::Events::IconsVisible);
+        return iconsVisible;
+    }

-        return s_iconMinScale +
-            (s_iconMaxScale - s_iconMinScale) *
-            (1.0f - AZ::GetClamp(AZ::GetMax(0.0f, sqrtf(distSq) - s_iconCloseDist) / s_iconFarDist, 0.0f, 1.0f));
+    float GetIconScale(const float distance)
+    {
+        return ed_iconMinScale +
+            (ed_iconMaxScale - ed_iconMinScale) *
+            (1.0f - AZ::GetClamp(AZ::GetMax(0.0f, distance - ed_iconCloseDist) / (ed_iconFarDist - ed_iconCloseDist), 0.0f, 1.0f));
+    }
+
+    float GetIconSize(const float distance)
+    {
+        return GetIconScale(distance) * IconSize;
    }

    static void DisplayComponents(
@@ -171,11 +182,14 @@ namespace AzToolsFramework

        const int viewportId = mouseInteraction.m_mouseInteraction.m_interactionId.m_viewportId;

-        const bool helpersVisible = HelpersVisible();
+        const bool iconsVisible = IconsVisible(viewportId);
+
+        const AZ::Matrix3x4 cameraView = AzFramework::CameraView(cameraState);
+        const AZ::Matrix4x4 cameraProjection = AzFramework::CameraProjection(cameraState);

        // selecting new entities
        AZ::EntityId entityIdUnderCursor;
-        float closestDistance = std::numeric_limits<float>::max();
+        float closestDistance = AZStd::numeric_limits<float>::max();
        for (size_t entityCacheIndex = 0; entityCacheIndex < m_entityDataCache->VisibleEntityDataCount(); ++entityCacheIndex)
        {
            const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
@@ -185,8 +199,7 @@ namespace AzToolsFramework
                continue;
            }

-            // 2d screen space selection - did we click an icon
-            if (helpersVisible)
+            if (iconsVisible)
            {
                // some components choose to hide their icons (e.g. meshes)
                // we also do not want to test against icons that may not be showing as they're inside a 'closed' entity container
@@ -197,17 +210,23 @@ namespace AzToolsFramework
                    const AZ::Vector3& entityPosition = m_entityDataCache->GetVisibleEntityPosition(entityCacheIndex);

                    // selecting based on 2d icon - should only do it when visible and not selected
-                    const AzFramework::ScreenPoint screenPosition = AzFramework::WorldToScreen(entityPosition, cameraState);
+                    const AZ::Vector3 ndcPoint = AzFramework::WorldToScreenNdc(entityPosition, cameraView, cameraProjection);
+                    const AzFramework::ScreenPoint screenPosition =
+                        AzFramework::ScreenPointFromNdc(AZ::Vector3ToVector2(ndcPoint), cameraState.m_viewportSize);

-                    const float distSqFromCamera = cameraState.m_position.GetDistanceSq(entityPosition);
-                    const auto iconRange = static_cast<float>(GetIconScale(distSqFromCamera) * s_iconSize * 0.5f);
+                    const float distanceFromCamera = cameraState.m_position.GetDistance(entityPosition);
+                    const auto iconRange = GetIconSize(distanceFromCamera) * 0.5f;
                    const auto screenCoords = mouseInteraction.m_mouseInteraction.m_mousePick.m_screenCoordinates;

+                    // 2d screen space selection - did we click an icon
                    if (screenCoords.m_x >= screenPosition.m_x - iconRange && screenCoords.m_x <= screenPosition.m_x + iconRange &&
-                        screenCoords.m_y >= screenPosition.m_y - iconRange && screenCoords.m_y <= screenPosition.m_y + iconRange)
+                        screenCoords.m_y >= screenPosition.m_y - iconRange && screenCoords.m_y <= screenPosition.m_y + iconRange &&
+                        ndcPoint.GetZ() < closestDistance)
                    {
+                        // use ndc z value for distance here which is in 0-1 range so will most likely 'win' when it comes to the
+                        // distance check (this is what we want as the cursor should always favor icons if they are hovered)
+                        closestDistance = ndcPoint.GetZ();
                        entityIdUnderCursor = entityId;
-                        break;
                    }
                }
            }
@@ -220,9 +239,14 @@ namespace AzToolsFramework
                if (AabbIntersectMouseRay(mouseInteraction.m_mouseInteraction, aabb))
                {
                    // if success, pick against specific component
-                    if (PickEntity(entityId, mouseInteraction.m_mouseInteraction, closestDistance, viewportId))
+                    float closestBoundDifference = AZStd::numeric_limits<float>::max();
+                    if (PickEntity(entityId, mouseInteraction.m_mouseInteraction, closestBoundDifference, viewportId))
                    {
-                        entityIdUnderCursor = entityId;
+                        if (closestBoundDifference < closestDistance)
+                        {
+                            closestDistance = closestBoundDifference;
+                            entityIdUnderCursor = entityId;
+                        }
                    }
                }
            }
@@ -276,55 +300,78 @@ namespace AzToolsFramework
    {
        AZ_PROFILE_FUNCTION(AzToolsFramework);

-        if (HelpersVisible())
+        const bool iconsVisible = IconsVisible(viewportInfo.m_viewportId);
+        const bool helpersVisible = HelpersVisible(viewportInfo.m_viewportId);
+
+        auto displayCheck = [this](const size_t entityCacheIndex, const AZ::EntityId entityId)
+        {
+            if (!m_entityDataCache->IsVisibleEntityVisible(entityCacheIndex) || !IsSelectableInViewport(entityId))
+            {
+                return false;
+            }
+            return true;
+        };
+
+        if (helpersVisible)
        {
            for (size_t entityCacheIndex = 0; entityCacheIndex < m_entityDataCache->VisibleEntityDataCount(); ++entityCacheIndex)
            {
-                const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
-
-                if (!m_entityDataCache->IsVisibleEntityVisible(entityCacheIndex) || !IsSelectableInViewport(entityId))
+                if (const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
+                    displayCheck(entityCacheIndex, entityId))
                {
-                    continue;
+                    // notify components to display
+                    DisplayComponents(entityId, viewportInfo, debugDisplay);
                }
+            }
+        }

-                // notify components to display
-                DisplayComponents(entityId, viewportInfo, debugDisplay);
+        if (iconsVisible)
+        {
+            auto editorViewportIconDisplay = EditorViewportIconDisplay::Get();
+            if (!editorViewportIconDisplay)
+            {
+                return;
+            }

-                if (m_entityDataCache->IsVisibleEntityIconHidden(entityCacheIndex) ||
-                    (m_entityDataCache->IsVisibleEntitySelected(entityCacheIndex) && !showIconCheck(entityId)))
+            for (size_t entityCacheIndex = 0; entityCacheIndex < m_entityDataCache->VisibleEntityDataCount(); ++entityCacheIndex)
+            {
+                if (const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
+                    displayCheck(entityCacheIndex, entityId))
                {
-                    continue;
-                }
-
-                int iconTextureId = 0;
-                EditorEntityIconComponentRequestBus::EventResult(
-                    iconTextureId, entityId, &EditorEntityIconComponentRequests::GetEntityIconTextureId);
-
-                const AZ::Vector3& entityPosition = m_entityDataCache->GetVisibleEntityPosition(entityCacheIndex);
-                const float distSqFromCamera = cameraState.m_position.GetDistanceSq(entityPosition);
-
-                const float iconScale = GetIconScale(distSqFromCamera);
-                const float iconSize = s_iconSize * iconScale;
-
-                using ComponentEntityAccentType = Components::EditorSelectionAccentSystemComponent::ComponentEntityAccentType;
-                const AZ::Color iconHighlight = [this, entityCacheIndex]()
-                {
-                    if (m_entityDataCache->IsVisibleEntityLocked(entityCacheIndex))
+                    if (m_entityDataCache->IsVisibleEntityIconHidden(entityCacheIndex) ||
+                        (m_entityDataCache->IsVisibleEntitySelected(entityCacheIndex) && !showIconCheck(entityId)))
                    {
-                        return AZ::Color(AZ::u8(100), AZ::u8(100), AZ::u8(100), AZ::u8(255));
+                        continue;
                    }

-                    if (m_entityDataCache->GetVisibleEntityAccent(entityCacheIndex) == ComponentEntityAccentType::Hover)
+                    int iconTextureId = 0;
+                    EditorEntityIconComponentRequestBus::EventResult(
+                        iconTextureId, entityId, &EditorEntityIconComponentRequests::GetEntityIconTextureId);
+
+                    using ComponentEntityAccentType = Components::EditorSelectionAccentSystemComponent::ComponentEntityAccentType;
+                    const AZ::Color iconHighlight = [this, entityCacheIndex]()
                    {
-                        return AZ::Color(AZ::u8(255), AZ::u8(120), AZ::u8(0), AZ::u8(204));
-                    }
+                        if (m_entityDataCache->IsVisibleEntityLocked(entityCacheIndex))
+                        {
+                            return AZ::Color(AZ::u8(100), AZ::u8(100), AZ::u8(100), AZ::u8(255));
+                        }

-                    return AZ::Color(1.0f, 1.0f, 1.0f, 1.0f);
-                }();
+                        if (m_entityDataCache->GetVisibleEntityAccent(entityCacheIndex) == ComponentEntityAccentType::Hover)
+                        {
+                            return AZ::Color(AZ::u8(255), AZ::u8(120), AZ::u8(0), AZ::u8(204));
+                        }

-                EditorViewportIconDisplay::Get()->DrawIcon({ viewportInfo.m_viewportId, iconTextureId, iconHighlight, entityPosition,
-                                                             EditorViewportIconDisplayInterface::CoordinateSpace::WorldSpace,
-                                                             AZ::Vector2{ iconSize, iconSize } });
+                        return AZ::Color(1.0f, 1.0f, 1.0f, 1.0f);
+                    }();
+
+                    const AZ::Vector3& entityPosition = m_entityDataCache->GetVisibleEntityPosition(entityCacheIndex);
+                    const float distanceFromCamera = cameraState.m_position.GetDistance(entityPosition);
+                    const float iconSize = GetIconSize(distanceFromCamera);
+
+                    editorViewportIconDisplay->DrawIcon({ viewportInfo.m_viewportId, iconTextureId, iconHighlight, entityPosition,
+                                                          EditorViewportIconDisplayInterface::CoordinateSpace::WorldSpace,
+                                                          AZ::Vector2{ iconSize, iconSize } });
+                }
            }
        }
    }
@@ -106,4 +106,12 @@ namespace AzToolsFramework
        const EditorVisibleEntityDataCache* m_entityDataCache = nullptr; //!< Entity Data queried by the EditorHelpers.
        const FocusModeInterface* m_focusModeInterface = nullptr; //!< API to interact with focus mode functionality.
    };
+
+    //! Calculate the icon scale based on how far away it is from a given point.
+    //! @note This is mostly likely distance from the camera.
+    float GetIconScale(float distance);
+
+    //! Calculate the icon size based on how far away it is from a given point.
+    //! @note This is the base icon size multiplied by the icon scale to give a final viewport size.
+    float GetIconSize(float distance);
 } // namespace AzToolsFramework
@@ -2521,10 +2521,9 @@ namespace AzToolsFramework
            AZStd::erase_if(
                m_selectedEntityIds,
                [readOnlyEntityPublicInterface](auto entityId)
-            {
-                return readOnlyEntityPublicInterface->IsReadOnly(entityId);
-            }
-            );
+                {
+                    return readOnlyEntityPublicInterface->IsReadOnly(entityId);
+                });
        }

        // note: create/destroy pattern to be addressed
@@ -3285,9 +3284,9 @@ namespace AzToolsFramework
            QObject::connect(
                action, &QAction::triggered, action,
                [this]
-            {
-                ToggleCenterPivotSelection();
-            });
+                {
+                    ToggleCenterPivotSelection();
+                });
        }
    }

@@ -32,6 +32,8 @@ namespace AzToolsFramework
    constexpr inline AZ::Crc32 EditReset = AZ_CRC_CE("com.o3de.action.editortransform.editreset");
    constexpr inline AZ::Crc32 EditResetManipulator = AZ_CRC_CE("com.o3de.action.editortransform.editresetmanipulator");
    constexpr inline AZ::Crc32 ViewportUiVisible = AZ_CRC_CE("com.o3de.action.editortransform.viewportuivisible");
+    constexpr inline AZ::Crc32 Helpers = AZ_CRC_CE("com.o3de.action.editor.helpers");
+    constexpr inline AZ::Crc32 Icons = AZ_CRC_CE("com.o3de.action.editor.icons");
    //@}

    //! Provide interface for EditorTransformComponentSelection requests.