Merge branch 'upstream/development' into LYN-6769_TestingRPCs

Code/Editor/EditorPreferencesPageViewportManipulator.cpp

@@ -10,6 +10,8 @@
 
 #include "EditorPreferencesPageViewportManipulator.h"
 
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
+
 // Editor
 #include "EditorViewportSettings.h"
 #include "Settings.h"
@@ -19,7 +21,17 @@ void CEditorPreferencesPage_ViewportManipulator::Reflect(AZ::SerializeContext& s
     serialize.Class<Manipulators>()
         ->Version(1)
         ->Field("LineBoundWidth", &Manipulators::m_manipulatorLineBoundWidth)
-        ->Field("CircleBoundWidth", &Manipulators::m_manipulatorCircleBoundWidth);
+        ->Field("CircleBoundWidth", &Manipulators::m_manipulatorCircleBoundWidth)
+        ->Field("LinearManipulatorAxisLength", &Manipulators::m_linearManipulatorAxisLength)
+        ->Field("PlanarManipulatorAxisLength", &Manipulators::m_planarManipulatorAxisLength)
+        ->Field("SurfaceManipulatorRadius", &Manipulators::m_surfaceManipulatorRadius)
+        ->Field("SurfaceManipulatorOpacity", &Manipulators::m_surfaceManipulatorOpacity)
+        ->Field("LinearManipulatorConeLength", &Manipulators::m_linearManipulatorConeLength)
+        ->Field("LinearManipulatorConeRadius", &Manipulators::m_linearManipulatorConeRadius)
+        ->Field("ScaleManipulatorBoxHalfExtent", &Manipulators::m_scaleManipulatorBoxHalfExtent)
+        ->Field("RotationManipulatorRadius", &Manipulators::m_rotationManipulatorRadius)
+        ->Field("ManipulatorViewBaseScale", &Manipulators::m_manipulatorViewBaseScale)
+        ->Field("FlipManipulatorAxesTowardsView", &Manipulators::m_flipManipulatorAxesTowardsView);
 
     serialize.Class<CEditorPreferencesPage_ViewportManipulator>()->Version(2)->Field(
         "Manipulators", &CEditorPreferencesPage_ViewportManipulator::m_manipulators);
@@ -36,7 +48,55 @@ void CEditorPreferencesPage_ViewportManipulator::Reflect(AZ::SerializeContext& s
                 AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_manipulatorCircleBoundWidth, "Circle Bound Width",
                 "Manipulator Circle Bound Width")
             ->Attribute(AZ::Edit::Attributes::Min, 0.001f)
-            ->Attribute(AZ::Edit::Attributes::Max, 2.0f);
+            ->Attribute(AZ::Edit::Attributes::Max, 2.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_linearManipulatorAxisLength, "Linear Manipulator Axis Length",
+                "Length of default Linear Manipulator (for Translation and Scale Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.1f)
+            ->Attribute(AZ::Edit::Attributes::Max, 5.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_planarManipulatorAxisLength, "Planar Manipulator Axis Length",
+                "Length of default Planar Manipulator (for Translation Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.1f)
+            ->Attribute(AZ::Edit::Attributes::Max, 5.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_surfaceManipulatorRadius, "Surface Manipulator Radius",
+                "Radius of default Surface Manipulator (for Translation Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.05f)
+            ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_surfaceManipulatorOpacity, "Surface Manipulator Opacity",
+                "Opacity of default Surface Manipulator (for Translation Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_linearManipulatorConeLength, "Linear Manipulator Cone Length",
+                "Length of cone for default Linear Manipulator (for Translation Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.05f)
+            ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_linearManipulatorConeRadius, "Linear Manipulator Cone Radius",
+                "Radius of cone for default Linear Manipulator (for Translation Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.05f)
+            ->Attribute(AZ::Edit::Attributes::Max, 0.5f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_scaleManipulatorBoxHalfExtent, "Scale Manipulator Box Half Extent",
+                "Half extent of box for default Scale Manipulator")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.05f)
+            ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_rotationManipulatorRadius, "Rotation Manipulator Radius",
+                "Radius of default Angular Manipulators (for Rotation Manipulators)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.5f)
+            ->Attribute(AZ::Edit::Attributes::Max, 5.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &Manipulators::m_manipulatorViewBaseScale, "Manipulator View Base Scale",
+                "The base scale to apply to all Manipulator Views (default is 1.0)")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.5f)
+            ->Attribute(AZ::Edit::Attributes::Max, 2.0f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &Manipulators::m_flipManipulatorAxesTowardsView, "Flip Manipulator Axes Towards View",
+                "Determines whether Planar and Linear Manipulators should switch to face the view (camera) in the Editor");
 
         editContext
             ->Class<CEditorPreferencesPage_ViewportManipulator>("Manipulator Viewport Preferences", "Manipulator Viewport Preferences")
@@ -82,10 +142,32 @@ void CEditorPreferencesPage_ViewportManipulator::OnApply()
 {
     SandboxEditor::SetManipulatorLineBoundWidth(m_manipulators.m_manipulatorLineBoundWidth);
     SandboxEditor::SetManipulatorCircleBoundWidth(m_manipulators.m_manipulatorCircleBoundWidth);
+
+    AzToolsFramework::SetLinearManipulatorAxisLength(m_manipulators.m_linearManipulatorAxisLength);
+    AzToolsFramework::SetPlanarManipulatorAxisLength(m_manipulators.m_planarManipulatorAxisLength);
+    AzToolsFramework::SetSurfaceManipulatorRadius(m_manipulators.m_surfaceManipulatorRadius);
+    AzToolsFramework::SetSurfaceManipulatorOpacity(m_manipulators.m_surfaceManipulatorOpacity);
+    AzToolsFramework::SetLinearManipulatorConeLength(m_manipulators.m_linearManipulatorConeLength);
+    AzToolsFramework::SetLinearManipulatorConeRadius(m_manipulators.m_linearManipulatorConeRadius);
+    AzToolsFramework::SetScaleManipulatorBoxHalfExtent(m_manipulators.m_scaleManipulatorBoxHalfExtent);
+    AzToolsFramework::SetRotationManipulatorRadius(m_manipulators.m_rotationManipulatorRadius);
+    AzToolsFramework::SetFlipManipulatorAxesTowardsView(m_manipulators.m_flipManipulatorAxesTowardsView);
+    AzToolsFramework::SetManipulatorViewBaseScale(m_manipulators.m_manipulatorViewBaseScale);
 }
 
 void CEditorPreferencesPage_ViewportManipulator::InitializeSettings()
 {
     m_manipulators.m_manipulatorLineBoundWidth = SandboxEditor::ManipulatorLineBoundWidth();
     m_manipulators.m_manipulatorCircleBoundWidth = SandboxEditor::ManipulatorCircleBoundWidth();
+
+    m_manipulators.m_linearManipulatorAxisLength = AzToolsFramework::LinearManipulatorAxisLength();
+    m_manipulators.m_planarManipulatorAxisLength = AzToolsFramework::PlanarManipulatorAxisLength();
+    m_manipulators.m_surfaceManipulatorRadius = AzToolsFramework::SurfaceManipulatorRadius();
+    m_manipulators.m_surfaceManipulatorOpacity = AzToolsFramework::SurfaceManipulatorOpacity();
+    m_manipulators.m_linearManipulatorConeLength = AzToolsFramework::LinearManipulatorConeLength();
+    m_manipulators.m_linearManipulatorConeRadius = AzToolsFramework::LinearManipulatorConeRadius();
+    m_manipulators.m_scaleManipulatorBoxHalfExtent = AzToolsFramework::ScaleManipulatorBoxHalfExtent();
+    m_manipulators.m_rotationManipulatorRadius = AzToolsFramework::RotationManipulatorRadius();
+    m_manipulators.m_flipManipulatorAxesTowardsView = AzToolsFramework::FlipManipulatorAxesTowardsView();
+    m_manipulators.m_manipulatorViewBaseScale = AzToolsFramework::ManipulatorViewBaseScale();
 }

Code/Editor/EditorPreferencesPageViewportManipulator.h

@@ -41,6 +41,16 @@ private:
 
         float m_manipulatorLineBoundWidth = 0.0f;
         float m_manipulatorCircleBoundWidth = 0.0f;
+        float m_linearManipulatorAxisLength = 0.0f;
+        float m_planarManipulatorAxisLength = 0.0f;
+        float m_surfaceManipulatorRadius = 0.0f;
+        float m_surfaceManipulatorOpacity = 0.0f;
+        float m_linearManipulatorConeLength = 0.0f;
+        float m_linearManipulatorConeRadius = 0.0f;
+        float m_scaleManipulatorBoxHalfExtent = 0.0f;
+        float m_rotationManipulatorRadius = 0.0f;
+        float m_manipulatorViewBaseScale = 0.0f;
+        bool m_flipManipulatorAxesTowardsView = false;
     };
 
     Manipulators m_manipulators;

Code/Editor/EditorViewportSettings.cpp

@@ -12,6 +12,7 @@
 #include <AzCore/Settings/SettingsRegistry.h>
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <AzCore/std/string/string_view.h>
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
 
 namespace SandboxEditor
 {
@@ -57,31 +58,6 @@ namespace SandboxEditor
     constexpr AZStd::string_view CameraDefaultStartingPositionY = "/Amazon/Preferences/Editor/Camera/DefaultStartingPosition/y";
     constexpr AZStd::string_view CameraDefaultStartingPositionZ = "/Amazon/Preferences/Editor/Camera/DefaultStartingPosition/z";
 
-    template<typename T>
-    void SetRegistry(const AZStd::string_view setting, T&& value)
-    {
-        if (auto* registry = AZ::SettingsRegistry::Get())
-        {
-            registry->Set(setting, AZStd::forward<T>(value));
-        }
-    }
-
-    template<typename T>
-    AZStd::remove_cvref_t<T> GetRegistry(const AZStd::string_view setting, T&& defaultValue)
-    {
-        AZStd::remove_cvref_t<T> value = AZStd::forward<T>(defaultValue);
-        if (const auto* registry = AZ::SettingsRegistry::Get())
-        {
-            T potentialValue;
-            if (registry->Get(potentialValue, setting))
-            {
-                value = AZStd::move(potentialValue);
-            }
-        }
-
-        return value;
-    }
-
     struct EditorViewportSettingsCallbacksImpl : public EditorViewportSettingsCallbacks
     {
         EditorViewportSettingsCallbacksImpl()
@@ -118,399 +94,409 @@ namespace SandboxEditor
     AZ::Vector3 CameraDefaultEditorPosition()
     {
         return AZ::Vector3(
-            aznumeric_cast<float>(GetRegistry(CameraDefaultStartingPositionX, 0.0)),
-            aznumeric_cast<float>(GetRegistry(CameraDefaultStartingPositionY, -10.0)),
-            aznumeric_cast<float>(GetRegistry(CameraDefaultStartingPositionZ, 4.0)));
+            aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraDefaultStartingPositionX, 0.0)),
+            aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraDefaultStartingPositionY, -10.0)),
+            aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraDefaultStartingPositionZ, 4.0)));
     }
 
     void SetCameraDefaultEditorPosition(const AZ::Vector3& defaultCameraPosition)
     {
-        SetRegistry(CameraDefaultStartingPositionX, defaultCameraPosition.GetX());
-        SetRegistry(CameraDefaultStartingPositionY, defaultCameraPosition.GetY());
-        SetRegistry(CameraDefaultStartingPositionZ, defaultCameraPosition.GetZ());
+        AzToolsFramework::SetRegistry(CameraDefaultStartingPositionX, defaultCameraPosition.GetX());
+        AzToolsFramework::SetRegistry(CameraDefaultStartingPositionY, defaultCameraPosition.GetY());
+        AzToolsFramework::SetRegistry(CameraDefaultStartingPositionZ, defaultCameraPosition.GetZ());
     }
 
     AZ::u64 MaxItemsShownInAssetBrowserSearch()
     {
-        return GetRegistry(AssetBrowserMaxItemsShownInSearchSetting, aznumeric_cast<AZ::u64>(50));
+        return AzToolsFramework::GetRegistry(AssetBrowserMaxItemsShownInSearchSetting, aznumeric_cast<AZ::u64>(50));
     }
 
     void SetMaxItemsShownInAssetBrowserSearch(const AZ::u64 numberOfItemsShown)
     {
-        SetRegistry(AssetBrowserMaxItemsShownInSearchSetting, numberOfItemsShown);
+        AzToolsFramework::SetRegistry(AssetBrowserMaxItemsShownInSearchSetting, numberOfItemsShown);
     }
 
     bool GridSnappingEnabled()
     {
-        return GetRegistry(GridSnappingSetting, false);
+        return AzToolsFramework::GetRegistry(GridSnappingSetting, false);
     }
 
     void SetGridSnapping(const bool enabled)
     {
-        SetRegistry(GridSnappingSetting, enabled);
+        AzToolsFramework::SetRegistry(GridSnappingSetting, enabled);
     }
 
     float GridSnappingSize()
     {
-        return aznumeric_cast<float>(GetRegistry(GridSizeSetting, 0.1));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(GridSizeSetting, 0.1));
     }
 
     void SetGridSnappingSize(const float size)
     {
-        SetRegistry(GridSizeSetting, size);
+        AzToolsFramework::SetRegistry(GridSizeSetting, size);
     }
 
     bool AngleSnappingEnabled()
     {
-        return GetRegistry(AngleSnappingSetting, false);
+        return AzToolsFramework::GetRegistry(AngleSnappingSetting, false);
     }
 
     void SetAngleSnapping(const bool enabled)
     {
-        SetRegistry(AngleSnappingSetting, enabled);
+        AzToolsFramework::SetRegistry(AngleSnappingSetting, enabled);
     }
 
     float AngleSnappingSize()
     {
-        return aznumeric_cast<float>(GetRegistry(AngleSizeSetting, 5.0));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(AngleSizeSetting, 5.0));
     }
 
     void SetAngleSnappingSize(const float size)
     {
-        SetRegistry(AngleSizeSetting, size);
+        AzToolsFramework::SetRegistry(AngleSizeSetting, size);
     }
 
     bool ShowingGrid()
     {
-        return GetRegistry(ShowGridSetting, false);
+        return AzToolsFramework::GetRegistry(ShowGridSetting, false);
     }
 
     void SetShowingGrid(const bool showing)
     {
-        SetRegistry(ShowGridSetting, showing);
+        AzToolsFramework::SetRegistry(ShowGridSetting, showing);
     }
 
     bool StickySelectEnabled()
     {
-        return GetRegistry(StickySelectSetting, false);
+        return AzToolsFramework::GetRegistry(StickySelectSetting, false);
     }
 
     void SetStickySelectEnabled(const bool enabled)
     {
-        SetRegistry(StickySelectSetting, enabled);
+        AzToolsFramework::SetRegistry(StickySelectSetting, enabled);
     }
 
     float ManipulatorLineBoundWidth()
     {
-        return aznumeric_cast<float>(GetRegistry(ManipulatorLineBoundWidthSetting, 0.1));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(ManipulatorLineBoundWidthSetting, 0.1));
     }
 
     void SetManipulatorLineBoundWidth(const float lineBoundWidth)
     {
-        SetRegistry(ManipulatorLineBoundWidthSetting, lineBoundWidth);
+        AzToolsFramework::SetRegistry(ManipulatorLineBoundWidthSetting, lineBoundWidth);
     }
 
     float ManipulatorCircleBoundWidth()
     {
-        return aznumeric_cast<float>(GetRegistry(ManipulatorCircleBoundWidthSetting, 0.1));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(ManipulatorCircleBoundWidthSetting, 0.1));
     }
 
     void SetManipulatorCircleBoundWidth(const float circleBoundWidth)
     {
-        SetRegistry(ManipulatorCircleBoundWidthSetting, circleBoundWidth);
+        AzToolsFramework::SetRegistry(ManipulatorCircleBoundWidthSetting, circleBoundWidth);
     }
 
     float CameraTranslateSpeed()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraTranslateSpeedSetting, 10.0));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraTranslateSpeedSetting, 10.0));
     }
 
     void SetCameraTranslateSpeed(const float speed)
     {
-        SetRegistry(CameraTranslateSpeedSetting, speed);
+        AzToolsFramework::SetRegistry(CameraTranslateSpeedSetting, speed);
     }
 
     float CameraBoostMultiplier()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraBoostMultiplierSetting, 3.0));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraBoostMultiplierSetting, 3.0));
     }
 
     void SetCameraBoostMultiplier(const float multiplier)
     {
-        SetRegistry(CameraBoostMultiplierSetting, multiplier);
+        AzToolsFramework::SetRegistry(CameraBoostMultiplierSetting, multiplier);
     }
 
     float CameraRotateSpeed()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraRotateSpeedSetting, 0.005));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraRotateSpeedSetting, 0.005));
     }
 
     void SetCameraRotateSpeed(const float speed)
     {
-        SetRegistry(CameraRotateSpeedSetting, speed);
+        AzToolsFramework::SetRegistry(CameraRotateSpeedSetting, speed);
     }
 
     float CameraScrollSpeed()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraScrollSpeedSetting, 0.02));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraScrollSpeedSetting, 0.02));
     }
 
     void SetCameraScrollSpeed(const float speed)
     {
-        SetRegistry(CameraScrollSpeedSetting, speed);
+        AzToolsFramework::SetRegistry(CameraScrollSpeedSetting, speed);
     }
 
     float CameraDollyMotionSpeed()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraDollyMotionSpeedSetting, 0.01));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraDollyMotionSpeedSetting, 0.01));
     }
 
     void SetCameraDollyMotionSpeed(const float speed)
     {
-        SetRegistry(CameraDollyMotionSpeedSetting, speed);
+        AzToolsFramework::SetRegistry(CameraDollyMotionSpeedSetting, speed);
     }
 
     bool CameraOrbitYawRotationInverted()
     {
-        return GetRegistry(CameraOrbitYawRotationInvertedSetting, false);
+        return AzToolsFramework::GetRegistry(CameraOrbitYawRotationInvertedSetting, false);
     }
 
     void SetCameraOrbitYawRotationInverted(const bool inverted)
     {
-        SetRegistry(CameraOrbitYawRotationInvertedSetting, inverted);
+        AzToolsFramework::SetRegistry(CameraOrbitYawRotationInvertedSetting, inverted);
     }
 
     bool CameraPanInvertedX()
     {
-        return GetRegistry(CameraPanInvertedXSetting, true);
+        return AzToolsFramework::GetRegistry(CameraPanInvertedXSetting, true);
     }
 
     void SetCameraPanInvertedX(const bool inverted)
     {
-        SetRegistry(CameraPanInvertedXSetting, inverted);
+        AzToolsFramework::SetRegistry(CameraPanInvertedXSetting, inverted);
     }
 
     bool CameraPanInvertedY()
     {
-        return GetRegistry(CameraPanInvertedYSetting, true);
+        return AzToolsFramework::GetRegistry(CameraPanInvertedYSetting, true);
     }
 
     void SetCameraPanInvertedY(const bool inverted)
     {
-        SetRegistry(CameraPanInvertedYSetting, inverted);
+        AzToolsFramework::SetRegistry(CameraPanInvertedYSetting, inverted);
     }
 
     float CameraPanSpeed()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraPanSpeedSetting, 0.01));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraPanSpeedSetting, 0.01));
     }
 
     void SetCameraPanSpeed(float speed)
     {
-        SetRegistry(CameraPanSpeedSetting, speed);
+        AzToolsFramework::SetRegistry(CameraPanSpeedSetting, speed);
     }
 
     float CameraRotateSmoothness()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraRotateSmoothnessSetting, 5.0));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraRotateSmoothnessSetting, 5.0));
     }
 
     void SetCameraRotateSmoothness(const float smoothness)
     {
-        SetRegistry(CameraRotateSmoothnessSetting, smoothness);
+        AzToolsFramework::SetRegistry(CameraRotateSmoothnessSetting, smoothness);
     }
 
     float CameraTranslateSmoothness()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraTranslateSmoothnessSetting, 5.0));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraTranslateSmoothnessSetting, 5.0));
     }
 
     void SetCameraTranslateSmoothness(const float smoothness)
     {
-        SetRegistry(CameraTranslateSmoothnessSetting, smoothness);
+        AzToolsFramework::SetRegistry(CameraTranslateSmoothnessSetting, smoothness);
     }
 
     bool CameraRotateSmoothingEnabled()
     {
-        return GetRegistry(CameraRotateSmoothingSetting, true);
+        return AzToolsFramework::GetRegistry(CameraRotateSmoothingSetting, true);
     }
 
     void SetCameraRotateSmoothingEnabled(const bool enabled)
     {
-        SetRegistry(CameraRotateSmoothingSetting, enabled);
+        AzToolsFramework::SetRegistry(CameraRotateSmoothingSetting, enabled);
     }
 
     bool CameraTranslateSmoothingEnabled()
     {
-        return GetRegistry(CameraTranslateSmoothingSetting, true);
+        return AzToolsFramework::GetRegistry(CameraTranslateSmoothingSetting, true);
     }
 
     void SetCameraTranslateSmoothingEnabled(const bool enabled)
     {
-        SetRegistry(CameraTranslateSmoothingSetting, enabled);
+        AzToolsFramework::SetRegistry(CameraTranslateSmoothingSetting, enabled);
     }
 
     bool CameraCaptureCursorForLook()
     {
-        return GetRegistry(CameraCaptureCursorLookSetting, true);
+        return AzToolsFramework::GetRegistry(CameraCaptureCursorLookSetting, true);
     }
 
     void SetCameraCaptureCursorForLook(const bool capture)
     {
-        SetRegistry(CameraCaptureCursorLookSetting, capture);
+        AzToolsFramework::SetRegistry(CameraCaptureCursorLookSetting, capture);
     }
 
     float CameraDefaultOrbitDistance()
     {
-        return aznumeric_cast<float>(GetRegistry(CameraDefaultOrbitDistanceSetting, 20.0));
+        return aznumeric_cast<float>(AzToolsFramework::GetRegistry(CameraDefaultOrbitDistanceSetting, 20.0));
     }
 
     void SetCameraDefaultOrbitDistance(const float distance)
     {
-        SetRegistry(CameraDefaultOrbitDistanceSetting, distance);
+        AzToolsFramework::SetRegistry(CameraDefaultOrbitDistanceSetting, distance);
     }
 
     AzFramework::InputChannelId CameraTranslateForwardChannelId()
     {
         return AzFramework::InputChannelId(
-            GetRegistry(CameraTranslateForwardIdSetting, AZStd::string("keyboard_key_alphanumeric_W")).c_str());
+            AzToolsFramework::GetRegistry(CameraTranslateForwardIdSetting, AZStd::string("keyboard_key_alphanumeric_W")).c_str());
     }
 
     void SetCameraTranslateForwardChannelId(AZStd::string_view cameraTranslateForwardId)
     {
-        SetRegistry(CameraTranslateForwardIdSetting, cameraTranslateForwardId);
+        AzToolsFramework::SetRegistry(CameraTranslateForwardIdSetting, cameraTranslateForwardId);
     }
 
     AzFramework::InputChannelId CameraTranslateBackwardChannelId()
     {
         return AzFramework::InputChannelId(
-            GetRegistry(CameraTranslateBackwardIdSetting, AZStd::string("keyboard_key_alphanumeric_S")).c_str());
+            AzToolsFramework::GetRegistry(CameraTranslateBackwardIdSetting, AZStd::string("keyboard_key_alphanumeric_S")).c_str());
     }
 
     void SetCameraTranslateBackwardChannelId(AZStd::string_view cameraTranslateBackwardId)
     {
-        SetRegistry(CameraTranslateBackwardIdSetting, cameraTranslateBackwardId);
+        AzToolsFramework::SetRegistry(CameraTranslateBackwardIdSetting, cameraTranslateBackwardId);
     }
 
     AzFramework::InputChannelId CameraTranslateLeftChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraTranslateLeftIdSetting, AZStd::string("keyboard_key_alphanumeric_A")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraTranslateLeftIdSetting, AZStd::string("keyboard_key_alphanumeric_A")).c_str());
     }
 
     void SetCameraTranslateLeftChannelId(AZStd::string_view cameraTranslateLeftId)
     {
-        SetRegistry(CameraTranslateLeftIdSetting, cameraTranslateLeftId);
+        AzToolsFramework::SetRegistry(CameraTranslateLeftIdSetting, cameraTranslateLeftId);
     }
 
     AzFramework::InputChannelId CameraTranslateRightChannelId()
     {
         return AzFramework::InputChannelId(
-            GetRegistry(CameraTranslateRightIdSetting, AZStd::string("keyboard_key_alphanumeric_D")).c_str());
+            AzToolsFramework::GetRegistry(CameraTranslateRightIdSetting, AZStd::string("keyboard_key_alphanumeric_D")).c_str());
     }
 
     void SetCameraTranslateRightChannelId(AZStd::string_view cameraTranslateRightId)
     {
-        SetRegistry(CameraTranslateRightIdSetting, cameraTranslateRightId);
+        AzToolsFramework::SetRegistry(CameraTranslateRightIdSetting, cameraTranslateRightId);
     }
 
     AzFramework::InputChannelId CameraTranslateUpChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraTranslateUpIdSetting, AZStd::string("keyboard_key_alphanumeric_E")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraTranslateUpIdSetting, AZStd::string("keyboard_key_alphanumeric_E")).c_str());
     }
 
     void SetCameraTranslateUpChannelId(AZStd::string_view cameraTranslateUpId)
     {
-        SetRegistry(CameraTranslateUpIdSetting, cameraTranslateUpId);
+        AzToolsFramework::SetRegistry(CameraTranslateUpIdSetting, cameraTranslateUpId);
     }
 
     AzFramework::InputChannelId CameraTranslateDownChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraTranslateDownIdSetting, AZStd::string("keyboard_key_alphanumeric_Q")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraTranslateDownIdSetting, AZStd::string("keyboard_key_alphanumeric_Q")).c_str());
     }
 
     void SetCameraTranslateDownChannelId(AZStd::string_view cameraTranslateDownId)
     {
-        SetRegistry(CameraTranslateDownIdSetting, cameraTranslateDownId);
+        AzToolsFramework::SetRegistry(CameraTranslateDownIdSetting, cameraTranslateDownId);
     }
 
     AzFramework::InputChannelId CameraTranslateBoostChannelId()
     {
         return AzFramework::InputChannelId(
-            GetRegistry(CameraTranslateBoostIdSetting, AZStd::string("keyboard_key_modifier_shift_l")).c_str());
+            AzToolsFramework::GetRegistry(CameraTranslateBoostIdSetting, AZStd::string("keyboard_key_modifier_shift_l")).c_str());
     }
 
     void SetCameraTranslateBoostChannelId(AZStd::string_view cameraTranslateBoostId)
     {
-        SetRegistry(CameraTranslateBoostIdSetting, cameraTranslateBoostId);
+        AzToolsFramework::SetRegistry(CameraTranslateBoostIdSetting, cameraTranslateBoostId);
     }
 
     AzFramework::InputChannelId CameraOrbitChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraOrbitIdSetting, AZStd::string("keyboard_key_modifier_alt_l")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraOrbitIdSetting, AZStd::string("keyboard_key_modifier_alt_l")).c_str());
     }
 
     void SetCameraOrbitChannelId(AZStd::string_view cameraOrbitId)
     {
-        SetRegistry(CameraOrbitIdSetting, cameraOrbitId);
+        AzToolsFramework::SetRegistry(CameraOrbitIdSetting, cameraOrbitId);
     }
 
     AzFramework::InputChannelId CameraFreeLookChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraFreeLookIdSetting, AZStd::string("mouse_button_right")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraFreeLookIdSetting, AZStd::string("mouse_button_right")).c_str());
     }
 
     void SetCameraFreeLookChannelId(AZStd::string_view cameraFreeLookId)
     {
-        SetRegistry(CameraFreeLookIdSetting, cameraFreeLookId);
+        AzToolsFramework::SetRegistry(CameraFreeLookIdSetting, cameraFreeLookId);
     }
 
     AzFramework::InputChannelId CameraFreePanChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraFreePanIdSetting, AZStd::string("mouse_button_middle")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraFreePanIdSetting, AZStd::string("mouse_button_middle")).c_str());
     }
 
     void SetCameraFreePanChannelId(AZStd::string_view cameraFreePanId)
     {
-        SetRegistry(CameraFreePanIdSetting, cameraFreePanId);
+        AzToolsFramework::SetRegistry(CameraFreePanIdSetting, cameraFreePanId);
     }
 
     AzFramework::InputChannelId CameraOrbitLookChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraOrbitLookIdSetting, AZStd::string("mouse_button_left")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraOrbitLookIdSetting, AZStd::string("mouse_button_left")).c_str());
     }
 
     void SetCameraOrbitLookChannelId(AZStd::string_view cameraOrbitLookId)
     {
-        SetRegistry(CameraOrbitLookIdSetting, cameraOrbitLookId);
+        AzToolsFramework::SetRegistry(CameraOrbitLookIdSetting, cameraOrbitLookId);
     }
 
     AzFramework::InputChannelId CameraOrbitDollyChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraOrbitDollyIdSetting, AZStd::string("mouse_button_right")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraOrbitDollyIdSetting, AZStd::string("mouse_button_right")).c_str());
     }
 
     void SetCameraOrbitDollyChannelId(AZStd::string_view cameraOrbitDollyId)
     {
-        SetRegistry(CameraOrbitDollyIdSetting, cameraOrbitDollyId);
+        AzToolsFramework::SetRegistry(CameraOrbitDollyIdSetting, cameraOrbitDollyId);
     }
 
     AzFramework::InputChannelId CameraOrbitPanChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraOrbitPanIdSetting, AZStd::string("mouse_button_middle")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraOrbitPanIdSetting, AZStd::string("mouse_button_middle")).c_str());
     }
 
     void SetCameraOrbitPanChannelId(AZStd::string_view cameraOrbitPanId)
     {
-        SetRegistry(CameraOrbitPanIdSetting, cameraOrbitPanId);
+        AzToolsFramework::SetRegistry(CameraOrbitPanIdSetting, cameraOrbitPanId);
     }
 
     AzFramework::InputChannelId CameraFocusChannelId()
     {
-        return AzFramework::InputChannelId(GetRegistry(CameraFocusIdSetting, AZStd::string("keyboard_key_alphanumeric_X")).c_str());
+        return AzFramework::InputChannelId(
+            AzToolsFramework::GetRegistry(CameraFocusIdSetting, AZStd::string("keyboard_key_alphanumeric_X")).c_str());
     }
 
     void SetCameraFocusChannelId(AZStd::string_view cameraFocusId)
     {
-        SetRegistry(CameraFocusIdSetting, cameraFocusId);
+        AzToolsFramework::SetRegistry(CameraFocusIdSetting, cameraFocusId);
     }
 } // namespace SandboxEditor

Code/Editor/GameEngine.cpp

@@ -35,7 +35,6 @@
 
 // CryCommon
 #include <CryCommon/INavigationSystem.h>
-#include <CryCommon/LyShine/ILyShine.h>
 #include <CryCommon/MainThreadRenderRequestBus.h>
 
 // Editor
@@ -595,13 +594,6 @@ void CGameEngine::SwitchToInEditor()
     // Enable accelerators.
     GetIEditor()->EnableAcceleratos(true);
 
-
-    // reset UI system
-    if (gEnv->pLyShine)
-    {
-        gEnv->pLyShine->Reset();
-    }
-
     // [Anton] - order changed, see comments for CGameEngine::SetSimulationMode
     //! Send event to switch out of game.
     GetIEditor()->GetObjectManager()->SendEvent(EVENT_OUTOFGAME);

Code/Editor/Plugins/EditorCommon/UiEditorDLLBus.h

@@ -1,41 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-#include <LyShine/UiBase.h>
-
-class UndoStack;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that the UI Editor needs to implement
-class UiEditorDLLInterface
-    : public AZ::EBusTraits
-{
-public: // member functions
-
-    virtual ~UiEditorDLLInterface(){}
-
-    //! Get the selected elements in the UiEditor
-    virtual LyShine::EntityArray GetSelectedElements() = 0;
-
-    //! Get the id of the active Canvas the UiEditor
-    virtual AZ::EntityId GetActiveCanvasId() = 0;
-
-    //! Get the active undo stack for the UI Editor
-    virtual UndoStack* GetActiveUndoStack() = 0;
-
-    //! Soft-switch to the given file.  Note that this should prompt for unsaved changes, etc.
-    virtual void OpenSourceCanvasFile(QString absolutePathToFile) = 0;
-
-public: // static member functions
-
-    static const char* GetUniqueName() { return "UiEditorDLLInterface"; }
-};
-
-typedef AZ::EBus<UiEditorDLLInterface> UiEditorDLLBus;

Code/Editor/Plugins/EditorCommon/editorcommon_files.cmake

@@ -13,7 +13,6 @@ set(FILES
     EditorCommonAPI.h
     ActionOutput.h
     ActionOutput.cpp
-    UiEditorDLLBus.h
     DockTitleBarWidget.cpp
     DockTitleBarWidget.h
     SaveUtilities/AsyncSaveRunner.h

Code/Editor/Util/Image.cpp

@@ -75,17 +75,16 @@ void CImageEx::ReverseUpDown()
     }
 
     uint32* pPixData = GetData();
-    uint32* pReversePix = new uint32[GetWidth() * GetHeight()];
-
-    for (int i = GetHeight() - 1, i2 = 0; i >= 0; i--, i2++)
+    const int height = GetHeight();
+    const int width = GetWidth(); 
+    for (int i = 0; i < height / 2; i++)
     {
-        for (int k = 0; k < GetWidth(); k++)
+        for (int j = 0; j < width; j++)
         {
-            pReversePix[i2 * GetWidth() + k] = pPixData[i * GetWidth() + k];
+            AZStd::swap(pPixData[i * width + j], pPixData[(height - 1 - i) * width + j]);
         }
     }
 
-    Attach(pReversePix, GetWidth(), GetHeight());
 }
 
 void CImageEx::FillAlpha(unsigned char value)

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -486,9 +486,11 @@ namespace AZ
 
         // Merge Command Line arguments
         constexpr bool executeRegDumpCommands = false;
-        SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(*m_settingsRegistry, m_commandLine, executeRegDumpCommands);
 
+#if defined(AZ_DEBUG_BUILD) || defined(AZ_PROFILE_BUILD)
+        // Skip over merging the User Registry in non-debug and profile configurations
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_O3deUserRegistry(*m_settingsRegistry, AZ_TRAIT_OS_PLATFORM_CODENAME, {});
+#endif
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(*m_settingsRegistry, m_commandLine, executeRegDumpCommands);
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*m_settingsRegistry);
 

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryConsoleUtils.h

@@ -23,7 +23,7 @@ namespace AZ::SettingsRegistryConsoleUtils
     inline constexpr const char* SettingsRegistryRemove = "sr_regremove";
     inline constexpr const char* SettingsRegistryDump = "sr_regdump";
     inline constexpr const char* SettingsRegistryDumpAll = "sr_regdumpall";
-    inline constexpr const char* SettingsRegistryMergeFile = "sr_regset-file";
+    inline constexpr const char* SettingsRegistryMergeFile = "sr_regset_file";
 
     // RAII structure which owns the instances of the Settings Registry Console commands
     // registered with an AZ Console
@@ -53,7 +53,7 @@ namespace AZ::SettingsRegistryConsoleUtils
     //! "sr_regdumpall" accepts 0 arguments and dumps the entire settings registry
     //!  NOTE: this might result in a large amount of output to the console
     //!
-    //! "sr_regset-file" accepts 1 or 2 arguments - <file-path> [<anchor json path>]
+    //! "sr_regset_file" accepts 1 or 2 arguments - <file-path> [<anchor json path>]
     //!  Merges the json formatted file <file path> into the settings registry underneath the root anchor ""
     //!  or <anchor json path> if supplied
     [[nodiscard]] ConsoleFunctorHandle RegisterAzConsoleCommands(SettingsRegistryInterface& registry, AZ::IConsole& azConsole);

Code/Framework/AzFramework/AzFramework/Terrain/TerrainDataRequestBus.cpp

@@ -12,13 +12,57 @@
 
 namespace AzFramework::Terrain
 {
+    // Create a handler that can be accessed from Python scripts to receive terrain change notifications.
+    class TerrainDataNotificationHandler final
+        : public AzFramework::Terrain::TerrainDataNotificationBus::Handler
+        , public AZ::BehaviorEBusHandler
+    {
+    public:
+        AZ_EBUS_BEHAVIOR_BINDER(
+            TerrainDataNotificationHandler,
+            "{A83EF103-295A-4653-8279-F30FBF3F9037}",
+            AZ::SystemAllocator,
+            OnTerrainDataCreateBegin,
+            OnTerrainDataCreateEnd,
+            OnTerrainDataDestroyBegin,
+            OnTerrainDataDestroyEnd,
+            OnTerrainDataChanged);
+
+        void OnTerrainDataCreateBegin() override
+        {
+            Call(FN_OnTerrainDataCreateBegin);
+        }
+
+        void OnTerrainDataCreateEnd() override
+        {
+            Call(FN_OnTerrainDataCreateEnd);
+        }
+
+        void OnTerrainDataDestroyBegin() override
+        {
+            Call(FN_OnTerrainDataDestroyBegin);
+        }
+
+        void OnTerrainDataDestroyEnd() override
+        {
+            Call(FN_OnTerrainDataDestroyEnd);
+        }
+
+        void OnTerrainDataChanged(
+            const AZ::Aabb& dirtyRegion, AzFramework::Terrain::TerrainDataNotifications::TerrainDataChangedMask dataChangedMask) override
+        {
+            Call(FN_OnTerrainDataChanged, dirtyRegion, dataChangedMask);
+        }
+    };
+
     void TerrainDataRequests::Reflect(AZ::ReflectContext* context)
     {
         if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
         {
             behaviorContext->EBus<AzFramework::Terrain::TerrainDataRequestBus>("TerrainDataRequestBus")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                 ->Attribute(AZ::Script::Attributes::Category, "Terrain")
-                ->Event("GetHeight", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetHeight)
+                ->Attribute(AZ::Script::Attributes::Module, "terrain")
                 ->Event("GetNormal", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetNormal)
                 ->Event("GetMaxSurfaceWeight", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetMaxSurfaceWeight)
                 ->Event("GetMaxSurfaceWeightFromVector2",
@@ -34,8 +78,24 @@ namespace AzFramework::Terrain
                 ->Event("GetTerrainAabb", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetTerrainAabb)
                 ->Event("GetTerrainHeightQueryResolution",
                     &AzFramework::Terrain::TerrainDataRequestBus::Events::GetTerrainHeightQueryResolution)
+                ->Event("GetHeight", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetHeightVal)
+                ->Event("GetHeightFromVector2", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetHeightValFromVector2)
+                ->Event("GetHeightFromFloats", &AzFramework::Terrain::TerrainDataRequestBus::Events::GetHeightValFromFloats)
                 ;
+
+            behaviorContext->EBus<AzFramework::Terrain::TerrainDataNotificationBus>("TerrainDataNotificationBus")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Terrain")
+                ->Attribute(AZ::Script::Attributes::Module, "terrain")
+                ->Event("OnTerrainDataCreateBegin", &AzFramework::Terrain::TerrainDataNotifications::OnTerrainDataCreateBegin)
+                ->Event("OnTerrainDataCreateEnd", &AzFramework::Terrain::TerrainDataNotifications::OnTerrainDataCreateEnd)
+                ->Event("OnTerrainDataDestroyBegin", &AzFramework::Terrain::TerrainDataNotifications::OnTerrainDataDestroyBegin)
+                ->Event("OnTerrainDataDestroyEnd", &AzFramework::Terrain::TerrainDataNotifications::OnTerrainDataDestroyEnd)
+                ->Event("OnTerrainDataChanged", &AzFramework::Terrain::TerrainDataNotifications::OnTerrainDataChanged)
+                ->Handler<AzFramework::Terrain::TerrainDataNotificationHandler>()
+            ;
         }
 
+        //TerrainDataNotificationHandler::Reflect(context);
     }
 } // namespace AzFramework::Terrain

Code/Framework/AzFramework/AzFramework/Terrain/TerrainDataRequestBus.h

@@ -144,13 +144,31 @@ namespace AzFramework
                 return result;
             }
             SurfaceData::SurfacePoint BehaviorContextGetSurfacePointFromVector2(
-                const AZ::Vector2& inPosition,
-                Sampler sampleFilter = Sampler::DEFAULT) const
+                const AZ::Vector2& inPosition, Sampler sampleFilter = Sampler::DEFAULT) const
             {
                 SurfaceData::SurfacePoint result;
                 GetSurfacePointFromVector2(inPosition, result, sampleFilter);
                 return result;
             }
+                
+            // Functions without the optional bool* parameter that can be used from Python tests.
+            float GetHeightVal(AZ::Vector3 position, Sampler sampler = Sampler::BILINEAR) const
+            {
+                bool terrainExists;
+                return GetHeight(position, sampler, &terrainExists);
+            }
+
+            float GetHeightValFromVector2(AZ::Vector2 position, Sampler sampler = Sampler::BILINEAR) const
+            {
+                bool terrainExists;
+                return GetHeightFromVector2(position, sampler, &terrainExists);
+            }
+
+            float GetHeightValFromFloats(float x, float y, Sampler sampler = Sampler::BILINEAR) const
+            {
+                bool terrainExists;
+                return GetHeightFromFloats(x, y, sampler, &terrainExists);
+            }
         };
         using TerrainDataRequestBus = AZ::EBus<TerrainDataRequests>;
 

Code/Framework/AzFramework/Platform/Common/Xcb/AzFramework/XcbInputDeviceKeyboard.h

@@ -5,6 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+#pragma once
 
 #include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
 #include <AzFramework/XcbEventHandler.h>

Code/Framework/AzFramework/Tests/InputTests.cpp

@@ -29,6 +29,13 @@ namespace InputUnitTests
     ////////////////////////////////////////////////////////////////////////////////////////////////
     class InputTest : public ScopedAllocatorSetupFixture
     {
+    public:
+        InputTest() : ScopedAllocatorSetupFixture()
+        {
+            // Many input tests are only valid if the GamePad device is supported on this platform.
+            m_gamepadSupported = InputDeviceGamepad::GetMaxSupportedGamepads() > 0;
+        }
+
     protected:
         ////////////////////////////////////////////////////////////////////////////////////////////
         void SetUp() override
@@ -46,6 +53,7 @@ namespace InputUnitTests
         
         ////////////////////////////////////////////////////////////////////////////////////////////
         AZStd::unique_ptr<InputSystemComponent> m_inputSystemComponent;
+        bool m_gamepadSupported;
     };
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -78,12 +86,17 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputContext_ActivateDeactivate_Successfull)
-#else
     TEST_F(InputTest, InputContext_ActivateDeactivate_Successfull)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputContext_ActivateDeactivate_Successfull";
+        #else
+            SUCCEED() << "Skipping test InputContext_ActivateDeactivate_Successfull";
+        #endif
+            return;
+        }
         // Create an input context (they are inactive by default).
         InputContext inputContext("TestInputContext");
 
@@ -148,12 +161,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputContext_AddRemoveInputMapping_Successfull)
-#else
     TEST_F(InputTest, InputContext_AddRemoveInputMapping_Successfull)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputContext_AddRemoveInputMapping_Successfull";
+        #else
+            SUCCEED() << "Skipping test InputContext_AddRemoveInputMapping_Successfull";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -256,12 +275,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputContext_ConsumeProcessedInput_Consumed)
-#else
     TEST_F(InputTest, InputContext_ConsumeProcessedInput_Consumed)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputContext_ConsumeProcessedInput_Consumed";
+        #else
+            SUCCEED() << "Skipping test InputContext_ConsumeProcessedInput_Consumed";
+        #endif
+            return;
+        }
+
         InputContext::InitData initData;
 
         // Create a high priority input context that consumes input processed by any of its mappings.
@@ -340,12 +365,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputContext_FilteredInput_Mapped)
-#else
     TEST_F(InputTest, InputContext_FilteredInput_Mapped)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputContext_FilteredInput_Mapped";
+        #else
+            SUCCEED() << "Skipping test InputContext_FilteredInput_Mapped";
+        #endif
+            return;
+        }
+
         // Create an input context that initially only listens for keyboard input.
         InputContext::InitData initData;
         initData.autoActivate = true;
@@ -413,12 +444,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingOr_AddRemoveSourceInput_Successful)
-#else
     TEST_F(InputTest, InputMappingOr_AddRemoveSourceInput_Successful)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingOr_AddRemoveSourceInput_Successful";
+        #else
+            SUCCEED() << "Skipping test InputMappingOr_AddRemoveSourceInput_Successful";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -491,12 +528,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingOr_SingleSourceInput_Mapped)
-#else
     TEST_F(InputTest, InputMappingOr_SingleSourceInput_Mapped)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingOr_SingleSourceInput_Mapped";
+        #else
+            SUCCEED() << "Skipping test InputMappingOr_SingleSourceInput_Mapped";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -558,12 +601,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingOr_MultipleSourceInputs_Mapped)
-#else
     TEST_F(InputTest, InputMappingOr_MultipleSourceInputs_Mapped)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingOr_MultipleSourceInputs_Mapped";
+        #else
+            SUCCEED() << "Skipping test InputMappingOr_MultipleSourceInputs_Mapped";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -650,12 +699,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingAnd_AddRemoveSourceInput_Successful)
-#else
     TEST_F(InputTest, InputMappingAnd_AddRemoveSourceInput_Successful)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingAnd_AddRemoveSourceInput_Successful";
+        #else
+            SUCCEED() << "Skipping test InputMappingAnd_AddRemoveSourceInput_Successful";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -728,12 +783,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingAnd_SingleSourceInput_Mapped)
-#else
     TEST_F(InputTest, InputMappingAnd_SingleSourceInput_Mapped)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingAnd_SingleSourceInput_Mapped";
+        #else
+            SUCCEED() << "Skipping test InputMappingAnd_SingleSourceInput_Mapped";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -795,12 +856,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingAnd_MultipleSourceInputs_Mapped)
-#else
     TEST_F(InputTest, InputMappingAnd_MultipleSourceInputs_Mapped)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingAnd_MultipleSourceInputs_Mapped";
+        #else
+            SUCCEED() << "Skipping test InputMappingAnd_MultipleSourceInputs_Mapped";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -909,12 +976,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingAnd_MultipleSourceInputsWithDifferentValues_ValuesAveraged)
-#else
     TEST_F(InputTest, InputMappingAnd_MultipleSourceInputsWithDifferentValues_ValuesAveraged)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingAnd_MultipleSourceInputsWithDifferentValues_ValuesAveraged";
+        #else
+            SUCCEED() << "Skipping test InputMappingAnd_MultipleSourceInputsWithDifferentValues_ValuesAveraged";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();
@@ -969,12 +1042,18 @@ namespace InputUnitTests
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
-#if AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
-    TEST_F(InputTest, DISABLED_InputMappingAnd_MultipleSourceInputsFromTheSameInputDeviceTypeWithDifferentIndicies_NotMapped)
-#else
     TEST_F(InputTest, InputMappingAnd_MultipleSourceInputsFromTheSameInputDeviceTypeWithDifferentIndicies_NotMapped)
-#endif // AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS
     {
+        if (!m_gamepadSupported)
+        {
+        #if defined(GTEST_SKIP)
+            GTEST_SKIP() << "Skipping test InputMappingAnd_MultipleSourceInputsFromTheSameInputDeviceTypeWithDifferentIndicies_NotMapped";
+        #else
+            SUCCEED() << "Skipping test InputMappingAnd_MultipleSourceInputsFromTheSameInputDeviceTypeWithDifferentIndicies_NotMapped";
+        #endif
+            return;
+        }
+
         // Create an input context and activate it.
         InputContext inputContext("TestInputContext");
         inputContext.Activate();

Code/Framework/AzQtComponents/AzQtComponents/Components/FancyDocking.cpp

@@ -53,7 +53,6 @@ static void OptimizedSetParent(QWidget* widget, QWidget* parent)
 
 namespace AzQtComponents
 {
-    static const FancyDockingDropZoneConstants g_FancyDockingConstants;
 
     // Constant for the threshold in pixels for snapping to edges while dragging for docking
     static const int g_snapThresholdInPixels = 15;
@@ -155,7 +154,7 @@ namespace AzQtComponents
 
         // Timer for updating our hovered drop zone opacity
         QObject::connect(m_dropZoneHoverFadeInTimer, &QTimer::timeout, this, &FancyDocking::onDropZoneHoverFadeInUpdate);
-        m_dropZoneHoverFadeInTimer->setInterval(g_FancyDockingConstants.dropZoneHoverFadeUpdateIntervalMS);
+        m_dropZoneHoverFadeInTimer->setInterval(FancyDockingDropZoneConstants::dropZoneHoverFadeUpdateIntervalMS);
         QIcon dragIcon = QIcon(QStringLiteral(":/Cursors/Grabbing.svg"));
         m_dragCursor = QCursor(dragIcon.pixmap(16), 5, 2);
     }
@@ -333,13 +332,13 @@ namespace AzQtComponents
      */
     void FancyDocking::onDropZoneHoverFadeInUpdate()
     {
-        const qreal dropZoneHoverOpacity = g_FancyDockingConstants.dropZoneHoverFadeIncrement + m_dropZoneState.dropZoneHoverOpacity();
+        const qreal dropZoneHoverOpacity = FancyDockingDropZoneConstants::dropZoneHoverFadeIncrement + m_dropZoneState.dropZoneHoverOpacity();
 
         // Once we've reached the full drop zone opacity, cut it off in case we
         // went over and stop the timer
-        if (dropZoneHoverOpacity >= g_FancyDockingConstants.dropZoneOpacity)
+        if (dropZoneHoverOpacity >= FancyDockingDropZoneConstants::dropZoneOpacity)
         {
-            m_dropZoneState.setDropZoneHoverOpacity(g_FancyDockingConstants.dropZoneOpacity);
+            m_dropZoneState.setDropZoneHoverOpacity(FancyDockingDropZoneConstants::dropZoneOpacity);
             m_dropZoneHoverFadeInTimer->stop();
         }
         else
@@ -792,12 +791,12 @@ namespace AzQtComponents
         QPoint mainWindowTopLeft = multiscreenMapFromGlobal(mainWindow->mapToGlobal(mainWindowRect.topLeft()));
         QPoint mainWindowTopRight = multiscreenMapFromGlobal(mainWindow->mapToGlobal(mainWindowRect.topRight()));
         QPoint mainWindowBottomLeft = multiscreenMapFromGlobal(mainWindow->mapToGlobal(mainWindowRect.bottomLeft()));
-        QSize absoluteLeftRightSize(g_FancyDockingConstants.absoluteDropZoneSizeInPixels, mainWindowRect.height());
+        QSize absoluteLeftRightSize(FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels, mainWindowRect.height());
         QRect absoluteLeftDropZone(mainWindowTopLeft, absoluteLeftRightSize);
-        QRect absoluteRightDropZone(mainWindowTopRight - QPoint(g_FancyDockingConstants.absoluteDropZoneSizeInPixels, 0), absoluteLeftRightSize);
-        QSize absoluteTopBottomSize(mainWindowRect.width(), g_FancyDockingConstants.absoluteDropZoneSizeInPixels);
+        QRect absoluteRightDropZone(mainWindowTopRight - QPoint(FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels, 0), absoluteLeftRightSize);
+        QSize absoluteTopBottomSize(mainWindowRect.width(), FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels);
         QRect absoluteTopDropZone(mainWindowTopLeft, absoluteTopBottomSize);
-        QRect absoluteBottomDropZone(mainWindowBottomLeft - QPoint(0, g_FancyDockingConstants.absoluteDropZoneSizeInPixels), absoluteTopBottomSize);
+        QRect absoluteBottomDropZone(mainWindowBottomLeft - QPoint(0, FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels), absoluteTopBottomSize);
 
         // If the drop target is a main window, then we will only show the absolute
         // drop zone if the cursor is in that zone already
@@ -986,16 +985,16 @@ namespace AzQtComponents
         switch (m_dropZoneState.absoluteDropZoneArea())
         {
         case Qt::LeftDockWidgetArea:
-            dockRect.setX(dockRect.x() + g_FancyDockingConstants.absoluteDropZoneSizeInPixels);
+            dockRect.setX(dockRect.x() + FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels);
             break;
         case Qt::RightDockWidgetArea:
-            dockRect.setWidth(dockRect.width() - g_FancyDockingConstants.absoluteDropZoneSizeInPixels);
+            dockRect.setWidth(dockRect.width() - FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels);
             break;
         case Qt::TopDockWidgetArea:
-            dockRect.setY(dockRect.y() + g_FancyDockingConstants.absoluteDropZoneSizeInPixels);
+            dockRect.setY(dockRect.y() + FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels);
             break;
         case Qt::BottomDockWidgetArea:
-            dockRect.setHeight(dockRect.height() - g_FancyDockingConstants.absoluteDropZoneSizeInPixels);
+            dockRect.setHeight(dockRect.height() - FancyDockingDropZoneConstants::absoluteDropZoneSizeInPixels);
             break;
         }
 
@@ -1034,15 +1033,15 @@ namespace AzQtComponents
         // Set the drop zone width/height to the default, but if the dock widget
         // width and/or height is below the threshold, then switch to scaling them
         // down accordingly
-        int dropZoneWidth = g_FancyDockingConstants.dropZoneSizeInPixels;
-        if (dockWidth < g_FancyDockingConstants.minDockSizeBeforeDropZoneScalingInPixels)
+        int dropZoneWidth = FancyDockingDropZoneConstants::dropZoneSizeInPixels;
+        if (dockWidth < FancyDockingDropZoneConstants::minDockSizeBeforeDropZoneScalingInPixels)
         {
-            dropZoneWidth = aznumeric_cast<int>(dockWidth * g_FancyDockingConstants.dropZoneScaleFactor);
+            dropZoneWidth = aznumeric_cast<int>(dockWidth * FancyDockingDropZoneConstants::dropZoneScaleFactor);
         }
-        int dropZoneHeight = g_FancyDockingConstants.dropZoneSizeInPixels;
-        if (dockHeight < g_FancyDockingConstants.minDockSizeBeforeDropZoneScalingInPixels)
+        int dropZoneHeight = FancyDockingDropZoneConstants::dropZoneSizeInPixels;
+        if (dockHeight < FancyDockingDropZoneConstants::minDockSizeBeforeDropZoneScalingInPixels)
         {
-            dropZoneHeight = aznumeric_cast<int>(dockHeight * g_FancyDockingConstants.dropZoneScaleFactor);
+            dropZoneHeight = aznumeric_cast<int>(dockHeight * FancyDockingDropZoneConstants::dropZoneScaleFactor);
         }
 
         // Calculate the inner corners to be used when constructing the drop zone polygons
@@ -1078,7 +1077,7 @@ namespace AzQtComponents
         int innerDropZoneWidth = m_dropZoneState.innerDropZoneRect().width();
         int innerDropZoneHeight = m_dropZoneState.innerDropZoneRect().height();
         int centerDropZoneDiameter = (innerDropZoneWidth < innerDropZoneHeight) ? innerDropZoneWidth : innerDropZoneHeight;
-        centerDropZoneDiameter = aznumeric_cast<int>(centerDropZoneDiameter * g_FancyDockingConstants.centerTabDropZoneScale);
+        centerDropZoneDiameter = aznumeric_cast<int>(centerDropZoneDiameter * FancyDockingDropZoneConstants::centerTabDropZoneScale);
 
         // Setup our center tab drop zone
         const QSize centerDropZoneSize(centerDropZoneDiameter, centerDropZoneDiameter);
@@ -1986,7 +1985,7 @@ namespace AzQtComponents
             // hasn't faded in all the way yet, then ignore the drop zone area
             // which will make the widget floating
             bool modifiedKeyPressed = FancyDockingDropZoneWidget::CheckModifierKey();
-            if (modifiedKeyPressed || m_dropZoneState.dropZoneHoverOpacity() != g_FancyDockingConstants.dropZoneOpacity)
+            if (modifiedKeyPressed || m_dropZoneState.dropZoneHoverOpacity() != FancyDockingDropZoneConstants::dropZoneOpacity)
             {
                 area = Qt::NoDockWidgetArea;
             }
@@ -3026,7 +3025,7 @@ namespace AzQtComponents
         {
             bool modifiedKeyPressed = FancyDockingDropZoneWidget::CheckModifierKey();
 
-            m_ghostWidget->setWindowOpacity(modifiedKeyPressed ? 1.0f : g_FancyDockingConstants.draggingDockWidgetOpacity);
+            m_ghostWidget->setWindowOpacity(modifiedKeyPressed ? 1.0f : FancyDockingDropZoneConstants::draggingDockWidgetOpacity);
             m_ghostWidget->setPixmap(m_state.dockWidgetScreenGrab.screenGrab, m_state.placeholder(), m_state.placeholderScreen());
         }
     }

Code/Framework/AzQtComponents/AzQtComponents/Components/FancyDockingDropZoneWidget.cpp

@@ -19,26 +19,6 @@
 
 namespace AzQtComponents
 {
-    static const FancyDockingDropZoneConstants g_Constants;
-
-    FancyDockingDropZoneConstants::FancyDockingDropZoneConstants()
-    {
-        draggingDockWidgetOpacity = 0.6;
-        dropZoneOpacity = 0.4;
-        dropZoneSizeInPixels = 40;
-        minDockSizeBeforeDropZoneScalingInPixels = dropZoneSizeInPixels * 3;
-        dropZoneScaleFactor = 0.25;
-        centerTabDropZoneScale = 0.5;
-        centerTabIconScale = 0.5;
-        dropZoneColor = QColor(155, 155, 155);
-        dropZoneBorderColor = Qt::black;
-        dropZoneBorderInPixels = 1;
-        absoluteDropZoneSizeInPixels = 25;
-        dockingTargetDelayMS = 110;
-        dropZoneHoverFadeUpdateIntervalMS = 20;
-        dropZoneHoverFadeIncrement = dropZoneOpacity / (dockingTargetDelayMS / dropZoneHoverFadeUpdateIntervalMS);
-        centerDropZoneIconPath = QString(":/stylesheet/img/UI20/docking/tabs_icon.svg");
-    }
 
     FancyDockingDropZoneWidget::FancyDockingDropZoneWidget(QMainWindow* mainWindow, QWidget* coordinatesRelativeTo, QScreen* screen, FancyDockingDropZoneState* dropZoneState)
         // NOTE: this will not work with multiple monitors if this widget has a parent. The floating drop zone
@@ -154,7 +134,7 @@ namespace AzQtComponents
 
             // Draw all of the normal drop zones if they exist (if a dock widget is hovered over)
             painter.setPen(Qt::NoPen);
-            painter.setOpacity(g_Constants.dropZoneOpacity);
+            painter.setOpacity(FancyDockingDropZoneConstants::dropZoneOpacity);
             auto dropZones = m_dropZoneState->dropZones();
             for (auto it = dropZones.cbegin(); it != dropZones.cend(); ++it)
             {
@@ -189,7 +169,7 @@ namespace AzQtComponents
         // Otherwise, set the normal color
         else
         {
-            painter.setBrush(g_Constants.dropZoneColor);
+            painter.setBrush(FancyDockingDropZoneConstants::dropZoneColor);
         }
 
         // negate the window position to offset everything by that much
@@ -214,8 +194,8 @@ namespace AzQtComponents
             // Scale the tabs icon based on the drop zone size and our specified offset
             // Doing this through QIcon to make sure that SVG is rendered already in desired resolution
             const QSize& dropZoneSize = dropZoneRect.size();
-            const QSize requestedIconSize = dropZoneSize * g_Constants.centerTabIconScale;
-            const QIcon dropZoneIcon = QIcon(g_Constants.centerDropZoneIconPath);
+            const QSize requestedIconSize = dropZoneSize * FancyDockingDropZoneConstants::centerTabIconScale;
+            const QIcon dropZoneIcon = QIcon(FancyDockingDropZoneConstants::centerDropZoneIconPath);
             const QPixmap dropZonePixmap = dropZoneIcon.pixmap(requestedIconSize);
             const QSize receivedIconSize = dropZoneIcon.actualSize(requestedIconSize);
 
@@ -264,7 +244,7 @@ namespace AzQtComponents
             }
             else
             {
-                painter.setBrush(g_Constants.dropZoneColor);
+                painter.setBrush(FancyDockingDropZoneConstants::dropZoneColor);
             }
             painter.drawRect(absoluteDropZoneRect);
 
@@ -313,8 +293,8 @@ namespace AzQtComponents
         const QPoint innerBottomRight = innerDropZoneRect.bottomRight();
 
         // Draw the lines using the appropriate pen
-        QPen dropZoneBorderPen(g_Constants.dropZoneBorderColor);
-        dropZoneBorderPen.setWidth(g_Constants.dropZoneBorderInPixels);
+        QPen dropZoneBorderPen(FancyDockingDropZoneConstants::dropZoneBorderColor);
+        dropZoneBorderPen.setWidth(FancyDockingDropZoneConstants::dropZoneBorderInPixels);
         painter.setPen(dropZoneBorderPen);
         painter.setOpacity(1);
         painter.drawLine(topLeft, innerTopLeft);

Code/Framework/AzQtComponents/AzQtComponents/Components/FancyDockingDropZoneWidget.h

@@ -28,63 +28,58 @@ class QPainter;
 
 namespace AzQtComponents
 {
-    struct AZ_QT_COMPONENTS_API FancyDockingDropZoneConstants
+    namespace FancyDockingDropZoneConstants
     {
         // Constant for the opacity of the screen grab for the dock widget being dragged
-        qreal draggingDockWidgetOpacity;
+        static constexpr qreal draggingDockWidgetOpacity = 0.6;
 
         // Constant for the opacity of the normal drop zones
-        qreal dropZoneOpacity;
+        static constexpr qreal dropZoneOpacity  = 0.4;
 
         // Constant for the default drop zone size (in pixels)
-        int dropZoneSizeInPixels;
+        static constexpr int dropZoneSizeInPixels  = 40;
 
         // Constant for the dock width/height size (in pixels) before we need to start
         // scaling down the drop zone sizes, or else they will overlap with the center
         // tab icon or each other
-        int minDockSizeBeforeDropZoneScalingInPixels;
+        static constexpr int minDockSizeBeforeDropZoneScalingInPixels = dropZoneSizeInPixels * 3;
 
         // Constant for the factor by which we must scale down the drop zone sizes once
         // the dock width/height size is too small
-        qreal dropZoneScaleFactor;
+        static constexpr qreal dropZoneScaleFactor  = 0.25;
 
         // Constant for the percentage to scale down the inner drop zone rectangle for the center tab drop zone
-        qreal centerTabDropZoneScale;
+        static constexpr qreal centerTabDropZoneScale  = 0.5;
 
         // Constant for the percentage to scale down the center tab drop zone for the center tab icon
-        qreal centerTabIconScale;
+        static constexpr qreal centerTabIconScale  = 0.5;
 
         // Constant for the drop zone hotspot default color
-        QColor dropZoneColor;
+        static const QColor dropZoneColor = QColor(155, 155, 155);
 
         // Constant for the drop zone border color
-        QColor dropZoneBorderColor;
+        static const QColor dropZoneBorderColor = Qt::black;
 
         // Constant for the border width in pixels separating the drop zones
-        int dropZoneBorderInPixels;
+        static constexpr int dropZoneBorderInPixels  = 1;
 
         // Constant for the border width in pixels separating the drop zones
-        int absoluteDropZoneSizeInPixels;
+        static constexpr int absoluteDropZoneSizeInPixels  = 25;
 
         // Constant for the delay (in milliseconds) before a drop zone becomes active
         // once it is hovered over
-        int dockingTargetDelayMS;
+        static constexpr int dockingTargetDelayMS = 110;
 
         // Constant for the rate at which we will update (fade in) the drop zone opacity
         // when hovered over (in milliseconds)
-        int dropZoneHoverFadeUpdateIntervalMS;
+        static constexpr int dropZoneHoverFadeUpdateIntervalMS  = 20;
 
         // Constant for the incremental opacity increase for the hovered drop zone
         // that will fade in to the full drop zone opacity in the desired time
-        qreal dropZoneHoverFadeIncrement;
+        static constexpr qreal dropZoneHoverFadeIncrement = dropZoneOpacity / (dockingTargetDelayMS / dropZoneHoverFadeUpdateIntervalMS);
 
         // Constant for the path to the center drop zone tabs icon
-        QString centerDropZoneIconPath;
-
-        FancyDockingDropZoneConstants();
-
-        FancyDockingDropZoneConstants(const FancyDockingDropZoneConstants&) = delete;
-        FancyDockingDropZoneConstants& operator=(const FancyDockingDropZoneConstants&) = delete;
+        static const QString centerDropZoneIconPath = QStringLiteral(":/stylesheet/img/UI20/docking/tabs_icon.svg");
     };
 
     class FancyDockingDropZoneState

Code/Framework/AzQtComponents/AzQtComponents/Components/Widgets/ColorPicker/ColorController.cpp

@@ -323,7 +323,7 @@ namespace AzQtComponents
                     saturation *= 2.0 - lightness;
                 }
                 double value = (lightness + saturation) / 2.0;
-                saturation = (2.0 * saturation) / (lightness + saturation);
+                saturation = qFuzzyIsNull(lightness + saturation) ? 0 : (2.0 * saturation) / (lightness + saturation);
 
                 m_hsv.saturation = AZ::GetClamp(saturation, 0.0, 1.0);
                 m_hsv.value = AZ::GetClamp(value, 0.0, 12.5);
@@ -341,11 +341,12 @@ namespace AzQtComponents
                 double saturation = m_hsv.saturation * m_hsv.value;
                 if (lightness <= 1.0)
                 {
-                    saturation /= lightness;
+                    saturation = (qFuzzyIsNull(lightness)) ? 0.0 : saturation / lightness;
                 }
                 else
                 {
-                    saturation /= 2.0 - lightness;
+                    double two_minus_lightness = 2.0 - lightness;
+                    saturation = (qFuzzyIsNull(two_minus_lightness)) ? 0.0 : saturation / two_minus_lightness;
                 }
                 lightness /= 2.0;
 

Code/Framework/AzQtComponents/AzQtComponents/Tests/ColorControllerTests.cpp

@@ -164,11 +164,7 @@ namespace
     }
 }
 
-#if AZ_TRAIT_DISABLE_FAILED_ZERO_COLOR_CONVERSION_TEST
-TEST(AzQtComponents, DISABLED_ColorConversionsTestAllZeros)
-#else
 TEST(AzQtComponents, ColorConversionsTestAllZeros)
-#endif // AZ_TRAIT_DISABLE_FAILED_ZERO_COLOR_CONVERSION_TEST
 {
     TestConversions({ 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 });
 }

Code/Framework/AzTest/AzTest/Platform/Linux/AzTest_Traits_Linux.h

@@ -18,12 +18,11 @@
 
 #define AZ_TRAIT_DISABLE_FAILED_ATOM_RPI_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_ARCHIVE_TESTS true
-#define AZ_TRAIT_DISABLE_FAILED_ZERO_COLOR_CONVERSION_TEST true
+
 #define AZ_TRAIT_DISABLE_FAILED_FRAMEPROFILER_TEST true
 #define AZ_TRAIT_DISABLE_FAILED_FRAMEWORK_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_GRADIENT_SIGNAL_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_MULTIPLAYER_GRIDMATE_TESTS true
-#define AZ_TRAIT_DISABLE_FAILED_INPUT_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_NATIVE_WINDOWS_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_PROCESS_LAUNCHER_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_EMOTION_FX_TESTS true

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp

@@ -30,6 +30,7 @@
 #include <AzToolsFramework/ContainerEntity/ContainerEntitySystemComponent.h>
 #include <AzToolsFramework/Entity/EditorEntityContextComponent.h>
 #include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntitySystemComponent.h>
 #include <AzToolsFramework/FocusMode/FocusModeSystemComponent.h>
 #include <AzToolsFramework/Slice/SliceMetadataEntityContextComponent.h>
 #include <AzToolsFramework/Prefab/PrefabSystemComponent.h>
@@ -268,6 +269,7 @@ namespace AzToolsFramework
                 azrtti_typeid<Components::EditorEntityUiSystemComponent>(),
                 azrtti_typeid<FocusModeSystemComponent>(),
                 azrtti_typeid<ContainerEntitySystemComponent>(),
+                azrtti_typeid<ReadOnlyEntitySystemComponent>(),
                 azrtti_typeid<SliceMetadataEntityContextComponent>(),
                 azrtti_typeid<Prefab::PrefabSystemComponent>(),
                 azrtti_typeid<EditorEntityFixupComponent>(),

Code/Framework/AzToolsFramework/AzToolsFramework/AzToolsFrameworkModule.cpp

@@ -23,6 +23,7 @@
 #include <AzToolsFramework/Entity/EditorEntityModelComponent.h>
 #include <AzToolsFramework/Entity/EditorEntitySearchComponent.h>
 #include <AzToolsFramework/Entity/EditorEntitySortComponent.h>
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntitySystemComponent.h>
 #include <AzToolsFramework/FocusMode/FocusModeSystemComponent.h>
 #include <AzToolsFramework/PropertyTreeEditor/PropertyTreeEditorComponent.h>
 #include <AzToolsFramework/Render/EditorIntersectorComponent.h>
@@ -75,6 +76,7 @@ namespace AzToolsFramework
             EditorEntityFixupComponent::CreateDescriptor(),
             EntityUtilityComponent::CreateDescriptor(),
             ContainerEntitySystemComponent::CreateDescriptor(),
+            ReadOnlyEntitySystemComponent::CreateDescriptor(),
             FocusModeSystemComponent::CreateDescriptor(),
             SliceMetadataEntityContextComponent::CreateDescriptor(),
             SliceRequestComponent::CreateDescriptor(),

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/ReadOnly/ReadOnlyEntityBus.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/EntityId.h>
+#include <AzCore/EBus/EBus.h>
+
+#include <AzFramework/Entity/EntityContext.h>
+
+namespace AzToolsFramework
+{
+    //! Used to notify changes of state for read-only entities.
+    class ReadOnlyEntityPublicNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        //////////////////////////////////////////////////////////////////////////
+        // EBusTraits overrides
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AzFramework::EntityContextId;
+        //////////////////////////////////////////////////////////////////////////
+        
+        //! Triggered when an entity's read-only status changes.
+        //! @param entityId The entity whose status has changed.
+        //! @param readOnly The read-only state the container was changed to.
+        virtual void OnReadOnlyEntityStatusChanged([[maybe_unused]] const AZ::EntityId& entityId, [[maybe_unused]] bool readOnly) {}
+
+    protected:
+        ~ReadOnlyEntityPublicNotifications() = default;
+    };
+    using ReadOnlyEntityPublicNotificationBus = AZ::EBus<ReadOnlyEntityPublicNotifications>;
+
+    //! Used by the ReadOnlyEntitySystemComponent to query the read-only state of entities as set by systems using the API.
+    class ReadOnlyEntityQueryRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        //////////////////////////////////////////////////////////////////////////
+        // EBusTraits overrides
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AzFramework::EntityContextId;
+        //////////////////////////////////////////////////////////////////////////
+        
+        //! Triggered when an entity's read-only status is queried.
+        //! Allows multiple systems to weigh in on the read-only status of an entity.
+        //! @param entityId The entity whose status has changed.
+        //! @param[out] isReadOnly The output of the query. Should only be changed to true, and left untouched if false.
+        virtual void IsReadOnly(const AZ::EntityId& entityId, bool& isReadOnly) = 0;
+
+    protected:
+        ~ReadOnlyEntityQueryRequests() = default;
+    };
+    using ReadOnlyEntityQueryRequestBus = AZ::EBus<ReadOnlyEntityQueryRequests>;
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/ReadOnly/ReadOnlyEntityInterface.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <AzFramework/Entity/EntityContextBus.h>
+
+namespace AzToolsFramework
+{
+    //! An entity registered as read-only cannot be altered in the editor.
+    class ReadOnlyEntityPublicInterface
+    {
+    public:
+        AZ_RTTI(ReadOnlyEntityPublicInterface, "{921FE15B-6EBD-47F0-8238-BC63318DEDEA}");
+
+        //! Returns whether the entity id provided is registered as read-only.
+        virtual bool IsReadOnly(const AZ::EntityId& entityId) = 0;
+    };
+
+    //! An entity registered as read-only cannot be altered in the editor.
+    class ReadOnlyEntityQueryInterface
+    {
+    public:
+        AZ_RTTI(ReadOnlyEntityQueryInterface, "{2ACD63C5-1F3E-4DE8-880E-8115F857D329}");
+
+        //! Refreshes the cached read-only status for the entities provided.
+        //! @param entityIds The entityIds whose read-only state will be queried again.
+        virtual void RefreshReadOnlyState(const EntityIdList& entityIds) = 0;
+
+        //! Refreshes the cached read-only status for all entities.
+        //! Useful when disconnecting a handler at runtime.
+        virtual void RefreshReadOnlyStateForAllEntities() = 0;
+    };
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/ReadOnly/ReadOnlyEntitySystemComponent.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntitySystemComponent.h>
+
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntityBus.h>
+#include <AzToolsFramework/API/ToolsApplicationAPI.h>
+
+namespace AzToolsFramework
+{
+    void ReadOnlyEntitySystemComponent::Activate()
+    {
+        AZ::Interface<ReadOnlyEntityQueryInterface>::Register(this);
+        AZ::Interface<ReadOnlyEntityPublicInterface>::Register(this);
+        EditorEntityContextNotificationBus::Handler::BusConnect();
+    }
+
+    void ReadOnlyEntitySystemComponent::Deactivate()
+    {
+        EditorEntityContextNotificationBus::Handler::BusDisconnect();
+        AZ::Interface<ReadOnlyEntityPublicInterface>::Unregister(this);
+        AZ::Interface<ReadOnlyEntityQueryInterface>::Unregister(this);
+    }
+
+    void ReadOnlyEntitySystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<ReadOnlyEntitySystemComponent, AZ::Component>()->Version(1);
+        }
+    }
+
+    void ReadOnlyEntitySystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC_CE("ReadOnlyEntityService"));
+    }
+
+    bool ReadOnlyEntitySystemComponent::IsReadOnly(const AZ::EntityId& entityId)
+    {
+        if (!m_readOnlystates.contains(entityId))
+        {
+            QueryReadOnlyStateForEntity(entityId);
+        }
+
+        return m_readOnlystates[entityId];
+    }
+
+    void ReadOnlyEntitySystemComponent::RefreshReadOnlyState(const EntityIdList& entityIds)
+    {
+        for (const AZ::EntityId entityId : entityIds)
+        {
+            bool wasReadOnly = m_readOnlystates[entityId];
+            QueryReadOnlyStateForEntity(entityId);
+
+            if (bool isReadOnly = m_readOnlystates[entityId]; wasReadOnly != isReadOnly)
+            {
+                ReadOnlyEntityPublicNotificationBus::Broadcast(
+                    &ReadOnlyEntityPublicNotificationBus::Events::OnReadOnlyEntityStatusChanged, entityId, isReadOnly);
+            }
+        }
+    }
+
+    void ReadOnlyEntitySystemComponent::RefreshReadOnlyStateForAllEntities()
+    {
+        for (auto elem : m_readOnlystates)
+        {
+            AZ::EntityId entityId = elem.first;
+            bool wasReadOnly = m_readOnlystates[entityId];
+            QueryReadOnlyStateForEntity(entityId);
+
+            if (bool isReadOnly = m_readOnlystates[entityId]; wasReadOnly != isReadOnly)
+            {
+                ReadOnlyEntityPublicNotificationBus::Broadcast(
+                    &ReadOnlyEntityPublicNotificationBus::Events::OnReadOnlyEntityStatusChanged, entityId, isReadOnly);
+            }
+        }
+    }
+
+    void ReadOnlyEntitySystemComponent::OnContextReset()
+    {
+        m_readOnlystates.clear();
+    }
+
+    void ReadOnlyEntitySystemComponent::QueryReadOnlyStateForEntity(const AZ::EntityId& entityId)
+    {
+        bool isReadOnly = false;
+
+        ReadOnlyEntityQueryRequestBus::Broadcast(
+            &ReadOnlyEntityQueryRequestBus::Events::IsReadOnly, entityId, isReadOnly);
+
+        m_readOnlystates[entityId] = isReadOnly;
+    }
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/ReadOnly/ReadOnlyEntitySystemComponent.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/Memory/SystemAllocator.h>
+
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntityInterface.h>
+
+namespace AzToolsFramework
+{
+    //! System Component to track read-only entity registration.
+    //! An entity registered as ReadOnly cannot be altered in the Editor.
+    class ReadOnlyEntitySystemComponent final
+        : public AZ::Component
+        , private ReadOnlyEntityPublicInterface
+        , private ReadOnlyEntityQueryInterface
+        , private EditorEntityContextNotificationBus::Handler
+    {
+    public:
+        AZ_COMPONENT(ReadOnlyEntitySystemComponent, "{B32EB03F-D88F-4B3A-9C16-071AF04DA646}");
+
+        ReadOnlyEntitySystemComponent() = default;
+        virtual ~ReadOnlyEntitySystemComponent() = default;
+
+        // AZ::Component overrides ...
+        void Activate() override;
+        void Deactivate() override;
+
+        static void Reflect(AZ::ReflectContext* context);
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+
+        // ReadOnlyEntityPublicNotifications overrides ...
+        bool IsReadOnly(const AZ::EntityId& entityId) override;
+        
+        // ReadOnlyEntityQueryInterface overrides ...
+        void RefreshReadOnlyState(const EntityIdList& entityIds) override;
+        void RefreshReadOnlyStateForAllEntities() override;
+
+        // EditorEntityContextNotificationBus overrides ...
+        void OnContextReset() override;
+
+    private:
+        void QueryReadOnlyStateForEntity(const AZ::EntityId& entityId);
+
+        AZStd::unordered_map<AZ::EntityId, bool> m_readOnlystates;
+    };
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.cpp

@@ -14,7 +14,7 @@
 
 namespace AzToolsFramework
 {
-    AZ_CVAR(bool, cl_manipulatorDrawDebug, false, nullptr, AZ::ConsoleFunctorFlags::Null, "Enable debug drawing for Manipulators");
+    AZ_CVAR(bool, ed_manipulatorDrawDebug, false, nullptr, AZ::ConsoleFunctorFlags::Null, "Enable debug drawing for Manipulators");
 
     const AZ::Color BaseManipulator::s_defaultMouseOverColor = AZ::Color(1.0f, 1.0f, 0.0f, 1.0f); // yellow
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.h

@@ -28,7 +28,7 @@ namespace AzFramework
 
 namespace AzToolsFramework
 {
-    AZ_CVAR_EXTERNED(bool, cl_manipulatorDrawDebug);
+    AZ_CVAR_EXTERNED(bool, ed_manipulatorDrawDebug);
 
     namespace UndoSystem
     {

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LinearManipulator.cpp

@@ -207,7 +207,7 @@ namespace AzToolsFramework
             ? AZ::Transform::CreateFromQuaternionAndTranslation(m_visualOrientationOverride, GetLocalPosition())
             : GetLocalTransform();
 
-        if (cl_manipulatorDrawDebug)
+        if (ed_manipulatorDrawDebug)
         {
             if (PerformingAction())
             {

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorView.cpp

@@ -21,6 +21,7 @@
 #include <AzToolsFramework/Manipulators/PlanarManipulator.h>
 #include <AzToolsFramework/Manipulators/SplineSelectionManipulator.h>
 #include <AzToolsFramework/Maths/TransformUtils.h>
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
 #include <AzToolsFramework/ViewportSelection/EditorSelectionUtil.h>
 
 AZ_CVAR(
@@ -30,6 +31,13 @@ AZ_CVAR(
     nullptr,
     AZ::ConsoleFunctorFlags::Null,
     "Display additional debug drawing for manipulator bounds");
+AZ_CVAR(
+    float,
+    ed_planarManipulatorBoundScaleFactor,
+    1.75f,
+    nullptr,
+    AZ::ConsoleFunctorFlags::Null,
+    "The scale factor to apply to the planar manipulator bounds");
 
 namespace AzToolsFramework
 {
@@ -78,7 +86,8 @@ namespace AzToolsFramework
         {
             // check if we actually needed to flip the axis, if so, write to shouldCorrect
             // so we know and are able to draw it differently if we wish (e.g. hollow if flipped)
-            const bool correcting = ShouldFlipCameraAxis(worldFromLocal, localPosition, axis, cameraState);
+            const bool correcting =
+                FlipManipulatorAxesTowardsView() && ShouldFlipCameraAxis(worldFromLocal, localPosition, axis, cameraState);
 
             // the corrected axis, if no flip was required, output == input
             correctedAxis = correcting ? -axis : axis;
@@ -325,7 +334,8 @@ namespace AzToolsFramework
     float ManipulatorView::ManipulatorViewScaleMultiplier(
         const AZ::Vector3& worldPosition, const AzFramework::CameraState& cameraState) const
     {
-        return ScreenSizeFixed() ? CalculateScreenToWorldMultiplier(worldPosition, cameraState) : 1.0f;
+        const float screenScale = ScreenSizeFixed() ? CalculateScreenToWorldMultiplier(worldPosition, cameraState) : 1.0f;
+        return screenScale * ManipulatorViewBaseScale();
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -342,47 +352,77 @@ namespace AzToolsFramework
         const AZ::Vector3 axis1 = m_axis1;
         const AZ::Vector3 axis2 = m_axis2;
 
-        CameraCorrectAxis(
-            axis1, m_cameraCorrectedAxis1, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
-            manipulatorState.m_localPosition, cameraState);
-        CameraCorrectAxis(
-            axis2, m_cameraCorrectedAxis2, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
-            manipulatorState.m_localPosition, cameraState);
+        // support partial application of CameraCorrectAxis to reduce redundant call site parameters
+        auto cameraCorrectAxisPartialFn =
+            [&manipulatorState, &managerState, &mouseInteraction, &cameraState](const AZ::Vector3& inAxis, AZ::Vector3& outAxis)
+        {
+            CameraCorrectAxis(
+                inAxis, outAxis, managerState, mouseInteraction, manipulatorState.m_worldFromLocal, manipulatorState.m_localPosition,
+                cameraState);
+        };
 
-        const Picking::BoundShapeQuad quadBound = CalculateQuadBound(
-            manipulatorState.m_localPosition, manipulatorState, m_cameraCorrectedAxis1, m_cameraCorrectedAxis2,
-            m_size *
-                ManipulatorViewScaleMultiplier(
-                    manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState));
+        cameraCorrectAxisPartialFn(axis1, m_cameraCorrectedAxis1);
+        cameraCorrectAxisPartialFn(axis2, m_cameraCorrectedAxis2);
+        cameraCorrectAxisPartialFn(axis1 * axis1.Dot(m_offset), m_cameraCorrectedOffsetAxis1);
+        cameraCorrectAxisPartialFn(axis2 * axis2.Dot(m_offset), m_cameraCorrectedOffsetAxis2);
+
+        const AZ::Vector3 totalScale =
+            manipulatorState.m_nonUniformScale * AZ::Vector3(manipulatorState.m_worldFromLocal.GetUniformScale());
+
+        const auto cameraCorrectedVisualOffset = (m_cameraCorrectedOffsetAxis1 + m_cameraCorrectedOffsetAxis2) * totalScale.GetReciprocal();
+        const auto viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const Picking::BoundShapeQuad quadBoundVisual = CalculateQuadBound(
+            manipulatorState.m_localPosition + (cameraCorrectedVisualOffset * viewScale), manipulatorState, m_cameraCorrectedAxis1,
+            m_cameraCorrectedAxis2, m_size * viewScale);
 
         debugDisplay.SetLineWidth(defaultLineWidth(manipulatorState.m_mouseOver));
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_axis1Color, m_mouseOverColor).GetAsVector4());
-        debugDisplay.DrawLine(quadBound.m_corner4, quadBound.m_corner3);
+        debugDisplay.DrawLine(quadBoundVisual.m_corner4, quadBoundVisual.m_corner3);
+        debugDisplay.DrawLine(quadBoundVisual.m_corner1, quadBoundVisual.m_corner2);
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_axis2Color, m_mouseOverColor).GetAsVector4());
-        debugDisplay.DrawLine(quadBound.m_corner2, quadBound.m_corner3);
+        debugDisplay.DrawLine(quadBoundVisual.m_corner2, quadBoundVisual.m_corner3);
+        debugDisplay.DrawLine(quadBoundVisual.m_corner1, quadBoundVisual.m_corner4);
 
         if (manipulatorState.m_mouseOver)
         {
             debugDisplay.SetColor(Vector3ToVector4(m_mouseOverColor.GetAsVector3(), 0.5f));
 
             debugDisplay.CullOff();
-            debugDisplay.DrawQuad(quadBound.m_corner1, quadBound.m_corner2, quadBound.m_corner3, quadBound.m_corner4);
+            debugDisplay.DrawQuad(
+                quadBoundVisual.m_corner1, quadBoundVisual.m_corner2, quadBoundVisual.m_corner3, quadBoundVisual.m_corner4);
             debugDisplay.CullOn();
         }
 
-        RefreshBoundInternal(managerId, manipulatorId, quadBound);
+        // total size of bounds to use for mouse intersection
+        const float hitSize = m_size * ed_planarManipulatorBoundScaleFactor;
+        // size of edge bounds (the 'margin/border' outside the visual representation)
+        const float edgeSize = (hitSize - m_size) * 0.5f;
+        const AZ::Vector3 edgeOffset =
+            ((m_cameraCorrectedAxis1 * edgeSize + m_cameraCorrectedAxis2 * edgeSize) * totalScale.GetReciprocal());
+        const auto cameraCorrectedHitOffset = cameraCorrectedVisualOffset - edgeOffset;
+        const Picking::BoundShapeQuad quadBoundHit = CalculateQuadBound(
+            manipulatorState.m_localPosition + (cameraCorrectedHitOffset * viewScale), manipulatorState, m_cameraCorrectedAxis1,
+            m_cameraCorrectedAxis2, hitSize * viewScale);
+
+        if (ed_manipulatorDisplayBoundDebug)
+        {
+            debugDisplay.DrawQuad(quadBoundHit.m_corner1, quadBoundHit.m_corner2, quadBoundHit.m_corner3, quadBoundHit.m_corner4);
+        }
+
+        RefreshBoundInternal(managerId, manipulatorId, quadBoundHit);
     }
 
     void ManipulatorViewQuadBillboard::Draw(
         const ManipulatorManagerId managerId,
-        const ManipulatorManagerState& /*managerState*/,
+        [[maybe_unused]] const ManipulatorManagerState& managerState,
         const ManipulatorId manipulatorId,
         const ManipulatorState& manipulatorState,
         AzFramework::DebugDisplayRequests& debugDisplay,
         const AzFramework::CameraState& cameraState,
-        const ViewportInteraction::MouseInteraction& /*mouseInteraction*/)
+        [[maybe_unused]] const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
         const Picking::BoundShapeQuad quadBound = CalculateQuadBoundBillboard(
             manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal,
@@ -442,7 +482,7 @@ namespace AzToolsFramework
 
     void ManipulatorViewLineSelect::Draw(
         const ManipulatorManagerId managerId,
-        const ManipulatorManagerState& /*managerState*/,
+        [[maybe_unused]] const ManipulatorManagerState& managerState,
         const ManipulatorId manipulatorId,
         const ManipulatorState& manipulatorState,
         AzFramework::DebugDisplayRequests& debugDisplay,
@@ -570,7 +610,7 @@ namespace AzToolsFramework
 
     void ManipulatorViewSphere::Draw(
         const ManipulatorManagerId managerId,
-        const ManipulatorManagerState& /*managerState*/,
+        [[maybe_unused]] const ManipulatorManagerState& managerState,
         const ManipulatorId manipulatorId,
         const ManipulatorState& manipulatorState,
         AzFramework::DebugDisplayRequests& debugDisplay,
@@ -599,12 +639,12 @@ namespace AzToolsFramework
 
     void ManipulatorViewCircle::Draw(
         const ManipulatorManagerId managerId,
-        const ManipulatorManagerState& /*managerState*/,
+        [[maybe_unused]] const ManipulatorManagerState& managerState,
         const ManipulatorId manipulatorId,
         const ManipulatorState& manipulatorState,
         AzFramework::DebugDisplayRequests& debugDisplay,
         const AzFramework::CameraState& cameraState,
-        const ViewportInteraction::MouseInteraction& /*mouseInteraction*/)
+        [[maybe_unused]] const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
         const float viewScale =
             ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
@@ -665,7 +705,7 @@ namespace AzToolsFramework
 
     void ManipulatorViewSplineSelect::Draw(
         const ManipulatorManagerId managerId,
-        const ManipulatorManagerState& /*managerState*/,
+        [[maybe_unused]] const ManipulatorManagerState& managerState,
         const ManipulatorId manipulatorId,
         const ManipulatorState& manipulatorState,
         AzFramework::DebugDisplayRequests& debugDisplay,
@@ -698,12 +738,17 @@ namespace AzToolsFramework
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     AZStd::unique_ptr<ManipulatorViewQuad> CreateManipulatorViewQuad(
-        const PlanarManipulator& planarManipulator, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const float size)
+        const PlanarManipulator& planarManipulator,
+        const AZ::Color& axis1Color,
+        const AZ::Color& axis2Color,
+        const AZ::Vector3& offset,
+        const float size)
     {
         AZStd::unique_ptr<ManipulatorViewQuad> viewQuad = AZStd::make_unique<ManipulatorViewQuad>();
         viewQuad->m_axis1 = planarManipulator.GetAxis1();
         viewQuad->m_axis2 = planarManipulator.GetAxis2();
         viewQuad->m_size = size;
+        viewQuad->m_offset = offset;
         viewQuad->m_axis1Color = axis1Color;
         viewQuad->m_axis2Color = axis2Color;
         return viewQuad;

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorView.h

@@ -54,7 +54,7 @@ namespace AzToolsFramework
         AZ_RTTI(ManipulatorView, "{7529E3E9-39B3-4D15-899A-FA13770113B2}")
 
         ManipulatorView();
-        ManipulatorView(bool screenSizeFixed);
+        explicit ManipulatorView(bool screenSizeFixed);
         virtual ~ManipulatorView();
         ManipulatorView(ManipulatorView&&) = default;
         ManipulatorView& operator=(ManipulatorView&&) = default;
@@ -117,13 +117,16 @@ namespace AzToolsFramework
 
         AZ::Vector3 m_axis1 = AZ::Vector3(1.0f, 0.0f, 0.0f);
         AZ::Vector3 m_axis2 = AZ::Vector3(0.0f, 1.0f, 0.0f);
+        AZ::Vector3 m_offset = AZ::Vector3::CreateZero();
         AZ::Color m_axis1Color = AZ::Color(1.0f, 0.0f, 0.0f, 1.0f);
         AZ::Color m_axis2Color = AZ::Color(1.0f, 0.0f, 0.0f, 1.0f);
         float m_size = 0.06f; //!< size to render and do mouse ray intersection tests against.
 
     private:
-        AZ::Vector3 m_cameraCorrectedAxis1;
-        AZ::Vector3 m_cameraCorrectedAxis2;
+        AZ::Vector3 m_cameraCorrectedAxis1; //!< First axis of quad (should be orthogonal to second axis).
+        AZ::Vector3 m_cameraCorrectedAxis2; //!< Second axis of quad (should be orthogonal to first axis).
+        AZ::Vector3 m_cameraCorrectedOffsetAxis1; //!< Offset along first axis (parallel with first axis).
+        AZ::Vector3 m_cameraCorrectedOffsetAxis2; //!< Offset along second axis (parallel with second axis).
     };
 
     //! A screen aligned quad, centered at the position of the manipulator, display filled.
@@ -379,7 +382,11 @@ namespace AzToolsFramework
     // Helpers to create various manipulator views.
 
     AZStd::unique_ptr<ManipulatorViewQuad> CreateManipulatorViewQuad(
-        const PlanarManipulator& planarManipulator, const AZ::Color& axis1Color, const AZ::Color& axis2Color, float size);
+        const PlanarManipulator& planarManipulator,
+        const AZ::Color& axis1Color,
+        const AZ::Color& axis2Color,
+        const AZ::Vector3& offset,
+        float size);
 
     AZStd::unique_ptr<ManipulatorViewQuadBillboard> CreateManipulatorViewQuadBillboard(const AZ::Color& color, float size);
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/MultiLinearManipulator.cpp

@@ -132,7 +132,7 @@ namespace AzToolsFramework
         const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        if (cl_manipulatorDrawDebug)
+        if (ed_manipulatorDrawDebug)
         {
             const AZ::Transform combined = TransformUniformScale(GetSpace()) * GetLocalTransform();
             for (const auto& fixed : m_fixedAxes)

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/PlanarManipulator.cpp

@@ -171,7 +171,7 @@ namespace AzToolsFramework
         const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        if (cl_manipulatorDrawDebug)
+        if (ed_manipulatorDrawDebug)
         {
             if (PerformingAction())
             {

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp

@@ -9,6 +9,7 @@
 #include "ScaleManipulators.h"
 
 #include <AzToolsFramework/Maths/TransformUtils.h>
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
 
 namespace AzToolsFramework
 {
@@ -120,25 +121,25 @@ namespace AzToolsFramework
     void ScaleManipulators::ConfigureView(
         const float axisLength, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const AZ::Color& axis3Color)
     {
-        const float boxSize = 0.1f;
+        const float boxHalfExtent = ScaleManipulatorBoxHalfExtent();
         const AZ::Color colors[] = { axis1Color, axis2Color, axis3Color };
 
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_axisScaleManipulators.size(); ++manipulatorIndex)
         {
-            const auto lineLength = axisLength - boxSize;
+            const auto lineLength = axisLength - (2.0f * boxHalfExtent);
 
             ManipulatorViews views;
-            views.emplace_back(
-                CreateManipulatorViewLine(*m_axisScaleManipulators[manipulatorIndex], colors[manipulatorIndex], axisLength, m_lineBoundWidth));
+            views.emplace_back(CreateManipulatorViewLine(
+                *m_axisScaleManipulators[manipulatorIndex], colors[manipulatorIndex], axisLength, m_lineBoundWidth));
             views.emplace_back(CreateManipulatorViewBox(
                 AZ::Transform::CreateIdentity(), colors[manipulatorIndex],
-                m_axisScaleManipulators[manipulatorIndex]->GetAxis() * lineLength, AZ::Vector3(boxSize)));
+                m_axisScaleManipulators[manipulatorIndex]->GetAxis() * (lineLength + boxHalfExtent), AZ::Vector3(boxHalfExtent)));
             m_axisScaleManipulators[manipulatorIndex]->SetViews(AZStd::move(views));
         }
 
         ManipulatorViews views;
         views.emplace_back(CreateManipulatorViewBox(
-            AZ::Transform::CreateIdentity(), AZ::Color::CreateOne(), AZ::Vector3::CreateZero(), AZ::Vector3(boxSize)));
+            AZ::Transform::CreateIdentity(), AZ::Color::CreateOne(), AZ::Vector3::CreateZero(), AZ::Vector3(boxHalfExtent)));
         m_uniformScaleManipulator->SetViews(AZStd::move(views));
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/TranslationManipulators.cpp

@@ -10,13 +10,10 @@
 
 #include <AzCore/Math/VectorConversions.h>
 #include <AzToolsFramework/Manipulators/ManipulatorView.h>
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
 
 namespace AzToolsFramework
 {
-    static const float SurfaceManipulatorTransparency = 0.75f;
-    static const float LinearManipulatorAxisLength = 2.0f;
-    static const float SurfaceManipulatorRadius = 0.1f;
-
     static const AZ::Color LinearManipulatorXAxisColor = AZ::Color(1.0f, 0.0f, 0.0f, 1.0f);
     static const AZ::Color LinearManipulatorYAxisColor = AZ::Color(0.0f, 1.0f, 0.0f, 1.0f);
     static const AZ::Color LinearManipulatorZAxisColor = AZ::Color(0.0f, 0.0f, 1.0f, 1.0f);
@@ -240,18 +237,16 @@ namespace AzToolsFramework
         const AZ::Color& axis2Color,
         const AZ::Color& axis3Color /*= AZ::Color(0.0f, 0.0f, 1.0f, 0.5f)*/)
     {
-        const float coneLength = 0.28f;
-        const float coneRadius = 0.07f;
-
         const AZ::Color axesColor[] = { axis1Color, axis2Color, axis3Color };
 
-        const auto configureLinearView = [lineBoundWidth = m_lineBoundWidth, coneLength, axisLength,
-                                          coneRadius](LinearManipulator* linearManipulator, const AZ::Color& color)
+        const auto configureLinearView =
+            [lineBoundWidth = m_lineBoundWidth, coneLength = LinearManipulatorConeLength(), axisLength,
+             coneRadius = LinearManipulatorConeRadius()](LinearManipulator* linearManipulator, const AZ::Color& color)
         {
             const auto lineLength = axisLength - coneLength;
 
             ManipulatorViews views;
-            views.emplace_back(CreateManipulatorViewLine(*linearManipulator, color, lineLength, lineBoundWidth));
+            views.emplace_back(CreateManipulatorViewLine(*linearManipulator, color, axisLength, lineBoundWidth));
             views.emplace_back(
                 CreateManipulatorViewCone(*linearManipulator, color, linearManipulator->GetAxis() * lineLength, coneLength, coneRadius));
             linearManipulator->SetViews(AZStd::move(views));
@@ -264,17 +259,23 @@ namespace AzToolsFramework
     }
 
     void TranslationManipulators::ConfigurePlanarView(
+        const float planeSize,
         const AZ::Color& plane1Color,
         const AZ::Color& plane2Color /*= AZ::Color(0.0f, 1.0f, 0.0f, 0.5f)*/,
         const AZ::Color& plane3Color /*= AZ::Color(0.0f, 0.0f, 1.0f, 0.5f)*/)
     {
-        const float planeSize = 0.6f;
         const AZ::Color planesColor[] = { plane1Color, plane2Color, plane3Color };
 
+        const float linearAxisLength = LinearManipulatorAxisLength();
+        const float linearConeLength = LinearManipulatorConeLength();
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_planarManipulators.size(); ++manipulatorIndex)
         {
+            const auto& planarManipulator = *m_planarManipulators[manipulatorIndex];
             const AZStd::shared_ptr<ManipulatorViewQuad> manipulatorView = CreateManipulatorViewQuad(
-                *m_planarManipulators[manipulatorIndex], planesColor[manipulatorIndex], planesColor[(manipulatorIndex + 1) % 3], planeSize);
+                *m_planarManipulators[manipulatorIndex], planesColor[manipulatorIndex], planesColor[(manipulatorIndex + 1) % 3],
+                (planarManipulator.GetAxis1() + planarManipulator.GetAxis2()) *
+                    (((linearAxisLength - linearConeLength) * 0.5f) - (planeSize * 0.5f)),
+                planeSize);
 
             m_planarManipulators[manipulatorIndex]->SetViews(ManipulatorViews{ manipulatorView });
         }
@@ -286,12 +287,11 @@ namespace AzToolsFramework
         {
             m_surfaceManipulator->SetView(CreateManipulatorViewSphere(
                 color, radius,
-                [](const ViewportInteraction::MouseInteraction& /*mouseInteraction*/, bool mouseOver,
+                []([[maybe_unused]] const ViewportInteraction::MouseInteraction& mouseInteraction, bool mouseOver,
                    const AZ::Color& defaultColor) -> AZ::Color
                 {
                     const AZ::Color color[2] = {
-                        defaultColor,
-                        Vector3ToVector4(BaseManipulator::s_defaultMouseOverColor.GetAsVector3(), SurfaceManipulatorTransparency)
+                        defaultColor, Vector3ToVector4(BaseManipulator::s_defaultMouseOverColor.GetAsVector3(), SurfaceManipulatorOpacity())
                     };
 
                     return color[mouseOver];
@@ -325,16 +325,19 @@ namespace AzToolsFramework
     void ConfigureTranslationManipulatorAppearance3d(TranslationManipulators* translationManipulators)
     {
         translationManipulators->SetAxes(AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY(), AZ::Vector3::CreateAxisZ());
-        translationManipulators->ConfigurePlanarView(LinearManipulatorXAxisColor, LinearManipulatorYAxisColor, LinearManipulatorZAxisColor);
+        translationManipulators->ConfigurePlanarView(
+            PlanarManipulatorAxisLength(), LinearManipulatorXAxisColor, LinearManipulatorYAxisColor, LinearManipulatorZAxisColor);
         translationManipulators->ConfigureLinearView(
-            LinearManipulatorAxisLength, LinearManipulatorXAxisColor, LinearManipulatorYAxisColor, LinearManipulatorZAxisColor);
-        translationManipulators->ConfigureSurfaceView(SurfaceManipulatorRadius, SurfaceManipulatorColor);
+            LinearManipulatorAxisLength(), LinearManipulatorXAxisColor, LinearManipulatorYAxisColor, LinearManipulatorZAxisColor);
+        translationManipulators->ConfigureSurfaceView(SurfaceManipulatorRadius(), SurfaceManipulatorColor);
     }
 
     void ConfigureTranslationManipulatorAppearance2d(TranslationManipulators* translationManipulators)
     {
         translationManipulators->SetAxes(AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY());
-        translationManipulators->ConfigurePlanarView(LinearManipulatorXAxisColor);
-        translationManipulators->ConfigureLinearView(LinearManipulatorAxisLength, LinearManipulatorXAxisColor, LinearManipulatorYAxisColor);
+        translationManipulators->ConfigurePlanarView(
+            PlanarManipulatorAxisLength(), LinearManipulatorXAxisColor, LinearManipulatorYAxisColor);
+        translationManipulators->ConfigureLinearView(
+            LinearManipulatorAxisLength(), LinearManipulatorXAxisColor, LinearManipulatorYAxisColor);
     }
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/TranslationManipulators.h

@@ -53,6 +53,7 @@ namespace AzToolsFramework
         void SetAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3 = AZ::Vector3::CreateAxisZ());
 
         void ConfigurePlanarView(
+            float planeSize,
             const AZ::Color& plane1Color,
             const AZ::Color& plane2Color = AZ::Color(0.0f, 1.0f, 0.0f, 0.5f),
             const AZ::Color& plane3Color = AZ::Color(0.0f, 0.0f, 1.0f, 0.5f));

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp

@@ -521,21 +521,18 @@ namespace AzToolsFramework
                 nestedInstanceLink.has_value(),
                 "A valid link was not found for one of the instances provided as input for the CreatePrefab operation.");    
 
-            PrefabDomReference nestedInstanceLinkDom = nestedInstanceLink->get().GetLinkDom();
-            AZ_Assert(
-                nestedInstanceLinkDom.has_value(),
-                "A valid DOM was not found for the link corresponding to one of the instances provided as input for the "
-                "CreatePrefab operation.");
-
-            PrefabDomValueReference nestedInstanceLinkPatches =
-                PrefabDomUtils::FindPrefabDomValue(nestedInstanceLinkDom->get(), PrefabDomUtils::PatchesName);
-            AZ_Assert(
-                nestedInstanceLinkPatches.has_value(),
-                "A valid DOM for patches was not found for the link corresponding to one of the instances provided as input for the "
-                "CreatePrefab operation.");
-
             PrefabDom patchesCopyForUndoSupport;
-            patchesCopyForUndoSupport.CopyFrom(nestedInstanceLinkPatches->get(), patchesCopyForUndoSupport.GetAllocator());
+            PrefabDomReference nestedInstanceLinkDom = nestedInstanceLink->get().GetLinkDom();
+            if (nestedInstanceLinkDom.has_value())
+            {
+                PrefabDomValueReference nestedInstanceLinkPatches =
+                    PrefabDomUtils::FindPrefabDomValue(nestedInstanceLinkDom->get(), PrefabDomUtils::PatchesName);
+                if (nestedInstanceLinkPatches.has_value())
+                {
+                    patchesCopyForUndoSupport.CopyFrom(nestedInstanceLinkPatches->get(), patchesCopyForUndoSupport.GetAllocator());
+                }
+            }
+
             PrefabUndoHelpers::RemoveLink(
                 sourceInstance->GetTemplateId(), targetTemplateId, sourceInstance->GetInstanceAlias(), sourceInstance->GetLinkId(),
                 AZStd::move(patchesCopyForUndoSupport), undoBatch);

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportSettings.cpp

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
+
+namespace AzToolsFramework
+{
+    constexpr AZStd::string_view FlipManipulatorAxesTowardsViewSetting = "/Amazon/Preferences/Editor/Manipulator/FlipManipulatorAxesTowardsView";
+    constexpr AZStd::string_view LinearManipulatorAxisLengthSetting = "/Amazon/Preferences/Editor/Manipulator/LinearManipulatorAxisLength";
+    constexpr AZStd::string_view PlanarManipulatorAxisLengthSetting = "/Amazon/Preferences/Editor/Manipulator/PlanarManipulatorAxisLength";
+    constexpr AZStd::string_view SurfaceManipulatorRadiusSetting = "/Amazon/Preferences/Editor/Manipulator/SurfaceManipulatorRadius";
+    constexpr AZStd::string_view SurfaceManipulatorOpacitySetting = "/Amazon/Preferences/Editor/Manipulator/SurfaceManipulatorOpacity";
+    constexpr AZStd::string_view LinearManipulatorConeLengthSetting = "/Amazon/Preferences/Editor/Manipulator/LinearManipulatorConeLength";
+    constexpr AZStd::string_view LinearManipulatorConeRadiusSetting = "/Amazon/Preferences/Editor/Manipulator/LinearManipulatorConeRadius";
+    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";
+
+    bool FlipManipulatorAxesTowardsView()
+    {
+        return GetRegistry(FlipManipulatorAxesTowardsViewSetting, true);
+    }
+
+    void SetFlipManipulatorAxesTowardsView(const bool enabled)
+    {
+        SetRegistry(FlipManipulatorAxesTowardsViewSetting, enabled);
+    }
+
+    float LinearManipulatorAxisLength()
+    {
+        return aznumeric_cast<float>(GetRegistry(LinearManipulatorAxisLengthSetting, 2.0));
+    }
+
+    void SetLinearManipulatorAxisLength(const float length)
+    {
+        SetRegistry(LinearManipulatorAxisLengthSetting, length);
+    }
+
+    float PlanarManipulatorAxisLength()
+    {
+        return aznumeric_cast<float>(GetRegistry(PlanarManipulatorAxisLengthSetting, 0.6));
+    }
+
+    void SetPlanarManipulatorAxisLength(const float length)
+    {
+        SetRegistry(PlanarManipulatorAxisLengthSetting, length);
+    }
+
+    float SurfaceManipulatorRadius()
+    {
+        return aznumeric_cast<float>(GetRegistry(SurfaceManipulatorRadiusSetting, 0.1));
+    }
+
+    void SetSurfaceManipulatorRadius(const float radius)
+    {
+        SetRegistry(SurfaceManipulatorRadiusSetting, radius);
+    }
+
+    float SurfaceManipulatorOpacity()
+    {
+        return aznumeric_cast<float>(GetRegistry(SurfaceManipulatorOpacitySetting, 0.75));
+    }
+
+    void SetSurfaceManipulatorOpacity(const float opacity)
+    {
+        SetRegistry(SurfaceManipulatorOpacitySetting, opacity);
+    }
+
+    float LinearManipulatorConeLength()
+    {
+        return aznumeric_cast<float>(GetRegistry(LinearManipulatorConeLengthSetting, 0.28));
+    }
+
+    void SetLinearManipulatorConeLength(const float length)
+    {
+        SetRegistry(LinearManipulatorConeLengthSetting, length);
+    }
+
+    float LinearManipulatorConeRadius()
+    {
+        return aznumeric_cast<float>(GetRegistry(LinearManipulatorConeRadiusSetting, 0.1));
+    }
+
+    void SetLinearManipulatorConeRadius(const float radius)
+    {
+        SetRegistry(LinearManipulatorConeRadiusSetting, radius);
+    }
+
+    float ScaleManipulatorBoxHalfExtent()
+    {
+        return aznumeric_cast<float>(GetRegistry(ScaleManipulatorBoxHalfExtentSetting, 0.1));
+    }
+
+    void SetScaleManipulatorBoxHalfExtent(const float size)
+    {
+        SetRegistry(ScaleManipulatorBoxHalfExtentSetting, size);
+    }
+
+    float RotationManipulatorRadius()
+    {
+        return aznumeric_cast<float>(GetRegistry(RotationManipulatorRadiusSetting, 2.0));
+    }
+
+    void SetRotationManipulatorRadius(const float radius)
+    {
+        SetRegistry(RotationManipulatorRadiusSetting, radius);
+    }
+
+    float ManipulatorViewBaseScale()
+    {
+        return aznumeric_cast<float>(GetRegistry(ManipulatorViewBaseScaleSetting, 1.0));
+    }
+
+    void SetManipulatorViewBaseScale(const float scale)
+    {
+        SetRegistry(ManipulatorViewBaseScaleSetting, scale);
+    }
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportSettings.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Settings/SettingsRegistry.h>
+
+namespace AzToolsFramework
+{
+    template<typename T>
+    void SetRegistry(const AZStd::string_view setting, T&& value)
+    {
+        if (auto* registry = AZ::SettingsRegistry::Get())
+        {
+            registry->Set(setting, AZStd::forward<T>(value));
+        }
+    }
+
+    template<typename T>
+    AZStd::remove_cvref_t<T> GetRegistry(const AZStd::string_view setting, T&& defaultValue)
+    {
+        AZStd::remove_cvref_t<T> value = AZStd::forward<T>(defaultValue);
+        if (const auto* registry = AZ::SettingsRegistry::Get())
+        {
+            T potentialValue;
+            if (registry->Get(potentialValue, setting))
+            {
+                value = AZStd::move(potentialValue);
+            }
+        }
+
+        return value;
+    }
+
+    bool FlipManipulatorAxesTowardsView();
+    void SetFlipManipulatorAxesTowardsView(bool enabled);
+
+    float LinearManipulatorAxisLength();
+    void SetLinearManipulatorAxisLength(float length);
+
+    float PlanarManipulatorAxisLength();
+    void SetPlanarManipulatorAxisLength(float length);
+
+    float SurfaceManipulatorRadius();
+    void SetSurfaceManipulatorRadius(float radius);
+
+    float SurfaceManipulatorOpacity();
+    void SetSurfaceManipulatorOpacity(float opacity);
+
+    float LinearManipulatorConeLength();
+    void SetLinearManipulatorConeLength(float length);
+
+    float LinearManipulatorConeRadius();
+    void SetLinearManipulatorConeRadius(float radius);
+
+    float ScaleManipulatorBoxHalfExtent();
+    void SetScaleManipulatorBoxHalfExtent(float halfExtent);
+
+    float RotationManipulatorRadius();
+    void SetRotationManipulatorRadius(float radius);
+
+    float ManipulatorViewBaseScale();
+    void SetManipulatorViewBaseScale(float scale);
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp

@@ -33,6 +33,7 @@
 #include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
 #include <AzToolsFramework/ToolsComponents/TransformComponent.h>
 #include <AzToolsFramework/Viewport/ActionBus.h>
+#include <AzToolsFramework/Viewport/ViewportSettings.h>
 #include <AzToolsFramework/ViewportSelection/EditorSelectionUtil.h>
 #include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
 #include <Entity/EditorEntityContextBus.h>
@@ -1376,7 +1377,7 @@ namespace AzToolsFramework
         // view
         rotationManipulators->SetLocalAxes(AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY(), AZ::Vector3::CreateAxisZ());
         rotationManipulators->ConfigureView(
-            2.0f, AzFramework::ViewportColors::XAxisColor, AzFramework::ViewportColors::YAxisColor,
+            RotationManipulatorRadius(), AzFramework::ViewportColors::XAxisColor, AzFramework::ViewportColors::YAxisColor,
             AzFramework::ViewportColors::ZAxisColor);
 
         struct SharedRotationState
@@ -1535,7 +1536,8 @@ namespace AzToolsFramework
             RecalculateAverageManipulatorTransform(m_entityIdManipulators.m_lookups, m_pivotOverrideFrame, m_pivotMode, m_referenceFrame));
 
         scaleManipulators->SetAxes(AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY(), AZ::Vector3::CreateAxisZ());
-        scaleManipulators->ConfigureView(2.0f, AZ::Color::CreateOne(), AZ::Color::CreateOne(), AZ::Color::CreateOne());
+        scaleManipulators->ConfigureView(
+            LinearManipulatorAxisLength(), AZ::Color::CreateOne(), AZ::Color::CreateOne(), AZ::Color::CreateOne());
 
         struct SharedScaleState
         {

Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake

@@ -159,6 +159,10 @@ set(FILES
     Entity/SliceEditorEntityOwnershipServiceBus.h
     Entity/EntityUtilityComponent.h
     Entity/EntityUtilityComponent.cpp
+    Entity/ReadOnly/ReadOnlyEntityInterface.h
+    Entity/ReadOnly/ReadOnlyEntityBus.h
+    Entity/ReadOnly/ReadOnlyEntitySystemComponent.cpp
+    Entity/ReadOnly/ReadOnlyEntitySystemComponent.h
     Fingerprinting/TypeFingerprinter.h
     Fingerprinting/TypeFingerprinter.cpp
     FocusMode/FocusModeInterface.h
@@ -502,6 +506,8 @@ set(FILES
     Viewport/ViewportMessages.cpp
     Viewport/ViewportTypes.h
     Viewport/ViewportTypes.cpp
+    Viewport/ViewportSettings.h
+    Viewport/ViewportSettings.cpp
     ViewportUi/Button.h
     ViewportUi/Button.cpp
     ViewportUi/ButtonGroup.h

Code/Framework/AzToolsFramework/Tests/Entity/ReadOnly/ReadOnlyEntityFixture.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <Tests/Entity/ReadOnly/ReadOnlyEntityFixture.h>
+
+#include <AzToolsFramework/Entity/EditorEntityHelpers.h>
+
+namespace AzToolsFramework
+{
+    void ReadOnlyEntityFixture::SetUpEditorFixtureImpl()
+    {
+        // Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
+        // shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash 
+        // in the unit tests.
+        AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
+
+        m_readOnlyEntityPublicInterface = AZ::Interface<ReadOnlyEntityPublicInterface>::Get();
+        ASSERT_TRUE(m_readOnlyEntityPublicInterface != nullptr);
+
+        GenerateTestHierarchy();
+    }
+
+    void ReadOnlyEntityFixture::TearDownEditorFixtureImpl()
+    {
+    }
+
+    void ReadOnlyEntityFixture::GenerateTestHierarchy() 
+    {
+        /*
+        *   Root
+        *   |_  Child
+        *       |_  GrandChild1
+        *       |_  GrandChild2
+        */
+
+        m_entityMap[RootEntityName] =           CreateEditorEntity(RootEntityName, AZ::EntityId());
+        m_entityMap[ChildEntityName] =          CreateEditorEntity(ChildEntityName, m_entityMap[RootEntityName]);
+        m_entityMap[GrandChild1EntityName] =    CreateEditorEntity(GrandChild1EntityName, m_entityMap[ChildEntityName]);
+        m_entityMap[GrandChild2EntityName] =    CreateEditorEntity(GrandChild2EntityName, m_entityMap[ChildEntityName]);
+    }
+
+    AZ::EntityId ReadOnlyEntityFixture::CreateEditorEntity(const char* name, AZ::EntityId parentId)
+    {
+        AZ::Entity* entity = nullptr;
+        UnitTest::CreateDefaultEditorEntity(name, &entity);
+
+        // Parent
+        AZ::TransformBus::Event(entity->GetId(), &AZ::TransformInterface::SetParent, parentId);
+
+        return entity->GetId();
+    }
+
+    ReadOnlyHandlerAlwaysTrue::ReadOnlyHandlerAlwaysTrue()
+    {
+        auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        ReadOnlyEntityQueryRequestBus::Handler::BusConnect(editorEntityContextId);
+    }
+
+    ReadOnlyHandlerAlwaysTrue::~ReadOnlyHandlerAlwaysTrue()
+    {
+        ReadOnlyEntityQueryRequestBus::Handler::BusDisconnect();
+
+        if (auto readOnlyEntityQueryInterface = AZ::Interface<ReadOnlyEntityQueryInterface>::Get())
+        {
+            readOnlyEntityQueryInterface->RefreshReadOnlyStateForAllEntities();
+        }
+    }
+
+    void ReadOnlyHandlerAlwaysTrue::IsReadOnly([[maybe_unused]] const AZ::EntityId& entityId, bool& isReadOnly)
+    {
+        isReadOnly = true;
+    }
+
+    ReadOnlyHandlerAlwaysFalse::ReadOnlyHandlerAlwaysFalse()
+    {
+        auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        ReadOnlyEntityQueryRequestBus::Handler::BusConnect(editorEntityContextId);
+    }
+
+    ReadOnlyHandlerAlwaysFalse::~ReadOnlyHandlerAlwaysFalse()
+    {
+        ReadOnlyEntityQueryRequestBus::Handler::BusDisconnect();
+
+        if (auto readOnlyEntityQueryInterface = AZ::Interface<ReadOnlyEntityQueryInterface>::Get())
+        {
+            readOnlyEntityQueryInterface->RefreshReadOnlyStateForAllEntities();
+        }
+    }
+
+    ReadOnlyHandlerEntityId::ReadOnlyHandlerEntityId(AZ::EntityId entityId)
+        : m_entityId(entityId)
+    {
+        auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        ReadOnlyEntityQueryRequestBus::Handler::BusConnect(editorEntityContextId);
+    }
+
+    ReadOnlyHandlerEntityId::~ReadOnlyHandlerEntityId()
+    {
+        ReadOnlyEntityQueryRequestBus::Handler::BusDisconnect();
+
+        if (auto readOnlyEntityQueryInterface = AZ::Interface<ReadOnlyEntityQueryInterface>::Get())
+        {
+            readOnlyEntityQueryInterface->RefreshReadOnlyStateForAllEntities();
+        }
+    }
+
+    void ReadOnlyHandlerEntityId::IsReadOnly(const AZ::EntityId& entityId, bool& isReadOnly)
+    {
+        if (entityId == m_entityId)
+        {
+            isReadOnly = true;
+        }
+    }
+}

Code/Framework/AzToolsFramework/Tests/Entity/ReadOnly/ReadOnlyEntityFixture.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/TransformBus.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+#include <AzTest/AzTest.h>
+
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntityBus.h>
+#include <AzToolsFramework/Entity/ReadOnly/ReadOnlyEntityInterface.h>
+
+namespace AzToolsFramework
+{
+    class ReadOnlyEntityFixture
+        : public UnitTest::ToolsApplicationFixture
+    {
+    protected:
+        void SetUpEditorFixtureImpl() override;
+        void TearDownEditorFixtureImpl() override;
+
+        void GenerateTestHierarchy();
+        AZ::EntityId CreateEditorEntity(const char* name, AZ::EntityId parentId);
+
+        AZStd::unordered_map<AZStd::string, AZ::EntityId> m_entityMap;
+
+        ReadOnlyEntityPublicInterface* m_readOnlyEntityPublicInterface = nullptr;
+
+    public:
+        inline static const char* RootEntityName = "Root";
+        inline static const char* ChildEntityName = "Child";
+        inline static const char* GrandChild1EntityName = "GrandChild1";
+        inline static const char* GrandChild2EntityName = "GrandChild2";
+    };
+
+    class ReadOnlyHandlerAlwaysTrue
+        : public ReadOnlyEntityQueryRequestBus::Handler
+    {
+    public:
+        ReadOnlyHandlerAlwaysTrue();
+        ~ReadOnlyHandlerAlwaysTrue();
+
+        // ReadOnlyEntityQueryNotificationBus overrides ...
+        void IsReadOnly(const AZ::EntityId& entityId, bool& isReadOnly) override;
+    };
+
+    class ReadOnlyHandlerAlwaysFalse
+        : public ReadOnlyEntityQueryRequestBus::Handler
+    {
+    public:
+        ReadOnlyHandlerAlwaysFalse();
+        ~ReadOnlyHandlerAlwaysFalse();
+
+        // ReadOnlyEntityQueryNotificationBus overrides ...
+        void IsReadOnly([[maybe_unused]] const AZ::EntityId& entityId, [[maybe_unused]] bool& isReadOnly) override {}
+    };
+
+    class ReadOnlyHandlerEntityId
+        : public ReadOnlyEntityQueryRequestBus::Handler
+    {
+    public:
+        ReadOnlyHandlerEntityId(AZ::EntityId entityId);
+        ~ReadOnlyHandlerEntityId();
+
+        // ReadOnlyEntityQueryNotificationBus overrides ...
+        void IsReadOnly(const AZ::EntityId& entityId, bool& isReadOnly) override;
+
+    private:
+        AZ::EntityId m_entityId;
+    };
+}

Code/Framework/AzToolsFramework/Tests/Entity/ReadOnly/ReadOnlyEntityTests.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <Tests/Entity/ReadOnly/ReadOnlyEntityFixture.h>
+
+namespace AzToolsFramework
+{
+    TEST_F(ReadOnlyEntityFixture, NoHandlerEntityIsNotReadOnlyByDefault)
+    {
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+    }
+
+    TEST_F(ReadOnlyEntityFixture, SingleHandlerEntityIsReadOnly)
+    {
+        // Create a handler that sets all entities to read-only.
+        ReadOnlyHandlerAlwaysTrue alwaysTrueHandler;
+
+        // All entities should be marked read-only now.
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[RootEntityName]));
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild1EntityName]));
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild2EntityName]));
+    }
+
+    TEST_F(ReadOnlyEntityFixture, SingleHandlerEntityIsNotReadOnly)
+    {
+        // Create a handler that sets all entities to read-only.
+        ReadOnlyHandlerAlwaysFalse alwaysFalseHandler;
+
+        // All entities should not be marked read-only now.
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[RootEntityName]));
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild1EntityName]));
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild2EntityName]));
+    }
+
+    TEST_F(ReadOnlyEntityFixture, SingleHandlerWithLogic)
+    {
+        // Create a handler that sets just the child entity to read-only.
+        ReadOnlyHandlerEntityId entityIdHandler(m_entityMap[ChildEntityName]);
+
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[RootEntityName]));
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild1EntityName]));
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild2EntityName]));
+    }
+
+    TEST_F(ReadOnlyEntityFixture, TwoHandlersCanOverlap)
+    {
+        // Create two handlers that set different entities to read-only.
+        ReadOnlyHandlerEntityId entityIdHandler1(m_entityMap[ChildEntityName]);
+        ReadOnlyHandlerEntityId entityIdHandler2(m_entityMap[GrandChild2EntityName]);
+
+        // Both entities should be marked as read-only, while others aren't.
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[RootEntityName]));
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild1EntityName]));
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[GrandChild2EntityName]));
+    }
+
+    TEST_F(ReadOnlyEntityFixture, EnsureCacheIsRefreshedCorrectly)
+    {
+        // Verify the child entity is not marked as read-only
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+
+        // Create a handler that sets the child entity to read-only.
+        ReadOnlyHandlerEntityId entityIdHandler(m_entityMap[ChildEntityName]);
+
+        // Communicate to the ReadOnlyEntitySystemComponent that the read-only state for the child entity may have changed.
+        // Note that this operation would usually be executed by the handler, hence the Query interface call.
+        if (auto readOnlyEntityQueryInterface = AZ::Interface<ReadOnlyEntityQueryInterface>::Get())
+        {
+            readOnlyEntityQueryInterface->RefreshReadOnlyState({ m_entityMap[ChildEntityName] });
+        }
+
+        // Verify the child entity is marked as read-only
+        EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+    }
+
+    TEST_F(ReadOnlyEntityFixture, EnsureCacheIsClearedCorrectly)
+    {
+        {
+            // Create a handler that sets the child entity to read-only.
+            ReadOnlyHandlerEntityId entityIdHandler(m_entityMap[ChildEntityName]);
+
+            // Verify the child entity is marked as read-only
+            EXPECT_TRUE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+        }
+        // When the handler goes out of scope, it calls RefreshReadOnlyStateForAllEntities and refreshes the cache.
+
+        // Verify the child entity is no longer marked as read-only
+        EXPECT_FALSE(m_readOnlyEntityPublicInterface->IsReadOnly(m_entityMap[ChildEntityName]));
+    }
+}

Code/Framework/AzToolsFramework/Tests/Prefab/PrefabDeleteTests.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/Settings/SettingsRegistryMergeUtils.h>
+#include <AzToolsFramework/Entity/EditorEntityHelpers.h>
+#include <AzToolsFramework/ToolsComponents/TransformComponent.h>
+
+#include <Prefab/PrefabTestComponent.h>
+#include <Prefab/PrefabTestDomUtils.h>
+#include <Prefab/PrefabTestFixture.h>
+
+namespace UnitTest
+{
+    using PrefabDeleteTest = PrefabTestFixture;
+
+    TEST_F(PrefabDeleteTest, DeleteEntitiesInInstance_DeleteSingleEntitySucceeds)
+    {
+        PrefabEntityResult createEntityResult = m_prefabPublicInterface->CreateEntity(AZ::EntityId(), AZ::Vector3());
+
+        // Verify that a valid entity is created.
+        AZ::EntityId testEntityId = createEntityResult.GetValue();
+        ASSERT_TRUE(testEntityId.IsValid());
+        AZ::Entity* testEntity = AzToolsFramework::GetEntityById(testEntityId);
+        ASSERT_TRUE(testEntity != nullptr);
+
+        m_prefabPublicInterface->DeleteEntitiesInInstance(AzToolsFramework::EntityIdList{ testEntityId });
+
+        // Verify that entity can't be found after deletion.
+        testEntity = AzToolsFramework::GetEntityById(testEntityId);
+        EXPECT_TRUE(testEntity == nullptr);
+    }
+
+    TEST_F(PrefabDeleteTest, DeleteEntitiesInInstance_DeleteSinglePrefabSucceeds)
+    {
+        PrefabEntityResult createEntityResult = m_prefabPublicInterface->CreateEntity(AZ::EntityId(), AZ::Vector3());
+
+        // Verify that a valid entity is created.
+        AZ::EntityId createdEntityId = createEntityResult.GetValue();
+        ASSERT_TRUE(createdEntityId.IsValid());
+        AZ::Entity* createdEntity = AzToolsFramework::GetEntityById(createdEntityId);
+        ASSERT_TRUE(createdEntity != nullptr);
+
+        // Rather than hardcode a path, use a path from settings registry since that will work on all platforms.
+        AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
+        AZ::IO::FixedMaxPath path;
+        registry->Get(path.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        CreatePrefabResult createPrefabResult =
+            m_prefabPublicInterface->CreatePrefabInMemory(AzToolsFramework::EntityIdList{ createdEntityId }, path);
+
+        AZ::EntityId createdPrefabContainerId = createPrefabResult.GetValue();
+        ASSERT_TRUE(createdPrefabContainerId.IsValid());
+        AZ::Entity* prefabContainerEntity = AzToolsFramework::GetEntityById(createdPrefabContainerId);
+        ASSERT_TRUE(prefabContainerEntity != nullptr);
+
+        // Verify that the prefab container entity and the entity within are deleted.
+        m_prefabPublicInterface->DeleteEntitiesInInstance(AzToolsFramework::EntityIdList{ createdPrefabContainerId });
+        prefabContainerEntity = AzToolsFramework::GetEntityById(createdPrefabContainerId);
+        EXPECT_TRUE(prefabContainerEntity == nullptr);
+        createdEntity = AzToolsFramework::GetEntityById(createdEntityId);
+        EXPECT_TRUE(createdEntity == nullptr);
+    }
+
+    TEST_F(PrefabDeleteTest, DeleteEntitiesAndAllDescendantsInInstance_DeletingEntityDeletesChildEntityToo)
+    {
+        PrefabEntityResult parentEntityCreationResult = m_prefabPublicInterface->CreateEntity(AZ::EntityId(), AZ::Vector3());
+
+        // Verify that valid parent entity is created.
+        AZ::EntityId parentEntityId = parentEntityCreationResult.GetValue();
+        ASSERT_TRUE(parentEntityId.IsValid());
+        AZ::Entity* parentEntity = AzToolsFramework::GetEntityById(parentEntityId);
+        ASSERT_TRUE(parentEntity != nullptr);
+
+        // Verify that valid child entity is created.
+        PrefabEntityResult childEntityCreationResult = m_prefabPublicInterface->CreateEntity(parentEntityId, AZ::Vector3());
+        AZ::EntityId childEntityId = childEntityCreationResult.GetValue();
+        ASSERT_TRUE(childEntityId.IsValid());
+        AZ::Entity* childEntity = AzToolsFramework::GetEntityById(childEntityId);
+        ASSERT_TRUE(childEntity != nullptr);
+
+        // PrefabTestFixture won't add required editor components by default. Hence we add them here.
+        AddRequiredEditorComponents(childEntity);
+        AddRequiredEditorComponents(parentEntity);
+
+        // Parent the child entity under the parent entity.
+        AZ::TransformBus::Event(childEntityId, &AZ::TransformBus::Events::SetParent, parentEntityId);
+
+        // Delete parent entity and its children.
+        m_prefabPublicInterface->DeleteEntitiesAndAllDescendantsInInstance(AzToolsFramework::EntityIdList{ parentEntityId });
+
+        // Verify that both the parent and child entities are deleted.
+        parentEntity = AzToolsFramework::GetEntityById(parentEntityId);
+        EXPECT_TRUE(parentEntity == nullptr);
+        childEntity = AzToolsFramework::GetEntityById(childEntityId);
+        EXPECT_TRUE(childEntity == nullptr);
+    }
+
+    TEST_F(PrefabDeleteTest, DeleteEntitiesAndAllDescendantsInInstance_DeletingEntityDeletesChildPrefabToo)
+    {
+        PrefabEntityResult entityToBePutUnderPrefabResult = m_prefabPublicInterface->CreateEntity(AZ::EntityId(), AZ::Vector3());
+
+        // Verify that a valid entity is created that will be put in a prefab later.
+        AZ::EntityId entityToBePutUnderPrefabId = entityToBePutUnderPrefabResult.GetValue();
+        ASSERT_TRUE(entityToBePutUnderPrefabId.IsValid());
+        AZ::Entity* entityToBePutUnderPrefab = AzToolsFramework::GetEntityById(entityToBePutUnderPrefabId);
+        ASSERT_TRUE(entityToBePutUnderPrefab != nullptr);
+
+        // Verify that a valid parent entity is created.
+        PrefabEntityResult parentEntityCreationResult = m_prefabPublicInterface->CreateEntity(AZ::EntityId(), AZ::Vector3());
+        AZ::EntityId parentEntityId = parentEntityCreationResult.GetValue();
+        ASSERT_TRUE(parentEntityId.IsValid());
+        AZ::Entity* parentEntity = AzToolsFramework::GetEntityById(parentEntityId);
+        ASSERT_TRUE(parentEntity != nullptr);
+
+        // Rather than hardcode a path, use a path from settings registry since that will work on all platforms.
+        AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
+        AZ::IO::FixedMaxPath path;
+        registry->Get(path.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
+        CreatePrefabResult createPrefabResult =
+            m_prefabPublicInterface->CreatePrefabInMemory(AzToolsFramework::EntityIdList{ entityToBePutUnderPrefabId }, path);
+
+        // Verify that a valid prefab container entity is created.
+        AZ::EntityId createdPrefabContainerId = createPrefabResult.GetValue();
+        ASSERT_TRUE(createdPrefabContainerId.IsValid());
+        AZ::Entity* prefabContainerEntity = AzToolsFramework::GetEntityById(createdPrefabContainerId);
+        ASSERT_TRUE(prefabContainerEntity != nullptr);
+
+        // PrefabTestFixture won't add required editor components by default. Hence we add them here.
+        AddRequiredEditorComponents(parentEntity);
+        AddRequiredEditorComponents(prefabContainerEntity);
+
+        // Parent the prefab under the parent entity.
+        AZ::TransformBus::Event(createdPrefabContainerId, &AZ::TransformBus::Events::SetParent, parentEntityId);
+
+        // Delete the parent entity.
+        m_prefabPublicInterface->DeleteEntitiesAndAllDescendantsInInstance(AzToolsFramework::EntityIdList{ parentEntityId });
+
+        // Validate that the parent and the prefab under it and the entity inside the prefab are all deleted.
+        parentEntity = AzToolsFramework::GetEntityById(parentEntityId);
+        ASSERT_TRUE(parentEntity == nullptr);
+        entityToBePutUnderPrefab = AzToolsFramework::GetEntityById(entityToBePutUnderPrefabId);
+        ASSERT_TRUE(entityToBePutUnderPrefab == nullptr);
+        prefabContainerEntity = AzToolsFramework::GetEntityById(createdPrefabContainerId);
+        EXPECT_TRUE(prefabContainerEntity == nullptr);
+    }
+} // namespace UnitTest

Code/Framework/AzToolsFramework/Tests/Prefab/PrefabTestFixture.cpp

@@ -57,6 +57,11 @@ namespace UnitTest
         return AZStd::make_unique<PrefabTestToolsApplication>("PrefabTestApplication");
     }
 
+    void PrefabTestFixture::PropagateAllTemplateChanges()
+    {
+        m_prefabSystemComponent->OnSystemTick();
+    }
+
     AZ::Entity* PrefabTestFixture::CreateEntity(const char* entityName, const bool shouldActivate)
     {
         // Circumvent the EntityContext system and generate a new entity with a transformcomponent
@@ -125,4 +130,13 @@ namespace UnitTest
             EXPECT_EQ(entityInInstance->GetState(), AZ::Entity::State::Active);
         }
     }
+
+    void PrefabTestFixture::AddRequiredEditorComponents(AZ::Entity* entity)
+    {
+        ASSERT_TRUE(entity != nullptr);
+        entity->Deactivate();
+        AzToolsFramework::EditorEntityContextRequestBus::Broadcast(
+            &AzToolsFramework::EditorEntityContextRequests::AddRequiredComponents, *entity);
+        entity->Activate();
+    }
 }

Code/Framework/AzToolsFramework/Tests/Prefab/PrefabTestFixture.h

@@ -52,6 +52,8 @@ namespace UnitTest
 
         AZStd::unique_ptr<ToolsTestApplication> CreateTestApplication() override;
 
+        void PropagateAllTemplateChanges();
+
         AZ::Entity* CreateEntity(const char* entityName, const bool shouldActivate = true);
 
         void CompareInstances(const Instance& instanceA, const Instance& instanceB, bool shouldCompareLinkIds = true,
@@ -62,6 +64,8 @@ namespace UnitTest
         //! Validates that all entities within a prefab instance are in 'Active' state.
         void ValidateInstanceEntitiesActive(Instance& instance);
 
+        void AddRequiredEditorComponents(AZ::Entity* entity);
+
         PrefabSystemComponent* m_prefabSystemComponent = nullptr;
         PrefabLoaderInterface* m_prefabLoaderInterface = nullptr;
         PrefabPublicInterface* m_prefabPublicInterface = nullptr;

Code/Framework/AzToolsFramework/Tests/UI/EntityOutlinerTests.cpp

@@ -128,7 +128,7 @@ namespace UnitTest
         void ProcessDeferredUpdates()
         {
             // Force a prefab propagation for updates that are deferred to the next tick.
-            m_prefabSystemComponent->OnSystemTick();
+            PropagateAllTemplateChanges();
 
             // Ensure the model process its entity update queue
             m_model->ProcessEntityUpdates();

Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake

@@ -28,6 +28,9 @@ set(FILES
     Entity/EditorEntitySearchComponentTests.cpp
     Entity/EditorEntitySelectionTests.cpp
     Entity/EntityUtilityComponentTests.cpp
+    Entity/ReadOnly/ReadOnlyEntityFixture.cpp
+    Entity/ReadOnly/ReadOnlyEntityFixture.h
+    Entity/ReadOnly/ReadOnlyEntityTests.cpp
     EntityIdQLabelTests.cpp
     EntityInspectorTests.cpp
     EntityOwnershipService/EntityOwnershipServiceTestFixture.cpp
@@ -66,6 +69,7 @@ set(FILES
     Prefab/PrefabFocus/PrefabFocusTests.cpp
     Prefab/MockPrefabFileIOActionValidator.cpp
     Prefab/MockPrefabFileIOActionValidator.h
+    Prefab/PrefabDeleteTests.cpp
     Prefab/PrefabDuplicateTests.cpp
     Prefab/PrefabEntityAliasTests.cpp
     Prefab/PrefabInstanceToTemplatePropagatorTests.cpp

Code/Legacy/CryCommon/LyShine/Bus/Sprite/UiSpriteBus.h

@@ -1,58 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-
-// Forward declarations
-class ISprite;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified of changes to the sprite settings
-class UiSpriteSettingsChangeNotification
-    : public AZ::EBusTraits
-{
-public:
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    /**
-        * Overrides the default AZ::EBusTraits address policy so that the bus
-        * has multiple addresses at which to receive messages. This bus is 
-        * identified by Sprite pointer. Messages addressed to an ID are received by 
-        * handlers connected to that ID.
-        */
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-    /**
-        * Overrides the default AZ::EBusTraits ID type so that Sprite pointers are 
-        * used to access the addresses of the bus.
-        */
-    typedef ISprite* BusIdType;
-    //////////////////////////////////////////////////////////////////////////
-
-    virtual ~UiSpriteSettingsChangeNotification() {}
-
-    //! Called when the sprite settings such as number of cells etc change
-    virtual void OnSpriteSettingsChanged() = 0;
-};
-
-typedef AZ::EBus<UiSpriteSettingsChangeNotification> UiSpriteSettingsChangeNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Notify listeners when sprite image sources change.
-class UiSpriteSourceNotificationInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiSpriteSourceNotificationInterface() {}
-
-    //! A sprite image (or sequence of images) has changed file sources.
-    virtual void OnSpriteSourceChanged() = 0;
-};
-
-typedef AZ::EBus<UiSpriteSourceNotificationInterface> UiSpriteSourceNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/Tools/UiSystemToolsBus.h

@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-#include <AzCore/Component/Component.h>
-#include <AzCore/Slice/SliceComponent.h>
-#include <AzCore/Serialization/ObjectStream.h>
-
-namespace AZ
-{
-    namespace IO
-    {
-        class FileIOStream;
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus interface for tools to talk to the LyShine system
-//! It is valid to use this bus from resource compilers or the UI Editor
-class UiSystemToolsInterface
-    : public AZ::EBusTraits
-{
-public: // types
-
-    class CanvasAssetHandle
-    {
-    public:
-        virtual ~CanvasAssetHandle() {};
-    };
-
-public:
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-
-    using MutexType = AZStd::recursive_mutex;
-
-    // Public functions
-
-    //! Load a canvas but do not init or activate the entities
-    //! The CanvasAssetHandle is an opaque pointer only valid to be passed to the
-    //! methods below.
-    virtual CanvasAssetHandle* LoadCanvasFromStream(AZ::IO::GenericStream& stream, const AZ::ObjectStream::FilterDescriptor& filterDesc) = 0;
-
-    //! Save a canvas to a stream
-    virtual void SaveCanvasToStream(CanvasAssetHandle* canvas, AZ::IO::FileIOStream& stream) = 0;
-
-    //! Get the slice component for a loaded canvas
-    virtual AZ::SliceComponent* GetRootSliceSliceComponent(CanvasAssetHandle* canvas) = 0;
-
-    //! Get the slice entity for a loaded canvas
-    virtual AZ::Entity* GetRootSliceEntity(CanvasAssetHandle* canvas) = 0;
-
-    //! Get the canvas entity for a loaded canvas
-    virtual AZ::Entity* GetCanvasEntity(CanvasAssetHandle* canvas) = 0;
-
-    //! Replace the slice component with a new one. The old slice component is not deleted.
-    //! The client is responsible for that.
-    virtual void ReplaceRootSliceSliceComponent(CanvasAssetHandle* canvas, AZ::SliceComponent* newSliceComponent) = 0;
-
-    //! Replace the canvas entity with a new one. The old canvas entity is not deleted.
-    //! The client is responsible for that.
-    virtual void ReplaceCanvasEntity(CanvasAssetHandle* canvas, AZ::Entity* newCanvasEntity) = 0;
-    
-    //! Delete the canvas file object and its canvas entity and slice entity.
-    virtual void DestroyCanvas(CanvasAssetHandle* canvas) = 0;
-};
-
-using UiSystemToolsBus = AZ::EBus<UiSystemToolsInterface>;
-

Code/Legacy/CryCommon/LyShine/Bus/UiAnimateEntityBus.h

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-// Forward declarations
-class ISprite;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiAnimateEntityInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiAnimateEntityInterface() {}
-
-    //! Called when the animation system has updated the data members of an entity's components
-    virtual void PropertyValuesChanged() = 0;
-
-public: // static member data
-
-    //! More than one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-};
-
-typedef AZ::EBus<UiAnimateEntityInterface> UiAnimateEntityBus;

Code/Legacy/CryCommon/LyShine/Bus/UiAnimationBus.h

@@ -1,122 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-
-#include <LyShine/Animation/IUiAnimation.h>
-
-struct IUiAnimNode;
-
-namespace AZ
-{
-    class Entity;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiAnimNodeInterface
-    : public AZ::EBusTraits
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-    typedef IUiAnimNode* BusIdType;
-    //! Only one implementation for an IAnimNode* can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiAnimNodeInterface() {}
-
-    virtual AZ::EntityId GetAzEntityId() = 0;
-    virtual void SetAzEntity(AZ::Entity* entity) = 0;
-};
-
-typedef AZ::EBus<UiAnimNodeInterface> UiAnimNodeBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiAnimationInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiAnimationInterface() {}
-
-    //! Start a sequence
-    virtual void StartSequence(const AZStd::string& sequenceName) = 0;
-
-    //! Play a sequence from startTime to endTime
-    virtual void PlaySequenceRange(const AZStd::string& sequenceName, float startTime, float endTime) = 0;
-
-    //! Stop a sequence
-    virtual void StopSequence(const AZStd::string& sequenceName) = 0;
-
-    //! Abort a sequence
-    virtual void AbortSequence(const AZStd::string& sequenceName) = 0;
-
-    //! Pause a sequence
-    virtual void PauseSequence(const AZStd::string& sequenceName) = 0;
-
-    //! Resume a sequence
-    virtual void ResumeSequence(const AZStd::string& sequenceName) = 0;
-
-    //! Reset a sequence
-    virtual void ResetSequence(const AZStd::string& sequenceName) = 0;
-
-    //! Get the speed of a sequence
-    virtual float GetSequencePlayingSpeed(const AZStd::string& sequenceName) = 0;
-
-    //! Set the speed of a sequence
-    virtual void SetSequencePlayingSpeed(const AZStd::string& sequenceName, float speed) = 0;
-
-    //! Get the current time of a sequence
-    virtual float GetSequencePlayingTime(const AZStd::string& sequenceName) = 0;
-
-    //! Get whether a sequence is currently playing
-    virtual bool IsSequencePlaying(const AZStd::string& sequenceName) = 0;
-    
-    //! Get the length of a sequence in seconds
-    virtual float GetSequenceLength(const AZStd::string& sequenceName) = 0;
-
-    //! Set the behavior a sequence will exhibit when it stops playing
-    virtual void SetSequenceStopBehavior(IUiAnimationSystem::ESequenceStopBehavior stopBehavior) = 0;
-    
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiAnimationInterface> UiAnimationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiAnimationNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiAnimationNotifications(){}
-
-    //! Called on an animation event
-    virtual void OnUiAnimationEvent(IUiAnimationListener::EUiAnimationEvent uiAnimationEvent, AZStd::string animSequenceName) = 0;
-
-    //! Called on animation track event triggered
-    virtual void OnUiTrackEvent(AZStd::string eventName, AZStd::string valueName, AZStd::string animSequenceName) {}
-};
-
-typedef AZ::EBus<UiAnimationNotifications> UiAnimationNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiButtonBus.h

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/UiBase.h>
-
-class ISprite;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiButtonInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    typedef AZStd::function<void(AZ::EntityId, AZ::Vector2)> OnClickCallback;
-
-public: // member functions
-
-    virtual ~UiButtonInterface() {}
-
-    //! Get the on-click callback
-    virtual OnClickCallback GetOnClickCallback() = 0;
-
-    //! Set the on-click callback
-    virtual void SetOnClickCallback(OnClickCallback onClick) = 0;
-
-    //! Get the action name
-    virtual const LyShine::ActionName& GetOnClickActionName() = 0;
-
-    //! Set the action name
-    virtual void SetOnClickActionName(const LyShine::ActionName& actionName) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiButtonInterface> UiButtonBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiButtonNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiButtonNotifications() {}
-
-    //! Notify listeners that the button was clicked
-    virtual void OnButtonClick() {}
-};
-
-typedef AZ::EBus<UiButtonNotifications> UiButtonNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiCanvasBus.h

@@ -1,483 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <AzCore/Math/Matrix4x4.h>
-#include <AzFramework/Input/Channels/InputChannelDigitalWithSharedModifierKeyStates.h>
-#include <AzFramework/Input/User/LocalUserId.h>
-#include <LyShine/UiBase.h>
-
-// Forward declarations
-struct IUiAnimationSystem;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiCanvasInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    //! Deleting a canvas will delete all its child elements recursively and all of their components
-    virtual ~UiCanvasInterface() {}
-
-    //! Get the asset ID path name of this canvas. If not loaded or saved yet this will be ""
-    virtual const AZStd::string& GetPathname() = 0;
-
-    //! Get the ID of this canvas. This will remain the same while this canvas is loaded.
-    virtual LyShine::CanvasId GetCanvasId() = 0;
-
-    //! Get the unique ID of this canvas
-    virtual AZ::u64 GetUniqueCanvasId() = 0;
-
-    //! Get the draw order of this canvas. Rendering is back-to-front, so higher numbers render in front of lower numbers.
-    virtual int GetDrawOrder() = 0;
-
-    //! Set the draw order of this canvas. Rendering is back-to-front, so higher numbers render in front of lower numbers.
-    virtual void SetDrawOrder(int drawOrder) = 0;
-
-    //! Get the flag indicating if this canvas will stay loaded through a level unload.
-    virtual bool GetKeepLoadedOnLevelUnload() = 0;
-
-    //! Set the flag indicating if this canvas will stay loaded through a level unload.
-    virtual void SetKeepLoadedOnLevelUnload(bool keepLoaded) = 0;
-
-    //! Force a layout recompute. Layouts marked for a recompute are handled on the canvas update,
-    //! so this can be used if an immediate recompute is desired
-    virtual void RecomputeChangedLayouts() = 0;
-
-    //! Get the number child elements of this canvas
-    virtual int GetNumChildElements() = 0;
-
-    //! Get the specified child element, index must be less than GetNumChildElements()
-    virtual AZ::Entity* GetChildElement(int index) = 0;
-
-    //! Get the specified child entity Id, index must be less than GetNumChildElements()
-    virtual AZ::EntityId GetChildElementEntityId(int index) = 0;
-
-    //! Get the child elements of this canvas
-    virtual LyShine::EntityArray GetChildElements() = 0;
-
-    //! Get the child entity Ids of this canvas
-    virtual AZStd::vector<AZ::EntityId> GetChildElementEntityIds() = 0;
-
-    //! Create a new element that is a child of the canvas, the canvas has ownership of the child
-    virtual AZ::Entity* CreateChildElement(const LyShine::NameType& name) = 0;
-
-    //! Return the element on this canvas with the given id or nullptr if no match
-    virtual AZ::Entity* FindElementById(LyShine::ElementId id) = 0;
-
-    //! Return the first element on this canvas with the given name or nullptr if no match
-    virtual AZ::Entity* FindElementByName(const LyShine::NameType& name) = 0;
-
-    //! Return the first element on this canvas with the given name or nullptr if no match
-    virtual AZ::EntityId FindElementEntityIdByName(const LyShine::NameType& name) = 0;
-
-    //! Find all elements on this canvas with the given name
-    virtual void FindElementsByName(const LyShine::NameType& name, LyShine::EntityArray& result) = 0;
-
-    //! Return the element with the given hierarchical name or nullptr if no match
-    //! \param name, a hierarchical name relative to the root with '/' as the separator
-    virtual AZ::Entity* FindElementByHierarchicalName(const LyShine::NameType& name) = 0;
-
-    //! Find all elements on this canvas matching the predicate
-    virtual void FindElements(AZStd::function<bool(const AZ::Entity*)> predicate, LyShine::EntityArray& result) = 0;
-
-    //! Get the front-most element whose bounds include the given point in canvas space
-    //! \return nullptr if no match
-    virtual AZ::Entity* PickElement(AZ::Vector2 point) = 0;
-
-    //! Get all element whose bounds intersect with the given box in canvas space
-    //! \return empty EntityArray if no match
-    virtual LyShine::EntityArray PickElements(const AZ::Vector2& bound0, const AZ::Vector2& bound1) = 0;
-
-    //! Look for an entity with interactable component to handle an event at given point
-    virtual AZ::EntityId FindInteractableToHandleEvent(AZ::Vector2 point) = 0;
-
-    //! Save this canvas to the given path in XML
-    //! \return true if no error
-    virtual bool SaveToXml(const AZStd::string& assetIdPathname, const AZStd::string& sourceAssetPathname) = 0;
-
-    //! Initialize a set of entities that have been added to the canvas
-    //! Used when instantiating a slice or for undo/redo, copy/paste
-    //! \param topLevelEntities - The elements that were created
-    //! \param makeUniqueNamesAndIds If false the entity names and ElementIds in the string are kept, else unique ones are generated
-    //! \param insertionPoint The parent element for the created elements, if nullptr the root element is the parent
-    virtual void FixupCreatedEntities(LyShine::EntityArray topLevelEntities, bool makeUniqueNamesAndIds, AZ::Entity* optionalInsertionPoint) = 0;
-
-    //! Add an existing entity to the canvas (only for internal use from editor)
-    //! \param element      The newly created element to add to the canvas
-    //! \param parent       The parent element for the created element, if nullptr the root element is the parent
-    //! \param insertBefore The sibling element to place this element before, if nullptr then add as last child
-    virtual void AddElement(AZ::Entity* element, AZ::Entity* parent, AZ::Entity* insertBefore) = 0;
-
-    //! Go through all elements in the canvas and reinitialize them
-    //! This is done whenever a slice asset changes and the entity context is rebuilt from the root slice asset
-    virtual void ReinitializeElements() = 0;
-
-    //! Save this canvas to an XML string
-    //! \return the resulting string
-    virtual AZStd::string SaveToXmlString() = 0;
-
-    //! Get an element name that is unique to the children of the specified parent and to an optional array of elements
-    //! \param parentEntityId   The entityId of the parent who's children's names must not match the returned name
-    //! \param baseName         The name to append a unique identifier to
-    //! \param includedChildren An array of any other elements who's names must not match the returned name
-    //! \return Unique name that does not match the specified parent's children or the optional array of children
-    virtual AZStd::string GetUniqueChildName(AZ::EntityId parentEntityId, AZStd::string baseName, const LyShine::EntityArray* includeChildren) = 0;
-
-    //! Clone an element and add it to this canvas as a child of the given parent element
-    //! The entity and all its components/children are cloned and new IDs are generated
-    //! NOTE: Only state that is persistent/reflected is cloned
-    //! \param sourceEntity The entity to clone
-    //! \param parentEntity The parent element for the created elements, if nullptr the root element is the parent
-    //! \return The new entity
-    virtual AZ::Entity* CloneElement(AZ::Entity* sourceEntity, AZ::Entity* parentEntity) = 0;
-
-    //! Clone an element and add it to this canvas as a child of the given parent element
-    //! The entity and all its components/children are cloned and new IDs are generated
-    //! NOTE: Only state that is persistent/reflected is cloned
-    //! \param sourceEntity The entity to clone (may be from a different canvas)
-    //! \param parentEntity The parent element for the created elements, if invalid the root element is the parent
-    //! \param insertBefore The child of the parent element that the new element should be inserted before, if invalid the new element is the last child element
-    //! \return The new entity
-    virtual AZ::EntityId CloneElementEntityId(AZ::EntityId sourceEntity, AZ::EntityId parentEntity, AZ::EntityId insertBefore) = 0;
-
-    //! Create a clone of this canvas entity
-    //! \param canvasSize The resolution to display the canvas at
-    virtual AZ::Entity* CloneCanvas(const AZ::Vector2& canvasSize) = 0;
-
-    //! Set the transformation from canvas space to viewport space
-    virtual void SetCanvasToViewportMatrix(const AZ::Matrix4x4& matrix) = 0;
-
-    //! Get the transformation from canvas space to viewport space
-    virtual const AZ::Matrix4x4& GetCanvasToViewportMatrix() = 0;
-
-    //! Get the transformation from viewport space to canvas space
-    virtual void GetViewportToCanvasMatrix(AZ::Matrix4x4& matrix) = 0;
-
-    //! Returns the "target" size of the canvas (in pixels)
-    //
-    //! The target canvas size changes depending on whether you're running in
-    //! the UI Editor or in-game. While in-game, we assume that the canvas size
-    //! fills the screen, so the target canvas size is the size of the viewport.
-    //
-    //! When using the editor, however, the target size is the "authored" size of
-    //! the canvas. The canvas is authored in one resolution, but it may be
-    //! displayed by the game at whatever the game resolution is set to.
-    virtual AZ::Vector2 GetCanvasSize() = 0;
-
-    //! Set the authored size of the canvas (in pixels)
-    virtual void SetCanvasSize(const AZ::Vector2& canvasSize) = 0;
-
-    //! Set the target size of the canvas (in pixels)
-    //!
-    //! This should be called before the UpdateCanvas and RenderCanvas methods.
-    //! When running in game in full screen mode the target canvas size should be set to the viewport size
-    virtual void SetTargetCanvasSize(bool isInGame, const AZ::Vector2& targetCanvasSize) = 0;
-
-    //! Get scale to adjust for the difference between canvas size (authored size)
-    //! and the viewport size (target canvas size) when running on current device
-    virtual AZ::Vector2 GetDeviceScale() = 0;
-
-    //! Get flag that indicates whether visual element's vertices should snap to the nearest pixel
-    virtual bool GetIsPixelAligned() = 0;
-
-    //! Set flag that indicates whether visual element's vertices should snap to the nearest pixel
-    virtual void SetIsPixelAligned(bool isPixelAligned) = 0;
-
-    //! Get flag that indicates whether text should snap to the nearest pixel
-    virtual bool GetIsTextPixelAligned() = 0;
-
-    //! Set flag that indicates whether text should snap to the nearest pixel
-    virtual void SetIsTextPixelAligned(bool isTextPixelAligned) = 0;
-
-    //! Get the animation system for this canvas
-    virtual IUiAnimationSystem* GetAnimationSystem() = 0;
-
-    //! Get flag that governs whether the canvas is enabled
-    //
-    //! A canvas that's enabled will be updated and rendered each frame.
-    virtual bool GetEnabled() = 0;
-
-    //! Set flag that governs whether the canvas is enabled
-    //
-    //! A canvas that's enabled will be updated and rendered each frame.
-    virtual void SetEnabled(bool enabled) = 0;
-
-    //! Get flag that controls whether the canvas is rendering to a texture
-    virtual bool GetIsRenderToTexture() = 0;
-
-    //! Set flag that controls whether the canvas is rendering to a texture
-    virtual void SetIsRenderToTexture(bool isRenderToTexture) = 0;
-
-    //! Get the render target name that this canvas will render to
-    virtual AZStd::string GetRenderTargetName() = 0;
-
-    //! Set the render target name that this canvas will render to
-    virtual void SetRenderTargetName(const AZStd::string& name) = 0;
-
-    //! Get flag that controls whether this canvas automatically handles positional input (mouse/touch)
-    virtual bool GetIsPositionalInputSupported() = 0;
-
-    //! Set flag that controls whether this canvas automatically handles positional input (mouse/touch)
-    virtual void SetIsPositionalInputSupported(bool isSupported) = 0;
-
-    //! Get flag that controls whether this canvas consumes all input events while it is enabled
-    virtual bool GetIsConsumingAllInputEvents() = 0;
-
-    //! Set flag that controls whether this canvas consumes all input events while it is enabled
-    virtual void SetIsConsumingAllInputEvents(bool isConsuming) = 0;
-
-    //! Get flag that controls whether this canvas automatically handles multi-touch input
-    virtual bool GetIsMultiTouchSupported() = 0;
-
-    //! Set flag that controls whether this canvas automatically handles multi-touch input
-    virtual void SetIsMultiTouchSupported(bool isSupported) = 0;
-
-    //! Get flag that controls whether this canvas automatically handles navigation input (via keyboard/gamepad)
-    virtual bool GetIsNavigationSupported() = 0;
-
-    //! Set flag that controls whether this canvas automatically handles navigation input (via keyboard/gamepad)
-    virtual void SetIsNavigationSupported(bool isSupported) = 0;
-
-    //! Get the analog (eg. thumb-stick) input value that must be exceeded before a navigation command will be processed
-    virtual float GetNavigationThreshold() = 0;
-
-    //! Set the analog (eg. thumb-stick) input value that must be exceeded before a navigation command will be processed
-    virtual void SetNavigationThreshold(float navigationThreshold) = 0;
-
-    //! Get the delay (milliseconds) before a held navigation command will begin repeating
-    virtual AZ::u64 GetNavigationRepeatDelay() = 0;
-
-    //! Set the delay (milliseconds) before a held navigation command will begin repeating
-    virtual void SetNavigationRepeatDelay(AZ::u64 navigationRepeatDelay) = 0;
-
-    //! Get the delay (milliseconds) before a held navigation command will continue repeating
-    virtual AZ::u64 GetNavigationRepeatPeriod() = 0;
-
-    //! Set the delay (milliseconds) before a held navigation command will continue repeating
-    virtual void SetNavigationRepeatPeriod(AZ::u64 navigationRepeatPeriod) = 0;
-
-    //! Get the local user id that is being used to filter incoming input events
-    virtual AzFramework::LocalUserId GetLocalUserIdInputFilter() = 0;
-
-    //! Set the local user id that will be used to filter incoming input events
-    virtual void SetLocalUserIdInputFilter(AzFramework::LocalUserId localUserId) = 0;
-
-    //! Handle an input event for the canvas
-    virtual bool HandleInputEvent(const AzFramework::InputChannel::Snapshot& inputSnapshot,
-        const AZ::Vector2* viewportPos = nullptr,
-        AzFramework::ModifierKeyMask activeModifierKeys = AzFramework::ModifierKeyMask::None) = 0;
-
-    //! Handle a unicode text event for the canvas
-    virtual bool HandleTextEvent(const AZStd::string& textUTF8) = 0;
-
-    //! Handle a positional input event for the canvas, this could come from
-    //! a ray cast intersection for example
-    virtual bool HandleInputPositionalEvent(const AzFramework::InputChannel::Snapshot& inputSnapshot, AZ::Vector2 viewportPos) = 0;
-
-    //! Get the mouse position of the last input event
-    virtual AZ::Vector2 GetMousePosition() = 0;
-
-    //! Get the element to be displayed when hovering over an interactable
-    virtual AZ::EntityId GetTooltipDisplayElement() = 0;
-
-    //! Set the element to be displayed when hovering over an interactable
-    virtual void SetTooltipDisplayElement(AZ::EntityId entityId) = 0;
-
-    //! Force the active interactable for the canvas to be the given one,
-    //! also force AutoActivation of interactable,
-    //! intended for internal use by UI components
-    virtual void ForceFocusInteractable(AZ::EntityId interactableId) = 0;
-
-    //! Force the active interactable for the canvas to be the given one,
-    //! also set last mouse pos to point,
-    //! intended for internal use by UI components
-    virtual void ForceActiveInteractable(AZ::EntityId interactableId, bool shouldStayActive, AZ::Vector2 point) = 0;
-
-    //! Get the hover interactable
-    virtual AZ::EntityId GetHoverInteractable() = 0;
-
-    //! Force the hover interactable for the canvas to be the given one, this can be useful when using
-    //! keyboard/gamepad navigation and the current hover interactable is deleted by a script and the script
-    //! wants to specify the new hover interactable
-    virtual void ForceHoverInteractable(AZ::EntityId interactableId) = 0;
-
-    //! Clear all active interactables, and all hover interactables if last input was positional (mouse/touch).
-    //! This is intended for internal use by UI components
-    virtual void ClearAllInteractables() = 0;
-
-    //! Generate Enter pressed/released input events on an interactable.
-    //! Useful for automated testing to simulate button clicks
-    virtual void ForceEnterInputEventOnInteractable(AZ::EntityId interactableId) = 0;
-
-public: // static member data
-
-    //! Only one component on an entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiCanvasInterface> UiCanvasBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! The canvas component implements this bus and it is provided for C++ implementations of
-//! UI components to use to talk to the canvas
-class UiCanvasComponentImplementationInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiCanvasComponentImplementationInterface() {}
-
-    //! Mark the render graph for the canvas as dirty. This will cause the render graph to get
-    //! cleared and rebuilt on the next render.
-    virtual void MarkRenderGraphDirty() = 0;
-
-public: // static member data
-
-    //! Only one component on an entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiCanvasComponentImplementationInterface> UiCanvasComponentImplementationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified of canvas actions
-class UiCanvasActionNotification
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiCanvasActionNotification(){}
-
-    //! Called when the canvas sends an action to the listener
-    virtual void OnAction(AZ::EntityId entityId, const LyShine::ActionName& actionName) = 0;
-};
-
-typedef AZ::EBus<UiCanvasActionNotification> UiCanvasNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified when the draw order of any
-//! canvas changes
-class UiCanvasOrderNotification
-    : public AZ::EBusTraits
-{
-public: // member functions
-
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-
-    virtual ~UiCanvasOrderNotification(){}
-
-    //! Called when the draw order setting for a canvas changes
-    //! Note this is used to update the order in the UiCanvasManager so that
-    //! order has not been updated when this fires.
-    virtual void OnCanvasDrawOrderChanged(AZ::EntityId canvasEntityId) = 0;
-};
-
-typedef AZ::EBus<UiCanvasOrderNotification> UiCanvasOrderNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified when any canvas has been
-//! enabled or disabled
-class UiCanvasEnabledStateNotification
-    : public AZ::EBusTraits
-{
-public: // member functions
-
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-
-    virtual ~UiCanvasEnabledStateNotification() {}
-
-    //! Called when the canvas was enabled or disabled
-    virtual void OnCanvasEnabledStateChanged(AZ::EntityId canvasEntityId, bool enabled) = 0;
-};
-
-typedef AZ::EBus<UiCanvasEnabledStateNotification> UiCanvasEnabledStateNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified of canvas size or scale changes
-class UiCanvasSizeNotification
-    : public AZ::EBusTraits
-{
-public:
-    virtual ~UiCanvasSizeNotification() {}
-
-    //! Called when the target canvas size or uniform device scale changes.
-    virtual void OnCanvasSizeOrScaleChange(AZ::EntityId canvasEntityId) = 0;
-};
-
-typedef AZ::EBus<UiCanvasSizeNotification> UiCanvasSizeNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified of changes to the canvas
-//! pixel alignment settings
-class UiCanvasPixelAlignmentNotification
-    : public AZ::ComponentBus
-{
-public:
-    virtual ~UiCanvasPixelAlignmentNotification() {}
-
-    //! Called when the pixel alignment setting for the canvas changes
-    virtual void OnCanvasPixelAlignmentChange() {}
-
-    //! Called when the text pixel alignment setting for the canvas changes
-    virtual void OnCanvasTextPixelAlignmentChange() {}
-};
-
-typedef AZ::EBus<UiCanvasPixelAlignmentNotification> UiCanvasPixelAlignmentNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified of canvas input.
-//! Note that interactables already get methods called on them when they themselves are interacted
-//! with. This notification bus is intended for other entities or Lua to know when some other
-//! entities are interacted with.
-class UiCanvasInputNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiCanvasInputNotifications() {}
-
-    //! Called when an element is pressed. Will return an invalid entity id if no interactable was
-    //! pressed.
-    virtual void OnCanvasPrimaryPressed([[maybe_unused]] AZ::EntityId entityId) {};
-
-    //! Called when an element is released. The released entity that is sent is the entity that was
-    //! active (if any).
-    virtual void OnCanvasPrimaryReleased([[maybe_unused]] AZ::EntityId entityId) {};
-
-    //! Called when an element is pressed. Will be an invalid entity id if no interactable was
-    //! pressed.
-    virtual void OnCanvasMultiTouchPressed([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int multiTouchIndex) {};
-
-    //! Called when an element is released. The released entity that is sent is the entity that was
-    //! active (if any).
-    virtual void OnCanvasMultiTouchReleased([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int multiTouchIndex) {};
-
-    //! Called when an element starts being hovered
-    virtual void OnCanvasHoverStart([[maybe_unused]] AZ::EntityId entityId) {};
-
-    //! Called when an element ends being hovered
-    virtual void OnCanvasHoverEnd([[maybe_unused]] AZ::EntityId entityId) {};
-
-    //! Called when the enter key is pressed
-    virtual void OnCanvasEnterPressed([[maybe_unused]] AZ::EntityId entityId) {};
-
-    //! Called when the enter key is released
-    virtual void OnCanvasEnterReleased([[maybe_unused]] AZ::EntityId entityId) {};
-};
-
-typedef AZ::EBus<UiCanvasInputNotifications> UiCanvasInputNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiCanvasManagerBus.h

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzFramework/Input/User/LocalUserId.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiCanvasManagerInterface
-    : public AZ::EBusTraits
-{
-public: // types
-
-    typedef std::vector<AZ::EntityId> CanvasEntityList;
-
-public:
-    //! Create a canvas
-    virtual AZ::EntityId CreateCanvas() = 0;
-
-    //! Load a canvas
-    virtual AZ::EntityId LoadCanvas(const AZStd::string& canvasPathname) = 0;
-
-    //! Unload a canvas
-    virtual void UnloadCanvas(AZ::EntityId canvasEntityId) = 0;
-
-    //! Find a canvas by path, optionally load the canvas if it was not found
-    virtual AZ::EntityId FindLoadedCanvasByPathName(const AZStd::string& canvasPathname, bool loadIfNotFound = false) = 0;
-
-    //! Get a list of canvases that are loaded in game, this is sorted by draw order
-    virtual CanvasEntityList GetLoadedCanvases() = 0;
-
-    //! Set the local user id that will be used to filter incoming input events for all canvases.
-    //! Can be overriden for an individual canvas using UiCanvasInterface::SetLocalUserIdInputFilter.
-    virtual void SetLocalUserIdInputFilterForAllCanvases(AzFramework::LocalUserId localUserId) = 0;
-};
-typedef AZ::EBus<UiCanvasManagerInterface> UiCanvasManagerBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to be notified of canvas manager changes
-class UiCanvasManagerNotification
-    : public AZ::EBusTraits
-{
-public:
-    //////////////////////////////////////////////////////////////////////////
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-    //////////////////////////////////////////////////////////////////////////
-
-    virtual ~UiCanvasManagerNotification() {}
-
-    //! Called when a canvas has been loaded
-    virtual void OnCanvasLoaded([[maybe_unused]] AZ::EntityId canvasEntityId) {}
-
-    //! Called when a canvas has been unloaded/destroyed
-    virtual void OnCanvasUnloaded([[maybe_unused]] AZ::EntityId canvasEntityId) {}
-
-    //! Called when a canvas has been reloaded (due to hot-loading)
-    //! For a hot-load, the OnCanvasLoaded/OnCanvasUnloaded notifications are not sent - only this one is
-    virtual void OnCanvasReloaded([[maybe_unused]] AZ::EntityId canvasEntityId) {}
-};
-
-typedef AZ::EBus<UiCanvasManagerNotification> UiCanvasManagerNotificationBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiCanvasUpdateNotificationBus.h

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Elements that require update notifications should connect to this bus using the entity id of their
-//! containing canvas.
-class UiCanvasUpdateNotification
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiCanvasUpdateNotification() {}
-
-    //! Update the component. This is called when the game is running.
-    //! It is different from the TickBus in that it is called only when the canvas is updated.
-    //! So it is not called if the canvas is disabled.
-    virtual void Update(float deltaTime) = 0;
-
-    //! Update the component while in the editor.
-    //! This is called every frame when in the editor and the game is NOT running.
-    virtual void UpdateInEditor(float /*deltaTime*/) {}
-
-public: // static member data
-
-    //! Multiple components on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-};
-
-typedef AZ::EBus<UiCanvasUpdateNotification> UiCanvasUpdateNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiCheckboxBus.h

@@ -1,95 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiCheckboxInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    //! params: sending entity id, new state
-    typedef AZStd::function<void(AZ::EntityId, AZ::Vector2, bool)> StateChangeCallback;
-
-public: // member functions
-
-    virtual ~UiCheckboxInterface() {}
-
-    //! Query the state of the checkbox
-    //! \return     The current state for the checkbox.
-    virtual bool GetState() = 0;
-
-    //! Manually override the state of the checkbox
-    //! \param isOn     The new desired state of the checkbox.
-    virtual void SetState(bool checked) = 0;
-
-    //! Toggle the state of the checkbox
-    //! \return     The new state of the checkbox.
-    virtual bool ToggleState() = 0;
-
-    //! Get the state change callback
-    virtual StateChangeCallback GetStateChangeCallback() = 0;
-
-    //! Set the state change callback
-    virtual void SetStateChangeCallback(StateChangeCallback onChange) = 0;
-
-    //! Set the optional checked (ON) entity
-    virtual void SetCheckedEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the optional checked (ON) entity
-    virtual AZ::EntityId GetCheckedEntity() = 0;
-
-    //! Set the optional unchecked (OFF) entity
-    virtual void SetUncheckedEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the optional unchecked (OFF) entity
-    virtual AZ::EntityId GetUncheckedEntity() = 0;
-
-    //! Get the action triggered when turned on
-    virtual const LyShine::ActionName& GetTurnOnActionName() = 0;
-
-    //! Set the action triggered when turned on
-    virtual void SetTurnOnActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the action triggered when turned off
-    virtual const LyShine::ActionName& GetTurnOffActionName() = 0;
-
-    //! Set the action triggered when turned off
-    virtual void SetTurnOffActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the action triggered when changed
-    virtual const LyShine::ActionName& GetChangedActionName() = 0;
-
-    //! Set the action triggered when changed
-    virtual void SetChangedActionName(const LyShine::ActionName& actionName) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiCheckboxInterface> UiCheckboxBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiCheckboxNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiCheckboxNotifications() {}
-
-    //! Notify listeners that the checkbox state has changed
-    virtual void OnCheckboxStateChange([[maybe_unused]] bool checked) {}
-};
-
-typedef AZ::EBus<UiCheckboxNotifications> UiCheckboxNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiDraggableBus.h

@@ -1,99 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiDraggableInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    //! States that the component can be in during a drag. Lua scripts can switch the state to alert the user
-    enum class DragState
-    {
-        Normal,
-        Valid,
-        Invalid
-    };
-
-public: // member functions
-
-    virtual ~UiDraggableInterface() {}
-
-    //! Get the state of the drag
-    virtual DragState GetDragState() = 0;
-
-    //! Set the state of the drag. This is only relevant during a drag.
-    //! The state affects the visual state of the draggable and can be used to indicate when it is
-    //! over a valid drop target.
-    virtual void SetDragState(DragState dragState) = 0;
-
-    //! Redo the drag, this is not usually needed but if a UiDraggableNotificationBus handler causes
-    //! drop targets to move, and keyboard or console navigation is being used, it can be needed.
-    //! In that case the handler should call this method after moving drop targets.
-    virtual void RedoDrag(AZ::Vector2 point) = 0;
-
-    //! Set this draggable element to be a proxy for another draggable element and start a drag on
-    //! this draggable element at the specified point
-    virtual void SetAsProxy(AZ::EntityId originalDraggableId, AZ::Vector2 point) = 0;
-
-    //! Conclude the drag of a proxy. This should be called from the OnDragEnd callback of the proxy and
-    //! will result in calling OnDragEnd on the draggable element that this is a proxy for
-    virtual void ProxyDragEnd(AZ::Vector2 point) = 0;
-        
-    //! Check if this draggable element is a proxy
-    virtual bool IsProxy() = 0;
-
-    //! Get the original draggable element that this element is a proxy for
-    //! Returns an invalid entity id if this is not a proxy
-    virtual AZ::EntityId GetOriginalFromProxy() = 0;
-
-    //! Get the flag that indicates if this draggable can be dropped on any canvas
-    virtual bool GetCanDropOnAnyCanvas() = 0;
-
-    //! Set the flag that indicates if this draggable can be dropped on any canvas
-    virtual void SetCanDropOnAnyCanvas(bool anyCanvas) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDraggableInterface> UiDraggableBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiDraggableNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiDraggableNotifications() {}
-
-    //! Called on drag start
-    virtual void OnDragStart(AZ::Vector2 position) = 0;
-
-    //! Called on position change during drag
-    virtual void OnDrag(AZ::Vector2 position) = 0;
-
-    //! Called on drag end
-    virtual void OnDragEnd(AZ::Vector2 position) = 0;
-};
-
-typedef AZ::EBus<UiDraggableNotifications> UiDraggableNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiDropTargetBus.h

@@ -1,89 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiDropTargetInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    using DropState = int;
-    enum
-    {
-        DropStateNormal = 0,
-        DropStateValid,
-        DropStateInvalid,
-
-        NumDropStates
-    };
-
-public: // member functions
-
-    virtual ~UiDropTargetInterface() {}
-
-    //! Get the OnDrop action name
-    virtual const LyShine::ActionName& GetOnDropActionName() = 0;
-
-    //! Set the OnDrop action name
-    virtual void SetOnDropActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Called when mouse/touch enters the bounds of this drop target while dragging a UiDraggableComponent
-    virtual void HandleDropHoverStart(AZ::EntityId draggable) = 0;
-
-    //! Called on the currently drop hovered drop target component when mouse/touch moves outside of bounds
-    virtual void HandleDropHoverEnd(AZ::EntityId draggable) = 0;
-
-    //! Called when a draggable is dropped on this drop target
-    virtual void HandleDrop(AZ::EntityId draggable) = 0;
-
-    //! Get the state of the drop
-    virtual DropState GetDropState() = 0;
-
-    //! Set the state of the drop target.
-    //! The state affects the visual state of the drop target and can be used to indicate when it has
-    //! a valid draggable hovering over it.
-    virtual void SetDropState(DropState dropState) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDropTargetInterface> UiDropTargetBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiDropTargetNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiDropTargetNotifications() {}
-
-    //! Called on starting hovering over a drop target
-    virtual void OnDropHoverStart(AZ::EntityId draggable) = 0;
-
-    //! Called on ending hovering over a drop target
-    virtual void OnDropHoverEnd(AZ::EntityId draggable) = 0;
-
-    //! Called on drop
-    virtual void OnDrop(AZ::EntityId draggable) = 0;
-};
-
-typedef AZ::EBus<UiDropTargetNotifications> UiDropTargetNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiDropdownBus.h

@@ -1,123 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! The UI Dropdown Component is an interactable component which displays a list of options when clicked.
-//! In its default state, the dropdown display a simple button, next to an arrow indicating the dropdown
-//! functionality. When the arrow / option is clicked, the dropdown list appears, displaying the options available.
-//! If the list is too long to be displayed, a scrollbar can be added to scroll up and down the list of options.
-class UiDropdownInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDropdownInterface() {}
-
-    //! Get the currently selected option
-    virtual AZ::EntityId GetValue() = 0;
-
-    //! Set the currently selected option manually
-    virtual void SetValue(AZ::EntityId value) = 0;
-
-    //! Get the content element this dropdown will expand
-    virtual AZ::EntityId GetContent() = 0;
-
-    //! Set the content element this dropdown will expand
-    virtual void SetContent(AZ::EntityId content) = 0;
-
-    //! Get whether this dropdown should expand automatically on hover
-    virtual bool GetExpandOnHover() = 0;
-
-    //! Set whether this dropdown should expand automatically on hover
-    virtual void SetExpandOnHover(bool expandOnHover) = 0;
-
-    //! Get how long to wait before expanding upon hover / collapsing upon exit
-    virtual float GetWaitTime() = 0;
-
-    //! Set how long to wait before expanding upon hover / collapsing upon exit
-    virtual void SetWaitTime(float waitTime) = 0;
-
-    //! Get whether this dropdown should collapse when the user clicks outside
-    virtual bool GetCollapseOnOutsideClick() = 0;
-
-    //! Set whether this dropdown should collapse when the user clicks outside
-    virtual void SetCollapseOnOutsideClick(bool collapseOnOutsideClick) = 0;
-
-    //! Get the element the dropdown content will parent to when expanded (the canvas by default)
-    virtual AZ::EntityId GetExpandedParentId() = 0;
-
-    //! Set the element the dropdown content will parent to when expanded
-    virtual void SetExpandedParentId(AZ::EntityId expandedParentId) = 0;
-
-    //! Get the text element to display to show the currently selected option
-    virtual AZ::EntityId GetTextElement() = 0;
-
-    //! Set the text element to display to show the currently selected option
-    virtual void SetTextElement(AZ::EntityId textElement) = 0;
-
-    //! Get the icon element to display to show the currently selected option
-    virtual AZ::EntityId GetIconElement() = 0;
-
-    //! Set the icon element to display to show the currently selected option
-    virtual void SetIconElement(AZ::EntityId iconElement) = 0;
-
-    //! Expand the dropdown
-    virtual void Expand() = 0;
-
-    //! Collapse the dropdown
-    virtual void Collapse() = 0;
-
-    //! Get the name of the action that is sent when the dropdown is expanded
-    virtual const LyShine::ActionName& GetExpandedActionName() = 0;
-
-    //! Set the name of the action that is sent when the dropdown is expanded
-    virtual void SetExpandedActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the name of the action that is sent when the dropdown is collapsed
-    virtual const LyShine::ActionName& GetCollapsedActionName() = 0;
-
-    //! Set the name of the action that is sent when the dropdown is collapsed
-    virtual void SetCollapsedActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the name of the action that is sent when the dropdown value is changed
-    virtual const LyShine::ActionName& GetOptionSelectedActionName() = 0;
-
-    //! Set the name of the action that is sent when the dropdown value is changed
-    virtual void SetOptionSelectedActionName(const LyShine::ActionName& actionName) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDropdownInterface> UiDropdownBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiDropdownNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDropdownNotifications() {}
-
-    //! Notify listeners that the dropdown was expanded
-    virtual void OnDropdownExpanded() {}
-
-    //! Notify listeners that the dropdown was collapsed
-    virtual void OnDropdownCollapsed() {}
-
-    //! Notify listeners that an option was selected
-    virtual void OnDropdownValueChanged([[maybe_unused]] AZ::EntityId option) {}
-};
-
-typedef AZ::EBus<UiDropdownNotifications> UiDropdownNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiDropdownOptionBus.h

@@ -1,62 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! The UiDropdownOptionComponent is a component that is designed to work in conjunction with the
-//! UiDropdownComponent. It represents any option of that dropdown that the user should be able to
-//! select to update the value of the dropdown.
-class UiDropdownOptionInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDropdownOptionInterface() {}
-
-    //! Get the owning dropdown of this option
-    virtual AZ::EntityId GetOwningDropdown() = 0;
-
-    //! Set the owning dropdown of this option
-    virtual void SetOwningDropdown(AZ::EntityId owningDropdown) = 0;
-
-    //! Get the text element of this option
-    virtual AZ::EntityId GetTextElement() = 0;
-
-    //! Set the text element of this option
-    virtual void SetTextElement(AZ::EntityId textElement) = 0;
-
-    //! Get the icon element of this option
-    virtual AZ::EntityId GetIconElement() = 0;
-
-    //! Set the icon element of this option
-    virtual void SetIconElement(AZ::EntityId iconElement) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDropdownOptionInterface> UiDropdownOptionBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiDropdownOptionNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDropdownOptionNotifications() {}
-
-    //! Notify listeners that the dropdown option was selected
-    virtual void OnDropdownOptionSelected() {}
-};
-
-typedef AZ::EBus<UiDropdownOptionNotifications> UiDropdownOptionNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiDynamicLayoutBus.h

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that a dynamic layout component needs to implement. A dynamic layout component
-//! clones a prototype element to achieve the desired number of children. The parent is resized
-//! accordingly
-class UiDynamicLayoutInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDynamicLayoutInterface() {}
-
-    //! Clone a prototype element or remove cloned elements to end up with the specified number of children
-    virtual void SetNumChildElements(int numChildren) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDynamicLayoutInterface> UiDynamicLayoutBus;

Code/Legacy/CryCommon/LyShine/Bus/UiDynamicScrollBoxBus.h

@@ -1,233 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that a dynamic scrollbox component needs to implement. A dynamic scrollbox
-//! component sets up scrollbox content as a horizontal or vertical list of elements that are
-//! cloned from prototype entities. Only the minimum number of entities are created for efficient
-//! scrolling
-class UiDynamicScrollBoxInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDynamicScrollBoxInterface() {}
-
-    //! Refresh the content. Should be called when list size or element content has changed.
-    //! This will reset any cached information such as element sizes, so it is recommended
-    //! to use AddElementsToEnd and RemoveElementsFromFront if possible when elements vary
-    //! in size. AddElementsToEnd and RemoveElementsFromFront will also ensure that the
-    //! scroll offset is adjusted to keep the visible elements in place
-    virtual void RefreshContent() = 0;
-
-    //! Add elements to the end of the list.
-    //! Used with lists that are not divided into sections
-    virtual void AddElementsToEnd(int numElementsToAdd, bool scrollToEndIfWasAtEnd) = 0;
-
-    //! Remove elements from the front of the list.
-    //! Used with lists that are not divided into sections
-    virtual void RemoveElementsFromFront(int numElementsToRemove) = 0;
-
-    //! Scroll to the end of the list
-    virtual void ScrollToEnd() = 0;
-
-    //! Get the element index of the specified child element. Returns -1 if not found.
-    //! If the list is divided into sections, the index is local to the section
-    virtual int GetElementIndexOfChild(AZ::EntityId childElement) = 0;
-
-    //! Get the section index of the specified child element. Returns -1 if not found.
-    //! Used with lists that are divided into sections
-    virtual int GetSectionIndexOfChild(AZ::EntityId childElement) = 0;
-
-    //! Get the child element at the specified element index.
-    //! Used with lists that are not divided into sections
-    virtual AZ::EntityId GetChildAtElementIndex(int index) = 0;
-
-    //! Get the child element at the specified section index and element index.
-    //! Used with lists that are divided into sections
-    virtual AZ::EntityId GetChildAtSectionAndElementIndex(int sectionIndex, int index) = 0;
-
-    //! Get whether the list should automatically prepare and refresh its content post activation
-    virtual bool GetAutoRefreshOnPostActivate() = 0;
-
-    //! Set whether the list should automatically prepare and refresh its content post activation
-    virtual void SetAutoRefreshOnPostActivate(bool autoRefresh) = 0;
-
-    //! Get the prototype entity used for the elements
-    virtual AZ::EntityId GetPrototypeElement() = 0;
-
-    //! Set the prototype entity used for the elements
-    virtual void SetPrototypeElement(AZ::EntityId prototypeElement) = 0;
-
-    //! Get whether the elements vary in size
-    virtual bool GetElementsVaryInSize() = 0;
-
-    //! Set whether the elements vary in size
-    virtual void SetElementsVaryInSize(bool varyInSize) = 0;
-
-    //! Get whether to auto calculate the elements when they vary in size
-    virtual bool GetAutoCalculateVariableElementSize() = 0;
-
-    //! Set whether to auto calculate the elements when they vary in size
-    virtual void SetAutoCalculateVariableElementSize(bool autoCalculateSize) = 0;
-
-    //! Get the estimated size for the variable elements. If set to 0, then element sizes
-    //! are calculated up front rather than when becoming visible
-    virtual float GetEstimatedVariableElementSize() = 0;
-
-    //! Set the estimated size for the variable elements. If set to 0, then element sizes
-    //! are calculated up front rather than when becoming visible
-    virtual void SetEstimatedVariableElementSize(float estimatedSize) = 0;
-
-    //! Get whether the list is divided into sections with headers
-    virtual bool GetSectionsEnabled() = 0;
-
-    //! Set whether the list is divided into sections with headers
-    virtual void SetSectionsEnabled(bool enabled) = 0;
-
-    //! Get the prototype entity used for the headers
-    virtual AZ::EntityId GetPrototypeHeader() = 0;
-
-    //! Set the prototype entity used for the headers
-    virtual void SetPrototypeHeader(AZ::EntityId prototypeHeader) = 0;
-
-    //! Get whether headers stick to the beginning of the visible list area
-    virtual bool GetHeadersSticky() = 0;
-
-    //! Set whether headers stick to the beginning of the visible list area
-    virtual void SetHeadersSticky(bool stickyHeaders) = 0;
-
-    //! Get whether the headers vary in size
-    virtual bool GetHeadersVaryInSize() = 0;
-
-    //! Set whether the headers vary in size
-    virtual void SetHeadersVaryInSize(bool varyInSize) = 0;
-
-    //! Get whether to auto calculate the headers when they vary in size
-    virtual bool GetAutoCalculateVariableHeaderSize() = 0;
-
-    //! Set whether to auto calculate the headers when they vary in size
-    virtual void SetAutoCalculateVariableHeaderSize(bool autoCalculateSize) = 0;
-
-    //! Get the estimated size for the variable headers. If set to 0, then header sizes
-    //! are calculated up front rather than when becoming visible
-    virtual float GetEstimatedVariableHeaderSize() = 0;
-
-    //! Set the estimated size for the variable headers. If set to 0, then header sizes
-    //! are calculated up front rather than when becoming visible
-    virtual void SetEstimatedVariableHeaderSize(float estimatedSize) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDynamicScrollBoxInterface> UiDynamicScrollBoxBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that provides data needed to display a list of elements
-class UiDynamicScrollBoxDataInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDynamicScrollBoxDataInterface() {}
-
-    //! Returns the number of elements in the list.
-    //! Called when the list is being constructed (in the component's InGamePostActivate or when RefreshContent is being called explicitely).
-    //! Used with lists that are not divided into sections
-    virtual int GetNumElements() { return 0; }
-
-    //! Returns the width of an element at the specified index.
-    //! Called when a horizontal list contains elements of varying size, and the element's "auto calculate size" option is disabled.
-    //! Used with lists that are not divided into sections
-    virtual float GetElementWidth([[maybe_unused]] int index) { return 0.0f; }
-
-    //! Returns the height of an element at the specified index.
-    //! Called when a vertical list contains elements of varying size, and the element's "auto calculate size" option is disabled.
-    //! Used with lists that are not divided into sections
-    virtual float GetElementHeight([[maybe_unused]] int index) { return 0.0f; }
-
-    //! Returns the number of sections in the list.
-    //! Called when the list is being constructed (in the component's InGamePostActivate or when RefreshContent is being called explicitely).
-    //! Used with lists that are divided into sections
-    virtual int GetNumSections() { return 0; }
-
-    //! Returns the number of elements in the specified section.
-    //! Called when the list is being constructed (in the component's InGamePostActivate or when RefreshContent is being called explicitely).
-    //! Used with lists that are divided into sections
-    virtual int GetNumElementsInSection([[maybe_unused]] int sectionIndex) { return 0; }
-
-    //! Returns the width of an element at the specified section.
-    //! Called when a horizontal list contains elements of varying size, and the element's "auto calculate size" option is disabled.
-    //! Used with lists that are divided into sections
-    virtual float GetElementInSectionWidth([[maybe_unused]] int sectionIndex, [[maybe_unused]] int elementindex) { return 0.0f; }
-
-    //! Returns the height of an element at the specified section.
-    //! Called when a vertical list contains elements of varying size, and the element's "auto calculate size" option is disabled.
-    //! Used with lists that are divided into sections
-    virtual float GetElementInSectionHeight([[maybe_unused]] int sectionIndex, [[maybe_unused]] int elementindex) { return 0.0f; }
-
-    //! Returns the width of a header at the specified section.
-    //! Called when a horizontal list contains headers of varying size, and the header's "auto calculate size" option is disabled.
-    //! Used with lists that are divided into sections
-    virtual float GetSectionHeaderWidth([[maybe_unused]] int sectionIndex) { return 0.0f; }
-
-    //! Returns the height of a header at the specified section.
-    //! Called when a vertical list contains elements of varying size, and the header's "auto calculate size" option is disabled.
-    //! Used with lists that are divided into sections
-    virtual float GetSectionHeaderHeight([[maybe_unused]] int sectionIndex) { return 0.0f; }
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiDynamicScrollBoxDataInterface> UiDynamicScrollBoxDataBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement to receive notifications of element state
-//! changes, such as when an element is about to scroll into view
-class UiDynamicScrollBoxElementNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiDynamicScrollBoxElementNotifications(){}
-
-    //! Called when an element is about to become visible. Used to populate the element with data for display.
-    //! Used with lists that are not divided into sections
-    virtual void OnElementBecomingVisible([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int index) {}
-
-    //! Called when elements have variable sizes and are set to auto calculate.
-    //! Used with lists that are not divided into sections
-    virtual void OnPrepareElementForSizeCalculation([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int index) {}
-
-    //! Called when an element in a section is about to become visible. Used to populate the element with data for display
-    //! Used with lists that are divided into sections
-    virtual void OnElementInSectionBecomingVisible([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int sectionIndex, [[maybe_unused]] int index) {}
-
-    //! Called when elements in sections have variable sizes and are set to auto calculate
-    //! Used with lists that are divided into sections
-    virtual void OnPrepareElementInSectionForSizeCalculation([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int sectionIndex, [[maybe_unused]] int index) {}
-
-    //! Called when a header is about to become visible. Used to populate the header with data for display.
-    //! Used with lists that are divided into sections
-    virtual void OnSectionHeaderBecomingVisible([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int sectionIndex) {}
-
-    //! Called when headers have variable sizes and are set to auto calculate.
-    //! Used with lists that are divided into sections
-    virtual void OnPrepareSectionHeaderForSizeCalculation([[maybe_unused]] AZ::EntityId entityId, [[maybe_unused]] int sectionIndex) {}
-};
-
-typedef AZ::EBus<UiDynamicScrollBoxElementNotifications> UiDynamicScrollBoxElementNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiEditorBus.h

@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiEditorInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiEditorInterface() {}
-
-    //! Test if this entity should be visible in the Ui Canvas Editor
-    virtual bool GetIsVisible() = 0;
-
-    //! Set whether this entity should be visible in the Ui Canvas Editor
-    virtual void SetIsVisible(bool isVisible) = 0;
-
-    //! Test if this entity is selectable in the UI Canvas Editor
-    virtual bool GetIsSelectable() = 0;
-
-    //! Set whether this entity is selectable in the UI Canvas Editor
-    virtual void SetIsSelectable(bool isSelectable) = 0;
-
-    //! Test if this entity is currently selected in the UI Canvas Editor
-    virtual bool GetIsSelected() = 0;
-
-    //! Set whether this entity is currently selected in the UI Canvas Editor
-    virtual void SetIsSelected(bool isSelected) = 0;
-
-    //! Test if this entity is currently expanded in the UI Canvas Editor
-    virtual bool GetIsExpanded() = 0;
-
-    //! Set whether this entity is currently expanded in the UI Canvas Editor
-    virtual void SetIsExpanded(bool isExpanded) = 0;
-
-    //! Test if all the parents of this UI element are visible in the editor
-    virtual bool AreAllAncestorsVisible() = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiEditorInterface> UiEditorBus;

Code/Legacy/CryCommon/LyShine/Bus/UiEditorCanvasBus.h

@@ -1,102 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiEditorCanvasInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiEditorCanvasInterface() {}
-
-    //! Get the snap state.
-    virtual bool GetIsSnapEnabled() = 0;
-
-    //! Set the snap state.
-    virtual void SetIsSnapEnabled(bool enabled) = 0;
-
-    //! Get the translation distance to snap to
-    virtual float GetSnapDistance() = 0;
-
-    //! Set the translation distance to snap to
-    virtual void SetSnapDistance(float distance) = 0;
-
-    //! Get the degrees of rotation to snap to
-    virtual float GetSnapRotationDegrees() = 0;
-
-    //! Set the degrees of rotation to snap to
-    virtual void SetSnapRotationDegrees(float degrees) = 0;
-
-    //! Get the positions of the horizontal guide lines (along y-axis in canvas pixels)
-    virtual AZStd::vector<float> GetHorizontalGuidePositions() = 0;
-
-    //! Add a horizontal guide line
-    virtual void AddHorizontalGuide(float position) = 0;
-
-    //! Remove the horizontal guide line at the given index
-    virtual void RemoveHorizontalGuide(int index) = 0;
-
-    //! Set the position of the horizontal guide line at the given index
-    virtual void SetHorizontalGuidePosition(int index, float position) = 0;
-
-    //! Get the positions of the vertical guide lines (along x-axis in canvas pixels)
-    virtual AZStd::vector<float> GetVerticalGuidePositions() = 0;
-
-    //! Add a vertical guide line
-    virtual void AddVerticalGuide(float position) = 0;
-
-    //! Remove the vertical guide line at the given index
-    virtual void RemoveVerticalGuide(int index) = 0;
-
-    //! Set the position of the vertical guide line at the given index
-    virtual void SetVerticalGuidePosition(int index, float position) = 0;
-
-    //! Remove all of the guides
-    virtual void RemoveAllGuides() = 0;
-
-    //! Get the color to draw the guide lines on this canvas
-    virtual AZ::Color GetGuideColor() = 0;
-
-    //! Set the color to draw the guide lines on this canvas
-    virtual void SetGuideColor(const AZ::Color& color) = 0;
-
-    //! Get whether the guides on this canvas are locked
-    virtual bool GetGuidesAreLocked() = 0;
-
-    //! Set whether the guides on this canvas are locked
-    virtual void SetGuidesAreLocked(bool areLocked) = 0;
-
-    //! Check the canvas for any orphaned elements. These are elements not referenced as a child by the canvas or any of its descendant elements.
-    virtual bool CheckForOrphanedElements() = 0;
-
-    //! Recover any orphaned elements in the canvas by placing them under a special top-level element.
-    virtual void RecoverOrphanedElements() = 0;
-
-    //! Remove any orphaned elements in the canvas.
-    virtual void RemoveOrphanedElements() = 0;
-
-    //! Update the canvas from the UI Editor
-    //! \param deltaTime the amount of time in seconds since the last call to this function
-    //! \param isInGame, true if canvas being updated in preview mode, false if being updated in edit mode
-    virtual void UpdateCanvasInEditorViewport(float deltaTime, bool isInGame) = 0;
-
-    //! Render the canvas in the UI Editor
-    //! \param isInGame, true if canvas being rendered in preview mode, false if being rendered in edit mode
-    //! \param viewportSize, this is the size of the viewport that the canvas is being rendered to
-    virtual void RenderCanvasInEditorViewport(bool isInGame, AZ::Vector2 viewportSize) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiEditorCanvasInterface> UiEditorCanvasBus;

Code/Legacy/CryCommon/LyShine/Bus/UiEditorChangeNotificationBus.h

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-#include <AzCore/Component/EntityId.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiEditorChangeNotificationInterface
-    : public AZ::EBusTraits
-{
-public: // member functions
-
-    virtual ~UiEditorChangeNotificationInterface() {}
-
-    //! Called when the transform properties in the UI editor need to be refreshed
-    virtual void OnEditorTransformPropertiesNeedRefresh() = 0;
-
-    //! Forces a refresh of the entire properties tree in the UI Editor.
-    virtual void OnEditorPropertiesRefreshEntireTree() = 0;
-};
-
-typedef AZ::EBus<UiEditorChangeNotificationInterface> UiEditorChangeNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Notify components who store directories as properties when directory contents change.
-class UiEditorRefreshDirectoryNotificationInterface
-    : public AZ::EBusTraits
-{
-public: // member functions
-
-    virtual ~UiEditorRefreshDirectoryNotificationInterface() {}
-
-    //! Notify directory properties that they should refresh their contents
-    virtual void OnRefreshDirectory() = 0;
-};
-
-typedef AZ::EBus<UiEditorRefreshDirectoryNotificationInterface> UiEditorRefreshDirectoryNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiElementBus.h

@@ -1,199 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/UiBase.h>
-
-namespace LyShine
-{
-    class IRenderGraph;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiElementInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    //! Deleting an element will remove it from its parent and delete its child elements and components
-    virtual ~UiElementInterface() {}
-
-    //! Render the element and its child elements and components, this is done by adding primitives to the render graph
-    //! \param renderGraph, the render graph being added to
-    //! \param isInGame, true if element being rendered in game (or preview), false if being render in edit mode
-    virtual void RenderElement(LyShine::IRenderGraph* renderGraph, bool isInGame) = 0;
-
-    //! Retrieves the identifier of this element.
-    virtual LyShine::ElementId GetElementId() = 0;
-
-    //! Get the name of this element
-    virtual LyShine::NameType GetName() = 0;
-
-    //! Get the canvas that contains this element (returns AZ::InvalidEntityId if element has no canvas)
-    virtual AZ::EntityId GetCanvasEntityId() = 0;
-
-    //! Get the parent element of this element (returns nullptr if element has no parent)
-    virtual AZ::Entity* GetParent() = 0;
-
-    //! Get the parent entity Id of this element (returns invalid Id if element has no parent)
-    virtual AZ::EntityId GetParentEntityId() = 0;
-
-    //! Get the number child elements of this element
-    virtual int GetNumChildElements() = 0;
-
-    //! Get the specified child element, index must be less than GetNumChildElements()
-    virtual AZ::Entity* GetChildElement(int index) = 0;
-
-    //! Get the specified child entity Id, index must be less than GetNumChildElements()
-    virtual AZ::EntityId GetChildEntityId(int index) = 0;
-
-    //! Get the specified child's UiElementInterface, index must be less than GetNumChildElements()
-    //! and the element must be fully initialized
-    virtual UiElementInterface* GetChildElementInterface(int index) = 0;
-
-    //! Get the index of the specified child element
-    virtual int GetIndexOfChild(const AZ::Entity* child) = 0;
-
-    //! Get the index of the specified child element
-    virtual int GetIndexOfChildByEntityId(AZ::EntityId childId) = 0;
-
-    //! Get the child elements of this element
-    virtual LyShine::EntityArray GetChildElements() = 0;
-
-    //! Get the child entity Ids of this element
-    virtual AZStd::vector<AZ::EntityId> GetChildEntityIds() = 0;
-
-    //! Create a new element that is a child of this element, this element (the parent) has ownership of the child
-    //! The new entity will have a UiElementComponent added but will not yet be initialized or activated
-    virtual AZ::Entity* CreateChildElement(const LyShine::NameType& name) = 0;
-
-    //! Destroy this element
-    virtual void DestroyElement() = 0;
-
-    //! Queue up element for destruction at end of frame
-    virtual void DestroyElementOnFrameEnd() = 0;
-
-    //! Re-parent this element to move it in the hierarchy
-    //! \param newParent New parent element. If null then the canvas is the parent
-    //! \param nextElement  Element to insert this element before. If null element is put at end of child list
-    virtual void Reparent(AZ::Entity* newParent, AZ::Entity* insertBefore = nullptr) = 0;
-
-    //! Re-parent this element to move it in the hierarchy
-    //! \param newParent New parent element. If InvalidEntityId then the canvas is the parent
-    //! \param nextElement  Element to insert this element before. If InvalidEntityId then element is put at end of child list
-    virtual void ReparentByEntityId(AZ::EntityId newParent, AZ::EntityId insertBefore) = 0;
-
-    //! Add this element as a child of the specified parent
-    //! \param newParent New parent element. If null then the canvas is the parent
-    //! \param index  Child index where element is inserted. If -1 element is put at end of child list
-    virtual void AddToParentAtIndex(AZ::Entity* newParent, int index = -1) = 0;
-
-    //! Remove this element from its parent
-    virtual void RemoveFromParent() = 0;
-
-    //! Get the front-most child element whose bounds include the given point in canvas space
-    //! \return nullptr if no match
-    virtual AZ::Entity* FindFrontmostChildContainingPoint(AZ::Vector2 point, bool isInGame) = 0;
-
-    //! Get all the children whose bounds intersect with the given rect in canvas space
-    //! \return Empty EntityArray if no match
-    virtual LyShine::EntityArray FindAllChildrenIntersectingRect(const AZ::Vector2& bound0, const AZ::Vector2& bound1, bool isInGame) = 0;
-
-    //! Look for an entity with interactable component to handle an event at given point
-    virtual AZ::EntityId FindInteractableToHandleEvent(AZ::Vector2 point) = 0;
-
-    //! Look for a parent (ancestor) entity with interactable component to handle dragging starting at given point
-    virtual AZ::EntityId FindParentInteractableSupportingDrag(AZ::Vector2 point) = 0;
-
-    //! Return the first immediate child element with the given name or nullptr if no match
-    virtual AZ::Entity* FindChildByName(const LyShine::NameType& name) = 0;
-
-    //! Return the first descendant element with the given name or nullptr if no match
-    virtual AZ::Entity* FindDescendantByName(const LyShine::NameType& name) = 0;
-
-    //! Return the first immediate child entity Id with the given name or invalid Id if no match
-    virtual AZ::EntityId FindChildEntityIdByName(const LyShine::NameType& name) = 0;
-
-    //! Return the first descendant entity Id with the given name or invalid Id if no match
-    virtual AZ::EntityId FindDescendantEntityIdByName(const LyShine::NameType& name) = 0;
-
-    //! Return the first immediate child element with the given id or nullptr if no match
-    virtual AZ::Entity* FindChildByEntityId(AZ::EntityId id) = 0;
-
-    //! Return the descendant element with the given id or nullptr if no match
-    virtual AZ::Entity* FindDescendantById(LyShine::ElementId id) = 0;
-
-    //! recursively find descendant elements matching a predicate
-    //! \param result, any matching elements will be added to this array
-    virtual void FindDescendantElements(AZStd::function<bool(const AZ::Entity*)> predicate, LyShine::EntityArray& result) = 0;
-
-    //! recursively visit descendant elements and call the given function on them
-    //! The function is called first on the element and then on its children
-    virtual void CallOnDescendantElements(AZStd::function<void(const AZ::EntityId)> callFunction) = 0;
-
-    //! Return whether a given element is an ancestor of this element
-    virtual bool IsAncestor(AZ::EntityId id) = 0;
-
-    //! Enabled/disabled
-    virtual bool IsEnabled() = 0;
-    virtual void SetIsEnabled(bool isEnabled) = 0;
-    virtual bool GetAreElementAndAncestorsEnabled() = 0;
-
-    //! This can be used to disable the render without disabling the update/interaction.
-    //! This is used internally by components that temporarily disable rendering of other elements (though they preserve the existing value).
-    virtual bool IsRenderEnabled() = 0;
-    virtual void SetIsRenderEnabled(bool isRenderEnabled) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiElementInterface> UiElementBus;
-
-// UI_ANIMATION_REVISIT This may be a temporary location
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiElementChangeNotification
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiElementChangeNotification() {}
-
-    //! Notify listeners that a property has change on this entity
-    virtual void UiElementPropertyChanged() {}
-};
-
-typedef AZ::EBus<UiElementChangeNotification> UiElementChangeNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiElementNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiElementNotifications() {}
-
-    //! Notify listeners that the element is being destroyed
-    virtual void OnUiElementBeingDestroyed() {}
-
-    //! Notify listeners that the element has been fixed up (canvas and parent for the element have been set)
-    virtual void OnUiElementFixup(AZ::EntityId /*canvasEntityId*/, AZ::EntityId /*parentEntityId*/) {}
-
-    //! Notify listeners that the element has been enabled or disabled (the flag on this element was changed)
-    virtual void OnUiElementEnabledChanged(bool /*isEnabled*/) {}
-
-    //! Notify listeners that the element has been enabled or disabled either directly or to a change to an ancestors enabled flag
-    virtual void OnUiElementAndAncestorsEnabledChanged(bool /*areElementAndAncestorsEnabled*/) {}
-};
-
-typedef AZ::EBus<UiElementNotifications> UiElementNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiEntityContextBus.h

@@ -1,90 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-#include <AzCore/Math/Uuid.h>
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/Serialization/ObjectStream.h>
-#include <AzCore/Slice/SliceComponent.h>
-#include <AzCore/Math/Vector3.h>
-#include <AzFramework/Entity/EntityContextBus.h>
-#include <AzFramework/Entity/EntityContext.h>
-
-// Forward declarations
-namespace AZ
-{
-    class Entity;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus for making requests to the UI entity context.
-//! There is one UiEntityContext per UI canvas.
-class UiEntityContextRequests
-    : public AZ::EBusTraits
-{
-public:
-
-    virtual ~UiEntityContextRequests() {}
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides. Accessed by EntityContextId
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-    typedef AzFramework::EntityContextId BusIdType;
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-    //////////////////////////////////////////////////////////////////////////
-
-    //! Creates an entity in a UI context.
-    //! \return a new entity
-    virtual AZ::Entity* CreateUiEntity(const char* name) = 0;
-
-    //! Registers an existing entity with a UI context.
-    virtual void AddUiEntity(AZ::Entity* entity) = 0;
-
-    //! Registers an existing set of entities with a UI context.
-    virtual void AddUiEntities(const AzFramework::EntityList& entities) = 0;
-
-    //! Destroys an entity in a UI context.
-    //! \return whether or not the entity was destroyed. A false return value signifies the entity did not belong to the UI context.
-    virtual bool DestroyUiEntity(AZ::EntityId entityId) = 0;
-
-    //! Clones a set of entities.
-    //! \param sourceEntities - the source set of entities to clone
-    //! \param resultEntities - the set of entities cloned from the source
-    virtual bool CloneUiEntities(const AZStd::vector<AZ::EntityId>& sourceEntities, AzFramework::EntityList& resultEntities) = 0;
-
-};
-
-using UiEntityContextRequestBus = AZ::EBus<UiEntityContextRequests>;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus for receiving events/notifications from the UI entity context
-class UiEntityContextNotification
-    : public AZ::EBusTraits
-{
-public:
-
-    virtual ~UiEntityContextNotification() {};
-
-    //! Fired when the context is being reset.
-    virtual void OnContextReset() {}
-
-    //! Fired when a slice has been successfully instantiated.
-    virtual void OnSliceInstantiated(const AZ::Data::AssetId& /*sliceAssetId*/, const AZ::SliceComponent::SliceInstanceAddress& /*sliceAddress*/, const AzFramework::SliceInstantiationTicket& /*ticket*/) {}
-
-    //! Fired when a slice has failed to instantiate.
-    virtual void OnSliceInstantiationFailed(const AZ::Data::AssetId& /*sliceAssetId*/, const AzFramework::SliceInstantiationTicket& /*ticket*/) {}
-
-    //! Fired when the entity stream has been successfully loaded.
-    virtual void OnEntityStreamLoadSuccess() {}
-
-    //! Fired when the entity stream load has failed
-    virtual void OnEntityStreamLoadFailed() {}
-};
-
-using UiEntityContextNotificationBus = AZ::EBus<UiEntityContextNotification>;

Code/Legacy/CryCommon/LyShine/Bus/UiFaderBus.h

@@ -1,78 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Color.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiFaderInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiFaderInterface() {}
-
-    //! Get the fade value. This is a float between 0 and 1. 1 means no fade. 0 means complete fade to invisible.
-    virtual float GetFadeValue() = 0;
-
-    //! Set the fade value
-    virtual void SetFadeValue(float fade) = 0;
-
-    //! Trigger a fade animation.
-    //! \param targetValue The value to end the fade at [0,1]
-    //! \param speed       Speed measured in full fade amount per second; 0 means instant
-    //! \param listener    The listener to notify when the fade is completed or interrupted
-    virtual void Fade(float targetValue, float speed) = 0;
-
-    //! Get whether a fade animation is taking place
-    virtual bool IsFading() = 0;
-
-    //! Get the flag that indicates whether the fader should use render to texture
-    virtual bool GetUseRenderToTexture() = 0;
-
-    //! Set the flag that indicates whether the fader should use render to texture
-    virtual void SetUseRenderToTexture(bool useRenderToTexture) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiFaderInterface> UiFaderBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement
-class UiFaderNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiFaderNotifications(){}
-
-    //! Called when the animation triggered by UiFaderInterface::Fade() is done.
-    //! The listener is automatically removed from the fader component after this is called.
-    virtual void OnFadeComplete() = 0;
-
-    //! Called when the animation triggered by UiFaderInterface::Fade() is interrupted.
-    //! The listener is automatically removed from the fader component after this is called.
-    virtual void OnFadeInterrupted() = 0;
-
-    //! Called when the fader component is destroyed
-    virtual void OnFaderDestroyed() = 0;
-};
-
-typedef AZ::EBus<UiFaderNotifications> UiFaderNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiFlipbookAnimationBus.h

@@ -1,172 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <AzFramework/Entity/EntityContextBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus that defines the interface for flipbook animations.
-//!
-//! A flipbook animation component exists on an entity that has an image component
-//! and interacts with the image bus to achieve its functionality (such as by
-//! manipulating sprite-sheet indices).
-class UiFlipbookAnimationInterface
-    : public AZ::ComponentBus
-{
-public: // Types
-
-    //! Defines the looping behavior when playing back a flipbook animation.
-    enum class LoopType
-    {
-        None,       //!< No looping behavior
-        
-        Linear,     //!< When end frame is reached, next frame will be the loop start frame
-
-        PingPong    //!< When end frame is reached, next frame will be the previous frame, 
-                    //!< continuing in reverse until the start frame is reached.
-    };
-
-    //! Units of speed for framerate
-    enum class FramerateUnits
-    {
-        FPS,                //!< Framerate of animation
-
-        SecondsPerFrame,    //!< Number of seconds to wait before playing next frame
-    };
-
-public:
-    virtual ~UiFlipbookAnimationInterface() {}
-
-    //! Start the animation sequence, beginning at the start frame.
-    //!
-    //! If a LoopType other than None has been set, the animation won't stop
-    //! unless explicitly done so (or the image is unloaded/destroyed).
-    virtual void Start() = 0;
-
-    //! Stops animation playback.
-    virtual void Stop() = 0;
-
-    //! \return True if the flipbook animation is currently playing, false otherwise.
-    virtual bool IsPlaying() = 0;
-
-    //! \return The starting frame of the animation.
-    virtual AZ::u32 GetStartFrame() = 0;
-
-    //! Sets the starting frame of the animation.
-    virtual void SetStartFrame(AZ::u32 startFrame) = 0;
-
-    //! \return End frame of the animation.
-    virtual AZ::u32 GetEndFrame() = 0;
-
-    //! Sets the ending frame of the animation.
-    virtual void SetEndFrame(AZ::u32 endFrame) = 0;
-
-    //! \return The current frame of the animation that's being rendered.
-    virtual AZ::u32 GetCurrentFrame() = 0;
-
-    //! Sets the current frame of the animation to render.
-    //!
-    //! If the animation is currently playing, this will effectively "skip"
-    //! to the given frame.
-    virtual void SetCurrentFrame(AZ::u32 currentFrame) = 0;
-
-    //! This frame is distinct from the start frame and allows a "lead in"
-    //! seqence of frames to play leading up to the looping animation. The
-    //! frames that occur prior to the loop start frame will only play once.
-    //!
-    //! \return The frame to start the loop from.
-    virtual AZ::u32 GetLoopStartFrame() = 0;
-
-    //! Sets the starting frame for looping sequences.
-    virtual void SetLoopStartFrame(AZ::u32 loopStartFrame) = 0;
-
-    //! \return The LoopType of the flipbook animation.
-    virtual LoopType GetLoopType() = 0;
-
-    //! Sets the LoopType of the flipbook animation.
-    virtual void SetLoopType(LoopType loopType) = 0;
-    
-    //! Gets the speed used to determine when to transition to the next frame.
-    //!
-    //! Framerate is defined relative to unit of time, specified by FramerateUnits.
-    //!
-    //! See GetFramerateUnit, SetFramerateUnit.
-    virtual float GetFramerate() = 0;
-
-    //! Sets the speed used to determine when to transition to the next frame.
-    //!
-    //! Framerate is defined relative to unit of time, specified by FramerateUnits.
-    //!
-    //! See GetFramerateUnit, SetFramerateUnit.
-    virtual void SetFramerate(float framerate) = 0;
-
-    //! Gets the framerate unit.
-    virtual FramerateUnits GetFramerateUnit() = 0;
-
-    //! Sets the framerate unit.
-    virtual void SetFramerateUnit(FramerateUnits framerateUnit) = 0;
-
-    //! Gets the delay (in seconds) before playing the flipbook (applied only once during playback).
-    virtual float GetStartDelay() = 0;
-
-    //! Sets the delay (in seconds) before playing the flipbook (applied only once during playback).
-    virtual void SetStartDelay(float startDelay) = 0;
-    
-    //! Gets the delay (in seconds) before playing the loop sequence.
-    virtual float GetLoopDelay() = 0;
-
-    //! Sets the delay (in seconds) before playing the loop sequence.
-    virtual void SetLoopDelay(float loopDelay) = 0;
-
-    //! Gets the delay (in seconds) before playing the reverse loop sequence (PingPong loop types only).
-    virtual float GetReverseDelay() = 0;
-
-    //! Sets the delay (in seconds) before playing the reverse loop sequence (PingPong loop types only).
-    virtual void SetReverseDelay(float reverseDelay) = 0;
-
-    //! Returns true if the animation will begin playing when the component activates, false otherwise.
-    virtual bool GetIsAutoPlay() = 0;
-
-    //! Sets whether the animation will automatically begin playing.
-    //!
-    //! This flag is ignored after the component has activated.
-    virtual void SetIsAutoPlay(bool isAutoPlay) = 0;
-};
-
-using UiFlipbookAnimationBus = AZ::EBus<UiFlipbookAnimationInterface>;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Allows listeners to be aware of events, like loop completion, occurring.
-class UiFlipbookAnimationNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiFlipbookAnimationNotifications() {}
-
-    //! Notify listeners when the animation starts
-    virtual void OnAnimationStarted() {}
-
-    //! Notify listeners when the animation stops
-    virtual void OnAnimationStopped() {}
-
-    //! Notify listeners when the current loop sequence has completed
-    //!
-    //! This will only trigger for LoopType sequences other than None.
-    //!
-    //! For Linear LoopType, this will trigger on the last frame of the last
-    //! frame of the loop.
-    //!
-    //! For PingPong LoopType, this will trigger on the last frame of the
-    //! loop sequence before reversing the loop direction.
-    virtual void OnLoopSequenceCompleted() {}
-};
-
-typedef AZ::EBus<UiFlipbookAnimationNotifications> UiFlipbookAnimationNotificationsBus;

Code/Legacy/CryCommon/LyShine/Bus/UiGameEntityContextBus.h

@@ -1,106 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/EBus.h>
-#include <AzCore/Math/Uuid.h>
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/Serialization/ObjectStream.h>
-#include <AzCore/Serialization/IdUtils.h>
-#include <AzCore/Slice/SliceComponent.h>
-#include <AzCore/Math/Vector2.h>
-#include <AzFramework/Entity/EntityContextBus.h>
-#include <AzFramework/Entity/EntityContext.h>
-
-// Forward declarations
-namespace AZ
-{
-    class Entity;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus for making requests to the UI game entity context.
-class UiGameEntityContextRequests
-    : public AZ::EBusTraits
-{
-public:
-
-    virtual ~UiGameEntityContextRequests() {}
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides. Accessed by EntityContextId
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-    typedef AzFramework::EntityContextId BusIdType;
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-    //////////////////////////////////////////////////////////////////////////
-
-    //! Instantiates a dynamic slice asynchronously.
-    //! \return a ticket identifying the spawn request.
-    //!         Callers can immediately subscribe to the SliceInstantiationResultBus for this ticket
-    //!         to receive result for this specific request.
-    virtual AzFramework::SliceInstantiationTicket InstantiateDynamicSlice(
-        const AZ::Data::Asset<AZ::Data::AssetData>& /*sliceAsset*/,
-        const AZ::Vector2& /*position*/,
-        bool /*isViewportPosition*/,
-        AZ::Entity* /*parent*/,
-        const AZ::IdUtils::Remapper<AZ::EntityId>::IdMapper& /*customIdMapper*/)
-    { return AzFramework::SliceInstantiationTicket(); }
-};
-
-using UiGameEntityContextBus = AZ::EBus<UiGameEntityContextRequests>;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus for receiving notifications from the UI game entity context component.
-class UiGameEntityContextNotifications
-    : public AZ::EBusTraits
-{
-public:
-
-    virtual ~UiGameEntityContextNotifications() = default;
-
-    /// Fired when a slice has been successfully instantiated.
-    virtual void OnSliceInstantiated(const AZ::Data::AssetId& /*sliceAssetId*/,
-        const AZ::SliceComponent::SliceInstanceAddress& /*instance*/,
-        const AzFramework::SliceInstantiationTicket& /*ticket*/) {}
-
-    /// Fired when a slice asset could not be instantiated.
-    virtual void OnSliceInstantiationFailed(const AZ::Data::AssetId& /*sliceAssetId*/,
-        const AzFramework::SliceInstantiationTicket& /*ticket*/) {}
-};
-
-using UiGameEntityContextNotificationBus = AZ::EBus<UiGameEntityContextNotifications>;
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus for receiving notifications from the UI game entity context component. This bus is used
-//! by the UiSpawnerComponent that depends on the UiGameEntityContext fixing entities up before
-//! it sends out notifications to listeners on the UiSpawnerNotificationBus
-class UiGameEntityContextSliceInstantiationResults
-    : public AZ::EBusTraits
-{
-public:
-
-    virtual ~UiGameEntityContextSliceInstantiationResults() = default;
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides. Addressed by SliceInstantiationTicket
-    static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-    typedef AzFramework::SliceInstantiationTicket BusIdType;
-    //////////////////////////////////////////////////////////////////////////
-
-    //! Signals that a slice was successfully instantiated prior to entity registration.
-    virtual void OnEntityContextSlicePreInstantiate(const AZ::Data::AssetId& /*sliceAssetId*/, const AZ::SliceComponent::SliceInstanceAddress& /*sliceAddress*/) {}
-
-    //! Signals that a slice was successfully instantiated after entity registration.
-    virtual void OnEntityContextSliceInstantiated(const AZ::Data::AssetId& /*sliceAssetId*/, const AZ::SliceComponent::SliceInstanceAddress& /*sliceAddress*/) {}
-
-    //! Signals that a slice could not be instantiated.
-    virtual void OnEntityContextSliceInstantiationFailed(const AZ::Data::AssetId& /*sliceAssetId*/) {}
-};
-
-using UiGameEntityContextSliceInstantiationResultsBus = AZ::EBus<UiGameEntityContextSliceInstantiationResults>;

Code/Legacy/CryCommon/LyShine/Bus/UiImageBus.h

@@ -1,168 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Color.h>
-
-class ISprite;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiImageInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    enum class ImageType : int32_t
-    {
-        Stretched,      //!< the texture is stretched to fit the rect without maintaining aspect ratio
-        Sliced,         //!< the texture is sliced such that center stretches and the edges do not
-        Fixed,          //!< the texture is not stretched at all
-        Tiled,          //!< the texture is tiled (repeated)
-        StretchedToFit, //!< the texture is scaled to fit the rect while maintaining aspect ratio
-        StretchedToFill //!< the texture is scaled to fill the rect while maintaining aspect ratio
-    };
-
-    enum class SpriteType : int32_t
-    {
-        SpriteAsset,
-        RenderTarget,
-    };
-
-    enum class FillType : int32_t
-    {
-        None,           //!< the image is displayed fully filled
-        Linear,         //!< the image is filled linearly from one edge to the opposing edge
-        Radial,         //!< the image is filled radially around the center
-        RadialCorner,   //!< the image is filled radially around a corner
-        RadialEdge,     //!< the image is filled radially around the midpoint of an edge
-    };
-
-    enum class FillCornerOrigin : int32_t
-    {
-        TopLeft,
-        TopRight,
-        BottomRight,
-        BottomLeft,
-    };
-
-    enum class FillEdgeOrigin : int32_t
-    {
-        Left,
-        Top,
-        Right,
-        Bottom,
-    };
-
-public: // member functions
-
-    virtual ~UiImageInterface() {}
-
-    //! Gets the image color tint
-    virtual AZ::Color GetColor() = 0;
-
-    //! Sets the image color tint
-    virtual void SetColor(const AZ::Color& color) = 0;
-
-    //! Gets the image color alpha
-    virtual float GetAlpha() = 0;
-
-    //! Sets the image color alpha
-    virtual void SetAlpha(float color) = 0;
-
-    //! Gets the sprite for this element
-    virtual ISprite* GetSprite() = 0;
-
-    //! Sets the sprite for this element
-    virtual void SetSprite(ISprite* sprite) = 0;
-
-    //! Gets the source location of the image to be displayed by the element
-    virtual AZStd::string GetSpritePathname() = 0;
-    
-    //! Sets the source location of the image to be displayed by the element
-    virtual void SetSpritePathname(AZStd::string spritePath) = 0;
-
-    //! Sets the source location of the image to be displayed by the element only
-    //! if the sprite asset exists. Otherwise, the current sprite remains unchanged.
-    //! Returns whether the sprite changed
-    virtual bool SetSpritePathnameIfExists(AZStd::string spritePath) = 0;
-
-    //! Gets the name of the render target
-    virtual AZStd::string GetRenderTargetName() = 0;
-
-    //! Sets the name of the render target
-    virtual void SetRenderTargetName(AZStd::string renderTargetName) = 0;
-
-    //! Gets whether the render target is in sRGB color space
-    virtual bool GetIsRenderTargetSRGB() = 0;
-
-    //! Sets whether the render target is in sRGB color space
-    virtual void SetIsRenderTargetSRGB(bool isSRGB) = 0;
-
-    //! Gets the type of the sprite
-    virtual SpriteType GetSpriteType() = 0;
-
-    //! Sets the type of the sprite
-    virtual void SetSpriteType(SpriteType spriteType) = 0;
-
-    //! Gets the type of the image
-    virtual ImageType GetImageType() = 0;
-
-    //! Sets the type of the image
-    virtual void SetImageType(ImageType imageType) = 0;
-    
-    //! Gets the fill type for the image
-    virtual FillType GetFillType() = 0;
-
-    //! Sets the fill type for the image
-    virtual void SetFillType(FillType fillType) = 0;
-
-    //! Gets the fill amount for the image in the range [0,1]
-    virtual float GetFillAmount() = 0;
-
-    //! Sets the fill amount for the image in the range [0,1]
-    virtual void SetFillAmount(float fillAmount) = 0;
-
-    //! Gets the start angle for radial fill, measured clockwise in degrees from straight up
-    virtual float GetRadialFillStartAngle() = 0;
-
-    //! Sets the start angle for radial fill, measured clockwise in degrees from straight up
-    virtual void SetRadialFillStartAngle(float radialFillStartAngle) = 0;
-
-    //! Gets the corner fill origin
-    virtual FillCornerOrigin GetCornerFillOrigin() = 0;
-
-    //! Sets the corner fill origin
-    virtual void SetCornerFillOrigin(FillCornerOrigin cornerOrigin) = 0;
-
-    //! Gets the edge fill origin
-    virtual FillEdgeOrigin GetEdgeFillOrigin() = 0;
-
-    //! Sets the edge fill origin
-    virtual void SetEdgeFillOrigin(FillEdgeOrigin edgeOrigin) = 0;
-
-    //! Gets whether the image is filled clockwise
-    virtual bool GetFillClockwise() = 0;
-
-    //! Sets whether the image is filled clockwise
-    virtual void SetFillClockwise(bool fillClockwise) = 0;
-
-    //! Gets whether the center of a sliced image is filled
-    virtual bool GetFillCenter() = 0;
-
-    //! Sets whether the center of a sliced image is filled
-    virtual void SetFillCenter(bool fillCenter) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiImageInterface> UiImageBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiImageSequenceBus.h

@@ -1,42 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiImageSequenceInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    enum class ImageType : int32_t
-    {
-        Stretched,      //!< the texture is stretched to fit the rect without maintaining aspect ratio
-        Fixed,          //!< the texture is not stretched at all
-        StretchedToFit, //!< the texture is scaled to fit the rect while maintaining aspect ratio
-        StretchedToFill //!< the texture is scaled to fill the rect while maintaining aspect ratio
-    };
-
-public: // member functions
-
-    virtual ~UiImageSequenceInterface() {}
-
-    //! Gets the type of the image
-    virtual ImageType GetImageType() = 0;
-
-    //! Sets the type of the image
-    virtual void SetImageType(ImageType imageType) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiImageSequenceInterface> UiImageSequenceBus;

Code/Legacy/CryCommon/LyShine/Bus/UiIndexableImageBus.h

@@ -1,45 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Defines an interface for working with indexable image types, such as sprite-sheets or image sequences.
-class UiIndexableImageInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiIndexableImageInterface() {}
-    
-    //! Sets the index of the image to display
-    virtual void SetImageIndex(AZ::u32 index) = 0;
-
-    //! Gets the index of the image to display
-    virtual const AZ::u32 GetImageIndex() = 0;
-
-    //! Gets the number of indices for this image.
-    virtual const AZ::u32 GetImageIndexCount() = 0;    
-
-    //! Given an index, return its alias (if defined)
-    virtual AZStd::string GetImageIndexAlias(AZ::u32 index) = 0;
-
-    //! Given an index, set an alias for it
-    virtual void SetImageIndexAlias(AZ::u32 index, const AZStd::string& alias) = 0;
-
-    //! Given an alias, return the index that corresponds to it
-    virtual AZ::u32 GetImageIndexFromAlias(const AZStd::string& alias) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiIndexableImageInterface> UiIndexableImageBus;

Code/Legacy/CryCommon/LyShine/Bus/UiInitializationBus.h

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiInitializationInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiInitializationInterface() {}
-
-    //! Initialize the component after it has been created as part of a set of entities.
-    //! I.e. After a group of entities has been created and activated from a load or clone operation
-    //! in the game (not in the UI Editor) this is called on each created element.
-    //! This allows the component to perform operations that rely on related entities being
-    //! activated.
-    virtual void InGamePostActivate() = 0;
-
-public: // static member functions
-
-    static const char* GetUniqueName() { return "UiInitializationInterface"; }
-
-public: // static member data
-
-    //! Multiple components on an entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-};
-
-typedef AZ::EBus<UiInitializationInterface> UiInitializationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiInteractableActionsBus.h

@@ -1,85 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// This bus allows the get/set of properties for a group of actions that many interactable components
-// implement.
-// It is separate from UiInteractableBus because UiInteractableBus is part of a core system for how
-// the UI canvas communincates with any UI element that wants user input. Sometimes UI components
-// want input because they are part of a 2D puzzle for example but they do not always want to have
-// to support the standard action changes.
-class UiInteractableActionsInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    typedef AZStd::function<void(AZ::EntityId)> OnActionCallback;
-
-public: // member functions
-
-    virtual ~UiInteractableActionsInterface() {}
-
-    //! Get the hover start action name
-    virtual const LyShine::ActionName& GetHoverStartActionName() = 0;
-
-    //! Set the hover start action name
-    virtual void SetHoverStartActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the hover end action name
-    virtual const LyShine::ActionName& GetHoverEndActionName() = 0;
-
-    //! Set the hover end action name
-    virtual void SetHoverEndActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the pressed action name
-    virtual const LyShine::ActionName& GetPressedActionName() = 0;
-
-    //! Set the pressed action name
-    virtual void SetPressedActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the released action name
-    virtual const LyShine::ActionName& GetReleasedActionName() = 0;
-
-    //! Set the released action name
-    virtual void SetReleasedActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the hover start callback
-    virtual OnActionCallback GetHoverStartActionCallback() = 0;
-
-    //! Set the hover start callback
-    virtual void SetHoverStartActionCallback(OnActionCallback onActionCallback) = 0;
-
-    //! Get the hover end callback
-    virtual OnActionCallback GetHoverEndActionCallback() = 0;
-
-    //! Set the hover end callback
-    virtual void SetHoverEndActionCallback(OnActionCallback onActionCallback) = 0;
-
-    //! Get the pressed callback
-    virtual OnActionCallback GetPressedActionCallback() = 0;
-
-    //! Set the pressed callback
-    virtual void SetPressedActionCallback(OnActionCallback onActionCallback) = 0;
-
-    //! Get the release callback
-    virtual OnActionCallback GetReleasedActionCallback() = 0;
-
-    //! Set the release callback
-    virtual void SetReleasedActionCallback(OnActionCallback onActionCallback) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiInteractableActionsInterface> UiInteractableActionsBus;

Code/Legacy/CryCommon/LyShine/Bus/UiInteractableBus.h

@@ -1,180 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <AzFramework/Input/Channels/InputChannelDigitalWithSharedModifierKeyStates.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiInteractableInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiInteractableInterface() {}
-
-    //! Check whether this component can handle the event at the given location
-    virtual bool CanHandleEvent(AZ::Vector2 point) = 0;
-
-    //! Called on an interactable component when a pressed event is received over it
-    //! \param point, the point at which the event occurred (viewport space)
-    //! \param shouldStayActive, output - true if the interactable wants to become the active element for the canvas
-    //! \return true if the interactable handled the event
-    virtual bool HandlePressed(AZ::Vector2 point, bool& shouldStayActive) = 0;
-
-    //! Called on the currently pressed interactable component when a release event is received
-    //! \param point, the point at which the event occurred (viewport space)
-    //! \return true if the interactable handled the event
-    virtual bool HandleReleased(AZ::Vector2 point) = 0;
-
-    //! Called on an interactable component when a multi-touch pressed event is received over it
-    //! \param point, the point at which the event occurred (viewport space)
-    //! \param multiTouchIndex, the index of the multi-touch (the 'primary' touch with index 0 is sent to HandlePressed)
-    //! \return true if the interactable handled the event
-    virtual bool HandleMultiTouchPressed(AZ::Vector2 point, int multiTouchIndex) = 0;
-
-    //! Called on the currently pressed interactable component when a multi-touch release event is received
-    //! \param point, the point at which the event occurred (viewport space)
-    //! \param multiTouchIndex, the index of the multi-touch (the 'primary' touch with index 0 is sent to HandlePressed)
-    //! \return true if the interactable handled the event
-    virtual bool HandleMultiTouchReleased(AZ::Vector2 point, int multiTouchIndex) = 0;
-
-    //! Called on an interactable component when an enter pressed event is received
-    //! \param shouldStayActive, output - true if the interactable wants to become the active element for the canvas
-    //! \return true if the interactable handled the event
-    virtual bool HandleEnterPressed([[maybe_unused]] bool& shouldStayActive) { return false; }
-
-    //! Called on the currently pressed interactable component when an enter released event is received
-    //! \return true if the interactable handled the event
-    virtual bool HandleEnterReleased() { return false; }
-
-    //! Called when the interactable was navigated to via gamepad/keyboard, and auto activation is enabled on the interactable
-    //! \return true if the interactable handled the event
-    virtual bool HandleAutoActivation() { return false; }
-
-    //! Called on the currently active interactable component when text input is received
-    //! \return true if the interactable handled the event
-    virtual bool HandleTextInput([[maybe_unused]] const AZStd::string& textUTF8) { return false; };
-
-    //! Called on the currently active interactable component when input is received
-    //! \return true if the interactable handled the event
-    virtual bool HandleKeyInputBegan([[maybe_unused]] const AzFramework::InputChannel::Snapshot& inputSnapshot, [[maybe_unused]] AzFramework::ModifierKeyMask activeModifierKeys) { return false; }
-
-    //! Called on the currently active interactable component when a mouse/touch position event is received
-    //! \param point, the current mouse/touch position (viewport space)
-    virtual void InputPositionUpdate([[maybe_unused]] AZ::Vector2 point) {};
-
-    //! Called on the currently pressed interactable component when a multi-touch position event is received
-    //! \param point, the current mouse/touch position (viewport space)
-    //! \param multiTouchIndex, the index of the multi-touch (the 'primary' touch with index 0 is sent to HandlePressed)
-    virtual void MultiTouchPositionUpdate([[maybe_unused]] AZ::Vector2 point, [[maybe_unused]] int multiTouchIndex) {};
-
-    //! Returns true if this interactable supports taking active status when a drag is started on a child
-    //! interactble AND the given drag startPoint would be a valid drag start point
-    //! \param point, the start point of the drag (which would be on a child interactable) (viewport space)
-    virtual bool DoesSupportDragHandOff([[maybe_unused]] AZ::Vector2 startPoint) { return false; }
-
-    //! Called on a parent of the currently active interactable element to allow interactables that
-    //! contain other interactables to support drags that start on the child.
-    //! If this return true the hand-off occured and the caller will no longer be considered the
-    //! active interactable by the canvas.
-    //! \param currentActiveInteractable, the child element that is the currently active interactable
-    //! \param startPoint, the start point of the potential drag (viewport space)
-    //! \param currentPoint, the current points of the potential drag (viewport space)
-    virtual bool OfferDragHandOff([[maybe_unused]] AZ::EntityId currentActiveInteractable, [[maybe_unused]] AZ::Vector2 startPoint, [[maybe_unused]] AZ::Vector2 currentPoint, [[maybe_unused]] float dragThreshold) { return false; };
-
-    //! Called on the currently active interactable component when the active interactable changes
-    virtual void LostActiveStatus() {};
-
-    //! Called when mouse/touch enters the bounds of this interactable
-    virtual void HandleHoverStart() = 0;
-
-    //! Called on the currently hovered interactable component when mouse/touch moves outside of bounds
-    virtual void HandleHoverEnd() = 0;
-
-    //! Called when a descendant of the interactable becomes the hover interactable by being navigated to
-    virtual void HandleDescendantReceivedHoverByNavigation([[maybe_unused]] AZ::EntityId descendantEntityId) {};
-
-    //! Called when the interactable becomes the hover interactable by being navigated to from one of its descendants
-    virtual void HandleReceivedHoverByNavigatingFromDescendant([[maybe_unused]] AZ::EntityId descendantEntityId) {};
-
-    //! Query whether the interactable is currently pressed
-    virtual bool IsPressed() { return false; }
-
-    //! Enable/disable event handling
-    virtual bool IsHandlingEvents() { return true; }
-    virtual void SetIsHandlingEvents([[maybe_unused]] bool isHandlingEvents) {}
-
-    //! Enable/disable multi-touch event handling
-    virtual bool IsHandlingMultiTouchEvents() { return true; }
-    virtual void SetIsHandlingMultiTouchEvents([[maybe_unused]] bool isHandlingMultiTouchEvents) {}
-
-    //! Get/set whether the interactable automatically becomes active when navigated to via gamepad/keyboard
-    virtual bool GetIsAutoActivationEnabled() = 0;
-    virtual void SetIsAutoActivationEnabled(bool isEnabled) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiInteractableInterface> UiInteractableBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiInteractableActiveNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiInteractableActiveNotifications() {}
-
-    //! Notify listener that this interactable is no longer active
-    virtual void ActiveCancelled() {}
-
-    //! Notify listener that this interactable has given up active status to a new interactable
-    virtual void ActiveChanged([[maybe_unused]] AZ::EntityId m_newActiveInteractable, [[maybe_unused]] bool shouldStayActive) {}
-};
-
-typedef AZ::EBus<UiInteractableActiveNotifications> UiInteractableActiveNotificationBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that listeners need to implement in order to get notifications when actions are
-//! triggered
-class UiInteractableNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiInteractableNotifications(){}
-
-    //! Called on hover start
-    virtual void OnHoverStart() {};
-
-    //! Called on hover end
-    virtual void OnHoverEnd() {};
-
-    //! Called on pressed
-    virtual void OnPressed() {};
-
-    //! Called on released
-    virtual void OnReleased() {};
-
-    //! Called on receiving hover by being navigated to from a descendant
-    virtual void OnReceivedHoverByNavigatingFromDescendant([[maybe_unused]] AZ::EntityId descendantEntityId) {};
-};
-
-typedef AZ::EBus<UiInteractableNotifications> UiInteractableNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiInteractableStatesBus.h

@@ -1,111 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-#include <AzCore/Math/Color.h>
-
-class ISprite;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// This bus allows the get/set of properties for a group of states that many interactable components
-// implement.
-// It is separate from UiInteractableBus because UiInteractableBus is part of a core system for how
-// the UI canvas communincates with any UI element that wants user input. Sometimes UI components
-// want input because they are part of a 2D puzzle for example but they do not always want to have
-// to support the standard state changes.
-class UiInteractableStatesInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    //! The different visual states that an interactable can be in. An enum class is avoided so that 
-    //! derived components of UiInteractableComponent can extend with additional states.
-    using State = int;
-    enum
-    {
-        StateNormal = 0,
-        StateHover,
-        StatePressed,
-        StateDisabled,
-        NumStates
-    };
-
-public: // member functions
-
-    virtual ~UiInteractableStatesInterface() {}
-
-    //! Set the color to be used for the given target when the interactable is in the given state
-    //! If the interactable already has a color action for this state/target combination then replaces it
-    virtual void SetStateColor(State state, AZ::EntityId target, const AZ::Color& color) = 0;
-
-    //! Get the color to be used for the given target when the interactable is in the given state
-    //! \return the color to be used for the given target when the interactable is in the given state
-    virtual AZ::Color GetStateColor(State state, AZ::EntityId target) = 0;
-
-    //! Get whether the interactable has a color action for this state/target combination
-    //! \return true if the interactable has a color action for this state/target combination
-    virtual bool HasStateColor(State state, AZ::EntityId target) = 0;
-
-    //! Set the alpha to be used for the given target when the interactable is in the given state
-    //! If the interactable already has an alpha action for this state/target combination then replaces it
-    virtual void SetStateAlpha(State state, AZ::EntityId target, float alpha) = 0;
-
-    //! Get the alpha to be used for the given target when the interactable is in the given state
-    //! \return the alpha to be used for the given target when the interactable is in the given state
-    virtual float GetStateAlpha(State state, AZ::EntityId target) = 0;
-
-    //! Get whether the interactable has an alpha action for this state/target combination
-    //! \return true if the interactable has an alpha action for this state/target combination
-    virtual bool HasStateAlpha(State state, AZ::EntityId target) = 0;
-
-    //! Set the sprite to be used for the given target when the interactable is in the given state
-    //! If the interactable already has a sprite action for this state/target combination then replaces it
-    virtual void SetStateSprite(State state, AZ::EntityId target, ISprite* sprite) = 0;
-
-    //! Get the sprite to be used for the given target when the interactable is in the given state
-    //! \return the sprite to be used for the given target when the interactable is in the given state
-    virtual ISprite* GetStateSprite(State state, AZ::EntityId target) = 0;
-
-    //! Set the sprite path to be used for the given target when the interactable is in the given state
-    //! If the interactable already has a sprite action for this state/target combination then replaces it
-    virtual void SetStateSpritePathname(State state, AZ::EntityId target, const AZStd::string& spritePath) = 0;
-
-    //! Get the sprite path to be used for the given target when the interactable is in the given state
-    //! \return the sprite path to be used for the given target when the interactable is in the given state
-    virtual AZStd::string GetStateSpritePathname(State state, AZ::EntityId target) = 0;
-
-    //! Get whether the interactable has a sprite action for this state/target combination
-    //! \return true if the interactable has a sprite action for this state/target combination
-    virtual bool HasStateSprite(State state, AZ::EntityId target) = 0;
-
-    //! Set the font to be used for the given target when the interactable is in the given state
-    //! If the interactable already has a font action for this state/target combination then replaces it
-    virtual void SetStateFont(State state, AZ::EntityId target, const AZStd::string& fontPathname, unsigned int fontEffectIndex) = 0;
-
-    //! Get the font path to be used for the given target when the interactable is in the given state
-    //! \return the font path to be used for the given target when the interactable is in the given state
-    virtual AZStd::string GetStateFontPathname(State state, AZ::EntityId target) = 0;
-
-    //! Get the font effect to be used for the given target when the interactable is in the given state
-    //! \return the font effect to be used for the given target when the interactable is in the given state
-    virtual unsigned int GetStateFontEffectIndex(State state, AZ::EntityId target) = 0;
-
-    //! Get whether the interactable has a font action for this state/target combination
-    //! \return true if the interactable has a font action for this state/target combination
-    virtual bool HasStateFont(State state, AZ::EntityId target) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiInteractableStatesInterface> UiInteractableStatesBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiInteractionMaskBus.h

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiInteractionMaskInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiInteractionMaskInterface() {}
-
-    //! Check whether this element is masking the given point
-    virtual bool IsPointMasked(AZ::Vector2 point) = 0;
-
-public: // static member functions
-
-    static const char* GetUniqueName() { return "UIInteractionMaskInterface"; }
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiInteractionMaskInterface> UiInteractionMaskBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutBus.h

@@ -1,89 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/Bus/UiTransformBus.h>
-#include <LyShine/IDraw2d.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    //! Horizontal order used by layout components
-    enum class HorizontalOrder
-    {
-        LeftToRight,
-        RightToLeft
-    };
-
-    //! Vertical order used by layout components
-    enum class VerticalOrder
-    {
-        TopToBottom,
-        BottomToTop
-    };
-
-    //! Padding (in pixels) inside the edges of an element
-    struct Padding
-    {
-        AZ_TYPE_INFO(Padding, "{DE5C18B0-4214-4A37-B590-8D45CC450A96}")
-
-        Padding()
-            : m_left(0)
-            , m_top(0)
-            , m_right(0)
-            , m_bottom(0) {}
-
-        int m_left;
-        int m_right;
-        int m_top;
-        int m_bottom;
-    };
-
-public: // member functions
-
-    virtual ~UiLayoutInterface() {}
-
-    //! Get whether this layout component uses layout cells to calculate its layout
-    virtual bool IsUsingLayoutCellsToCalculateLayout() = 0;
-
-    //! Get whether this layout component should bypass the default layout cell values calculated by its children
-    virtual bool GetIgnoreDefaultLayoutCells() = 0;
-
-    //! Set whether this layout component should bypass the default layout cell values calculated by its children
-    virtual void SetIgnoreDefaultLayoutCells(bool ignoreDefaultLayoutCells) = 0;
-
-    //! Get the horizontal child alignment
-    virtual IDraw2d::HAlign GetHorizontalChildAlignment() = 0;
-
-    //! Set the horizontal child alignment
-    virtual void SetHorizontalChildAlignment(IDraw2d::HAlign alignment) = 0;
-
-    //! Get the vertical child alignment
-    virtual IDraw2d::VAlign GetVerticalChildAlignment() = 0;
-
-    //! Set the vertical child alignment
-    virtual void SetVerticalChildAlignment(IDraw2d::VAlign alignment) = 0;
-
-    //! Find out whether this layout component is currently overriding the transform of the specified element.
-    virtual bool IsControllingChild(AZ::EntityId childId) = 0;
-
-    //! Get the size the element needs to be to fit a specified number of child elements of a certain size
-    virtual AZ::Vector2 GetSizeToFitChildElements(const AZ::Vector2& childElementSize, int numChildElements) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutInterface> UiLayoutBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutCellBus.h

@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiLayoutCellBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutCellInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiLayoutCellInterface() {}
-
-    //! Get the overridden min width. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetMinWidth() = 0;
-
-    //! Set the overridden min width. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetMinWidth(float width) = 0;
-
-    //! Get the overridden min height. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetMinHeight() = 0;
-
-    //! Set the overridden min height. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetMinHeight(float height) = 0;
-
-    //! Get the overridden target width. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetTargetWidth() = 0;
-
-    //! Set the overridden target width. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetTargetWidth(float width) = 0;
-
-    //! Get the overridden target height. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetTargetHeight() = 0;
-
-    //! Set the overridden target height. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetTargetHeight(float height) = 0;
-
-    //! Get the overridden max width. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetMaxWidth() = 0;
-
-    //! Set the overridden max width. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetMaxWidth(float width) = 0;
-
-    //! Get the overridden max height. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetMaxHeight() = 0;
-
-    //! Set the overridden max height. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetMaxHeight(float height) = 0;
-
-    //! Get the overridden extra width ratio. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetExtraWidthRatio() = 0;
-
-    //! Set the overridden extra width ratio. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetExtraWidthRatio(float width) = 0;
-
-    //! Get the overridden extra height ratio. LyShine::UiLayoutCellUnspecifiedSize means it has not been overridden
-    virtual float GetExtraHeightRatio() = 0;
-
-    //! Set the overridden extra height ratio. LyShine::UiLayoutCellUnspecifiedSize means don't override
-    virtual void SetExtraHeightRatio(float height) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutCellInterface> UiLayoutCellBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutCellDefaultBus.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiLayoutCellBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutCellDefaultInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiLayoutCellDefaultInterface() {}
-
-    //! Get the minimum width
-    virtual float GetMinWidth() = 0;
-
-    //! Get the minimum height
-    virtual float GetMinHeight() = 0;
-
-    //! Get the target width
-    //! \param maxWidth A width that the element will not surpass. LyShine::UiLayoutCellUnspecifiedSize means no max 
-    virtual float GetTargetWidth(float maxWidth) = 0;
-
-    //! Get the target height
-    //! \param maxHeight A height that the element will not surpass. LyShine::UiLayoutCellUnspecifiedSize means no max
-    virtual float GetTargetHeight(float maxHeight) = 0;
-
-    //! Get the extra width ratio
-    virtual float GetExtraWidthRatio() = 0;
-
-    //! Get the extra height ratio
-    virtual float GetExtraHeightRatio() = 0;
-
-public: // static member data
-
-    //! Multiple components on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-};
-
-typedef AZ::EBus<UiLayoutCellDefaultInterface> UiLayoutCellDefaultBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutColumnBus.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/Bus/UiLayoutBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutColumnInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiLayoutColumnInterface() {}
-
-    //! Get the padding (in pixels) inside the edges of the element
-    virtual UiLayoutInterface::Padding GetPadding() = 0;
-
-    //! Set the padding (in pixels) inside the edges of the element
-    virtual void SetPadding(UiLayoutInterface::Padding padding) = 0;
-
-    //! Get the spacing (in pixels) between child elements
-    virtual float GetSpacing() = 0;
-
-    //! Set the spacing (in pixels) between child elements
-    virtual void SetSpacing(float spacing) = 0;
-
-    //! Get the vertical order for this layout
-    virtual UiLayoutInterface::VerticalOrder GetOrder() = 0;
-
-    //! Set the vertical order for this layout
-    virtual void SetOrder(UiLayoutInterface::VerticalOrder order) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutColumnInterface> UiLayoutColumnBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutControllerBus.h

@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! This interface can to be implemented by any component that wants to modify transform properties
-//! of elements are runtime using the Layout system. The methods in this interface will be called
-//! by the LayoutManager whenever the element is told to recompute its layout. Because an element
-//! might have multiple components that implement this interface, the handlers will be sorted by
-//! priority (lower priority number gets called earlier).
-class UiLayoutControllerInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiLayoutControllerInterface() {}
-
-    //! Set elements' width transform properties
-    virtual void ApplyLayoutWidth() = 0;
-
-    //! Set elements' height transform properties
-    virtual void ApplyLayoutHeight() = 0;
-
-public: // static member data
-
-    //! Events are ordered, each handler may set its priority
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::MultipleAndOrdered;
-
-    //! Priority will be used for ordering, lower priority number means it gets called earlier
-    struct BusHandlerOrderCompare
-    {
-        AZ_FORCE_INLINE bool operator()(const UiLayoutControllerInterface* left, const UiLayoutControllerInterface* right) const { return left->GetPriority() < right->GetPriority(); }
-    };
-
-protected: // member data
-
-    static const unsigned int k_defaultPriority = 100;  // Default is 100, make it lower to get called earlier, higher to get called later
-    virtual unsigned int GetPriority() const { return k_defaultPriority; }
-};
-
-typedef AZ::EBus<UiLayoutControllerInterface> UiLayoutControllerBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutFitterBus.h

@@ -1,55 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! This component resizes its element to fit its content. It uses cell sizing information given to
-//! it by other Layout components, Text component, or Image component (fixed type).
-class UiLayoutFitterInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    //! Fit type indicating enabled fits
-    enum class FitType
-    {
-        None,
-        HorizontalOnly,
-        VerticalOnly,
-        HorizontalAndVertical
-    };
-
-public: // member functions
-
-    virtual ~UiLayoutFitterInterface() {}
-
-    //! Get whether to resize the element horizontally
-    virtual bool GetHorizontalFit() = 0;
-
-    //! Set whether to resize the element horizontally
-    virtual void SetHorizontalFit(bool horizontalFit) = 0;
-
-    //! Get whether to resize the element vertically
-    virtual bool GetVerticalFit() = 0;
-
-    //! Set whether to resize the element vertically
-    virtual void SetVerticalFit(bool verticalFit) = 0;
-
-    //! Get the fit type
-    virtual FitType GetFitType() = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutFitterInterface> UiLayoutFitterBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutGridBus.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/Bus/UiLayoutBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutGridInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    //! Used to determine which direction to start the layout with
-    enum class StartingDirection
-    {
-        HorizontalOrder,
-        VerticalOrder
-    };
-
-public: // member functions
-
-    virtual ~UiLayoutGridInterface() {}
-
-    //! Get the padding (in pixels) inside the edges of the element
-    virtual UiLayoutInterface::Padding GetPadding() = 0;
-
-    //! Set the padding (in pixels) inside the edges of the element
-    virtual void SetPadding(UiLayoutInterface::Padding padding) = 0;
-
-    //! Get the spacing (in pixels) between child elements
-    virtual AZ::Vector2 GetSpacing() = 0;
-
-    //! Set the spacing (in pixels) between child elements
-    virtual void SetSpacing(AZ::Vector2 spacing) = 0;
-
-    //! Get the size (in pixels) of a child element in this layout
-    virtual AZ::Vector2 GetCellSize() = 0;
-
-    //! Set the size (in pixels) of a child element in this layout
-    virtual void SetCellSize(AZ::Vector2 size) = 0;
-
-    //! Get the horizontal order for this layout
-    virtual UiLayoutInterface::HorizontalOrder GetHorizontalOrder() = 0;
-
-    //! Set the horizontal order for this layout
-    virtual void SetHorizontalOrder(UiLayoutInterface::HorizontalOrder order) = 0;
-
-    //! Get the vertical order for this layout
-    virtual UiLayoutInterface::VerticalOrder GetVerticalOrder() = 0;
-
-    //! Set the vertical order for this layout
-    virtual void SetVerticalOrder(UiLayoutInterface::VerticalOrder order) = 0;
-
-    //! Get the starting direction for this layout
-    virtual StartingDirection GetStartingDirection() = 0;
-
-    //! Set the starting direction for this layout
-    virtual void SetStartingDirection(StartingDirection direction) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutGridInterface> UiLayoutGridBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutManagerBus.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutManagerInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiLayoutManagerInterface() {}
-
-public: // static member data
-
-    //! Mark an element to recompute its layout. This is called when something that affects the layout
-    //! has been modified. (ex. layout element size changed, layout element property changed, layout
-    //! element child count changed.)
-    virtual void MarkToRecomputeLayout(AZ::EntityId entityId) = 0;
-
-    //! Mark the specified element's parent to recompute its layout. The parent uses its child's layout
-    //! cell values to calculate its layout, so this is called when something that affects the
-    //! child's layout cell values has been modified. (ex. child's layout cell property changed.)
-    //! Since a child's layout cell values may affect its parent's layout cell values, the top level parent
-    //! is marked
-    virtual void MarkToRecomputeLayoutsAffectedByLayoutCellChange(AZ::EntityId entityId, bool isDefaultLayoutCell) = 0;
-
-    //! Unmark all elements from needing to recompute their layouts
-    virtual void UnmarkAllLayouts() = 0;
-
-    //! Recompute layouts of marked elements and clear the marked layout list
-    virtual void RecomputeMarkedLayouts() = 0;
-
-    //! Compute the layout for the specified element and its descendants
-    virtual void ComputeLayoutForElementAndDescendants(AZ::EntityId entityId) = 0;
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutManagerInterface> UiLayoutManagerBus;

Code/Legacy/CryCommon/LyShine/Bus/UiLayoutRowBus.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/Bus/UiLayoutBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiLayoutRowInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiLayoutRowInterface() {}
-
-    //! Get the padding (in pixels) inside the edges of the element
-    virtual UiLayoutInterface::Padding GetPadding() = 0;
-
-    //! Set the padding (in pixels) inside the edges of the element
-    virtual void SetPadding(UiLayoutInterface::Padding padding) = 0;
-
-    //! Get the spacing (in pixels) between child elements
-    virtual float GetSpacing() = 0;
-
-    //! Set the spacing (in pixels) between child elements
-    virtual void SetSpacing(float spacing) = 0;
-
-    //! Get the horizontal order for this layout
-    virtual UiLayoutInterface::HorizontalOrder GetOrder() = 0;
-
-    //! Set the horizontal order for this layout
-    virtual void SetOrder(UiLayoutInterface::HorizontalOrder order) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiLayoutRowInterface> UiLayoutRowBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiMarkupButtonBus.h

@@ -1,71 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Color.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! A markup button allows for button-like behavior on markup text.
-//!
-//! The markup itself is contained within a text component. The markup button
-//! handles interaction with the text, and can also apply styling (such as
-//! coloring for button/clickable text).
-//!
-//! Markup button behavior is only intended for mouse interactions.
-class UiMarkupButtonInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiMarkupButtonInterface() {}
-
-    //! Get the link color
-    virtual AZ::Color GetLinkColor() = 0;
-
-    //! Set the link color
-    virtual void SetLinkColor(const AZ::Color& linkColor) = 0;
-
-    //! Get the link hover color
-    virtual AZ::Color GetLinkHoverColor() = 0;
-
-    //! Set the link hover color
-    virtual void SetLinkHoverColor(const AZ::Color& linkHoverColor) = 0;
-
-public: // static member data
-
-        //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiMarkupButtonInterface> UiMarkupButtonBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiMarkupButtonNotifications
-    : public AZ::ComponentBus
-{
-public:
-
-    //////////////////////////////////////////////////////////////////////////
-    // EBusTraits overrides
-    static const bool EnableEventQueue = true;
-    //////////////////////////////////////////////////////////////////////////
-
-public: // member functions
-
-    virtual ~UiMarkupButtonNotifications() {}
-
-    virtual void OnHoverStart(int id, const AZStd::string& action, const AZStd::string& data) = 0;
-    virtual void OnHoverEnd(int id, const AZStd::string& action, const AZStd::string& data) = 0;
-    virtual void OnPressed(int id, const AZStd::string& action, const AZStd::string& data) = 0;
-    virtual void OnReleased(int id, const AZStd::string& action, const AZStd::string& data) = 0;
-    virtual void OnClick(int id, const AZStd::string& action, const AZStd::string& data) = 0;
-};
-
-typedef AZ::EBus<UiMarkupButtonNotifications> UiMarkupButtonNotificationsBus;
-

Code/Legacy/CryCommon/LyShine/Bus/UiMaskBus.h

@@ -1,62 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiMaskInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiMaskInterface() {}
-
-    //! Get whether masking is enabled
-    virtual bool GetIsMaskingEnabled() = 0;
-
-    //! Set whether masking is enabled
-    virtual void SetIsMaskingEnabled(bool enableMasking) = 0;
-
-    //! Get whether interaction masking is enabled
-    virtual bool GetIsInteractionMaskingEnabled() = 0;
-
-    //! Set whether interaction masking is enabled
-    virtual void SetIsInteractionMaskingEnabled(bool enableInteractionMasking) = 0;
-
-    //! Get whether mask visual is drawn to color buffer behind child elements
-    virtual bool GetDrawBehind() = 0;
-
-    //! Set whether mask visual is drawn to color buffer behind child elements
-    virtual void SetDrawBehind(bool drawMaskVisualBehindChildren) = 0;
-
-    //! Get whether mask visual is drawn to color buffer in front of child elements
-    virtual bool GetDrawInFront() = 0;
-
-    //! Set whether mask visual is drawn to color buffer in front of child elements
-    virtual void SetDrawInFront(bool drawMaskVisualInFrontOfChildren) = 0;
-
-    //! Get whether to use alpha test when drawing mask visual to stencil
-    virtual bool GetUseAlphaTest() = 0;
-
-    //! Set whether to use alpha test when drawing mask visual to stencil
-    virtual void SetUseAlphaTest(bool useAlphaTest) = 0;
-
-    //! Get the flag that indicates whether the mask should use render to texture
-    virtual bool GetUseRenderToTexture() = 0;
-
-    //! Set the flag that indicates whether the mask should use render to texture
-    virtual void SetUseRenderToTexture(bool useRenderToTexture) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiMaskInterface> UiMaskBus;

Code/Legacy/CryCommon/LyShine/Bus/UiNavigationBus.h

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiNavigationInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    enum class NavigationMode
-    {
-        Automatic,
-        Custom,
-        None
-    };
-
-public: // member functions
-
-    virtual ~UiNavigationInterface() {}
-
-    //! Get the navigation mode
-    virtual NavigationMode GetNavigationMode() = 0;
-
-    //! Set the navigation mode
-    virtual void SetNavigationMode(NavigationMode navigationMode) = 0;
-
-    //! Get the entity to receive focus when up is pressed
-    virtual AZ::EntityId GetOnUpEntity() = 0;
-
-    //! Set the entity to receive focus when up is pressed
-    virtual void SetOnUpEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the entity to receive focus when down is pressed
-    virtual AZ::EntityId GetOnDownEntity() = 0;
-
-    //! Set the entity to receive focus when down is pressed
-    virtual void SetOnDownEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the entity to receive focus when left is pressed
-    virtual AZ::EntityId GetOnLeftEntity() = 0;
-
-    //! Set the entity to receive focus when left is pressed
-    virtual void SetOnLeftEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the entity to receive focus when right is pressed
-    virtual AZ::EntityId GetOnRightEntity() = 0;
-
-    //! Set the entity to receive focus when right is pressed
-    virtual void SetOnRightEntity(AZ::EntityId entityId) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiNavigationInterface> UiNavigationBus;
-
-
-

Code/Legacy/CryCommon/LyShine/Bus/UiParticleEmitterBus.h

@@ -1,393 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Color.h>
-#include <AzFramework/Entity/EntityContextBus.h>
-
-class ISprite;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Bus for making requests to the UiParticleEmitterComponent
-class UiParticleEmitterInterface
-    : public AZ::ComponentBus
-{
-public: // types
-
-    enum class EmitShape
-    {
-        Point,      //!< particles are emitted from the emitter position along the given angle
-        Circle,     //!< particles are emitted from a circle whose radius is the minimum of the element width and height
-        Quad        //!< particles are emitted from the quad with the same size as the element width and height
-    };
-
-    enum class ParticleCoordinateType
-    {
-        Cartesian,  //!< particles move using X,Y co-ordinates
-        Polar       //!< particles move using X: radial speed, Y: angular speed
-    };
-
-    enum class ParticleInitialDirectionType
-    {
-        RelativeToEmitAngle,    //!< particle initial direction is based on the emit angle
-        RelativeToEmitterCenter //!< particle initial direction is directed away from the emitter shape center
-    };
-
-    enum class ParticleKeyframeTangentType
-    {
-        EaseIn,     //!< A zero/flat tangent, a keyframe with ease in + ease out would act like an x^3 curve at the origin
-        EaseOut,    //!< A zero/flat tangent, a keyframe with ease in + ease out would act like an x^3 curve at the origin
-        Linear,     //!< The curve moves linearly from this keyframe towards the next/previous keyframe
-        Step        //!< The curve jumps from the current keyframe value to the next/previous keyframe value
-    };
-
-    struct ParticleFloatKeyframe
-    {
-        AZ_TYPE_INFO(ParticleFloatKeyframe, "{85DF04FE-F614-47C1-B88A-A9F7D4826F6F}");
-
-        float time = 0.0f;
-        float multiplier = 1.0f;
-        ParticleKeyframeTangentType inTangent = ParticleKeyframeTangentType::EaseIn;
-        ParticleKeyframeTangentType outTangent = ParticleKeyframeTangentType::EaseOut;
-    };
-
-    struct ParticleColorKeyframe
-    {
-        AZ_TYPE_INFO(ParticleColorKeyframe, "{22B0CBC0-21A5-44E3-90C5-9BFEF6E4E3C5}");
-
-        float time = 0.0f;
-        AZ::Color color = AZ::Color(1.0f, 1.0f, 1.0f, 1.0f);
-        ParticleKeyframeTangentType inTangent = ParticleKeyframeTangentType::EaseIn;
-        ParticleKeyframeTangentType outTangent = ParticleKeyframeTangentType::EaseOut;
-    };
-
-public: // member functions
-
-    virtual ~UiParticleEmitterInterface() {}
-
-    //! Gets whether the emitter is emitting particles
-    virtual bool GetIsEmitting() = 0;
-
-    //! Sets whether the emitter is emitting particles
-    virtual void SetIsEmitting(bool emitParticles) = 0;
-
-    //! Gets whether the emitter uses a fixed random seed
-    virtual bool GetIsRandomSeedFixed() = 0;
-
-    //! Sets whether the emitter uses a fixed random seed
-    virtual void SetIsRandomSeedFixed(bool randomSeedFixed) = 0;
-
-    //! Gets the emitter random seed
-    virtual int GetRandomSeed() = 0;
-
-    //! Sets the emitter random seed
-    virtual void SetRandomSeed(int randomSeed) = 0;
-
-    //! Gets whether the particles move relative to the emitter position
-    virtual bool GetIsParticlePositionRelativeToEmitter() = 0;
-
-    //! Sets whether the particles move relative to the emitter position
-    virtual void SetIsParticlePositionRelativeToEmitter(bool relativeToEmitter) = 0;
-
-    //! Gets the amount of particles emitted per second
-    virtual float GetParticleEmitRate() = 0;
-
-    //! Sets the amount of particles emitted per second
-    virtual void SetParticleEmitRate(float particleEmitRate) = 0;
-
-    //! Gets whether the emitter starts emitting on activate
-    virtual bool GetIsEmitOnActivate() = 0;
-
-    //! Sets whether the emitter starts emitting on activate
-    virtual void SetIsEmitOnActivate(bool emitOnActivate) = 0;
-
-    //! Gets whether the average particle count is reached as soon as the emitter starts emitting
-    virtual bool GetIsHitParticleCountOnActivate() = 0;
-
-    //! Sets whether the average particle count is reached as soon as the emitter starts emitting
-    virtual void SetIsHitParticleCountOnActivate(bool hitParticleCountOnActivate) = 0;
-
-    //! Gets whether the emitter lifetime is infinite
-    virtual bool GetIsEmitterLifetimeInfinite() = 0;
-
-    //! Sets whether the emitter lifetime is infinite
-    virtual void SetIsEmitterLifetimeInfinite(bool emitterLifetimeInfinite) = 0;
-
-    //! Gets the lifetime of the emitter (in seconds)
-    virtual float GetEmitterLifetime() = 0;
-
-    //! Sets the lifetime of the emitter (in seconds)
-    virtual void SetEmitterLifetime(float emitterLifetime) = 0;
-
-    //! Gets whether there is a cap on the amount of active particles
-    virtual bool GetIsParticleCountLimited() = 0;
-
-    //! Sets whether there is a cap on the amount of active particles
-    virtual void SetIsParticleCountLimited(bool particleCountLimited) = 0;
-
-    //! Gets the maximum amount of active particles
-    virtual AZ::u32 GetMaxParticles() = 0;
-
-    //! Sets the maximum amount of active particles
-    virtual void SetMaxParticles(AZ::u32 maxParticles) = 0;
-
-    //! Gets the shape of the emitter
-    virtual EmitShape GetEmitterShape() = 0;
-
-    //! Sets the shape of the emitter
-    virtual void SetEmitterShape(EmitShape emitterShape) = 0;
-
-    //! Gets whether the particles are emitted on the edge of the emitter shape
-    virtual bool GetIsEmitOnEdge() = 0;
-
-    //! Sets whether the particles are emitted on the edge of the emitter shape
-    virtual void SetIsEmitOnEdge(bool emitOnEdge) = 0;
-
-    //! Gets the inside distance from the emitter shape edge that particles should emit from
-    virtual float GetInsideEmitDistance() = 0;
-
-    //! Sets the inside distance from the emitter shape edge that particles should emit from
-    virtual void SetInsideEmitDistance(float insideEmitDistance) = 0;
-
-    //! Gets the outside distance from the emitter shape edge that particles should emit from
-    virtual float GetOutsideEmitDistance() = 0;
-
-    //! Sets the outside distance from the emitter shape edge that particles should emit from
-    virtual void SetOutsideEmitDistance(float outsideEmitDistance) = 0;
-
-    //! Gets how the initial direction is calculated for Cartesian movement.
-    virtual ParticleInitialDirectionType GetParticleInitialDirectionType() = 0;
-
-    //! Sets how the initial direction is calculated for Cartesian movement.
-    virtual void SetParticleInitialDirectionType(ParticleInitialDirectionType initialDirectionType) = 0;
-
-    //! Gets the angle that particles are emitted from (in degrees clockwise measured from straight up)
-    virtual float GetEmitAngle() = 0;
-
-    //! Sets the angle that particles are emitted from (in degrees clockwise measured from straight up)
-    virtual void SetEmitAngle(float emitAngle) = 0;
-
-    //! Gets the variation in the angle that particles are emitted from (in degrees, with 10 degrees variation being +/- 10 degrees about the emit angle)
-    virtual float GetEmitAngleVariation() = 0;
-
-    //! Sets the variation in the angle that particles are emitted from (in degrees, with 10 degrees variation being +/- 10 degrees about the emit angle)
-    virtual void SetEmitAngleVariation(float emitAngleVariation) = 0;
-
-    //! Gets whether the particle lifetime is infinite
-    virtual bool GetIsParticleLifetimeInfinite() = 0;
-
-    //! Sets whether the particle lifetime is infinite
-    virtual void SetIsParticleLifetimeInfinite(bool infiniteLifetime) = 0;
-
-    //! Gets the particle life time (in seconds)
-    virtual float GetParticleLifetime() = 0;
-
-    //! Sets the particle life time (in seconds)
-    virtual void SetParticleLifetime(float lifetime) = 0;
-
-    //! Gets the particle life time variation (in seconds, 1 second variation being up to +/- 1 second about the lifetime)
-    virtual float GetParticleLifetimeVariation() = 0;
-
-    //! Sets the particle life time variation (in seconds, 1 second variation being up to +/- 1 second about the lifetime)
-    virtual void SetParticleLifetimeVariation(float lifetimeVariation) = 0;
-
-    //! Gets the sprite to be used by the particles
-    virtual ISprite* GetSprite() = 0;
-
-    //! Sets the sprite to be used by the particles
-    virtual void SetSprite(ISprite* sprite) = 0;
-
-    //! Gets the source location of the image to be displayed by the particles
-    virtual AZStd::string GetSpritePathname() = 0;
-
-    //! Sets the source location of the image to be displayed by the particles
-    virtual void SetSpritePathname(AZStd::string spritePath) = 0;
-
-    //! Gets whether the sprite-sheet cell index changes over time
-    virtual bool GetIsSpriteSheetAnimated() = 0;
-
-    //! Sets whether the sprite-sheet cell index changes over time
-    virtual void SetIsSpriteSheetAnimated(bool isSpriteSheetAnimated) = 0;
-
-    //! Gets whether the sprite-sheet cell animation is looped
-    virtual bool GetIsSpriteSheetAnimationLooped() = 0;
-
-    //! Sets whether the sprite-sheet cell animation is looped
-    virtual void SetIsSpriteSheetAnimationLooped(bool isSpriteSheetAnimationLooped) = 0;
-
-    //! Gets whether the sprite-sheet cell (starting) index is random
-    virtual bool GetIsSpriteSheetIndexRandom() = 0;
-
-    //! Sets whether the sprite-sheet cell (starting) index is random
-    virtual void SetIsSpriteSheetIndexRandom(bool isSpriteSheetIndexRandom) = 0;
-
-    //! Gets the sprite-sheet cell (starting) index
-    virtual int GetSpriteSheetCellIndex() = 0;
-
-    //! Sets the sprite-sheet cell (starting) index
-    virtual void SetSpriteSheetCellIndex(int spriteSheetIndex) = 0;
-
-    //! Gets the sprite-sheet cell end index
-    virtual int GetSpriteSheetCellEndIndex() = 0;
-
-    //! Sets the sprite-sheet cell end index
-    virtual void SetSpriteSheetCellEndIndex(int spriteSheetEndIndex) = 0;
-
-    //! Gets the sprite-sheet cell frame delay (in seconds)
-    virtual float GetSpriteSheetFrameDelay() = 0;
-
-    //! Sets the sprite-sheet cell frame delay (in seconds)
-    virtual void SetSpriteSheetFrameDelay(float spriteSheetFrameDelay) = 0;
-
-    //! Gets whether the aspect ratio of the particles is locked
-    virtual bool GetIsParticleAspectRatioLocked() = 0;
-
-    //! Sets whether the aspect ratio of the particles is locked
-    virtual void SetIsParticleAspectRatioLocked(bool aspectRatioLocked) = 0;
-
-    //! Gets the particle pivot (where 0,0 is the top left of the particle and 1,1 is the bottom right of the particle)
-    virtual AZ::Vector2 GetParticlePivot() = 0;
-
-    //! Sets the particle pivot (where 0,0 is the top left of the particle and 1,1 is the bottom right of the particle)
-    virtual void SetParticlePivot(AZ::Vector2 particlePivot) = 0;
-
-    //! Gets the particle size
-    virtual AZ::Vector2 GetParticleSize() = 0;
-
-    //! Sets the particle size
-    virtual void SetParticleSize(AZ::Vector2 particleSize) = 0;
-
-    //! Gets the particle width
-    virtual float GetParticleWidth() = 0;
-
-    //! Sets the particle width
-    virtual void SetParticleWidth(float width) = 0;
-
-    //! Gets the particle width variation (a variation of 1 being up to 1 either side of the given width)
-    virtual float GetParticleWidthVariation() = 0;
-
-    //! Sets the particle width variation (a variation of 1 being up to 1 either side of the given width)
-    virtual void SetParticleWidthVariation(float widthVariation) = 0;
-
-    //! Gets the particle height
-    virtual float GetParticleHeight() = 0;
-
-    //! Sets the particle height
-    virtual void SetParticleHeight(float height) = 0;
-
-    //! Gets the particle height variation (a variation of 5 being up to 5 either side of the given height)
-    virtual float GetParticleHeightVariation() = 0;
-
-    //! Sets the particle height variation (a variation of 5 being up to 5 either side of the given height)
-    virtual void SetParticleHeightVariation(float heightVariation) = 0;
-
-    //! Gets the particle movement co-ordinate type
-    virtual ParticleCoordinateType GetParticleMovementCoordinateType() = 0;
-
-    //! Sets the particle movement co-ordinate type
-    virtual void SetParticleMovementCoordinateType(ParticleCoordinateType particleMovementCoordinateType) = 0;
-
-    //! Gets the particle acceleration co-ordinate type
-    virtual ParticleCoordinateType GetParticleAccelerationCoordinateType() = 0;
-
-    //! Sets the particle acceleration co-ordinate type
-    virtual void SetParticleAccelerationCoordinateType(ParticleCoordinateType particleAccelerationCoordinateType) = 0;
-
-    //! Gets the particle initial velocity for Polar movement
-    virtual AZ::Vector2 GetParticleInitialVelocity() = 0;
-
-    //! Sets the particle initial velocity for Polar movement
-    virtual void SetParticleInitialVelocity(AZ::Vector2 initialVelocity) = 0;
-
-    //! Gets the particle initial velocity variation for Polar movement (a variation of (1,2) being up to (1,2) either side of the initial velocity)
-    virtual AZ::Vector2 GetParticleInitialVelocityVariation() = 0;
-
-    //! Sets the particle initial velocity variation for Polar movement (a variation of (1,2) being up to (1,2) either side of the initial velocity)
-    virtual void SetParticleInitialVelocityVariation(AZ::Vector2 initialVelocityVariation) = 0;
-
-    //! Gets the particle speed for particles with a random initial direction for Cartesian movement
-    virtual float GetParticleSpeed() = 0;
-
-    //! Sets the particle speed for particles with a random initial direction for Cartesian movement
-    virtual void SetParticleSpeed(float speed) = 0;
-
-    //! Gets the particle speed variation for particles with a random initial direction for Cartesian movement (a variation of 1 being up to 1 either side of the given speed)
-    virtual float GetParticleSpeedVariation() = 0;
-
-    //! Sets the particle speed variation for particles with a random initial direction for Cartesian movement (a variation of 1 being up to 1 either side of the given speed)
-    virtual void SetParticleSpeedVariation(float speedVariation) = 0;
-
-    //! Gets the particle acceleration
-    virtual AZ::Vector2 GetParticleAcceleration() = 0;
-
-    //! Sets the particle acceleration
-    virtual void SetParticleAcceleration(AZ::Vector2 acceleration) = 0;
-
-    //! Gets whether the particle rotation is based on the current velocity
-    virtual bool GetIsParticleRotationFromVelocity() = 0;
-
-    //! Sets whether the particle rotation is based on the current velocity
-    virtual void SetIsParticleRotationFromVelocity(bool rotationFromVelocity) = 0;
-
-    //! Gets whether the particle initial rotation is based on the initial velocity
-    virtual bool GetIsParticleInitialRotationFromInitialVelocity() = 0;
-
-    //! Sets whether the particle initial rotation is based on the initial velocity
-    virtual void SetIsParticleInitialRotationFromInitialVelocity(bool rotationFromVelocity) = 0;
-
-    //! Gets the particle initial rotation (in degrees)
-    virtual float GetParticleInitialRotation() = 0;
-
-    //! Sets the particle initial rotation (in degrees)
-    virtual void SetParticleInitialRotation(float initialRotation) = 0;
-
-    //! Gets the particle initial rotation variation (in degrees, a variation of 10 being up to 10 degrees either side of the initial rotation)
-    virtual float GetParticleInitialRotationVariation() = 0;
-
-    //! Sets the particle initial rotation variation (in degrees, a variation of 10 being up to 10 degrees either side of the initial rotation)
-    virtual void SetParticleInitialRotationVariation(float initialRotationVariation) = 0;
-
-    //! Gets the particle rotation speed (in degrees per second)
-    virtual float GetParticleRotationSpeed() = 0;
-
-    //! Sets the particle rotation speed (in degrees per second)
-    virtual void SetParticleRotationSpeed(float rotationSpeed) = 0;
-
-    //! Gets the particle rotation speed variation (in degrees, a variation of 5 being up to 5 either side of the rotation speed)
-    virtual float GetParticleRotationSpeedVariation() = 0;
-
-    //! Sets the particle rotation speed variation (in degrees, a variation of 5 being up to 5 either side of the rotation speed)
-    virtual void SetParticleRotationSpeedVariation(float rotationSpeedVariation) = 0;
-
-    //! Gets the particle color tint
-    virtual AZ::Color GetParticleColor() = 0;
-
-    //! Sets the particle color tint
-    virtual void SetParticleColor(AZ::Color color) = 0;
-
-    //! Gets the particle color brightness variation (from 0-1, 0 being no variation, 1 being random variation from the original color down to black)
-    virtual float GetParticleColorBrightnessVariation() = 0;
-
-    //! Sets the particle color brightness variation (from 0-1, 0 being no variation, 1 being random variation from the original color down to black)
-    virtual void SetParticleColorBrightnessVariation(float brightnessVariation) = 0;
-
-    //! Gets the particle color tint variation
-    virtual float GetParticleColorTintVariation() = 0;
-
-    //! Sets the particle color tint variation
-    virtual void SetParticleColorTintVariation(float tintVariation) = 0;
-
-    //! Gets the particle alpha
-    virtual float GetParticleAlpha() = 0;
-
-    //! Sets the particle alpha
-    virtual void SetParticleAlpha(float alpha) = 0;
-};
-
-using UiParticleEmitterBus = AZ::EBus<UiParticleEmitterInterface>;

Code/Legacy/CryCommon/LyShine/Bus/UiRadioButtonBus.h

@@ -1,82 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that a radio button component needs to implement. A radio button component
-//! provides functionality for a button that can be turned on or off and is dependent on the other
-//! radio buttons in the same radio button group. This interface is designed to be used in
-//! conjunction with the UiRadioButtonGroupInterface, which describes the group for radio buttons.
-class UiRadioButtonInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRadioButtonInterface() {}
-
-    //! Query the state of the radio button
-    //! \return     The current state for the radio button.
-    virtual bool GetState() = 0;
-
-    //! Get the radio button group
-    virtual AZ::EntityId GetGroup() = 0;
-
-    //! Get the optional checked (ON) entity
-    virtual AZ::EntityId GetCheckedEntity() = 0;
-
-    //! Set the optional checked (ON) entity
-    virtual void SetCheckedEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the optional unchecked (OFF) entity
-    virtual AZ::EntityId GetUncheckedEntity() = 0;
-
-    //! Set the optional unchecked (OFF) entity
-    virtual void SetUncheckedEntity(AZ::EntityId entityId) = 0;
-
-    //! Get the action triggered when turned on
-    virtual const LyShine::ActionName& GetTurnOnActionName() = 0;
-
-    //! Set the action triggered when turned on
-    virtual void SetTurnOnActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the action triggered when turned off
-    virtual const LyShine::ActionName& GetTurnOffActionName() = 0;
-
-    //! Set the action triggered when turned off
-    virtual void SetTurnOffActionName(const LyShine::ActionName& actionName) = 0;
-
-    //! Get the action triggered when changed
-    virtual const LyShine::ActionName& GetChangedActionName() = 0;
-
-    //! Set the action triggered when changed
-    virtual void SetChangedActionName(const LyShine::ActionName& actionName) = 0;
-
-public: // static member data
-
-        //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiRadioButtonInterface> UiRadioButtonBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiRadioButtonNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRadioButtonNotifications() {}
-
-    //! Notify listeners that the radio button state has changed
-    virtual void OnRadioButtonStateChange([[maybe_unused]] bool checked) {}
-};
-
-typedef AZ::EBus<UiRadioButtonNotifications> UiRadioButtonNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiRadioButtonCommunicationBus.h

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that a radio button component needs to implement. This interface allows the
-//! radio button group to communicate with the radio button itself
-class UiRadioButtonCommunicationInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRadioButtonCommunicationInterface() {}
-
-    //! Used by the group to set the state of the radio button
-    //! \param     The new desired state of the radio button.
-    //! \param     Whether the button should inform listeners that it was changed.
-    virtual void SetState(bool isOn, bool sendNotifications) = 0;
-
-    //! Set the radio button group
-    virtual void SetGroup(AZ::EntityId group) = 0;
-
-public: // static member data
-
-    //! Only one component on an entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiRadioButtonCommunicationInterface> UiRadioButtonCommunicationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiRadioButtonGroupBus.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <AzCore/Math/Vector2.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that a radio button group component needs to implement. A radio button group
-//! component provides functionality to manage a group of radio buttons. A group of radio buttons
-//! allows users to choose one of a predefined set of mutually exclusive options. No more than one
-//! item may be selected.
-class UiRadioButtonGroupInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRadioButtonGroupInterface() {}
-
-    //! Query the state of the radio button group
-    //! \return     The currently checked radio button.
-    virtual AZ::EntityId GetCheckedRadioButton() = 0;
-
-    //! Set a radio button to a desired state
-    virtual void SetState(AZ::EntityId radioButton, bool isOn) = 0;
-
-    //! Get the allow uncheck flag
-    virtual bool GetAllowUncheck() = 0;
-
-    //! Set the allow uncheck flag
-    virtual void SetAllowUncheck(bool allowUncheck) = 0;
-
-    //! Add a new radio button to the group
-    virtual void AddRadioButton(AZ::EntityId radioButton) = 0;
-
-    //! Remove a radio button from the group
-    virtual void RemoveRadioButton(AZ::EntityId radioButton) = 0;
-
-    //! Query whether a radio button is in the group or not
-    virtual bool ContainsRadioButton(AZ::EntityId radioButton) = 0;
-
-    //! Get the action triggered when changed
-    virtual const LyShine::ActionName& GetChangedActionName() = 0;
-
-    //! Set the action triggered when changed
-    virtual void SetChangedActionName(const LyShine::ActionName& actionName) = 0;
-
-public: // static member data
-
-        //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiRadioButtonGroupInterface> UiRadioButtonGroupBus;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiRadioButtonGroupNotifications
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRadioButtonGroupNotifications() {}
-
-    //! Notify listeners that the radio button group state has changed
-    virtual void OnRadioButtonGroupStateChange([[maybe_unused]] AZ::EntityId checkedRadioButton) {}
-};
-
-typedef AZ::EBus<UiRadioButtonGroupNotifications> UiRadioButtonGroupNotificationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiRadioButtonGroupCommunicationBus.h

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! Interface class that a radio button group component needs to implement. This interface allows
-//! a radio button to communicate with the radio button group itself
-class UiRadioButtonGroupCommunicationInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRadioButtonGroupCommunicationInterface() {}
-
-    //! Registers a radio button within a group
-    //! \param      The radio button to add
-    //! \return     Whether the radio button was successfully added to the group or not
-    virtual bool RegisterRadioButton(AZ::EntityId radioButton) = 0;
-
-    //! Unregisters a radio button within a group
-    //! \param      The radio button to remove
-    virtual void UnregisterRadioButton(AZ::EntityId radioButton) = 0;
-
-    //! Called when a radio button wants to change state due to user action (i.e. by clicking it)
-    //! \param      The radio button to change the state of
-    //! \param      The new radio button state
-    virtual void RequestRadioButtonStateChange(AZ::EntityId radioButton, bool newState) = 0;
-
-public: // static member data
-
-    //! Only one component on an entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiRadioButtonGroupCommunicationInterface> UiRadioButtonGroupCommunicationBus;

Code/Legacy/CryCommon/LyShine/Bus/UiRenderBus.h

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-namespace LyShine
-{
-    class IRenderGraph;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiRenderInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRenderInterface() {}
-
-    //! Render the component into the render graph
-    virtual void Render(LyShine::IRenderGraph* renderGraph) = 0;
-
-public: // static member data
-
-    //! Multiple components on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-};
-
-typedef AZ::EBus<UiRenderInterface> UiRenderBus;

Code/Legacy/CryCommon/LyShine/Bus/UiRenderControlBus.h

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-
-namespace LyShine
-{
-    class IRenderGraph;
-}
-
-class UiElementInterface;
-class UiRenderInterface;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//! The UiRenderControlBus is used for controlling the rendering of elements that affect the rendering
-//! of their children.
-//! An example use is a mask component that needs to setup stencil write before rendering its
-//! components to increment the stencil buffer, switch to stencil test before rendering the child
-//! elements and then do a second pass to decrement the stencil buffer.
-//! The interface is designed to be flexible and could also be used for setting up scissoring or
-//! rendering to a texture.
-class UiRenderControlInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiRenderControlInterface() {}
-
-    //! This renders this element plus its children. It allows the RenderControl element to control
-    //! the order in which the element's component and children are rendered and to change state
-    //! at any point while rendering them.
-    //! \param renderGraph, the render graph being added to
-    //! \param elementInterface, pointer to the element interface for this element (for performance)
-    //! \param renderInterface, pointer to the render interface for this element (for performance)
-    //! \param numChildren, the number of child elements of this element
-    //! \param isInGame, true if element being rendered in game (or preview), false if being render in edit mode
-    virtual void Render(
-        LyShine::IRenderGraph* renderGraph,
-        UiElementInterface* elementInterface,
-        UiRenderInterface* renderInterface,
-        int numChildren,
-        bool isInGame) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiRenderControlInterface> UiRenderControlBus;

Code/Legacy/CryCommon/LyShine/Bus/UiScrollBarBus.h

@@ -1,63 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/ComponentBus.h>
-#include <LyShine/UiBase.h>
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-class UiScrollBarInterface
-    : public AZ::ComponentBus
-{
-public: // member functions
-
-    virtual ~UiScrollBarInterface() {}
-
-    //! Get the size of the handle relative to the scrollbar (0 - 1)
-    virtual float GetHandleSize() = 0;
-
-    //! Set the size of the handle relative to the scrollbar (0 - 1)
-    virtual void SetHandleSize(float size) = 0;
-
-    //! Get the minimum size of the handle in pixels
-    virtual float GetMinHandlePixelSize() = 0;
-
-    //! Set the minimum size of the handle in pixels
-    virtual void SetMinHandlePixelSize(float size) = 0;
-
-    //! Get the handle entity
-    virtual AZ::EntityId GetHandleEntity() = 0;
-
-    //! Set the handle entity
-    virtual void SetHandleEntity(AZ::EntityId entityId) = 0;
-
-    //! Get auto fade
-    virtual bool IsAutoFadeEnabled() = 0;
-
-    //! Set auto fade
-    virtual void SetAutoFadeEnabled(bool isAutoFadeEnabled) = 0;
-
-    //! Get the delay in seconds before the scrollbar will fade if unused
-    virtual float GetAutoFadeDelay() = 0;
-
-    //! Set the fade delay in seconds
-    virtual void SetAutoFadeDelay(float delay) = 0;
-
-    //! Get the speed in seconds that it will take for the scrollbar to fade to transparent
-    virtual float GetAutoFadeSpeed() = 0;
-
-    //! Set the fade speed in seconds
-    virtual void SetAutoFadeSpeed(float speed) = 0;
-
-public: // static member data
-
-    //! Only one component on a entity can implement the events
-    static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-};
-
-typedef AZ::EBus<UiScrollBarInterface> UiScrollBarBus;