Formatting-only change - Update Manipulator and Viewport AzToolsFramework files (#1143)

* formatting changes to AzToolsFramework viewport related types + API comment style updates

* minor format change - include ordering

* improve formatting by moving comment

* fix compile error and switch to use AZ_Printf

* small polish changes after review feedback

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/AngularManipulator.cpp

@@ -1,28 +1,32 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "AngularManipulator.h"
 
 #include <AzFramework/Entity/EntityDebugDisplayBus.h>
-#include <AzToolsFramework/Manipulators/ManipulatorView.h>
 #include <AzToolsFramework/Manipulators/ManipulatorSnapping.h>
+#include <AzToolsFramework/Manipulators/ManipulatorView.h>
 
 namespace AzToolsFramework
 {
-    static const float s_circularRotateThresholdDegrees = 80.0f;
+    static const float CircularRotateThresholdDegrees = 80.0f;
 
     AngularManipulator::ActionInternal AngularManipulator::CalculateManipulationDataStart(
-        const Fixed& fixed, const AZ::Transform& worldFromLocal, const AZ::Transform& localTransform,
-        const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection, const float rayDistance)
+        const Fixed& fixed,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Transform& localTransform,
+        const AZ::Vector3& rayOrigin,
+        const AZ::Vector3& rayDirection,
+        const float rayDistance)
     {
         const AZ::Transform worldFromLocalWithTransform = worldFromLocal * localTransform;
         const AZ::Vector3 worldAxis = TransformDirectionNoScaling(worldFromLocalWithTransform, fixed.m_axis);
@@ -35,7 +39,7 @@ namespace AzToolsFramework
         // if angular manipulator axis is at right angles to us, use initial ray direction
         // as plane normal and use hit position on manipulator as plane point
         const float pickAngle = AZ::RadToDeg(AZ::Acos(AZ::Abs(rayDirection.Dot(worldAxis))));
-        if (pickAngle > s_circularRotateThresholdDegrees)
+        if (pickAngle > CircularRotateThresholdDegrees)
         {
             actionInternal.m_start.m_planeNormal = -rayDirection;
             actionInternal.m_start.m_planePoint = rayOrigin + rayDirection * rayDistance;
@@ -43,8 +47,8 @@ namespace AzToolsFramework
 
         // store initial world hit position
         Internal::CalculateRayPlaneIntersectingPoint(
-            rayOrigin, rayDirection, actionInternal.m_start.m_planePoint,
-            actionInternal.m_start.m_planeNormal, actionInternal.m_current.m_worldHitPosition);
+            rayOrigin, rayDirection, actionInternal.m_start.m_planePoint, actionInternal.m_start.m_planeNormal,
+            actionInternal.m_current.m_worldHitPosition);
 
         // store entity transform (to go from local to world space)
         // and store our own starting local transform
@@ -56,31 +60,33 @@ namespace AzToolsFramework
     }
 
     AngularManipulator::Action AngularManipulator::CalculateManipulationDataAction(
-        const Fixed& fixed, ActionInternal& actionInternal, const AZ::Transform& worldFromLocal,
-        const AZ::Transform& localTransform, const bool snapping, const float angleStepDegrees,
-        const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection,
+        const Fixed& fixed,
+        ActionInternal& actionInternal,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Transform& localTransform,
+        const bool snapping,
+        const float angleStepDegrees,
+        const AZ::Vector3& rayOrigin,
+        const AZ::Vector3& rayDirection,
         const ViewportInteraction::KeyboardModifiers keyboardModifiers)
     {
         const AZ::Transform worldFromLocalWithTransform = worldFromLocal * localTransform;
         const AZ::Vector3 worldAxis = TransformDirectionNoScaling(worldFromLocalWithTransform, fixed.m_axis);
 
         AZ::Vector3 worldHitPosition = AZ::Vector3::CreateZero();
-        Internal::CalculateRayPlaneIntersectingPoint(rayOrigin, rayDirection,
-            actionInternal.m_start.m_planePoint, actionInternal.m_start.m_planeNormal,
-            worldHitPosition);
+        Internal::CalculateRayPlaneIntersectingPoint(
+            rayOrigin, rayDirection, actionInternal.m_start.m_planePoint, actionInternal.m_start.m_planeNormal, worldHitPosition);
 
         // get vector from center of rotation for current and previous frame
         const AZ::Vector3 center = worldFromLocalWithTransform.GetTranslation();
         const AZ::Vector3 currentWorldHitVector = (worldHitPosition - center).GetNormalizedSafe();
-        const AZ::Vector3 previousWorldHitVector =
-            (actionInternal.m_current.m_worldHitPosition - center).GetNormalizedSafe();
+        const AZ::Vector3 previousWorldHitVector = (actionInternal.m_current.m_worldHitPosition - center).GetNormalizedSafe();
 
         // calculate which direction we rotated
         const AZ::Vector3 worldAxisRight = worldAxis.Cross(previousWorldHitVector);
         const float rotateSign = Sign(currentWorldHitVector.Dot(worldAxisRight));
         // how far did we rotate this frame
-        const float rotationAngleRad = AZ::Acos(AZ::GetMin<float>(
-            1.0f, currentWorldHitVector.Dot(previousWorldHitVector)));
+        const float rotationAngleRad = AZ::Acos(AZ::GetMin<float>(1.0f, currentWorldHitVector.Dot(previousWorldHitVector)));
         actionInternal.m_current.m_worldHitPosition = worldHitPosition;
 
         // if we're snapping, only increment current radians when we know
@@ -148,16 +154,13 @@ namespace AzToolsFramework
         // calculate initial state when mouse press first happens
         m_actionInternal = CalculateManipulationDataStart(
             m_fixed, TransformNormalizedScale(GetSpace()), TransformNormalizedScale(GetLocalTransform()),
-            interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection,
-            rayIntersectionDistance);
+            interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection, rayIntersectionDistance);
 
         if (m_onLeftMouseDownCallback)
         {
             m_onLeftMouseDownCallback(CalculateManipulationDataAction(
-                m_fixed, m_actionInternal, m_actionInternal.m_start.m_worldFromLocal,
-                m_actionInternal.m_start.m_localTransform, snapping, angleStep,
-                interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection,
-                interaction.m_keyboardModifiers));
+                m_fixed, m_actionInternal, m_actionInternal.m_start.m_worldFromLocal, m_actionInternal.m_start.m_localTransform, snapping,
+                angleStep, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection, interaction.m_keyboardModifiers));
         }
     }
 
@@ -167,12 +170,9 @@ namespace AzToolsFramework
         {
             // calculate delta rotation
             m_onMouseMoveCallback(CalculateManipulationDataAction(
-                m_fixed, m_actionInternal, m_actionInternal.m_start.m_worldFromLocal,
-                m_actionInternal.m_start.m_localTransform,
-                AngleSnapping(interaction.m_interactionId.m_viewportId),
-                AngleStep(interaction.m_interactionId.m_viewportId),
-                interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection,
-                interaction.m_keyboardModifiers));
+                m_fixed, m_actionInternal, m_actionInternal.m_start.m_worldFromLocal, m_actionInternal.m_start.m_localTransform,
+                AngleSnapping(interaction.m_interactionId.m_viewportId), AngleStep(interaction.m_interactionId.m_viewportId),
+                interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection, interaction.m_keyboardModifiers));
         }
     }
 
@@ -181,12 +181,9 @@ namespace AzToolsFramework
         if (m_onLeftMouseUpCallback)
         {
             m_onLeftMouseUpCallback(CalculateManipulationDataAction(
-                m_fixed, m_actionInternal, m_actionInternal.m_start.m_worldFromLocal,
-                m_actionInternal.m_start.m_localTransform,
-                AngleSnapping(interaction.m_interactionId.m_viewportId),
-                AngleStep(interaction.m_interactionId.m_viewportId),
-                interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection,
-                interaction.m_keyboardModifiers));
+                m_fixed, m_actionInternal, m_actionInternal.m_start.m_worldFromLocal, m_actionInternal.m_start.m_localTransform,
+                AngleSnapping(interaction.m_interactionId.m_viewportId), AngleStep(interaction.m_interactionId.m_viewportId),
+                interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection, interaction.m_keyboardModifiers));
         }
     }
 
@@ -197,12 +194,9 @@ namespace AzToolsFramework
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
         m_manipulatorView->Draw(
-            GetManipulatorManagerId(), managerState,
-            GetManipulatorId(), {
-                ApplySpace(GetLocalTransform()), GetNonUniformScale(),
-                AZ::Vector3::CreateZero(), MouseOver()
-            },
-            debugDisplay, cameraState, mouseInteraction);
+            GetManipulatorManagerId(), managerState, GetManipulatorId(),
+            { ApplySpace(GetLocalTransform()), GetNonUniformScale(), AZ::Vector3::CreateZero(), MouseOver() }, debugDisplay, cameraState,
+            mouseInteraction);
     }
 
     void AngularManipulator::SetAxis(const AZ::Vector3& axis)

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/AngularManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -22,14 +22,14 @@ namespace AzToolsFramework
 {
     class ManipulatorView;
 
-    /// AngularManipulator serves as a visual tool for users to change a component's property based on rotation
-    /// around an axis. The rotation angle increases if the rotation goes counter clock-wise when looking
-    /// in the opposite direction the rotation axis points to.
+    //! AngularManipulator serves as a visual tool for users to change a component's property based on rotation
+    //! around an axis. The rotation angle increases if the rotation goes counter clock-wise when looking
+    //! in the opposite direction the rotation axis points to.
     class AngularManipulator
         : public BaseManipulator
         , public ManipulatorSpaceWithLocalTransform
     {
-        /// Private constructor.
+        //! Private constructor.
         explicit AngularManipulator(const AZ::Transform& worldFromLocal);
 
     public:
@@ -42,33 +42,36 @@ namespace AzToolsFramework
 
         ~AngularManipulator() = default;
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
+        //! A Manipulator must only be created and managed through a shared_ptr.
         static AZStd::shared_ptr<AngularManipulator> MakeShared(const AZ::Transform& worldFromLocal);
 
-        /// The state of the manipulator at the start of an interaction.
+        //! The state of the manipulator at the start of an interaction.
         struct Start
         {
-            AZ::Quaternion m_space; ///< Starting orientation space of manipulator.
-            AZ::Quaternion m_rotation; ///< Starting local rotation of the manipulator.
+            AZ::Quaternion m_space; //!< Starting orientation space of manipulator.
+            AZ::Quaternion m_rotation; //!< Starting local rotation of the manipulator.
         };
 
-        /// The state of the manipulator during an interaction.
+        //! The state of the manipulator during an interaction.
         struct Current
         {
-            AZ::Quaternion m_delta; ///< Amount of rotation to apply to manipulator during action.
+            AZ::Quaternion m_delta; //!< Amount of rotation to apply to manipulator during action.
         };
 
-        /// Mouse action data used by MouseActionCallback (wraps Start and Current manipulator state).
+        //! Mouse action data used by MouseActionCallback (wraps Start and Current manipulator state).
         struct Action
         {
             Start m_start;
             Current m_current;
             ViewportInteraction::KeyboardModifiers m_modifiers;
-            AZ::Quaternion LocalOrientation() const { return m_start.m_rotation * m_current.m_delta; }
+            AZ::Quaternion LocalOrientation() const
+            {
+                return m_start.m_rotation * m_current.m_delta;
+            }
         };
 
-        /// This is the function signature of callbacks that will be invoked whenever a manipulator
-        /// is clicked on or dragged.
+        //! This is the function signature of callbacks that will be invoked whenever a manipulator
+        //! is clicked on or dragged.
         using MouseActionCallback = AZStd::function<void(const Action&)>;
 
         void InstallLeftMouseDownCallback(const MouseActionCallback& onMouseDownCallback);
@@ -82,46 +85,49 @@ namespace AzToolsFramework
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         void SetAxis(const AZ::Vector3& axis);
-        const AZ::Vector3& GetAxis() const { return m_fixed.m_axis; }
+        const AZ::Vector3& GetAxis() const
+        {
+            return m_fixed.m_axis;
+        }
 
         void SetView(AZStd::unique_ptr<ManipulatorView>&& view);
-        ManipulatorView* GetView() const { return m_manipulatorView.get(); }
+        ManipulatorView* GetView() const
+        {
+            return m_manipulatorView.get();
+        }
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
-        void OnMouseMoveImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void SetBoundsDirtyImpl() override;
         void InvalidateImpl() override;
 
-        /// Unchanging data set once for the angular manipulator.
+        //! Unchanging data set once for the angular manipulator.
         struct Fixed
         {
-            AZ::Vector3 m_axis = AZ::Vector3::CreateAxisX(); ///< Axis for this angular manipulator to rotate around.
+            AZ::Vector3 m_axis = AZ::Vector3::CreateAxisX(); //!< Axis for this angular manipulator to rotate around.
         };
 
-        /// Initial data recorded when a press first happens with an angular manipulator.
+        //! Initial data recorded when a press first happens with an angular manipulator.
         struct StartInternal
         {
-            AZ::Transform m_worldFromLocal; ///< Initial transform when pressed.
-            AZ::Transform m_localTransform; ///< Additional transform (offset) to apply to manipulator.
-            AZ::Vector3 m_planePoint; ///< Position on plane to use for ray intersection.
-            AZ::Vector3 m_planeNormal; ///< Normal of plane to use for ray intersection.
+            AZ::Transform m_worldFromLocal; //!< Initial transform when pressed.
+            AZ::Transform m_localTransform; //!< Additional transform (offset) to apply to manipulator.
+            AZ::Vector3 m_planePoint; //!< Position on plane to use for ray intersection.
+            AZ::Vector3 m_planeNormal; //!< Normal of plane to use for ray intersection.
         };
 
-        /// Current data recorded each frame during an interaction with an angular manipulator.
+        //! Current data recorded each frame during an interaction with an angular manipulator.
         struct CurrentInternal
         {
-            float m_preSnapRadians = 0.0f; ///< Amount of rotation before a snap (snap increment accumulator).
-            float m_radians = 0.0f; ///< Amount of rotation about the axis for this action.
-            AZ::Vector3 m_worldHitPosition; ///< Initial world space hit position.
+            float m_preSnapRadians = 0.0f; //!< Amount of rotation before a snap (snap increment accumulator).
+            float m_radians = 0.0f; //!< Amount of rotation about the axis for this action.
+            AZ::Vector3 m_worldHitPosition; //!< Initial world space hit position.
         };
 
-        /// Wrap start and current internal data during an interaction with an angular manipulator.
+        //! Wrap start and current internal data during an interaction with an angular manipulator.
         struct ActionInternal
         {
             StartInternal m_start;
@@ -135,16 +141,25 @@ namespace AzToolsFramework
         MouseActionCallback m_onLeftMouseUpCallback = nullptr;
         MouseActionCallback m_onMouseMoveCallback = nullptr;
 
-        AZStd::unique_ptr<ManipulatorView> m_manipulatorView; ///< Look of manipulator.
+        AZStd::unique_ptr<ManipulatorView> m_manipulatorView; //!< Look of manipulator.
 
         static ActionInternal CalculateManipulationDataStart(
-            const Fixed& fixed, const AZ::Transform& worldFromLocal, const AZ::Transform& localTransform,
-            const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection, float rayDistance);
+            const Fixed& fixed,
+            const AZ::Transform& worldFromLocal,
+            const AZ::Transform& localTransform,
+            const AZ::Vector3& rayOrigin,
+            const AZ::Vector3& rayDirection,
+            float rayDistance);
 
         static Action CalculateManipulationDataAction(
-            const Fixed& fixed, ActionInternal& actionInternal, const AZ::Transform& worldFromLocal,
-            const AZ::Transform& localTransform, bool snapping, float angleStepDegrees,
-            const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection,
+            const Fixed& fixed,
+            ActionInternal& actionInternal,
+            const AZ::Transform& worldFromLocal,
+            const AZ::Transform& localTransform,
+            bool snapping,
+            float angleStepDegrees,
+            const AZ::Vector3& rayOrigin,
+            const AZ::Vector3& rayDirection,
             ViewportInteraction::KeyboardModifiers keyboardModifiers);
     };
 } // namespace AzToolsFramework

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

@@ -1,33 +1,30 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "BaseManipulator.h"
 
 #include <AzCore/Math/IntersectSegment.h>
-#include <AzToolsFramework/Viewport/ViewportMessages.h>
 #include <AzToolsFramework/Entity/EditorEntityHelpers.h>
+#include <AzToolsFramework/Viewport/ViewportMessages.h>
 
 namespace AzToolsFramework
 {
-    AZ_CVAR(
-        bool, cl_manipulatorDrawDebug, false, nullptr, AZ::ConsoleFunctorFlags::Null,
-        "Enable debug drawing for Manipulators");
+    AZ_CVAR(bool, cl_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
 
     AZ_CLASS_ALLOCATOR_IMPL(BaseManipulator, AZ::SystemAllocator, 0)
 
-        static bool EntityIdAndEntityComponentIdComparison(
-            const AZ::EntityId entityId, const AZ::EntityComponentIdPair& entityComponentId)
+    static bool EntityIdAndEntityComponentIdComparison(const AZ::EntityId entityId, const AZ::EntityComponentIdPair& entityComponentId)
     {
         return entityId == entityComponentId.GetEntityId();
     }
@@ -38,8 +35,7 @@ namespace AzToolsFramework
         EndUndoBatch();
     }
 
-    bool BaseManipulator::OnLeftMouseDown(
-        const ViewportInteraction::MouseInteraction& interaction, const float rayIntersectionDistance)
+    bool BaseManipulator::OnLeftMouseDown(const ViewportInteraction::MouseInteraction& interaction, const float rayIntersectionDistance)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -57,8 +53,7 @@ namespace AzToolsFramework
 
             (*this.*m_onLeftMouseDownImpl)(interaction, rayIntersectionDistance);
 
-            ToolsApplicationNotificationBus::Broadcast(
-                &ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
+            ToolsApplicationNotificationBus::Broadcast(&ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
 
             return true;
         }
@@ -66,8 +61,7 @@ namespace AzToolsFramework
         return false;
     }
 
-    bool BaseManipulator::OnRightMouseDown(
-        const ViewportInteraction::MouseInteraction& interaction, const float rayIntersectionDistance)
+    bool BaseManipulator::OnRightMouseDown(const ViewportInteraction::MouseInteraction& interaction, const float rayIntersectionDistance)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -85,8 +79,7 @@ namespace AzToolsFramework
 
             (*this.*m_onRightMouseDownImpl)(interaction, rayIntersectionDistance);
 
-            ToolsApplicationNotificationBus::Broadcast(
-                &ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
+            ToolsApplicationNotificationBus::Broadcast(&ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
 
             return true;
         }
@@ -118,8 +111,7 @@ namespace AzToolsFramework
         EndUndoBatch();
     }
 
-    bool BaseManipulator::OnMouseOver(
-        const ManipulatorId manipulatorId, const ViewportInteraction::MouseInteraction& interaction)
+    bool BaseManipulator::OnMouseOver(const ManipulatorId manipulatorId, const ViewportInteraction::MouseInteraction& interaction)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -132,8 +124,7 @@ namespace AzToolsFramework
     {
         OnMouseWheelImpl(interaction);
 
-        ToolsApplicationNotificationBus::Broadcast(
-            &ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
+        ToolsApplicationNotificationBus::Broadcast(&ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
     }
 
     void BaseManipulator::OnMouseMove(const ViewportInteraction::MouseInteraction& interaction)
@@ -142,16 +133,13 @@ namespace AzToolsFramework
 
         if (!m_performingAction)
         {
-            AZ_Warning(
-                "Manipulators", false,
-                "MouseMove action received, but this manipulator is not performing an action");
+            AZ_Warning("Manipulators", false, "MouseMove action received, but this manipulator is not performing an action");
 
             return;
         }
 
         // ensure property grid (entity inspector) values are refreshed
-        ToolsApplicationNotificationBus::Broadcast(
-            &ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
+        ToolsApplicationNotificationBus::Broadcast(&ToolsApplicationNotificationBus::Events::InvalidatePropertyDisplay, Refresh_Values);
 
         OnMouseMoveImpl(interaction);
     }
@@ -170,16 +158,14 @@ namespace AzToolsFramework
             Unregister();
         }
 
-        ManipulatorManagerRequestBus::Event(managerId,
-            &ManipulatorManagerRequestBus::Events::RegisterManipulator, shared_from_this());
+        ManipulatorManagerRequestBus::Event(managerId, &ManipulatorManagerRequestBus::Events::RegisterManipulator, shared_from_this());
     }
 
     void BaseManipulator::Unregister()
     {
         // if the manipulator has already been unregistered, the m_manipulatorManagerId
         // should be invalid which makes the call below a no-op.
-        ManipulatorManagerRequestBus::Event(m_manipulatorManagerId,
-            &ManipulatorManagerRequestBus::Events::UnregisterManipulator, this);
+        ManipulatorManagerRequestBus::Event(m_manipulatorManagerId, &ManipulatorManagerRequestBus::Events::UnregisterManipulator, this);
     }
 
     void BaseManipulator::Invalidate()
@@ -197,8 +183,7 @@ namespace AzToolsFramework
         if (m_performingAction)
         {
             AZ_Warning(
-                "Manipulators", false,
-                "MouseDown action received, but the manipulator (id: %d) is still performing an action",
+                "Manipulators", false, "MouseDown action received, but the manipulator (id: %d) is still performing an action",
                 GetManipulatorId());
 
             return;
@@ -214,8 +199,7 @@ namespace AzToolsFramework
         if (!m_performingAction)
         {
             AZ_Warning(
-                "Manipulators", false,
-                "MouseUp action received, but this manipulator (id: %d) didn't receive MouseDown action before",
+                "Manipulators", false, "MouseUp action received, but this manipulator (id: %d) didn't receive MouseDown action before",
                 GetManipulatorId());
             return;
         }
@@ -263,13 +247,13 @@ namespace AzToolsFramework
             if (entityComponentIdPair.GetComponentId() != AZ::InvalidComponentId)
             {
                 PropertyEditorEntityChangeNotificationBus::Event(
-                    entityComponentIdPair.GetEntityId(),
-                    &PropertyEditorEntityChangeNotifications::OnEntityComponentPropertyChanged,
+                    entityComponentIdPair.GetEntityId(), &PropertyEditorEntityChangeNotifications::OnEntityComponentPropertyChanged,
                     entityComponentIdPair.GetComponentId());
             }
             else
             {
-                AZ_Warning("Manipulators", false,
+                AZ_Warning(
+                    "Manipulators", false,
                     "This Manipulator was only registered with an EntityId and not an EntityComponentIdPair. "
                     "Please use AddEntityComponentIdPair() instead of AddEntityId() when registering what this "
                     "Manipulator is changing.");
@@ -280,8 +264,7 @@ namespace AzToolsFramework
                 for (const AZ::Component* component : entity->GetComponents())
                 {
                     PropertyEditorEntityChangeNotificationBus::Event(
-                        entity->GetId(), &PropertyEditorEntityChangeNotifications::OnEntityComponentPropertyChanged,
-                        component->GetId());
+                        entity->GetId(), &PropertyEditorEntityChangeNotifications::OnEntityComponentPropertyChanged, component->GetId());
                 }
             }
         }
@@ -298,9 +281,7 @@ namespace AzToolsFramework
         {
             // look for a match (keep looking in case we have several entity ids with different component ids)
             const auto entityComponentPairId =
-                m_entityComponentIdPairs.find_as(
-                    entityId, AZStd::hash<AZ::EntityId>(),
-                    &EntityIdAndEntityComponentIdComparison);
+                m_entityComponentIdPairs.find_as(entityId, AZStd::hash<AZ::EntityId>(), &EntityIdAndEntityComponentIdComparison);
 
             // update the afterErased variable so we can return an iterator
             // to the correct position in the container.
@@ -334,9 +315,8 @@ namespace AzToolsFramework
 
     bool BaseManipulator::HasEntityId(const AZ::EntityId entityId) const
     {
-        return m_entityComponentIdPairs.find_as(
-            entityId, AZStd::hash<AZ::EntityId>(),
-            &EntityIdAndEntityComponentIdComparison) != m_entityComponentIdPairs.end();
+        return m_entityComponentIdPairs.find_as(entityId, AZStd::hash<AZ::EntityId>(), &EntityIdAndEntityComponentIdComparison) !=
+            m_entityComponentIdPairs.end();
     }
 
     bool BaseManipulator::HasEntityComponentIdPair(const AZ::EntityComponentIdPair& entityComponentIdPair) const
@@ -346,7 +326,8 @@ namespace AzToolsFramework
 
     void Manipulators::Register(const ManipulatorManagerId manipulatorManagerId)
     {
-        ProcessManipulators([manipulatorManagerId](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [manipulatorManagerId](BaseManipulator* manipulator)
             {
                 manipulator->Register(manipulatorManagerId);
             });
@@ -354,7 +335,8 @@ namespace AzToolsFramework
 
     void Manipulators::Unregister()
     {
-        ProcessManipulators([](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [](BaseManipulator* manipulator)
             {
                 if (manipulator->Registered())
                 {
@@ -365,7 +347,8 @@ namespace AzToolsFramework
 
     void Manipulators::SetBoundsDirty()
     {
-        ProcessManipulators([](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [](BaseManipulator* manipulator)
             {
                 manipulator->SetBoundsDirty();
             });
@@ -373,7 +356,8 @@ namespace AzToolsFramework
 
     void Manipulators::AddEntityComponentIdPair(const AZ::EntityComponentIdPair& entityComponentIdPair)
     {
-        ProcessManipulators([&entityComponentIdPair](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [&entityComponentIdPair](BaseManipulator* manipulator)
             {
                 manipulator->AddEntityComponentIdPair(entityComponentIdPair);
             });
@@ -381,7 +365,8 @@ namespace AzToolsFramework
 
     void Manipulators::RemoveEntityComponentIdPair(const AZ::EntityComponentIdPair& entityComponentIdPair)
     {
-        ProcessManipulators([&entityComponentIdPair](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [&entityComponentIdPair](BaseManipulator* manipulator)
             {
                 manipulator->RemoveEntityComponentIdPair(entityComponentIdPair);
             });
@@ -389,7 +374,8 @@ namespace AzToolsFramework
 
     void Manipulators::RemoveEntityId(const AZ::EntityId entityId)
     {
-        ProcessManipulators([entityId](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [entityId](BaseManipulator* manipulator)
             {
                 manipulator->RemoveEntityId(entityId);
             });
@@ -398,7 +384,8 @@ namespace AzToolsFramework
     bool Manipulators::PerformingAction()
     {
         bool performingAction = false;
-        ProcessManipulators([&performingAction](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [&performingAction](BaseManipulator* manipulator)
             {
                 if (manipulator->PerformingAction())
                 {
@@ -412,7 +399,8 @@ namespace AzToolsFramework
     bool Manipulators::Registered()
     {
         bool registered = false;
-        ProcessManipulators([&registered](BaseManipulator* manipulator)
+        ProcessManipulators(
+            [&registered](BaseManipulator* manipulator)
             {
                 if (manipulator->Registered())
                 {
@@ -470,8 +458,12 @@ namespace AzToolsFramework
 
     namespace Internal
     {
-        bool CalculateRayPlaneIntersectingPoint(const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection,
-            const AZ::Vector3& pointOnPlane, const AZ::Vector3& planeNormal, AZ::Vector3& resultIntersectingPoint)
+        bool CalculateRayPlaneIntersectingPoint(
+            const AZ::Vector3& rayOrigin,
+            const AZ::Vector3& rayDirection,
+            const AZ::Vector3& pointOnPlane,
+            const AZ::Vector3& planeNormal,
+            AZ::Vector3& resultIntersectingPoint)
         {
             float t = 0.0f;
             if (AZ::Intersect::IntersectRayPlane(rayOrigin, rayDirection, pointOnPlane, planeNormal, t) > 0)
@@ -484,11 +476,12 @@ namespace AzToolsFramework
         }
 
         AZ::Vector3 TryConstrainHitPositionToView(
-            const AZ::Vector3& currentLocalHitPosition, const AZ::Vector3& startLocalHitPosition,
-            const AZ::Transform& localFromWorld, const AzFramework::CameraState& cameraState)
+            const AZ::Vector3& currentLocalHitPosition,
+            const AZ::Vector3& startLocalHitPosition,
+            const AZ::Transform& localFromWorld,
+            const AzFramework::CameraState& cameraState)
         {
-            if (currentLocalHitPosition.GetDistance(localFromWorld.TransformPoint(cameraState.m_position))
-                > cameraState.m_farClip)
+            if (currentLocalHitPosition.GetDistance(localFromWorld.TransformPoint(cameraState.m_position)) > cameraState.m_farClip)
             {
                 return startLocalHitPosition;
             }

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -22,13 +22,13 @@
 #include <AzCore/std/containers/set.h>
 #include <AzCore/std/smart_ptr/enable_shared_from_this.h>
 #include <AzToolsFramework/Manipulators/ManipulatorBus.h>
-#include "ManipulatorSpace.h"
+#include <AzToolsFramework/Manipulators/ManipulatorSpace.h>
 
 namespace AzFramework
 {
     struct CameraState;
     class DebugDisplayRequests;
-}
+} // namespace AzFramework
 
 namespace AzToolsFramework
 {
@@ -46,9 +46,8 @@ namespace AzToolsFramework
 
     struct ManipulatorManagerState;
 
-    /// The base class for manipulators, providing interfaces for users of manipulators to talk to.
-    class BaseManipulator
-        : public AZStd::enable_shared_from_this<BaseManipulator>
+    //! The base class for manipulators, providing interfaces for users of manipulators to talk to.
+    class BaseManipulator : public AZStd::enable_shared_from_this<BaseManipulator>
     {
     public:
         AZ_CLASS_ALLOCATOR_DECL
@@ -61,139 +60,181 @@ namespace AzToolsFramework
 
         using EntityComponentIds = AZStd::unordered_set<AZ::EntityComponentIdPair>;
 
-        /// Callback for the event when the mouse pointer is over this manipulator and the left mouse button is pressed.
-        /// @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera through the mouse pointer.
-        /// @param rayIntersectionDistance The parameter value in the ray's explicit equation that represents the intersecting point on the target manipulator in world space.
-        /// @return Return true if OnLeftMouseDownImpl was attached and will be used.
+        //! Callback for the event when the mouse pointer is over this manipulator and the left mouse button is pressed.
+        //! @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera
+        //! through the mouse pointer.
+        //! @param rayIntersectionDistance The parameter value in the ray's explicit equation that represents the intersecting point on the
+        //! target manipulator in world space.
+        //! @return Return true if OnLeftMouseDownImpl was attached and will be used.
         bool OnLeftMouseDown(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance);
 
-        /// Callback for the event when this manipulator is active and the left mouse button is released.
-        /// @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera through the mouse pointer.
+        //! Callback for the event when this manipulator is active and the left mouse button is released.
+        //! @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera
+        //! through the mouse pointer.
         void OnLeftMouseUp(const ViewportInteraction::MouseInteraction& interaction);
 
-        /// Callback for the event when the mouse pointer is over this manipulator and the right mouse button is pressed .
-        /// @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera through the mouse pointer.
-        /// @param rayIntersectionDistance The parameter value in the ray's explicit equation that represents the intersecting point on the target manipulator in world space.
-        /// @return Return true if OnRightMouseDownImpl was attached and will be used.
+        //! Callback for the event when the mouse pointer is over this manipulator and the right mouse button is pressed .
+        //! @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera
+        //! through the mouse pointer.
+        //! @param rayIntersectionDistance The parameter value in the ray's explicit equation that represents the intersecting point on the
+        //! target manipulator in world space.
+        //! @return Return true if OnRightMouseDownImpl was attached and will be used.
         bool OnRightMouseDown(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance);
 
-        /// Callback for the event when this manipulator is active and the right mouse button is released.
-        /// @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera through the mouse pointer.
+        //! Callback for the event when this manipulator is active and the right mouse button is released.
+        //! @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera
+        //! through the mouse pointer.
         void OnRightMouseUp(const ViewportInteraction::MouseInteraction& interaction);
 
-        /// Callback for the event when this manipulator is active and the mouse is moved.
-        /// @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera through the mouse pointer.
+        //! Callback for the event when this manipulator is active and the mouse is moved.
+        //! @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera
+        //! through the mouse pointer.
         void OnMouseMove(const ViewportInteraction::MouseInteraction& interaction);
 
-        /// Callback for the event when this manipulator is active and the mouse wheel is scrolled.
-        /// @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera through the mouse pointer.
+        //! Callback for the event when this manipulator is active and the mouse wheel is scrolled.
+        //! @param interaction It contains various mouse states when the event happens, as well as a ray shooting from the viewing camera
+        //! through the mouse pointer.
         void OnMouseWheel(const ViewportInteraction::MouseInteraction& interaction);
 
-        /// This function changes the state indicating whether the manipulator is under the mouse pointer.
-        /// It is called in the event of OnMouseMove and OnMouseWheel only when there is no manipulator currently performing actions.
+        //! This function changes the state indicating whether the manipulator is under the mouse pointer.
+        //! It is called in the event of OnMouseMove and OnMouseWheel only when there is no manipulator currently performing actions.
         bool OnMouseOver(ManipulatorId manipulatorId, const ViewportInteraction::MouseInteraction& interaction);
 
-        /// Register itself to a manipulator manager so that it can receive various mouse events and perform manipulations.
-        /// @param managerId The id identifying a unique manipulator manager.
+        //! Register itself to a manipulator manager so that it can receive various mouse events and perform manipulations.
+        //! @param managerId The id identifying a unique manipulator manager.
         void Register(ManipulatorManagerId managerId);
 
-        /// Unregister itself from the manipulator manager it was registered with.
+        //! Unregister itself from the manipulator manager it was registered with.
         void Unregister();
 
-        /// Bounds will need to be recalculated next time we render.
+        //! Bounds will need to be recalculated next time we render.
         void SetBoundsDirty();
 
-        /// Is this manipulator currently registered with a manipulator manager.
+        //! Is this manipulator currently registered with a manipulator manager.
         bool Registered() const
         {
-            return m_manipulatorId != InvalidManipulatorId &&
-                m_manipulatorManagerId != InvalidManipulatorManagerId;
+            return m_manipulatorId != InvalidManipulatorId && m_manipulatorManagerId != InvalidManipulatorManagerId;
         }
 
-        /// Is the manipulator in the middle of an action (between mouse down and mouse up).
-        bool PerformingAction() const { return m_performingAction; }
+        //! Is the manipulator in the middle of an action (between mouse down and mouse up).
+        bool PerformingAction() const
+        {
+            return m_performingAction;
+        }
 
-        /// Is the mouse currently over the manipulator (intersecting manipulator bound).
-        bool MouseOver() const { return m_mouseOver; }
+        //! Is the mouse currently over the manipulator (intersecting manipulator bound).
+        bool MouseOver() const
+        {
+            return m_mouseOver;
+        }
 
-        /// The unique id of this manipulator.
-        ManipulatorId GetManipulatorId() const { return m_manipulatorId; }
+        //! The unique id of this manipulator.
+        ManipulatorId GetManipulatorId() const
+        {
+            return m_manipulatorId;
+        }
 
-        /// The unique id of the manager this manipulator was registered with.
-        ManipulatorManagerId GetManipulatorManagerId() const { return m_manipulatorManagerId; }
+        //! The unique id of the manager this manipulator was registered with.
+        ManipulatorManagerId GetManipulatorManagerId() const
+        {
+            return m_manipulatorManagerId;
+        }
 
-        /// Returns all EntityComponentIdPairs associated with this manipulator.
+        //! Returns all EntityComponentIdPairs associated with this manipulator.
         const EntityComponentIds& EntityComponentIdPairs() const
         {
             return m_entityComponentIdPairs;
         }
 
-        /// Add an entity and component the manipulator is responsible for.
+        //! Add an entity and component the manipulator is responsible for.
         void AddEntityComponentIdPair(const AZ::EntityComponentIdPair& entityComponentIdPair);
 
-        /// Remove an entity from being affected by this manipulator.
-        /// @note All components on this entity registered with the manipulator will be removed.
+        //! Remove an entity from being affected by this manipulator.
+        //! @note All components on this entity registered with the manipulator will be removed.
         EntityComponentIds::iterator RemoveEntityId(AZ::EntityId entityId);
 
-        /// Remove a specific component (via a EntityComponentIdPair) being affected by this manipulator.
+        //! Remove a specific component (via a EntityComponentIdPair) being affected by this manipulator.
         EntityComponentIds::iterator RemoveEntityComponentIdPair(const AZ::EntityComponentIdPair& entityComponentIdPair);
 
-        /// Is this entity currently being tracked by this manipulator.
+        //! Is this entity currently being tracked by this manipulator.
         bool HasEntityId(AZ::EntityId entityId) const;
 
-        /// Is this entity component pair currently being tracked by this manipulator.
+        //! Is this entity component pair currently being tracked by this manipulator.
         bool HasEntityComponentIdPair(const AZ::EntityComponentIdPair& entityComponentIdPair) const;
 
-        /// Forward a mouse over event in a case where we need the manipulator to immediately refresh.
-        /// @note Only call this when a mouse over event has just happened.
+        //! Forward a mouse over event in a case where we need the manipulator to immediately refresh.
+        //! @note Only call this when a mouse over event has just happened.
         void ForwardMouseOverEvent(const ViewportInteraction::MouseInteraction& interaction);
 
         static const AZ::Color s_defaultMouseOverColor;
 
     protected:
-        /// Protected constructor.
+        //! Protected constructor.
         BaseManipulator() = default;
 
-        /// Called when unregistering - users of manipulators should not call it directly.
+        //! Called when unregistering - users of manipulators should not call it directly.
         void Invalidate();
 
-        /// The implementation to override in a derived class for Invalidate.
-        virtual void InvalidateImpl() {}
+        //! The implementation to override in a derived class for Invalidate.
+        virtual void InvalidateImpl()
+        {
+        }
 
-        /// The implementation to override in a derived class for OnLeftMouseDown.
-        /// Note: When implementing this function you must also call AttachLeftMouseDownImpl to ensure
-        /// m_onLeftMouseDownImpl is set to OnLeftMouseDownImpl, otherwise it will not be called
-        virtual void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& /*interaction*/, float /*rayIntersectionDistance*/) {}
-        void AttachLeftMouseDownImpl() { m_onLeftMouseDownImpl = &BaseManipulator::OnLeftMouseDownImpl; }
+        //! The implementation to override in a derived class for OnLeftMouseDown.
+        //! Note: When implementing this function you must also call AttachLeftMouseDownImpl to ensure
+        //! m_onLeftMouseDownImpl is set to OnLeftMouseDownImpl, otherwise it will not be called
+        virtual void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& /*interaction*/, float /*rayIntersectionDistance*/)
+        {
+        }
 
-        /// The implementation to override in a derived class for OnRightMouseDown.
-        /// Note: When implementing this function you must also call AttachRightMouseDownImpl to ensure
-        /// m_onRightMouseDownImpl is set to OnRightMouseDownImpl, otherwise it will not be called
-        virtual void OnRightMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& /*interaction*/, float /*rayIntersectionDistance*/) {}
-        void AttachRightMouseDownImpl() { m_onRightMouseDownImpl = &BaseManipulator::OnRightMouseDownImpl; }
+        void AttachLeftMouseDownImpl()
+        {
+            m_onLeftMouseDownImpl = &BaseManipulator::OnLeftMouseDownImpl;
+        }
 
-        /// The implementation to override in a derived class for OnLeftMouseUp.
-        virtual void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& /*interaction*/) {}
+        //! The implementation to override in a derived class for OnRightMouseDown.
+        //! Note: When implementing this function you must also call AttachRightMouseDownImpl to ensure
+        //! m_onRightMouseDownImpl is set to OnRightMouseDownImpl, otherwise it will not be called
+        virtual void OnRightMouseDownImpl(const ViewportInteraction::MouseInteraction& /*interaction*/, float /*rayIntersectionDistance*/)
+        {
+        }
 
-        /// The implementation to override in a derived class for OnRightMouseUp.
-        virtual void OnRightMouseUpImpl(const ViewportInteraction::MouseInteraction& /*interaction*/) {}
+        void AttachRightMouseDownImpl()
+        {
+            m_onRightMouseDownImpl = &BaseManipulator::OnRightMouseDownImpl;
+        }
 
-        /// The implementation to override in a derived class for OnMouseMove.
-        virtual void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& /*interaction*/) {}
+        //! The implementation to override in a derived class for OnLeftMouseUp.
+        virtual void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& /*interaction*/)
+        {
+        }
 
-        /// The implementation to override in a derived class for OnMouseOver.
-        virtual void OnMouseOverImpl(
-            ManipulatorId /*manipulatorId*/, const ViewportInteraction::MouseInteraction& /*interaction*/) {}
+        //! The implementation to override in a derived class for OnRightMouseUp.
+        virtual void OnRightMouseUpImpl(const ViewportInteraction::MouseInteraction& /*interaction*/)
+        {
+        }
 
-        /// The implementation to override in a derived class for OnMouseWheel.
-        virtual void OnMouseWheelImpl(const ViewportInteraction::MouseInteraction& /*interaction*/) {}
+        //! The implementation to override in a derived class for OnMouseMove.
+        virtual void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& /*interaction*/)
+        {
+        }
 
-        /// The implementation to override in a derived class for SetBoundsDirty.
-        virtual void SetBoundsDirtyImpl() {}
+        //! The implementation to override in a derived class for OnMouseOver.
+        virtual void OnMouseOverImpl(ManipulatorId /*manipulatorId*/, const ViewportInteraction::MouseInteraction& /*interaction*/)
+        {
+        }
 
-        /// Rendering for the manipulator - it is recommended drawing be delegated to a ManipulatorView.
+        //! The implementation to override in a derived class for OnMouseWheel.
+        virtual void OnMouseWheelImpl(const ViewportInteraction::MouseInteraction& /*interaction*/)
+        {
+        }
+
+        //! The implementation to override in a derived class for SetBoundsDirty.
+        virtual void SetBoundsDirtyImpl()
+        {
+        }
+
+        //! Rendering for the manipulator - it is recommended drawing be delegated to a ManipulatorView.
         virtual void Draw(
             const ManipulatorManagerState& managerState,
             AzFramework::DebugDisplayRequests& debugDisplay,
@@ -202,39 +243,39 @@ namespace AzToolsFramework
 
     private:
         friend class ManipulatorManager;
-        AZStd::unordered_set<AZ::EntityComponentIdPair> m_entityComponentIdPairs; ///< The entities this manipulator is associated with.
+        AZStd::unordered_set<AZ::EntityComponentIdPair> m_entityComponentIdPairs; //!< The entities this manipulator is associated with.
 
-        ManipulatorId m_manipulatorId = InvalidManipulatorId; ///< The unique id of this manipulator.
-        ManipulatorManagerId m_manipulatorManagerId = InvalidManipulatorManagerId; ///< The manager this manipulator was registered with.
-        UndoSystem::URSequencePoint* m_undoBatch = nullptr; ///< Undo active while mouse is pressed.
-        bool m_performingAction = false; ///< After mouse down and before mouse up.
-        bool m_mouseOver = false; ///< Is the mouse pointer over the manipulator bound.
+        ManipulatorId m_manipulatorId = InvalidManipulatorId; //!< The unique id of this manipulator.
+        ManipulatorManagerId m_manipulatorManagerId = InvalidManipulatorManagerId; //!< The manager this manipulator was registered with.
+        UndoSystem::URSequencePoint* m_undoBatch = nullptr; //!< Undo active while mouse is pressed.
+        bool m_performingAction = false; //!< After mouse down and before mouse up.
+        bool m_mouseOver = false; //!< Is the mouse pointer over the manipulator bound.
 
-        /// Member function pointers to OnLeftMouseDownImpl and OnRightMouseDownImpl.
-        /// Set in AttachLeft/RightMouseDownImpl.
+        //! Member function pointers to OnLeftMouseDownImpl and OnRightMouseDownImpl.
+        //! Set in AttachLeft/RightMouseDownImpl.
         void (BaseManipulator::*m_onLeftMouseDownImpl)(
             const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) = nullptr;
         void (BaseManipulator::*m_onRightMouseDownImpl)(
             const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) = nullptr;
 
-        /// Update the mouseOver state for this manipulator.
+        //! Update the mouseOver state for this manipulator.
         void UpdateMouseOver(ManipulatorId manipulatorId);
 
-        /// Manage correctly ending the undo batch.
+        //! Manage correctly ending the undo batch.
         void EndUndoBatch();
 
-        /// Record an action as having started.
+        //! Record an action as having started.
         void BeginAction();
 
-        /// Record an action as having stopped.
+        //! Record an action as having stopped.
         void EndAction();
 
-        /// Let other systems (UI) know that a component property has been modified by a manipulator.
+        //! Let other systems (UI) know that a component property has been modified by a manipulator.
         void NotifyEntityComponentPropertyChanged();
     };
 
-    /// Base class to be used when composing aggregate manipulator types - wraps some
-    /// common functionality all manipulators need.
+    //! Base class to be used when composing aggregate manipulator types - wraps some
+    //! common functionality all manipulators need.
     class Manipulators
     {
     public:
@@ -249,8 +290,10 @@ namespace AzToolsFramework
         bool PerformingAction();
         bool Registered();
 
-        /// Refresh the Manipulator and/or View based on the current view position.
-        virtual void RefreshView(const AZ::Vector3& /*worldViewPosition*/) {}
+        //! Refresh the Manipulator and/or View based on the current view position.
+        virtual void RefreshView(const AZ::Vector3& /*worldViewPosition*/)
+        {
+        }
 
         const AZ::Transform& GetLocalTransform() const;
         const AZ::Transform& GetSpace() const;
@@ -262,39 +305,59 @@ namespace AzToolsFramework
         void SetNonUniformScale(const AZ::Vector3& nonUniformScale);
 
     protected:
-        /// Common processing for base manipulator type - Implement for all
-        /// individual manipulators used in an aggregate manipulator.
+        //! Common processing for base manipulator type - Implement for all
+        //! individual manipulators used in an aggregate manipulator.
         virtual void ProcessManipulators(const AZStd::function<void(BaseManipulator*)>&) = 0;
 
-        ///@{
-        /// Allows implementers to perform additional logic when updating the location of the manipulator group.
-        virtual void SetSpaceImpl([[maybe_unused]] const AZ::Transform& worldFromLocal) {}
-        virtual void SetLocalTransformImpl([[maybe_unused]] const AZ::Transform& localTransform) {}
-        virtual void SetLocalPositionImpl([[maybe_unused]] const AZ::Vector3& localPosition) {}
-        virtual void SetLocalOrientationImpl([[maybe_unused]] const AZ::Quaternion& localOrientation) {}
-        virtual void SetNonUniformScaleImpl([[maybe_unused]] const AZ::Vector3& nonUniformScale) {}
-        ///@}
+        //!@{
+        //! Allows implementers to perform additional logic when updating the location of the manipulator group.
+        virtual void SetSpaceImpl([[maybe_unused]] const AZ::Transform& worldFromLocal)
+        {
+        }
 
-        ManipulatorSpaceWithLocalTransform m_manipulatorSpaceWithLocalTransform; ///< The space and local transform for the manipulators.
+        virtual void SetLocalTransformImpl([[maybe_unused]] const AZ::Transform& localTransform)
+        {
+        }
+
+        virtual void SetLocalPositionImpl([[maybe_unused]] const AZ::Vector3& localPosition)
+        {
+        }
+
+        virtual void SetLocalOrientationImpl([[maybe_unused]] const AZ::Quaternion& localOrientation)
+        {
+        }
+
+        virtual void SetNonUniformScaleImpl([[maybe_unused]] const AZ::Vector3& nonUniformScale)
+        {
+        }
+        //!@}
+
+        ManipulatorSpaceWithLocalTransform m_manipulatorSpaceWithLocalTransform; //!< The space and local transform for the manipulators.
     };
 
     namespace Internal
     {
-        /// This helper function calculates the intersecting point between a ray and a plane.
-        /// @param rayOrigin                     The origin of the ray to test.
-        /// @param rayDirection                  The direction of the ray to test.
-        /// @param maxRayLength
-        /// @param pointOnPlane                  A point on the plane.
-        /// @param planeNormal                   The normal vector of the plane.
-        /// @param[out] resultIntersectingPoint  This stores the result intersecting point. It will be left unchanged
-        ///                                      if there is no intersection between the ray and the plane.
-        /// @return                              Was there an intersection
-        bool CalculateRayPlaneIntersectingPoint(const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection,
-            const AZ::Vector3& pointOnPlane, const AZ::Vector3& planeNormal, AZ::Vector3& resultIntersectingPoint);
+        //! This helper function calculates the intersecting point between a ray and a plane.
+        //! @param rayOrigin                     The origin of the ray to test.
+        //! @param rayDirection                  The direction of the ray to test.
+        //! @param maxRayLength                  The maximum length of the ray to test.
+        //! @param pointOnPlane                  A point on the plane.
+        //! @param planeNormal                   The normal vector of the plane.
+        //! @param[out] resultIntersectingPoint  This stores the result intersecting point. It will be left unchanged
+        //!                                      if there is no intersection between the ray and the plane.
+        //! @return                              Was there an intersection
+        bool CalculateRayPlaneIntersectingPoint(
+            const AZ::Vector3& rayOrigin,
+            const AZ::Vector3& rayDirection,
+            const AZ::Vector3& pointOnPlane,
+            const AZ::Vector3& planeNormal,
+            AZ::Vector3& resultIntersectingPoint);
 
-        /// Returns startLocalHitPosition if currentLocalHitPosition is further away than the camera's far clip plane.
+        //! Returns startLocalHitPosition if currentLocalHitPosition is further away than the camera's far clip plane.
         AZ::Vector3 TryConstrainHitPositionToView(
-            const AZ::Vector3& currentLocalHitPosition, const AZ::Vector3& startLocalHitPosition,
-            const AZ::Transform& localFromWorld, const AzFramework::CameraState& cameraState);
-    }
+            const AZ::Vector3& currentLocalHitPosition,
+            const AZ::Vector3& startLocalHitPosition,
+            const AZ::Transform& localFromWorld,
+            const AzFramework::CameraState& cameraState);
+    } // namespace Internal
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BoxManipulatorRequestBus.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -21,31 +21,30 @@ namespace AZ
 
 namespace AzToolsFramework
 {
-    /// Interface for handling box manipulator requests.
-    /// Used by \ref BoxComponentMode.
-    class BoxManipulatorRequests
-        : public AZ::EntityComponentBus
+    //! Interface for handling box manipulator requests.
+    //! Used by \ref BoxComponentMode.
+    class BoxManipulatorRequests : public AZ::EntityComponentBus
     {
     public:
-        /// Get the X/Y/Z dimensions of the box shape/collider.
+        //! Get the X/Y/Z dimensions of the box shape/collider.
         virtual AZ::Vector3 GetDimensions() = 0;
-        /// Set the X/Y/Z dimensions of the box shape/collider.
+        //! Set the X/Y/Z dimensions of the box shape/collider.
         virtual void SetDimensions(const AZ::Vector3& dimensions) = 0;
-        /// Get the transform of the box shape/collider.
-        /// This is used by \ref BoxComponentMode instead of the \ref \AZ::TransformBus
-        /// because a collider may have an additional translation/orientation offset from
-        /// the Entity transform.
+        //! Get the transform of the box shape/collider.
+        //! This is used by \ref BoxComponentMode instead of the \ref \AZ::TransformBus
+        //! because a collider may have an additional translation/orientation offset from
+        //! the Entity transform.
         virtual AZ::Transform GetCurrentTransform() = 0;
-        /// Get the scale currently applied to the box.
-        /// With the Box Shape, the largest x/y/z component is taken
-        /// so scale is always uniform, with colliders the scale may
-        /// be different per component.
+        //! Get the scale currently applied to the box.
+        //! With the Box Shape, the largest x/y/z component is taken
+        //! so scale is always uniform, with colliders the scale may
+        //! be different per component.
         virtual AZ::Vector3 GetBoxScale() = 0;
 
     protected:
         ~BoxManipulatorRequests() = default;
     };
 
-    /// Type to inherit to implement BoxManipulatorRequests
+    //! Type to inherit to implement BoxManipulatorRequests
     using BoxManipulatorRequestBus = AZ::EBus<BoxManipulatorRequests>;
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/EditorVertexSelection.h

@@ -1,22 +1,22 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
 #include <AzCore/Math/VertexContainer.h>
 #include <AzCore/Math/VertexContainerInterface.h>
 #include <AzFramework/Entity/EntityDebugDisplayBus.h>
-#include <AzToolsFramework/Manipulators/ManipulatorBus.h>
 #include <AzToolsFramework/Manipulators/HoverSelection.h>
+#include <AzToolsFramework/Manipulators/ManipulatorBus.h>
 #include <AzToolsFramework/Manipulators/SelectionManipulator.h>
 #include <AzToolsFramework/Manipulators/TranslationManipulators.h>
 #include <AzToolsFramework/Viewport/ActionBus.h>
@@ -24,37 +24,74 @@
 
 namespace AzToolsFramework
 {
-    /// Concrete implementation of AZ::VariableVertices backed by an AZ::VertexContainer.
+    //! Concrete implementation of AZ::VariableVertices backed by an AZ::VertexContainer.
     template<typename Vertex>
-    class VariableVerticesVertexContainer
-        : public AZ::VariableVertices<Vertex>
+    class VariableVerticesVertexContainer : public AZ::VariableVertices<Vertex>
     {
     public:
         explicit VariableVerticesVertexContainer(AZ::VertexContainer<Vertex>& vertexContainer)
-            : m_vertexContainer(vertexContainer) {}
+            : m_vertexContainer(vertexContainer)
+        {
+        }
 
-        bool GetVertex(size_t index, Vertex& vertex) const override { return m_vertexContainer.GetVertex(index, vertex); }
-        bool UpdateVertex(size_t index, const Vertex& vertex) override { return m_vertexContainer.UpdateVertex(index, vertex); };
-        void AddVertex(const Vertex& vertex) override { m_vertexContainer.AddVertex(vertex); }
-        bool InsertVertex(size_t index, const Vertex& vertex) override { return m_vertexContainer.InsertVertex(index, vertex); }
-        bool RemoveVertex(size_t index) override { return m_vertexContainer.RemoveVertex(index); }
-        void SetVertices(const AZStd::vector<Vertex>& vertices) override { m_vertexContainer.SetVertices(vertices); };
-        void ClearVertices() override { m_vertexContainer.Clear(); }
-        size_t Size() const override { return m_vertexContainer.Size();  }
-        bool Empty() const override { return m_vertexContainer.Empty(); }
+        bool GetVertex(size_t index, Vertex& vertex) const override
+        {
+            return m_vertexContainer.GetVertex(index, vertex);
+        }
+
+        bool UpdateVertex(size_t index, const Vertex& vertex) override
+        {
+            return m_vertexContainer.UpdateVertex(index, vertex);
+        };
+
+        void AddVertex(const Vertex& vertex) override
+        {
+            m_vertexContainer.AddVertex(vertex);
+        }
+
+        bool InsertVertex(size_t index, const Vertex& vertex) override
+        {
+            return m_vertexContainer.InsertVertex(index, vertex);
+        }
+
+        bool RemoveVertex(size_t index) override
+        {
+            return m_vertexContainer.RemoveVertex(index);
+        }
+
+        void SetVertices(const AZStd::vector<Vertex>& vertices) override
+        {
+            m_vertexContainer.SetVertices(vertices);
+        };
+
+        void ClearVertices() override
+        {
+            m_vertexContainer.Clear();
+        }
+
+        size_t Size() const override
+        {
+            return m_vertexContainer.Size();
+        }
+
+        bool Empty() const override
+        {
+            return m_vertexContainer.Empty();
+        }
 
     private:
         AZ::VertexContainer<Vertex>& m_vertexContainer;
     };
 
-    /// Concrete implementation of AZ::FixedVertices backed by an AZStd::array.
+    //! Concrete implementation of AZ::FixedVertices backed by an AZStd::array.
     template<typename Vertex, size_t Count>
-    class FixedVerticesArray
-        : public AZ::FixedVertices<Vertex>
+    class FixedVerticesArray : public AZ::FixedVertices<Vertex>
     {
     public:
         explicit FixedVerticesArray(AZStd::array<Vertex, Count>& array)
-            : m_array(array) {}
+            : m_array(array)
+        {
+        }
 
         bool GetVertex(size_t index, Vertex& vertex) const override
         {
@@ -72,22 +109,26 @@ namespace AzToolsFramework
             if (index < m_array.size())
             {
                 m_array[index] = vertex;
-                return true;;
+                return true;
+                ;
             }
 
             return false;
         }
 
-        size_t Size() const override { return m_array.size(); }
+        size_t Size() const override
+        {
+            return m_array.size();
+        }
 
     private:
         AZStd::array<Vertex, Count>& m_array;
     };
 
-    /// EditorVertexSelection provides an interface for a collection of manipulators to expose
-    /// editing of vertices in a container/collection. EditorVertexSelection is templated on the
-    /// type of Vertex (Vector2/Vector3) stored in the container.
-    /// EditorVertexSelectionBase provides common behavior shared across Fixed and Variable selections.
+    //! EditorVertexSelection provides an interface for a collection of manipulators to expose
+    //! editing of vertices in a container/collection. EditorVertexSelection is templated on the
+    //! type of Vertex (Vector2/Vector3) stored in the container.
+    //! EditorVertexSelectionBase provides common behavior shared across Fixed and Variable selections.
     template<typename Vertex>
     class EditorVertexSelectionBase
         : private AzFramework::EntityDebugDisplayEventBus::Handler
@@ -99,89 +140,110 @@ namespace AzToolsFramework
         EditorVertexSelectionBase& operator=(EditorVertexSelectionBase&&) = default;
         virtual ~EditorVertexSelectionBase() = default;
 
-        /// Setup and configure the EditorVertexSelection for operation.
+        //! Setup and configure the EditorVertexSelection for operation.
         void Create(
-            const AZ::EntityComponentIdPair& entityComponentIdPair, ManipulatorManagerId managerId,
+            const AZ::EntityComponentIdPair& entityComponentIdPair,
+            ManipulatorManagerId managerId,
             AZStd::unique_ptr<HoverSelection> hoverSelection,
             TranslationManipulators::Dimensions dimensions,
             TranslationManipulatorConfiguratorFn translationManipulatorConfigurator);
 
-        /// Create a translation manipulator for a given vertex.
+        //! Create a translation manipulator for a given vertex.
         void CreateTranslationManipulator(
-            const AZ::EntityComponentIdPair& entityComponentIdPair,
-            ManipulatorManagerId managerId, const Vertex& vertex, size_t index);
+            const AZ::EntityComponentIdPair& entityComponentIdPair, ManipulatorManagerId managerId, const Vertex& vertex, size_t index);
 
-        /// Destroy all manipulators associated with the vertex selection.
+        //! Destroy all manipulators associated with the vertex selection.
         void Destroy();
 
-        /// Set custom callback for when vertex positions are updated.
+        //! Set custom callback for when vertex positions are updated.
         void SetVertexPositionsUpdatedCallback(const AZStd::function<void()>& callback);
 
-        /// Update manipulators based on local changes to vertex positions.
+        //! Update manipulators based on local changes to vertex positions.
         void RefreshLocal();
-        /// Update the translation manipulator to be correctly positioned based
-        /// on the current selection (recenter it).
+        //! Update the translation manipulator to be correctly positioned based
+        //! on the current selection (recenter it).
         void RefreshTranslationManipulator();
-        /// Update manipulators based on changes to the entity's transform and non-uniform scale.
+        //! Update manipulators based on changes to the entity's transform and non-uniform scale.
         void RefreshSpace(const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale = AZ::Vector3::CreateOne());
 
-        /// Set bounds dirty (need recalculating) for all owned manipulators (selection, translation, hover).
+        //! Set bounds dirty (need recalculating) for all owned manipulators (selection, translation, hover).
         void SetBoundsDirty();
 
-        /// How should the EditorVertexSelection respond to mouse input.
-        virtual bool HandleMouse(
-            const ViewportInteraction::MouseInteractionEvent& mouseInteraction);
+        //! How should the EditorVertexSelection respond to mouse input.
+        virtual bool HandleMouse(const ViewportInteraction::MouseInteractionEvent& mouseInteraction);
 
-        /// Snap the selected vertices to the terrain.
-        /// Note: With a multi-selection the manipulator will be translated to the picked
-        /// terrain position with all verts moved relative to it.
-        void SnapVerticesToTerrain(
-            const ViewportInteraction::MouseInteractionEvent& mouseInteraction);
+        //! Snap the selected vertices to the terrain.
+        //! Note: With a multi-selection the manipulator will be translated to the picked
+        //! terrain position with all vertices moved relative to it.
+        void SnapVerticesToTerrain(const ViewportInteraction::MouseInteractionEvent& mouseInteraction);
 
-        /// The Actions provided by the EditorVertexSelection while it is active.
-        /// e.g. Vertex deletion, duplication etc.
+        //! The Actions provided by the EditorVertexSelection while it is active.
+        //! e.g. Vertex deletion, duplication etc.
         AZStd::vector<ActionOverride> ActionOverrides() const;
 
-        /// Let the EditorVertexSelection know a batch movement is about to begin so it
-        /// can avoid certain unnecessary updates.
+        //! Let the EditorVertexSelection know a batch movement is about to begin so it
+        //! can avoid certain unnecessary updates.
         void BeginBatchMovement();
 
-        /// Let the EditorVertexSelection know a batch movement has ended so it can return
-        /// to its normal state.
+        //! Let the EditorVertexSelection know a batch movement has ended so it can return
+        //! to its normal state.
         void EndBatchMovement();
 
-        /// Set the position of the TranslationManipulators (if active).
+        //! Set the position of the TranslationManipulators (if active).
         void SetSelectedPosition(const AZ::Vector3& localPosition);
 
-        AZ::EntityId GetEntityId() const { return m_entityComponentIdPair.GetEntityId(); }
+        AZ::EntityId GetEntityId() const
+        {
+            return m_entityComponentIdPair.GetEntityId();
+        }
 
     protected:
-        /// Internal interface for EditorVertexSelection.
+        //! Internal interface for EditorVertexSelection.
         virtual void SetupSelectionManipulator(
             const AZStd::shared_ptr<SelectionManipulator>& selectionManipulator,
             const AZ::EntityComponentIdPair& entityComponentIdPair,
-            ManipulatorManagerId managerId, size_t index) = 0;
+            ManipulatorManagerId managerId,
+            size_t index) = 0;
         virtual void PrepareActions() = 0;
 
-        /// Default behavior when clicking on a selection manipulator (representing a vertex).
+        //! Default behavior when clicking on a selection manipulator (representing a vertex).
         void SelectionManipulatorSelectCallback(
-            size_t index, const ViewportInteraction::MouseInteraction& interaction,
-            const AZ::EntityComponentIdPair& entityComponentIdPair, ManipulatorManagerId managerId);
+            size_t index,
+            const ViewportInteraction::MouseInteraction& interaction,
+            const AZ::EntityComponentIdPair& entityComponentIdPair,
+            ManipulatorManagerId managerId);
 
-        /// Destroy the translation manipulator and deselect all vertices.
+        //! Destroy the translation manipulator and deselect all vertices.
         void ClearSelected();
 
-        AZ::ComponentId GetComponentId() const { return m_entityComponentIdPair.GetComponentId(); }
-        const AZ::EntityComponentIdPair& GetEntityComponentIdPair() const { return m_entityComponentIdPair; }
-        ManipulatorManagerId GetManipulatorManagerId() const { return m_manipulatorManagerId; }
+        AZ::ComponentId GetComponentId() const
+        {
+            return m_entityComponentIdPair.GetComponentId();
+        }
 
-        /// Is the translation vertex manipulator in 2D or 3D.
-        TranslationManipulators::Dimensions Dimensions() const { return m_dimensions; }
+        const AZ::EntityComponentIdPair& GetEntityComponentIdPair() const
+        {
+            return m_entityComponentIdPair;
+        }
 
-        /// How to configure the translation manipulator (view and axes).
-        TranslationManipulatorConfiguratorFn ConfiguratorFn() const { return  m_manipulatorConfiguratorFn; }
+        ManipulatorManagerId GetManipulatorManagerId() const
+        {
+            return m_manipulatorManagerId;
+        }
 
-        /// The state we are in when editing vertices.
+        //! Is the translation vertex manipulator in 2D or 3D.
+        TranslationManipulators::Dimensions Dimensions() const
+        {
+            return m_dimensions;
+        }
+
+        //! How to configure the translation manipulator (view and axes).
+        TranslationManipulatorConfiguratorFn ConfiguratorFn() const
+        {
+            return m_manipulatorConfiguratorFn;
+        }
+
+        //! The state we are in when editing vertices.
         enum class State
         {
             Selecting,
@@ -190,23 +252,22 @@ namespace AzToolsFramework
 
         void SetState(State state);
 
-        AZStd::unique_ptr<HoverSelection> m_hoverSelection = nullptr; ///< Interface to hover selection, representing bounds that can be selected.
-        AZStd::shared_ptr<IndexedTranslationManipulator<Vertex>> m_translationManipulator = nullptr; ///< Manipulator when vertex is selected to translate it.
-        AZStd::vector<AZStd::shared_ptr<SelectionManipulator>> m_selectionManipulators; ///< Manipulators for each vertex when entity is selected.
-        AZStd::array<AZStd::vector<ActionOverride>, 2> m_actionOverrides; ///< Available actions corresponding to each mode.
+        AZStd::unique_ptr<HoverSelection> m_hoverSelection =
+            nullptr; //!< Interface to hover selection, representing bounds that can be selected.
+        AZStd::shared_ptr<IndexedTranslationManipulator<Vertex>> m_translationManipulator =
+            nullptr; //!< Manipulator when vertex is selected to translate it.
+        AZStd::vector<AZStd::shared_ptr<SelectionManipulator>>
+            m_selectionManipulators; //!< Manipulators for each vertex when entity is selected.
+        AZStd::array<AZStd::vector<ActionOverride>, 2> m_actionOverrides; //!< Available actions corresponding to each mode.
 
     private:
         // AzFramework::EntityDebugDisplayEventBus
-        void DisplayEntityViewport(
-            const AzFramework::ViewportInfo& viewportInfo,
-            AzFramework::DebugDisplayRequests& debugDisplay) override;
+        void DisplayEntityViewport(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay) override;
 
         // AzFramework::ViewportDebugDisplayEventBus
-        void DisplayViewport2d(
-            const AzFramework::ViewportInfo& viewportInfo,
-            AzFramework::DebugDisplayRequests& debugDisplay) override;
+        void DisplayViewport2d(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay) override;
 
-        /// Set selected manipulator and vertices position from offset from starting position when pressed.
+        //! Set selected manipulator and vertices position from offset from starting position when pressed.
         void UpdateManipulatorsAndVerticesFromOffset(
             IndexedTranslationManipulator<Vertex>& translationManipulator,
             const AZ::Vector3& localManipulatorStartPosition,
@@ -217,23 +278,24 @@ namespace AzToolsFramework
         template<typename V, typename AZStd::enable_if<AZStd::is_same<V, AZ::Vector2>::value>::type* = nullptr>
         void UpdateManipulatorSpace(const AzFramework::ViewportInfo& viewportInfo) const;
 
-        EditorBoxSelect m_editorBoxSelect; ///< Provide box select support for vertex selection.
-        AZ::EntityComponentIdPair m_entityComponentIdPair; ///< Id of the Entity and Component this editor vertex selection was created on.
-        ManipulatorManagerId m_manipulatorManagerId; ///< Id of the manager manipulators created from this type will be associated with.
-        TranslationManipulators::Dimensions m_dimensions = TranslationManipulators::Dimensions::Three; ///< The dimensions this vertex selection was created with.
-        TranslationManipulatorConfiguratorFn m_manipulatorConfiguratorFn = nullptr; ///< Function pointer set on Create to decide look and functionality of translation manipulator.
-        AZStd::function<void()> m_onVertexPositionsUpdated = nullptr; ///< Callback for when vertex positions are changed.
-        State m_state = State::Selecting; ///< Different states VertexSelection can be in.
-        bool m_worldSpace = false; ///< Are the manipulators being used in local or world space.
-        bool m_batchMovementInProgress = false; ///< If a batch movement operation is in progress we do not want to
-                                                ///< refresh the VertexSelection during it for performance reasons.
+        EditorBoxSelect m_editorBoxSelect; //!< Provide box select support for vertex selection.
+        AZ::EntityComponentIdPair m_entityComponentIdPair; //!< Id of the Entity and Component this editor vertex selection was created on.
+        ManipulatorManagerId m_manipulatorManagerId; //!< Id of the manager manipulators created from this type will be associated with.
+        TranslationManipulators::Dimensions m_dimensions =
+            TranslationManipulators::Dimensions::Three; //!< The dimensions this vertex selection was created with.
+        TranslationManipulatorConfiguratorFn m_manipulatorConfiguratorFn =
+            nullptr; //!< Function pointer set on Create to decide look and functionality of translation manipulator.
+        AZStd::function<void()> m_onVertexPositionsUpdated = nullptr; //!< Callback for when vertex positions are changed.
+        State m_state = State::Selecting; //!< Different states VertexSelection can be in.
+        bool m_worldSpace = false; //!< Are the manipulators being used in local or world space.
+        bool m_batchMovementInProgress = false; //!< If a batch movement operation is in progress we do not want to
+                                                //!< refresh the VertexSelection during it for performance reasons.
     };
 
-    /// EditorVertexSelectionFixed provides selection and editing for a fixed length number of
-    /// vertices. New vertices cannot be inserted/added or removed.
+    //! EditorVertexSelectionFixed provides selection and editing for a fixed length number of
+    //! vertices. New vertices cannot be inserted/added or removed.
     template<typename Vertex>
-    class EditorVertexSelectionFixed
-        : public EditorVertexSelectionBase<Vertex>
+    class EditorVertexSelectionFixed : public EditorVertexSelectionBase<Vertex>
     {
     public:
         AZ_CLASS_ALLOCATOR_DECL
@@ -247,15 +309,15 @@ namespace AzToolsFramework
         void SetupSelectionManipulator(
             const AZStd::shared_ptr<SelectionManipulator>& selectionManipulator,
             const AZ::EntityComponentIdPair& entityComponentIdPair,
-            ManipulatorManagerId managerId, size_t index) override;
+            ManipulatorManagerId managerId,
+            size_t index) override;
         void PrepareActions() override;
     };
 
-    /// EditorVertexSelectionVariable provides selection and editing for a variable length number of
-    /// vertices. New vertices can be inserted/added or removed from the collection.
+    //! EditorVertexSelectionVariable provides selection and editing for a variable length number of
+    //! vertices. New vertices can be inserted/added or removed from the collection.
     template<typename Vertex>
-    class EditorVertexSelectionVariable
-        : public EditorVertexSelectionBase<Vertex>
+    class EditorVertexSelectionVariable : public EditorVertexSelectionBase<Vertex>
     {
     public:
         AZ_CLASS_ALLOCATOR_DECL
@@ -272,7 +334,8 @@ namespace AzToolsFramework
         void SetupSelectionManipulator(
             const AZStd::shared_ptr<SelectionManipulator>& selectionManipulator,
             const AZ::EntityComponentIdPair& entityComponentIdPair,
-            ManipulatorManagerId managerId, size_t vertIndex) override;
+            ManipulatorManagerId managerId,
+            size_t vertIndex) override;
 
         //! Presents a warning to the user that vertices will not be deleted.
         //! @note Allow overriding by derived classes to make this a noop if required.
@@ -281,21 +344,18 @@ namespace AzToolsFramework
     private:
         void PrepareActions() override;
 
-        /// @return The center point of the selected vertices.
-        Vertex InsertSelectedInPlace(
-            AZStd::vector<typename IndexedTranslationManipulator<Vertex>::VertexLookup>& manipulators);
+        //! @return The center point of the selected vertices.
+        Vertex InsertSelectedInPlace(AZStd::vector<typename IndexedTranslationManipulator<Vertex>::VertexLookup>& manipulators);
     };
 
-    /// Helper for inserting a vertex in a variable vertices container.
+    //! Helper for inserting a vertex in a variable vertices container.
     template<typename Vertex>
-    void InsertVertexAfter(
-        const AZ::EntityComponentIdPair& entityComponentIdPair, size_t vertIndex, const Vertex& localPosition);
+    void InsertVertexAfter(const AZ::EntityComponentIdPair& entityComponentIdPair, size_t vertIndex, const Vertex& localPosition);
 
-    /// Helper for removing a vertex in a variable vertices container.
-    /// Remove a vertex from the container and ensure the associated manipulator is unset and
-    /// property display values are refreshed.
+    //! Helper for removing a vertex in a variable vertices container.
+    //! Remove a vertex from the container and ensure the associated manipulator is unset and
+    //! property display values are refreshed.
     template<typename Vertex>
-    void SafeRemoveVertex(
-        const AZ::EntityComponentIdPair& entityComponentIdPair, size_t vertexIndex);
+    void SafeRemoveVertex(const AZ::EntityComponentIdPair& entityComponentIdPair, size_t vertexIndex);
 
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/HoverSelection.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -16,10 +16,10 @@
 
 namespace AzToolsFramework
 {
-    /// HoverSelection provides an interface for manipulator/s offering selection when
-    /// the mouse is hovered over a particular bound. This interface is used to represent
-    /// a Spline manipulator bound, and a series of LineSegment manipulator bounds.
-    /// This generic interface allows EditorVertexSelection to use either Spline or LineSegment selection.
+    //! HoverSelection provides an interface for manipulator/s offering selection when
+    //! the mouse is hovered over a particular bound. This interface is used to represent
+    //! a Spline manipulator bound, and a series of LineSegment manipulator bounds.
+    //! This generic interface allows EditorVertexSelection to use either Spline or LineSegment selection.
     class HoverSelection
     {
     public:
@@ -33,21 +33,37 @@ namespace AzToolsFramework
         virtual void SetNonUniformScale(const AZ::Vector3& nonUniformScale) = 0;
     };
 
-    /// NullHoverSelection is used when vertices cannot be inserted. This serves as a no-op
-    /// and is used to prevent the need for additional null checks in EditorVertexSelection.
-    class NullHoverSelection
-        : public HoverSelection
+    //! NullHoverSelection is used when vertices cannot be inserted. This serves as a no-op
+    //! and is used to prevent the need for additional null checks in EditorVertexSelection.
+    class NullHoverSelection : public HoverSelection
     {
     public:
         NullHoverSelection() = default;
         NullHoverSelection(const NullHoverSelection&) = delete;
         NullHoverSelection& operator=(const NullHoverSelection&) = delete;
 
-        void Register(ManipulatorManagerId /*managerId*/) override {}
-        void Unregister() override {}
-        void SetBoundsDirty() override {}
-        void Refresh() override {}
-        void SetSpace(const AZ::Transform& /*worldFromLocal*/) override {}
-        void SetNonUniformScale([[maybe_unused]] const AZ::Vector3& nonUniformScale) override {}
+        void Register([[maybe_unused]] ManipulatorManagerId managerId) override
+        {
+        }
+
+        void Unregister() override
+        {
+        }
+
+        void SetBoundsDirty() override
+        {
+        }
+
+        void Refresh() override
+        {
+        }
+
+        void SetSpace([[maybe_unused]] const AZ::Transform& worldFromLocal) override
+        {
+        }
+
+        void SetNonUniformScale([[maybe_unused]] const AZ::Vector3& nonUniformScale) override
+        {
+        }
     };
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineHoverSelection.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "LineHoverSelection.h"
 
@@ -22,17 +22,15 @@
 
 namespace AzToolsFramework
 {
-    static const AZ::Color s_lineSelectManipulatorColor = AZ::Color(0.0f, 1.0f, 0.0f, 1.0f);
+    static const AZ::Color LineSelectManipulatorColor = AZ::Color(0.0f, 1.0f, 0.0f, 1.0f);
 
     template<typename Vertex>
-    static void UpdateLineSegmentPosition(
-        const size_t vertIndex, const AZ::EntityId entityId, LineSegmentSelectionManipulator& lineSegment)
+    static void UpdateLineSegmentPosition(const size_t vertIndex, const AZ::EntityId entityId, LineSegmentSelectionManipulator& lineSegment)
     {
         Vertex start;
         bool foundStart = false;
         AZ::FixedVerticesRequestBus<Vertex>::EventResult(
-            foundStart, entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::GetVertex,
-            vertIndex, start);
+            foundStart, entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::GetVertex, vertIndex, start);
 
         if (foundStart)
         {
@@ -40,14 +38,12 @@ namespace AzToolsFramework
         }
 
         size_t size = 0;
-        AZ::FixedVerticesRequestBus<Vertex>::EventResult(
-            size, entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::Size);
+        AZ::FixedVerticesRequestBus<Vertex>::EventResult(size, entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::Size);
 
         Vertex end;
         bool foundEnd = false;
         AZ::FixedVerticesRequestBus<Vertex>::EventResult(
-            foundEnd, entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::GetVertex,
-            (vertIndex + 1) % size, end);
+            foundEnd, entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::GetVertex, (vertIndex + 1) % size, end);
 
         if (foundEnd)
         {
@@ -56,8 +52,7 @@ namespace AzToolsFramework
 
         // update the view
         const float lineWidth = 0.05f;
-        lineSegment.SetView(
-            CreateManipulatorViewLineSelect(lineSegment, s_lineSelectManipulatorColor, lineWidth));
+        lineSegment.SetView(CreateManipulatorViewLineSelect(lineSegment, LineSelectManipulatorColor, lineWidth));
     }
 
     template<typename Vertex>
@@ -66,9 +61,8 @@ namespace AzToolsFramework
         : m_entityId(entityComponentIdPair.GetEntityId())
     {
         // create a line segment manipulator from vertex positions and setup its callback
-        auto setupLineSegment = [this] (
-            const AZ::EntityComponentIdPair& entityComponentIdPair,
-            const ManipulatorManagerId managerId, const size_t vertIndex)
+        auto setupLineSegment =
+            [this](const AZ::EntityComponentIdPair& entityComponentIdPair, const ManipulatorManagerId managerId, const size_t vertIndex)
         {
             m_lineSegmentManipulators.push_back(LineSegmentSelectionManipulator::MakeShared());
             AZStd::shared_ptr<LineSegmentSelectionManipulator>& lineSegmentManipulator = m_lineSegmentManipulators.back();
@@ -81,11 +75,9 @@ namespace AzToolsFramework
 
             lineSegmentManipulator->InstallLeftMouseUpCallback(
                 [vertIndex, entityComponentIdPair](const LineSegmentSelectionManipulator::Action& action)
-            {
-                InsertVertexAfter<Vertex>(
-                    entityComponentIdPair, vertIndex,
-                    AZ::AdaptVertexIn<Vertex>(action.m_localLineHitPosition));
-            });
+                {
+                    InsertVertexAfter<Vertex>(entityComponentIdPair, vertIndex, AZ::AdaptVertexIn<Vertex>(action.m_localLineHitPosition));
+                });
         };
 
         // create all line segment manipulators for the polygon prism (used for selection bounds)
@@ -150,8 +142,7 @@ namespace AzToolsFramework
     void LineSegmentHoverSelection<Vertex>::Refresh()
     {
         size_t vertexCount = 0;
-        AZ::FixedVerticesRequestBus<Vertex>::EventResult(
-            vertexCount, m_entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::Size);
+        AZ::FixedVerticesRequestBus<Vertex>::EventResult(vertexCount, m_entityId, &AZ::FixedVerticesRequestBus<Vertex>::Handler::Size);
 
         // update the start/end positions of all the line segment manipulators to ensure
         // they stay consistent with the polygon prism shape

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineHoverSelection.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -25,17 +25,14 @@ namespace AzToolsFramework
 {
     class LineSegmentSelectionManipulator;
 
-    /// LineSegmentHoverSelection is a concrete implementation of HoverSelection wrapping a collection/container
-    /// of vertices and a list of LineSegmentManipulators. The underlying manipulators are used to control selection
-    /// by highlighting where on the line a new vertex will be inserted.
+    //! LineSegmentHoverSelection is a concrete implementation of HoverSelection wrapping a collection/container
+    //! of vertices and a list of LineSegmentManipulators. The underlying manipulators are used to control selection
+    //! by highlighting where on the line a new vertex will be inserted.
     template<typename Vertex>
-    class LineSegmentHoverSelection
-        : public HoverSelection
+    class LineSegmentHoverSelection : public HoverSelection
     {
     public:
-        explicit LineSegmentHoverSelection(
-            const AZ::EntityComponentIdPair& entityComponentIdPair,
-            ManipulatorManagerId managerId);
+        explicit LineSegmentHoverSelection(const AZ::EntityComponentIdPair& entityComponentIdPair, ManipulatorManagerId managerId);
         LineSegmentHoverSelection(const LineSegmentHoverSelection&) = delete;
         LineSegmentHoverSelection& operator=(const LineSegmentHoverSelection&) = delete;
         ~LineSegmentHoverSelection();
@@ -49,6 +46,6 @@ namespace AzToolsFramework
 
     private:
         AZ::EntityId m_entityId;
-        AZStd::vector<AZStd::shared_ptr<LineSegmentSelectionManipulator>> m_lineSegmentManipulators; ///< Manipulators for each line.
+        AZStd::vector<AZStd::shared_ptr<LineSegmentSelectionManipulator>> m_lineSegmentManipulators; //!< Manipulators for each line.
     };
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineSegmentSelectionManipulator.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "LineSegmentSelectionManipulator.h"
 
@@ -20,15 +20,20 @@
 namespace AzToolsFramework
 {
     LineSegmentSelectionManipulator::Action CalculateManipulationDataAction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale, const AZ::Vector3& rayOrigin,
-        const AZ::Vector3& rayDirection, const float rayLength, const AZ::Vector3& localStart, const AZ::Vector3& localEnd)
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Vector3& rayOrigin,
+        const AZ::Vector3& rayDirection,
+        const float rayLength,
+        const AZ::Vector3& localStart,
+        const AZ::Vector3& localEnd)
     {
         AZ::Vector3 worldClosestPositionRay, worldClosestPositionLineSegment;
         float rayProportion, lineSegmentProportion;
         AZ::Intersect::ClosestSegmentSegment(
-            rayOrigin, rayOrigin + rayDirection * rayLength,
-            worldFromLocal.TransformPoint(nonUniformScale * localStart), worldFromLocal.TransformPoint(nonUniformScale * localEnd),
-            rayProportion, lineSegmentProportion, worldClosestPositionRay, worldClosestPositionLineSegment);
+            rayOrigin, rayOrigin + rayDirection * rayLength, worldFromLocal.TransformPoint(nonUniformScale * localStart),
+            worldFromLocal.TransformPoint(nonUniformScale * localEnd), rayProportion, lineSegmentProportion, worldClosestPositionRay,
+            worldClosestPositionLineSegment);
 
         AZ::Transform worldFromLocalNormalized = worldFromLocal;
         const AZ::Vector3 scale = worldFromLocalNormalized.ExtractUniformScale() * nonUniformScale;
@@ -47,7 +52,9 @@ namespace AzToolsFramework
         AttachLeftMouseDownImpl();
     }
 
-    LineSegmentSelectionManipulator::~LineSegmentSelectionManipulator() {}
+    LineSegmentSelectionManipulator::~LineSegmentSelectionManipulator()
+    {
+    }
 
     void LineSegmentSelectionManipulator::InstallLeftMouseDownCallback(const MouseActionCallback& onMouseDownCallback)
     {
@@ -112,12 +119,9 @@ namespace AzToolsFramework
         if (mouseInteraction.m_keyboardModifiers.Ctrl() && !mouseInteraction.m_keyboardModifiers.Shift())
         {
             m_manipulatorView->Draw(
-                GetManipulatorManagerId(), managerState,
-                GetManipulatorId(), {
-                    TransformUniformScale(GetSpace()), GetNonUniformScale(),
-                    m_localStart, MouseOver()
-                },
-                debugDisplay, cameraState, mouseInteraction);
+                GetManipulatorManagerId(), managerState, GetManipulatorId(),
+                { TransformUniformScale(GetSpace()), GetNonUniformScale(), m_localStart, MouseOver() }, debugDisplay, cameraState,
+                mouseInteraction);
         }
     }
 
@@ -135,4 +139,4 @@ namespace AzToolsFramework
     {
         m_manipulatorView->Invalidate(GetManipulatorManagerId());
     }
-}
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineSegmentSelectionManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -20,12 +20,12 @@ namespace AzToolsFramework
 {
     class ManipulatorView;
 
-    /// A manipulator to expose where on a line a user is moving their mouse.
+    //! A manipulator to expose where on a line a user is moving their mouse.
     class LineSegmentSelectionManipulator
         : public BaseManipulator
         , public ManipulatorSpace
     {
-        /// Private constructor.
+        //! Private constructor.
         LineSegmentSelectionManipulator();
 
     public:
@@ -37,10 +37,10 @@ namespace AzToolsFramework
 
         ~LineSegmentSelectionManipulator();
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
+        //! A Manipulator must only be created and managed through a shared_ptr.
         static AZStd::shared_ptr<LineSegmentSelectionManipulator> MakeShared();
 
-        /// Mouse action data used by MouseActionCallback.
+        //! Mouse action data used by MouseActionCallback.
         struct Action
         {
             AZ::Vector3 m_localLineHitPosition;
@@ -57,18 +57,31 @@ namespace AzToolsFramework
             const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
-        void SetStart(const AZ::Vector3& startLocal) { m_localStart = startLocal; }
-        void SetEnd(const AZ::Vector3& endLocal) { m_localEnd = endLocal; }
-        const AZ::Vector3& GetStart() const { return m_localStart; }
-        const AZ::Vector3& GetEnd() const { return m_localEnd; }
+        void SetStart(const AZ::Vector3& startLocal)
+        {
+            m_localStart = startLocal;
+        }
+
+        void SetEnd(const AZ::Vector3& endLocal)
+        {
+            m_localEnd = endLocal;
+        }
+
+        const AZ::Vector3& GetStart() const
+        {
+            return m_localStart;
+        }
+
+        const AZ::Vector3& GetEnd() const
+        {
+            return m_localEnd;
+        }
 
         void SetView(AZStd::unique_ptr<ManipulatorView>&& view);
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
         void SetBoundsDirtyImpl() override;
@@ -79,12 +92,18 @@ namespace AzToolsFramework
         MouseActionCallback m_onLeftMouseDownCallback = nullptr;
         MouseActionCallback m_onLeftMouseUpCallback = nullptr;
 
-        ViewportInteraction::KeyboardModifiers m_keyboardModifiers; ///< What modifier keys are pressed when interacting with this manipulator.
+        ViewportInteraction::KeyboardModifiers
+            m_keyboardModifiers; //!< What modifier keys are pressed when interacting with this manipulator.
 
-        AZStd::unique_ptr<ManipulatorView> m_manipulatorView = nullptr; ///< Look of manipulator.
+        AZStd::unique_ptr<ManipulatorView> m_manipulatorView = nullptr; //!< Look of manipulator.
     };
 
     LineSegmentSelectionManipulator::Action CalculateManipulationDataAction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale, const AZ::Vector3& rayOrigin,
-        const AZ::Vector3& rayDirection, float rayLength, const AZ::Vector3& localStart, const AZ::Vector3& localEnd);
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Vector3& rayOrigin,
+        const AZ::Vector3& rayDirection,
+        float rayLength,
+        const AZ::Vector3& localStart,
+        const AZ::Vector3& localEnd);
 } // namespace AzToolsFramework

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "LinearManipulator.h"
 
@@ -22,13 +22,16 @@
 namespace AzToolsFramework
 {
     LinearManipulator::Starter CalculateLinearManipulationDataStart(
-        const LinearManipulator::Fixed& fixed, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-        const AZ::Transform& localTransform, const ViewportInteraction::MouseInteraction& interaction, const float intersectionDistance,
+        const LinearManipulator::Fixed& fixed,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
+        const ViewportInteraction::MouseInteraction& interaction,
+        const float intersectionDistance,
         const AzFramework::CameraState& cameraState)
     {
-        const ManipulatorInteraction manipulatorInteraction =
-            BuildManipulatorInteraction(
-                worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
+        const ManipulatorInteraction manipulatorInteraction = BuildManipulatorInteraction(
+            worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
 
         const AZ::Vector3 axis = TransformDirectionNoScaling(localTransform, fixed.m_axis);
         const AZ::Vector3 rayCrossAxis = manipulatorInteraction.m_localRayDirection.Cross(axis);
@@ -47,32 +50,35 @@ namespace AzToolsFramework
             manipulatorInteraction.m_localRayOrigin + manipulatorInteraction.m_localRayDirection * intersectionDistance;
 
         Internal::CalculateRayPlaneIntersectingPoint(
-            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection,
-            localIntersectionPoint, startTransition.m_localNormal, start.m_localHitPosition);
+            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection, localIntersectionPoint,
+            startTransition.m_localNormal, start.m_localHitPosition);
 
         start.m_screenPosition = interaction.m_mousePick.m_screenCoordinates;
         start.m_localPosition = localTransform.GetTranslation();
-        start.m_localScale = AZ::Vector3(localTransform.GetUniformScale());;
+        start.m_localScale = AZ::Vector3(localTransform.GetUniformScale());
+        ;
         start.m_localAxis = axis;
         // sign to determine which side of the linear axis we pressed
         // (useful to know when the visual axis flips to face the camera)
-        start.m_sign =
-            AZ::GetSign((start.m_localHitPosition - localTransform.GetTranslation()).Dot(axis));
+        start.m_sign = AZ::GetSign((start.m_localHitPosition - localTransform.GetTranslation()).Dot(axis));
 
         startTransition.m_screenToWorldScale =
             1.0f / CalculateScreenToWorldMultiplier((worldFromLocal * localTransform).GetTranslation(), cameraState);
 
-        return {startTransition, start};
+        return { startTransition, start };
     }
 
     LinearManipulator::Action CalculateLinearManipulationDataAction(
-        const LinearManipulator::Fixed& fixed, const LinearManipulator::Starter& starter,
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale, const AZ::Transform& localTransform,
-        const GridSnapParameters& gridSnapParams, const ViewportInteraction::MouseInteraction& interaction)
+        const LinearManipulator::Fixed& fixed,
+        const LinearManipulator::Starter& starter,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
+        const GridSnapParameters& gridSnapParams,
+        const ViewportInteraction::MouseInteraction& interaction)
     {
-        const ManipulatorInteraction manipulatorInteraction =
-            BuildManipulatorInteraction(
-                worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
+        const ManipulatorInteraction manipulatorInteraction = BuildManipulatorInteraction(
+            worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
 
         const auto& [startTransition, start] = starter;
 
@@ -81,8 +87,8 @@ namespace AzToolsFramework
         // if an invalid ray intersection is attempted
         AZ::Vector3 localHitPosition = start.m_localHitPosition;
         Internal::CalculateRayPlaneIntersectingPoint(
-            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection,
-            start.m_localHitPosition, startTransition.m_localNormal, localHitPosition);
+            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection, start.m_localHitPosition,
+            startTransition.m_localNormal, localHitPosition);
 
         localHitPosition = Internal::TryConstrainHitPositionToView(
             localHitPosition, start.m_localHitPosition, worldFromLocal.GetInverse(),
@@ -103,9 +109,8 @@ namespace AzToolsFramework
         LinearManipulator::Action action;
         action.m_fixed = fixed;
         action.m_start = start;
-        action.m_current.m_localPositionOffset = snapping
-            ? CalculateSnappedAmount(unsnappedOffset, axis, gridSize * scaleRecip)
-            : unsnappedOffset;
+        action.m_current.m_localPositionOffset =
+            snapping ? CalculateSnappedAmount(unsnappedOffset, axis, gridSize * scaleRecip) : unsnappedOffset;
         action.m_current.m_screenPosition = interaction.m_mousePick.m_screenCoordinates;
         action.m_viewportId = interaction.m_interactionId.m_viewportId;
 
@@ -191,7 +196,8 @@ namespace AzToolsFramework
 
             // note: m_localTransform must not be made uniform as it may contain a local scale we want to snap
             m_onLeftMouseUpCallback(CalculateLinearManipulationDataAction(
-                m_fixed, m_starter, TransformUniformScale(GetSpace()), GetNonUniformScale(), GetLocalTransform(), gridSnapParams, interaction));
+                m_fixed, m_starter, TransformUniformScale(GetSpace()), GetNonUniformScale(), GetLocalTransform(), gridSnapParams,
+                interaction));
         }
     }
 
@@ -202,16 +208,14 @@ namespace AzToolsFramework
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
         const AZ::Transform localTransform = m_useVisualsOverride
-            ? AZ::Transform::CreateFromQuaternionAndTranslation(
-                m_visualOrientationOverride, GetLocalPosition())
+            ? AZ::Transform::CreateFromQuaternionAndTranslation(m_visualOrientationOverride, GetLocalPosition())
             : GetLocalTransform();
 
         if (cl_manipulatorDrawDebug)
         {
             if (PerformingAction())
             {
-                const GridSnapParameters gridSnapParams =
-                    GridSnapSettings(mouseInteraction.m_interactionId.m_viewportId);
+                const GridSnapParameters gridSnapParams = GridSnapSettings(mouseInteraction.m_interactionId.m_viewportId);
 
                 const auto action = CalculateLinearManipulationDataAction(
                     m_fixed, m_starter, TransformUniformScale(GetSpace()), GetNonUniformScale(), GetLocalTransform(), gridSnapParams,
@@ -219,9 +223,10 @@ namespace AzToolsFramework
 
                 // display the exact hit (ray intersection) of the mouse pick on the manipulator
                 DrawTransformAxes(
-                    debugDisplay, TransformUniformScale(GetSpace()) *
-                    AZ::Transform::CreateTranslation(
-                        action.m_start.m_localHitPosition + GetNonUniformScale() * action.m_current.m_localPositionOffset));
+                    debugDisplay,
+                    TransformUniformScale(GetSpace()) *
+                        AZ::Transform::CreateTranslation(
+                            action.m_start.m_localHitPosition + GetNonUniformScale() * action.m_current.m_localPositionOffset));
             }
 
             AZ::Transform combined = GetLocalTransform();
@@ -229,8 +234,7 @@ namespace AzToolsFramework
             combined = GetSpace() * combined;
 
             DrawTransformAxes(debugDisplay, combined);
-            DrawAxis(
-                debugDisplay, combined.GetTranslation(), TransformDirectionNoScaling(combined, m_fixed.m_axis));
+            DrawAxis(debugDisplay, combined.GetTranslation(), TransformDirectionNoScaling(combined, m_fixed.m_axis));
         }
 
         for (auto& view : m_manipulatorViews)
@@ -238,12 +242,9 @@ namespace AzToolsFramework
             auto nonUniformScale = GetNonUniformScale();
 
             view->Draw(
-                GetManipulatorManagerId(), managerState,
-                GetManipulatorId(), {
-                    ApplySpace(localTransform), GetNonUniformScale(),
-                    AZ::Vector3::CreateZero(), MouseOver()
-                },
-                debugDisplay, cameraState, mouseInteraction);
+                GetManipulatorManagerId(), managerState, GetManipulatorId(),
+                { ApplySpace(localTransform), GetNonUniformScale(), AZ::Vector3::CreateZero(), MouseOver() }, debugDisplay, cameraState,
+                mouseInteraction);
         }
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LinearManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -22,13 +22,13 @@ namespace AzToolsFramework
 {
     struct GridSnapParameters;
 
-    /// LinearManipulator serves as a visual tool for users to modify values
-    /// in one dimension on an axis defined in 3D space.
+    //! LinearManipulator serves as a visual tool for users to modify values
+    //! in one dimension on an axis defined in 3D space.
     class LinearManipulator
         : public BaseManipulator
         , public ManipulatorSpaceWithLocalTransform
     {
-        /// Private constructor.
+        //! Private constructor.
         explicit LinearManipulator(const AZ::Transform& worldFromLocal);
 
     public:
@@ -41,68 +41,80 @@ namespace AzToolsFramework
 
         ~LinearManipulator() = default;
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
-        /// @note worldFromLocal should not contain scale.
+        //! A Manipulator must only be created and managed through a shared_ptr.
+        //! @note worldFromLocal should not contain scale.
         static AZStd::shared_ptr<LinearManipulator> MakeShared(const AZ::Transform& worldFromLocal);
 
-        /// Unchanging data set once for the linear manipulator.
+        //! Unchanging data set once for the linear manipulator.
         struct Fixed
         {
-            AZ::Vector3 m_axis = AZ::Vector3::CreateAxisX(); ///< The axis the manipulator will move along.
+            AZ::Vector3 m_axis = AZ::Vector3::CreateAxisX(); //!< The axis the manipulator will move along.
         };
 
-        /// Data passed between the initial press and first movement of the linear manipulator.
+        //! Data passed between the initial press and first movement of the linear manipulator.
         struct StartTransition
         {
-            /// The normal in local space of the manipulator when the mouse down event happens.
+            //! The normal in local space of the manipulator when the mouse down event happens.
             AZ::Vector3 m_localNormal;
-            /// Used to scale movement based on camera distance if we want screen space instead
-            /// of world space displacement.
+            //! Used to scale movement based on camera distance if we want screen space instead
+            //! of world space displacement.
             float m_screenToWorldScale;
         };
 
-        /// The state of the manipulator at the start of an interaction.
+        //! The state of the manipulator at the start of an interaction.
         struct Start
         {
-            AZ::Vector3 m_localPosition; ///< The current position of the manipulator in local space.
-            AZ::Vector3 m_localScale; ///< The current scale of the manipulator in local space.
-            AZ::Vector3 m_localHitPosition; ///< The intersection point in local space between the ray and the manipulator when the mouse down event happens.
-            AZ::Vector3 m_localAxis; ///< The axis in the local space of the manipulator itself.
-            float m_sign; ///< Used to determine which side of the axis we clicked on in case it's flipped to face the camera.
-            AzFramework::ScreenPoint m_screenPosition; ///< The initial position in screen space of the manipulator.
+            AZ::Vector3 m_localPosition; //!< The current position of the manipulator in local space.
+            AZ::Vector3 m_localScale; //!< The current scale of the manipulator in local space.
+            AZ::Vector3 m_localHitPosition; //!< The intersection point in local space between the ray and the manipulator when the mouse
+                                            //!< down event happens.
+            AZ::Vector3 m_localAxis; //!< The axis in the local space of the manipulator itself.
+            float m_sign; //!< Used to determine which side of the axis we clicked on in case it's flipped to face the camera.
+            AzFramework::ScreenPoint m_screenPosition; //!< The initial position in screen space of the manipulator.
         };
 
-        /// The state of the manipulator during an interaction.
+        //! The state of the manipulator during an interaction.
         struct Current
         {
-            AZ::Vector3 m_localPositionOffset; ///< The current offset of the manipulator from its starting position in local space.
-            AZ::Vector3 m_localScaleOffset; ///< The current offset of the manipulator from its starting scale in local space.
-            AzFramework::ScreenPoint m_screenPosition; ///< The current position in screen space of the manipulator.
+            AZ::Vector3 m_localPositionOffset; //!< The current offset of the manipulator from its starting position in local space.
+            AZ::Vector3 m_localScaleOffset; //!< The current offset of the manipulator from its starting scale in local space.
+            AzFramework::ScreenPoint m_screenPosition; //!< The current position in screen space of the manipulator.
         };
 
-        /// Mouse action data used by MouseActionCallback (wraps Fixed, Start and Current manipulator state).
+        //! Mouse action data used by MouseActionCallback (wraps Fixed, Start and Current manipulator state).
         struct Action
         {
             Fixed m_fixed;
             Start m_start;
             Current m_current;
             ViewportInteraction::KeyboardModifiers m_modifiers;
-            int m_viewportId; ///< The id of the viewport this manipulator is being used in.
-            AZ::Vector3 LocalScale() const { return m_start.m_localScale + m_current.m_localScaleOffset; }
-            AZ::Vector3 LocalScaleOffset() const { return m_current.m_localScaleOffset; }
-            AZ::Vector3 LocalPosition() const { return m_start.m_localPosition + m_current.m_localPositionOffset; }
-            AZ::Vector3 LocalPositionOffset() const { return m_current.m_localPositionOffset; }
+            int m_viewportId; //!< The id of the viewport this manipulator is being used in.
+            AZ::Vector3 LocalScale() const
+            {
+                return m_start.m_localScale + m_current.m_localScaleOffset;
+            }
+            AZ::Vector3 LocalScaleOffset() const
+            {
+                return m_current.m_localScaleOffset;
+            }
+            AZ::Vector3 LocalPosition() const
+            {
+                return m_start.m_localPosition + m_current.m_localPositionOffset;
+            }
+            AZ::Vector3 LocalPositionOffset() const
+            {
+                return m_current.m_localPositionOffset;
+            }
             AZ::Vector2 ScreenOffset() const
             {
-                return AzFramework::Vector2FromScreenVector(
-                    m_current.m_screenPosition - m_start.m_screenPosition);
+                return AzFramework::Vector2FromScreenVector(m_current.m_screenPosition - m_start.m_screenPosition);
             }
         };
 
-        /// This is the function signature of callbacks that will be invoked whenever a manipulator
-        /// is clicked on or dragged.
+        //! This is the function signature of callbacks that will be invoked whenever a manipulator
+        //! is clicked on or dragged.
         using MouseActionCallback = AZStd::function<void(const Action&)>;
-        /// Tuple of StartTransition (initial mouse down to mouse move) and Start state.
+        //! Tuple of StartTransition (initial mouse down to mouse move) and Start state.
         using Starter = AZStd::tuple<StartTransition, Start>;
 
         void InstallLeftMouseDownCallback(const MouseActionCallback& onMouseDownCallback);
@@ -116,7 +128,10 @@ namespace AzToolsFramework
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         void SetAxis(const AZ::Vector3& axis);
-        const AZ::Vector3& GetAxis() const { return m_fixed.m_axis; }
+        const AZ::Vector3& GetAxis() const
+        {
+            return m_fixed.m_axis;
+        }
 
         template<typename Views>
         void SetViews(Views&& views)
@@ -135,12 +150,9 @@ namespace AzToolsFramework
         }
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
-        void OnMouseMoveImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
         void SetBoundsDirtyImpl() override;
@@ -155,16 +167,24 @@ namespace AzToolsFramework
         MouseActionCallback m_onLeftMouseUpCallback = nullptr;
         MouseActionCallback m_onMouseMoveCallback = nullptr;
 
-        ManipulatorViews m_manipulatorViews; ///< Look of manipulator.
+        ManipulatorViews m_manipulatorViews; //!< Look of manipulator.
     };
 
     LinearManipulator::Starter CalculateLinearManipulationDataStart(
-        const LinearManipulator::Fixed& fixed, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-        const AZ::Transform& localTransform, const ViewportInteraction::MouseInteraction& interaction, float intersectionDistance,
+        const LinearManipulator::Fixed& fixed,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
+        const ViewportInteraction::MouseInteraction& interaction,
+        float intersectionDistance,
         const AzFramework::CameraState& cameraState);
 
     LinearManipulator::Action CalculateLinearManipulationDataAction(
-        const LinearManipulator::Fixed& fixed, const LinearManipulator::Starter& starter,
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale, const AZ::Transform& localTransform,
-        const GridSnapParameters& gridSnapParams, const ViewportInteraction::MouseInteraction& interaction);
+        const LinearManipulator::Fixed& fixed,
+        const LinearManipulator::Starter& starter,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
+        const GridSnapParameters& gridSnapParams,
+        const ViewportInteraction::MouseInteraction& interaction);
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorBus.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -26,56 +26,55 @@ namespace AzToolsFramework
     using ManipulatorManagerId = IdType<struct ManipulatorManagerType>;
     static const ManipulatorManagerId InvalidManipulatorManagerId = ManipulatorManagerId(0);
 
-    /// EBus interface used to send requests to ManipulatorManager.
-    class ManipulatorManagerRequests
-        : public AZ::EBusTraits
+    //! EBus interface used to send requests to ManipulatorManager.
+    class ManipulatorManagerRequests : public AZ::EBusTraits
     {
     public:
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById; /**< We can have multiple manipulator managers.
-                                                                                             In the case where there are multiple viewports, each displaying
-                                                                                             a different set of entities, a different manipulator manager is required
-                                                                                             to provide a different collision space for each viewport so that mouse
-                                                                                             hit detection can be handled properly. */
+        //! We can have multiple manipulator managers.
+        //! In the case where there are multiple viewports, each displaying
+        //! a different set of entities, a different manipulator manager is required
+        //! to provide a different collision space for each viewport so that mouse
+        //! hit detection can be handled properly.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
         using BusIdType = ManipulatorManagerId;
 
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
 
         virtual ~ManipulatorManagerRequests() = default;
 
-        /// Register a manipulator with the Manipulator Manager.
-        /// @param manipulator The manipulator parameter is passed as a shared_ptr so
-        /// that the system responsible for managing manipulators can maintain ownership
-        /// of the manipulator even if is destroyed while in use.
+        //! Register a manipulator with the Manipulator Manager.
+        //! @param manipulator The manipulator parameter is passed as a shared_ptr so
+        //! that the system responsible for managing manipulators can maintain ownership
+        //! of the manipulator even if is destroyed while in use.
         virtual void RegisterManipulator(AZStd::shared_ptr<BaseManipulator> manipulator) = 0;
 
-        /// Unregister a manipulator from the Manipulator Manager.
-        /// After unregistering the manipulator, it will be excluded from mouse hit detection
-        /// and will not receive any mouse action events. The Manipulator Manager will also
-        /// relinquish ownership of the manipulator.
+        //! Unregister a manipulator from the Manipulator Manager.
+        //! After unregistering the manipulator, it will be excluded from mouse hit detection
+        //! and will not receive any mouse action events. The Manipulator Manager will also
+        //! relinquish ownership of the manipulator.
         virtual void UnregisterManipulator(BaseManipulator* manipulator) = 0;
 
-        /// Delete a manipulator bound.
+        //! Delete a manipulator bound.
         virtual void DeleteManipulatorBound(Picking::RegisteredBoundId boundId) = 0;
 
-        /// Mark the bound of a manipulator dirty so it's excluded from mouse hit detection.
-        /// This should be called whenever a manipulator is moved.
+        //! Mark the bound of a manipulator dirty so it's excluded from mouse hit detection.
+        //! This should be called whenever a manipulator is moved.
         virtual void SetBoundDirty(Picking::RegisteredBoundId boundId) = 0;
 
-        /// Returns true if the manipulator manager is currently interacting, otherwise false.
+        //! Returns true if the manipulator manager is currently interacting, otherwise false.
         virtual bool Interacting() const = 0;
 
-        /// Update the bound for a manipulator.
-        /// If \ref boundId hasn't been registered before or it's invalid, a new bound is created and set using \ref boundShapeData
-        /// @param manipulatorId The id of the manipulator whose bound needs to update.
-        /// @param boundId The id of the bound that needs to update.
-        /// @param boundShapeData The pointer to the new bound shape data.
-        /// @return If \ref boundId has been registered return the same id, otherwise create a new bound and return its id.
+        //! Update the bound for a manipulator.
+        //! If \ref boundId hasn't been registered before or it's invalid, a new bound is created and set using \ref boundShapeData.
+        //! @param manipulatorId The id of the manipulator whose bound needs to update.
+        //! @param boundId The id of the bound that needs to update.
+        //! @param boundShapeData The pointer to the new bound shape data.
+        //! @return If \ref boundId has been registered return the same id, otherwise create a new bound and return its id.
         virtual Picking::RegisteredBoundId UpdateBound(
-            ManipulatorId manipulatorId, Picking::RegisteredBoundId boundId,
-            const Picking::BoundRequestShapeBase& boundShapeData) = 0;
+            ManipulatorId manipulatorId, Picking::RegisteredBoundId boundId, const Picking::BoundRequestShapeBase& boundShapeData) = 0;
     };
 
-    /// Type to inherit to implement ManipulatorManagerRequests.
+    //! Type to inherit to implement ManipulatorManagerRequests.
     using ManipulatorManagerRequestBus = AZ::EBus<ManipulatorManagerRequests>;
 
-}//namespace AzToolsFramework
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorManager.cpp

@@ -1,17 +1,17 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
-#include "BaseManipulator.h"
 #include "ManipulatorManager.h"
+#include "BaseManipulator.h"
 
 #include <AzCore/std/tuple.h>
 #include <AzToolsFramework/Picking/BoundInterface.h>
@@ -51,7 +51,8 @@ namespace AzToolsFramework
 
         if (manipulator->Registered())
         {
-            AZ_Assert(manipulator->GetManipulatorManagerId() == m_manipulatorManagerId,
+            AZ_Assert(
+                manipulator->GetManipulatorManagerId() == m_manipulatorManagerId,
                 "This manipulator was registered with a different manipulator manager!");
             return;
         }
@@ -75,8 +76,7 @@ namespace AzToolsFramework
     }
 
     Picking::RegisteredBoundId ManipulatorManager::UpdateBound(
-        const ManipulatorId manipulatorId, const Picking::RegisteredBoundId boundId,
-        const Picking::BoundRequestShapeBase& boundShapeData)
+        const ManipulatorId manipulatorId, const Picking::RegisteredBoundId boundId, const Picking::BoundRequestShapeBase& boundShapeData)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -99,8 +99,7 @@ namespace AzToolsFramework
             AZ_Assert(boundItr->second == manipulatorId, "Manipulator and its bounds are out of synchronization!");
         }
 
-        const Picking::RegisteredBoundId newBoundId =
-            m_boundManager.UpdateOrRegisterBound(boundShapeData, boundId);
+        const Picking::RegisteredBoundId newBoundId = m_boundManager.UpdateOrRegisterBound(boundShapeData, boundId);
 
         if (newBoundId != boundId)
         {
@@ -142,13 +141,6 @@ namespace AzToolsFramework
         }
     }
 
-    void ManipulatorManager::CheckModifierKeysChanged(
-        [[maybe_unused]] const ViewportInteraction::KeyboardModifiers keyboardModifiers,
-        const ViewportInteraction::MousePick& mousePick)
-    {
-        RefreshMouseOverState(mousePick);
-    }
-
     void ManipulatorManager::DrawManipulators(
         AzFramework::DebugDisplayRequests& debugDisplay,
         const AzFramework::CameraState& cameraState,
@@ -181,7 +173,8 @@ namespace AzToolsFramework
             if (found != m_boundIdToManipulatorIdMap.end())
             {
                 const auto manipulatorFound = m_manipulatorIdToPtrMap.find(found->second);
-                AZ_Assert(manipulatorFound != m_manipulatorIdToPtrMap.end(),
+                AZ_Assert(
+                    manipulatorFound != m_manipulatorIdToPtrMap.end(),
                     "Found a bound without a corresponding Manipulator, "
                     "it's likely a bound was not cleaned up correctly");
                 rayIntersectionDistance = hitItr.second;
@@ -194,10 +187,9 @@ namespace AzToolsFramework
 
     bool ManipulatorManager::ConsumeViewportMousePress(const ViewportInteraction::MouseInteraction& interaction)
     {
-        if (auto pickedManipulator = PickManipulator(interaction.m_mousePick);
-            pickedManipulator.has_value())
+        if (auto pickedManipulator = PickManipulator(interaction.m_mousePick); pickedManipulator.has_value())
         {
-            auto[manipulator, intersectionDistance] = pickedManipulator.value();
+            auto [manipulator, intersectionDistance] = pickedManipulator.value();
 
             if (interaction.m_mouseButtons.Left())
             {
@@ -249,24 +241,19 @@ namespace AzToolsFramework
         const ViewportInteraction::MousePick& mousePick)
     {
         float intersectionDistance = 0.0f;
-        const AZStd::shared_ptr<BaseManipulator> pickedManipulator = PerformRaycast(
-            mousePick.m_rayOrigin, mousePick.m_rayDirection, intersectionDistance);
+        const AZStd::shared_ptr<BaseManipulator> pickedManipulator =
+            PerformRaycast(mousePick.m_rayOrigin, mousePick.m_rayDirection, intersectionDistance);
 
-        return pickedManipulator.get() != nullptr
-            ? AZStd::make_optional(AZStd::make_tuple(pickedManipulator, intersectionDistance))
-            : AZStd::nullopt;
+        return pickedManipulator.get() != nullptr ? AZStd::make_optional(AZStd::make_tuple(pickedManipulator, intersectionDistance))
+                                                  : AZStd::nullopt;
     }
 
-    ManipulatorManager::PickedManipulatorId ManipulatorManager::PickManipulatorId(
-        const ViewportInteraction::MousePick& mousePick)
+    ManipulatorManager::PickedManipulatorId ManipulatorManager::PickManipulatorId(const ViewportInteraction::MousePick& mousePick)
     {
-        auto [manipulator, intersectionDistance] =
-            PickManipulator(mousePick).value_or(PickedManipulator(nullptr, 0.0f));
-        const ManipulatorId pickedManipulatorId = manipulator
-            ? manipulator->GetManipulatorId()
-            : InvalidManipulatorId;
+        auto [manipulator, intersectionDistance] = PickManipulator(mousePick).value_or(PickedManipulator(nullptr, 0.0f));
+        const ManipulatorId pickedManipulatorId = manipulator ? manipulator->GetManipulatorId() : InvalidManipulatorId;
 
-        return PickedManipulatorId{pickedManipulatorId, intersectionDistance};
+        return PickedManipulatorId{ pickedManipulatorId, intersectionDistance };
     }
 
     ManipulatorManager::ConsumeMouseMoveResult ManipulatorManager::ConsumeViewportMouseMove(

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorManager.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -23,7 +23,7 @@ namespace AzFramework
 {
     struct CameraState;
     class DebugDisplayRequests;
-}
+} // namespace AzFramework
 
 namespace AzToolsFramework
 {
@@ -40,15 +40,15 @@ namespace AzToolsFramework
     class BaseManipulator;
     class LinearManipulator;
 
-    /// State of overall manipulator manager.
+    //! State of overall manipulator manager.
     struct ManipulatorManagerState
     {
         bool m_interacting;
     };
 
-    /// This class serves to manage all relevant mouse events and coordinate all registered manipulators to function properly.
-    /// ManipulatorManager does not manage the life cycle of specific manipulators. The users of manipulators are responsible
-    /// for creating and deleting them at right time, as well as registering and unregistering accordingly.
+    //! This class serves to manage all relevant mouse events and coordinate all registered manipulators to function properly.
+    //! ManipulatorManager does not manage the life cycle of specific manipulators. The users of manipulators are responsible
+    //! for creating and deleting them at right time, as well as registering and unregistering accordingly.
     class ManipulatorManager
         : private ManipulatorManagerRequestBus::Handler
         , private EditorEntityInfoNotificationBus::Handler
@@ -59,7 +59,7 @@ namespace AzToolsFramework
         explicit ManipulatorManager(ManipulatorManagerId managerId);
         ~ManipulatorManager();
 
-        /// The result of consuming a mouse move.
+        //! The result of consuming a mouse move.
         enum class ConsumeMouseMoveResult
         {
             None,
@@ -80,57 +80,52 @@ namespace AzToolsFramework
         void DeleteManipulatorBound(Picking::RegisteredBoundId boundId) override;
         void SetBoundDirty(Picking::RegisteredBoundId boundId) override;
         Picking::RegisteredBoundId UpdateBound(
-            ManipulatorId manipulatorId, Picking::RegisteredBoundId boundId,
-            const Picking::BoundRequestShapeBase& boundShapeData) override;
-        bool Interacting() const override { return m_activeManipulator != nullptr; }
+            ManipulatorId manipulatorId, Picking::RegisteredBoundId boundId, const Picking::BoundRequestShapeBase& boundShapeData) override;
+        bool Interacting() const override
+        {
+            return m_activeManipulator != nullptr;
+        }
 
         void DrawManipulators(
             AzFramework::DebugDisplayRequests& debugDisplay,
             const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction);
 
-        // O3DE_DEPRECATED(LY-117150)
-        /// Check if the modifier key state has changed - if so we may need to refresh
-        /// certain manipulator bounds.
-        AZ_DEPRECATED(
-            void CheckModifierKeysChanged(
-                ViewportInteraction::KeyboardModifiers keyboardModifiers,
-                const ViewportInteraction::MousePick& mousePick),
-            "CheckModifierKeysChanged is deprecated and will be removed in a future release");
-
     protected:
-        /// @param rayOrigin The origin of the ray to test intersection with.
-        /// @param rayDirection The direction of the ray to test intersection with.
-        /// @param[out] rayIntersectionDistance The result intersecting point equals "rayOrigin + rayIntersectionDistance * rayDirection".
-        /// @return A pointer to a manipulator that the ray intersects. Null pointer if no intersection is detected.
+        //! @param rayOrigin The origin of the ray to test intersection with.
+        //! @param rayDirection The direction of the ray to test intersection with.
+        //! @param[out] rayIntersectionDistance The result intersecting point equals "rayOrigin + rayIntersectionDistance * rayDirection".
+        //! @return A pointer to a manipulator that the ray intersects. Null pointer if no intersection is detected.
         AZStd::shared_ptr<BaseManipulator> PerformRaycast(
             const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection, float& rayIntersectionDistance);
 
         // EditorEntityInfoNotifications ...
         void OnEntityInfoUpdatedVisibility(AZ::EntityId entityId, bool visible) override;
 
-        /// Alias for a Manipulator and intersection distance.
+        //! Alias for a Manipulator and intersection distance.
         using PickedManipulator = AZStd::tuple<AZStd::shared_ptr<BaseManipulator>, float>;
-        /// Alias for a ManipulatorId and intersection distance.
+        //! Alias for a ManipulatorId and intersection distance.
         using PickedManipulatorId = AZStd::tuple<ManipulatorId, float>;
 
-        /// Return the picked manipulator and intersection distance if a manipulator was intersected.
+        //! Return the picked manipulator and intersection distance if a manipulator was intersected.
         AZStd::optional<PickedManipulator> PickManipulator(const ViewportInteraction::MousePick& mousePick);
-        /// Wrapper for PickManipulator to return the ManipulatorId directly.
+        //! Wrapper for PickManipulator to return the ManipulatorId directly.
         PickedManipulatorId PickManipulatorId(const ViewportInteraction::MousePick& mousePick);
 
-        /// Called once per frame after all manipulators have been drawn (and their
-        /// bounds updated if required).
+        //! Called once per frame after all manipulators have been drawn (and their
+        //! bounds updated if required).
         void RefreshMouseOverState(const ViewportInteraction::MousePick& mousePick);
 
-        ManipulatorManagerId m_manipulatorManagerId; ///< This manipulator manager's id.
-        ManipulatorId m_nextManipulatorIdToGenerate; ///< Id to use for the next manipulator that is registered with this manager.
+        ManipulatorManagerId m_manipulatorManagerId; //!< This manipulator manager's id.
+        ManipulatorId m_nextManipulatorIdToGenerate; //!< Id to use for the next manipulator that is registered with this manager.
 
-        AZStd::unordered_map<ManipulatorId, AZStd::shared_ptr<BaseManipulator>> m_manipulatorIdToPtrMap; ///< Mapping from a manipulatorId to the corresponding manipulator.
-        AZStd::unordered_map<Picking::RegisteredBoundId, ManipulatorId> m_boundIdToManipulatorIdMap; ///< Mapping from a boundId to the corresponding manipulatorId.
+        AZStd::unordered_map<ManipulatorId, AZStd::shared_ptr<BaseManipulator>>
+            m_manipulatorIdToPtrMap; //!< Mapping from a manipulatorId to the corresponding manipulator.
+        AZStd::unordered_map<Picking::RegisteredBoundId, ManipulatorId>
+            m_boundIdToManipulatorIdMap; //!< Mapping from a boundId to the corresponding manipulatorId.
 
-        AZStd::shared_ptr<BaseManipulator> m_activeManipulator; ///< The manipulator we are currently interacting with.
-        Picking::ManipulatorBoundManager m_boundManager; ///< All active manipulator bounds that could be interacted with.
+        AZStd::shared_ptr<BaseManipulator> m_activeManipulator; //!< The manipulator we are currently interacting with.
+        Picking::ManipulatorBoundManager m_boundManager; //!< All active manipulator bounds that could be interacted with.
     };
 
     // The main/default ManipulatorManagerId to be used for

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSnapping.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "ManipulatorSnapping.h"
 
@@ -19,19 +19,27 @@
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
 
 AZ_CVAR(
-    AZ::Color, cl_viewportGridMainColor, AZ::Color::CreateFromRgba(26, 26, 26, 127), nullptr,
-    AZ::ConsoleFunctorFlags::Null, "Main color for snapping grid");
+    AZ::Color,
+    cl_viewportGridMainColor,
+    AZ::Color::CreateFromRgba(26, 26, 26, 127),
+    nullptr,
+    AZ::ConsoleFunctorFlags::Null,
+    "Main color for snapping grid");
 AZ_CVAR(
-    AZ::Color, cl_viewportGridFadeColor, AZ::Color::CreateFromRgba(127, 127, 127, 0), nullptr,
-    AZ::ConsoleFunctorFlags::Null, "Fade color for snapping grid");
+    AZ::Color,
+    cl_viewportGridFadeColor,
+    AZ::Color::CreateFromRgba(127, 127, 127, 0),
+    nullptr,
+    AZ::ConsoleFunctorFlags::Null,
+    "Fade color for snapping grid");
+AZ_CVAR(int, cl_viewportGridSquareCount, 20, nullptr, AZ::ConsoleFunctorFlags::Null, "Number of grid squares for snapping grid");
+AZ_CVAR(float, cl_viewportGridLineWidth, 1.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "Width of grid lines for snapping grid");
 AZ_CVAR(
-    int, cl_viewportGridSquareCount, 20, nullptr, AZ::ConsoleFunctorFlags::Null,
-    "Number of grid squares for snapping grid");
-AZ_CVAR(
-    float, cl_viewportGridLineWidth, 1.0f, nullptr, AZ::ConsoleFunctorFlags::Null,
-    "Width of grid lines for snapping grid");
-AZ_CVAR(
-    float, cl_viewportFadeLineDistanceScale, 1.0f, nullptr, AZ::ConsoleFunctorFlags::Null,
+    float,
+    cl_viewportFadeLineDistanceScale,
+    1.0f,
+    nullptr,
+    AZ::ConsoleFunctorFlags::Null,
     "The scale to be applied to the line that fades out (scales the current gridSize)");
 
 namespace AzToolsFramework
@@ -43,16 +51,17 @@ namespace AzToolsFramework
     }
 
     ManipulatorInteraction BuildManipulatorInteraction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-        const AZ::Vector3& worldRayOrigin, const AZ::Vector3& worldRayDirection)
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Vector3& worldRayOrigin,
+        const AZ::Vector3& worldRayDirection)
     {
         const AZ::Transform worldFromLocalUniform = AzToolsFramework::TransformUniformScale(worldFromLocal);
         const AZ::Transform localFromWorldUniform = worldFromLocalUniform.GetInverse();
 
-        return {localFromWorldUniform.TransformPoint(worldRayOrigin),
-                TransformDirectionNoScaling(localFromWorldUniform, worldRayDirection),
-                NonUniformScaleReciprocal(nonUniformScale),
-                ScaleReciprocal(worldFromLocalUniform)};
+        return { localFromWorldUniform.TransformPoint(worldRayOrigin),
+                 TransformDirectionNoScaling(localFromWorldUniform, worldRayDirection), NonUniformScaleReciprocal(nonUniformScale),
+                 ScaleReciprocal(worldFromLocalUniform) };
     }
 
     struct SnapAdjustment
@@ -87,8 +96,7 @@ namespace AzToolsFramework
     }
 
     AZ::Vector3 CalculateSnappedTerrainPosition(
-        const AZ::Vector3& worldSurfacePosition, const AZ::Transform& worldFromLocal,
-        const int viewportId, const float gridSize)
+        const AZ::Vector3& worldSurfacePosition, const AZ::Transform& worldFromLocal, const int viewportId, const float gridSize)
     {
         const AZ::Transform localFromWorld = worldFromLocal.GetInverse();
         const AZ::Vector3 localSurfacePosition = localFromWorld.TransformPoint(worldSurfacePosition);
@@ -101,8 +109,7 @@ namespace AzToolsFramework
         // find terrain height at xy snapped location
         float terrainHeight = 0.0f;
         ViewportInteraction::MainEditorViewportInteractionRequestBus::EventResult(
-            terrainHeight, viewportId,
-            &ViewportInteraction::MainEditorViewportInteractionRequestBus::Events::TerrainHeight,
+            terrainHeight, viewportId, &ViewportInteraction::MainEditorViewportInteractionRequestBus::Events::TerrainHeight,
             Vector3ToVector2(worldFromLocal.TransformPoint(localSnappedSurfacePosition)));
 
         // set snapped z value to terrain height
@@ -116,8 +123,7 @@ namespace AzToolsFramework
     {
         bool snapping = false;
         ViewportInteraction::ViewportInteractionRequestBus::EventResult(
-            snapping, viewportId,
-            &ViewportInteraction::ViewportInteractionRequestBus::Events::GridSnappingEnabled);
+            snapping, viewportId, &ViewportInteraction::ViewportInteractionRequestBus::Events::GridSnappingEnabled);
 
         return snapping;
     }
@@ -126,8 +132,7 @@ namespace AzToolsFramework
     {
         float gridSize = 0.0f;
         ViewportInteraction::ViewportInteractionRequestBus::EventResult(
-            gridSize, viewportId,
-            &ViewportInteraction::ViewportInteractionRequestBus::Events::GridSize);
+            gridSize, viewportId, &ViewportInteraction::ViewportInteractionRequestBus::Events::GridSize);
 
         return gridSize;
     }
@@ -136,7 +141,8 @@ namespace AzToolsFramework
     {
         bool snapping = GridSnapping(viewportId);
         const float gridSize = GridSize(viewportId);
-        if (AZ::IsClose(gridSize, 0.0f, 1e-2f)) // Same threshold value as min value for m_spinBox in SnapToWidget constructor in MainWindow.cpp
+        if (AZ::IsClose(
+                gridSize, 0.0f, 1e-2f)) // Same threshold value as min value for m_spinBox in SnapToWidget constructor in MainWindow.cpp
         {
             snapping = false;
         }
@@ -148,8 +154,7 @@ namespace AzToolsFramework
     {
         bool snapping = false;
         ViewportInteraction::ViewportInteractionRequestBus::EventResult(
-            snapping, viewportId,
-            &ViewportInteraction::ViewportInteractionRequestBus::Events::AngleSnappingEnabled);
+            snapping, viewportId, &ViewportInteraction::ViewportInteractionRequestBus::Events::AngleSnappingEnabled);
 
         return snapping;
     }
@@ -158,8 +163,7 @@ namespace AzToolsFramework
     {
         float angle = 0.0f;
         ViewportInteraction::ViewportInteractionRequestBus::EventResult(
-            angle, viewportId,
-            &ViewportInteraction::ViewportInteractionRequestBus::Events::AngleStep);
+            angle, viewportId, &ViewportInteraction::ViewportInteractionRequestBus::Events::AngleStep);
 
         return angle;
     }
@@ -168,14 +172,12 @@ namespace AzToolsFramework
     {
         bool show = false;
         ViewportInteraction::ViewportInteractionRequestBus::EventResult(
-            show, viewportId,
-            &ViewportInteraction::ViewportInteractionRequestBus::Events::ShowGrid);
+            show, viewportId, &ViewportInteraction::ViewportInteractionRequestBus::Events::ShowGrid);
 
         return show;
     }
 
-    void DrawSnappingGrid(
-        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Transform& worldFromLocal, const float squareSize)
+    void DrawSnappingGrid(AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Transform& worldFromLocal, const float squareSize)
     {
         debugDisplay.PushMatrix(worldFromLocal);
 
@@ -197,21 +199,17 @@ namespace AzToolsFramework
 
             // draw the faded end parts of the grid lines
             debugDisplay.DrawLine(
-                AZ::Vector3(lineOffset, -halfGridSize, 0.0f),
-                AZ::Vector3(lineOffset, -(halfGridSize + fadeLineLength), 0.0f),
+                AZ::Vector3(lineOffset, -halfGridSize, 0.0f), AZ::Vector3(lineOffset, -(halfGridSize + fadeLineLength), 0.0f),
                 gridMainColor, gridFadeColor);
             debugDisplay.DrawLine(
-                AZ::Vector3(lineOffset, halfGridSize, 0.0f),
-                AZ::Vector3(lineOffset, (halfGridSize + fadeLineLength), 0.0f),
+                AZ::Vector3(lineOffset, halfGridSize, 0.0f), AZ::Vector3(lineOffset, (halfGridSize + fadeLineLength), 0.0f), gridMainColor,
+                gridFadeColor);
+            debugDisplay.DrawLine(
+                AZ::Vector3(-halfGridSize, lineOffset, 0.0f), AZ::Vector3(-(halfGridSize + fadeLineLength), lineOffset, 0.0f),
                 gridMainColor, gridFadeColor);
             debugDisplay.DrawLine(
-                AZ::Vector3(-halfGridSize, lineOffset, 0.0f),
-                AZ::Vector3(-(halfGridSize + fadeLineLength), lineOffset, 0.0f),
-                gridMainColor, gridFadeColor);
-            debugDisplay.DrawLine(
-                AZ::Vector3(halfGridSize, lineOffset, 0.0f),
-                AZ::Vector3((halfGridSize + fadeLineLength), lineOffset, 0.0f),
-                gridMainColor, gridFadeColor);
+                AZ::Vector3(halfGridSize, lineOffset, 0.0f), AZ::Vector3((halfGridSize + fadeLineLength), lineOffset, 0.0f), gridMainColor,
+                gridFadeColor);
 
             // build a vector of the main grid lines to draw (start and end positions)
             lines.push_back(AZ::Vector3(lineOffset, -halfGridSize, 0.0f));

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSnapping.h

@@ -1,19 +1,19 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
-#include <AzCore/Math/Vector3.h>
 #include <AzCore/Math/Transform.h>
+#include <AzCore/Math/Vector3.h>
 
 namespace AzFramework
 {
@@ -22,7 +22,7 @@ namespace AzFramework
 
 namespace AzToolsFramework
 {
-    /// Structure to encapsulate grid snapping properties.
+    //! Structure to encapsulate grid snapping properties.
     struct GridSnapParameters
     {
         GridSnapParameters(bool gridSnap, float gridSize);
@@ -31,96 +31,92 @@ namespace AzToolsFramework
         float m_gridSize;
     };
 
-    /// Structure to hold transformed incoming viewport interaction from world space to manipulator space.
+    //! Structure to hold transformed incoming viewport interaction from world space to manipulator space.
     struct ManipulatorInteraction
     {
-        AZ::Vector3 m_localRayOrigin; ///< The ray origin (start) in the reference from of the manipulator.
-        AZ::Vector3 m_localRayDirection; ///< The ray direction in the reference from of the manipulator.
-        AZ::Vector3 m_nonUniformScaleReciprocal; ///< Handles inverting any non-uniform scale which was applied
-                                                 ///< separately from the transform.
-        float m_scaleReciprocal; ///< The scale reciprocal (1.0 / scale) of the transform used to move the
-                                 ///< ray from world space to local space.
+        AZ::Vector3 m_localRayOrigin; //!< The ray origin (start) in the reference from of the manipulator.
+        AZ::Vector3 m_localRayDirection; //!< The ray direction in the reference from of the manipulator.
+        AZ::Vector3 m_nonUniformScaleReciprocal; //!< Handles inverting any non-uniform scale which was applied
+                                                 //!< separately from the transform.
+        float m_scaleReciprocal; //!< The scale reciprocal (1.0 / scale) of the transform used to move the
+                                 //!< ray from world space to local space.
     };
 
-    /// Build a ManipulatorInteraction structure from the incoming viewport interaction.
+    //! Build a ManipulatorInteraction structure from the incoming viewport interaction.
     ManipulatorInteraction BuildManipulatorInteraction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-        const AZ::Vector3& worldRayOrigin, const AZ::Vector3& worldRayDirection);
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Vector3& worldRayOrigin,
+        const AZ::Vector3& worldRayDirection);
 
-    /// Calculate the offset along an axis to adjust a position to stay snapped to a given grid size.
-    /// @note This is snap up or down to the nearest grid segment (e.g. 0.2 snaps to 0.0 -> delta 0.2,
-    /// 0.7 snaps to 1.0 -> delta 0.3).
-    AZ::Vector3 CalculateSnappedOffset(
-        const AZ::Vector3& unsnappedPosition, const AZ::Vector3& axis, float size);
+    //! Calculate the offset along an axis to adjust a position to stay snapped to a given grid size.
+    //! @note This is snap up or down to the nearest grid segment (e.g. 0.2 snaps to 0.0 -> delta 0.2,
+    //! 0.7 snaps to 1.0 -> delta 0.3).
+    AZ::Vector3 CalculateSnappedOffset(const AZ::Vector3& unsnappedPosition, const AZ::Vector3& axis, float size);
 
-    /// Return the amount to snap from the starting position given the current grid size.
-    /// @note A movement of more than half size (in either direction) will cause a snap by size.
+    //! Return the amount to snap from the starting position given the current grid size.
+    //! @note A movement of more than half size (in either direction) will cause a snap by size.
     AZ::Vector3 CalculateSnappedAmount(const AZ::Vector3& unsnappedPosition, const AZ::Vector3& axis, float size);
 
-    /// For a given point on the terrain, calculate the closest xy position snapped to the grid
-    /// (z position is aligned to terrain height, not snapped to z grid)
+    //! For a given point on the terrain, calculate the closest xy position snapped to the grid
+    //! (z position is aligned to terrain height, not snapped to z grid)
     AZ::Vector3 CalculateSnappedTerrainPosition(
-        const AZ::Vector3& worldSurfacePosition, const AZ::Transform& worldFromLocal,
-        int viewportId, float gridSize);
+        const AZ::Vector3& worldSurfacePosition, const AZ::Transform& worldFromLocal, int viewportId, float gridSize);
 
-    /// Wrapper for grid snapping and grid size bus calls.
+    //! Wrapper for grid snapping and grid size bus calls.
     GridSnapParameters GridSnapSettings(int viewportId);
 
-    /// Wrapper for angle snapping enabled bus call.
+    //! Wrapper for angle snapping enabled bus call.
     bool AngleSnapping(int viewportId);
 
-    /// Wrapper for angle snapping increment bus call.
-    /// @return Angle in degrees
+    //! Wrapper for angle snapping increment bus call.
+    //! @return Angle in degrees.
     float AngleStep(int viewportId);
 
-    /// Wrapper for grid rendering check call.
+    //! Wrapper for grid rendering check call.
     bool ShowingGrid(int viewportId);
 
-    /// Render the grid used for snapping.
-    void DrawSnappingGrid(
-        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Transform& worldFromLocal, float squareSize);
+    //! Render the grid used for snapping.
+    void DrawSnappingGrid(AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Transform& worldFromLocal, float squareSize);
 
-    /// Round to x number of significant digits.
-    /// @param value Number to round.
-    /// @param exponent Precision to use when rounding.
+    //! Round to x number of significant digits.
+    //! @param value Number to round.
+    //! @param exponent Precision to use when rounding.
     inline float Round(const float value, const float exponent)
     {
         const float precision = std::pow(10.0f, exponent);
         return roundf(value * precision) / precision;
     }
 
-    /// Round to 3 significant digits (3 digits common usage).
+    //! Round to 3 significant digits (3 digits common usage).
     inline float Round3(const float value)
     {
         return Round(value, 3.0f);
     }
 
-    /// Util to return sign of floating point number.
-    /// value > 0 return 1.0
-    /// value < 0 return -1.0
-    /// value == 0 return 0.0
+    //! Util to return sign of floating point number.
+    //! value > 0 return 1.0
+    //! value < 0 return -1.0
+    //! value == 0 return 0.0
     inline float Sign(const float value)
     {
         return static_cast<float>((0.0f < value) - (value < 0.0f));
     }
 
-    /// Find the max scale element and return the reciprocal of it.
-    /// Note: The reciprocal will be rounded to three significant digits to eliminate 
-    /// noise in the value returned when dealing with values far from the origin.
+    //! Find the max scale element and return the reciprocal of it.
+    //! Note: The reciprocal will be rounded to three significant digits to eliminate
+    //! noise in the value returned when dealing with values far from the origin.
     inline float ScaleReciprocal(const AZ::Transform& transform)
     {
         return Round3(1.0f / transform.GetUniformScale());
     }
 
-    /// Find the reciprocal of the non-uniform scale.
-    /// Each element will be rounded to three significant digits to eliminate noise
-    /// when dealing with values far from the origin.
+    //! Find the reciprocal of the non-uniform scale.
+    //! Each element will be rounded to three significant digits to eliminate noise
+    //! when dealing with values far from the origin.
     inline AZ::Vector3 NonUniformScaleReciprocal(const AZ::Vector3& nonUniformScale)
     {
         AZ::Vector3 scaleReciprocal = nonUniformScale.GetReciprocal();
-        return AZ::Vector3(
-            Round3(scaleReciprocal.GetX()),
-            Round3(scaleReciprocal.GetY()),
-            Round3(scaleReciprocal.GetZ()));
+        return AZ::Vector3(Round3(scaleReciprocal.GetX()), Round3(scaleReciprocal.GetY()), Round3(scaleReciprocal.GetZ()));
     }
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSpace.h

@@ -20,7 +20,7 @@ namespace AZ
 
 namespace AzToolsFramework
 {
-    /// Handles location for manipulators which have a global space but no local transformation.
+    //! Handles location for manipulators which have a global space but no local transformation.
     class ManipulatorSpace
     {
     public:
@@ -32,17 +32,16 @@ namespace AzToolsFramework
         const AZ::Vector3& GetNonUniformScale() const;
         void SetNonUniformScale(const AZ::Vector3& nonUniformScale);
 
-        /// Calculates a transform combining the space and local transform, taking non-uniform scale into account.
+        //! Calculates a transform combining the space and local transform, taking non-uniform scale into account.
         AZ::Transform ApplySpace(const AZ::Transform& localTransform) const;
 
     private:
-        AZ::Transform m_space = AZ::Transform::CreateIdentity(); ///< Space the manipulator is in.
-        AZ::Vector3 m_nonUniformScale = AZ::Vector3::CreateOne(); ///< Handles non-uniform scale for the space the manipulator is in.
+        AZ::Transform m_space = AZ::Transform::CreateIdentity(); //!< Space the manipulator is in.
+        AZ::Vector3 m_nonUniformScale = AZ::Vector3::CreateOne(); //!< Handles non-uniform scale for the space the manipulator is in.
     };
 
-    /// Handles location for manipulators which have a global space and a local position, but no local rotation.
-    class ManipulatorSpaceWithLocalPosition
-        : public ManipulatorSpace
+    //! Handles location for manipulators which have a global space and a local position, but no local rotation.
+    class ManipulatorSpaceWithLocalPosition : public ManipulatorSpace
     {
     public:
         AZ_TYPE_INFO(ManipulatorSpaceWithLocalPosition, "{47BE15AF-60A8-436B-8F3F-7DDFB97220E6}")
@@ -52,12 +51,11 @@ namespace AzToolsFramework
         void SetLocalPosition(const AZ::Vector3& localPosition);
 
     private:
-        AZ::Vector3 m_localPosition = AZ::Vector3::CreateZero(); ///< Position in local space.
+        AZ::Vector3 m_localPosition = AZ::Vector3::CreateZero(); //!< Position in local space.
     };
 
-    /// Handles location for manipulators which have a global space and a local transform (position and rotation).
-    class ManipulatorSpaceWithLocalTransform
-        : public ManipulatorSpace
+    //! Handles location for manipulators which have a global space and a local transform (position and rotation).
+    class ManipulatorSpaceWithLocalTransform : public ManipulatorSpace
     {
     public:
         AZ_TYPE_INFO(ManipulatorSpaceWithLocalTransform, "{6D100797-1DD8-45B0-A21C-8893B770C0BC}")
@@ -72,6 +70,6 @@ namespace AzToolsFramework
         void SetLocalOrientation(const AZ::Quaternion& localOrientation);
 
     private:
-        AZ::Transform m_localTransform = AZ::Transform::CreateIdentity(); ///< Local transform.
+        AZ::Transform m_localTransform = AZ::Transform::CreateIdentity(); //!< Local transform.
     };
 } // namespace AzToolsFramework

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

@@ -1,26 +1,26 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "ManipulatorView.h"
 
-#include <AzCore/Component/TransformBus.h>
 #include <AzCore/Component/NonUniformScaleBus.h>
+#include <AzCore/Component/TransformBus.h>
 #include <AzCore/Math/VectorConversions.h>
 #include <AzCore/std/containers/array.h>
 #include <AzFramework/Entity/EntityDebugDisplayBus.h>
-#include <AzToolsFramework/Manipulators/ManipulatorManager.h>
 #include <AzToolsFramework/Manipulators/AngularManipulator.h>
-#include <AzToolsFramework/Manipulators/LinearManipulator.h>
 #include <AzToolsFramework/Manipulators/LineSegmentSelectionManipulator.h>
+#include <AzToolsFramework/Manipulators/LinearManipulator.h>
+#include <AzToolsFramework/Manipulators/ManipulatorManager.h>
 #include <AzToolsFramework/Manipulators/PlanarManipulator.h>
 #include <AzToolsFramework/Manipulators/SplineSelectionManipulator.h>
 #include <AzToolsFramework/Maths/TransformUtils.h>
@@ -33,8 +33,7 @@ namespace AzToolsFramework
     AZ::Transform WorldFromLocalWithUniformScale(const AZ::EntityId entityId)
     {
         AZ::Transform worldFromLocal = AZ::Transform::CreateIdentity();
-        AZ::TransformBus::EventResult(
-            worldFromLocal, entityId, &AZ::TransformBus::Events::GetWorldTM);
+        AZ::TransformBus::EventResult(worldFromLocal, entityId, &AZ::TransformBus::Events::GetWorldTM);
 
         return TransformUniformScale(worldFromLocal);
     }
@@ -56,13 +55,16 @@ namespace AzToolsFramework
         return AzToolsFramework::TransformDirectionNoScaling(m_worldFromLocal, direction);
     }
 
-    /// Take into account the location of the camera and orientate the axis so it faces the camera.
-    /// if we did correct the camera (shouldCorrect is true) then we know the axis facing us it negative.
-    /// we can use this to change the rendering for a flipped axis if we wish.
+    // Take into account the location of the camera and orientate the axis so it faces the camera.
+    // if we did correct the camera (shouldCorrect is true) then we know the axis facing us it negative.
+    // we can use this to change the rendering for a flipped axis if we wish.
     static void CameraCorrectAxis(
-        const AZ::Vector3& axis, AZ::Vector3& correctedAxis, const ManipulatorManagerState& managerState,
+        const AZ::Vector3& axis,
+        AZ::Vector3& correctedAxis,
+        const ManipulatorManagerState& managerState,
         const ViewportInteraction::MouseInteraction& mouseInteraction,
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& localPosition,
         const AzFramework::CameraState& cameraState,
         bool* shouldCorrect = nullptr)
     {
@@ -74,9 +76,7 @@ namespace AzToolsFramework
             const bool correcting = ShouldFlipCameraAxis(worldFromLocal, localPosition, axis, cameraState);
 
             // the corrected axis, if no flip was required, output == input
-            correctedAxis = correcting
-                ? -axis
-                : axis;
+            correctedAxis = correcting ? -axis : axis;
 
             // optional out ref to use if we care about the result
             if (shouldCorrect)
@@ -86,10 +86,13 @@ namespace AzToolsFramework
         }
     }
 
-    /// Calculate quad bound in world space.
+    // calculate quad bound in world space.
     static Picking::BoundShapeQuad CalculateQuadBound(
-        const AZ::Vector3& localPosition, const ManipulatorState& manipulatorState,
-        const AZ::Vector3& axis1, const AZ::Vector3& axis2, const float size)
+        const AZ::Vector3& localPosition,
+        const ManipulatorState& manipulatorState,
+        const AZ::Vector3& axis1,
+        const AZ::Vector3& axis2,
+        const float size)
     {
         const AZ::Vector3 worldPosition = manipulatorState.TransformPoint(localPosition);
         const AZ::Vector3 endAxis1World = manipulatorState.TransformDirectionNoScaling(axis1) * size;
@@ -104,8 +107,10 @@ namespace AzToolsFramework
     }
 
     static Picking::BoundShapeQuad CalculateQuadBoundBillboard(
-        const AZ::Vector3& localPosition, const AZ::Transform& worldFromLocal,
-        const float size, const AzFramework::CameraState& cameraState)
+        const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const float size,
+        const AzFramework::CameraState& cameraState)
     {
         const AZ::Vector3 worldPosition = worldFromLocal.TransformPoint(localPosition);
 
@@ -117,10 +122,13 @@ namespace AzToolsFramework
         return quadBound;
     }
 
-    /// Calculate line bound in world space (axis and length).
+    // calculate line bound in world space (axis and length).
     static Picking::BoundShapeLineSegment CalculateLineBound(
-        const AZ::Vector3& localPosition, const AZ::Transform& worldFromLocal,
-        const AZ::Vector3& axis, const float length, const float width)
+        const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& axis,
+        const float length,
+        const float width)
     {
         Picking::BoundShapeLineSegment lineBound;
         lineBound.m_start = worldFromLocal.TransformPoint(localPosition);
@@ -129,7 +137,7 @@ namespace AzToolsFramework
         return lineBound;
     }
 
-    /// Calculate line bound in world space (start and end point).
+    // calculate line bound in world space (start and end point).
     static Picking::BoundShapeLineSegment CalculateLineBound(
         const AZ::Vector3& localStartPosition,
         const AZ::Vector3& localEndPosition,
@@ -143,10 +151,14 @@ namespace AzToolsFramework
         return lineBound;
     }
 
-    /// Calculate cone bound in world space.
+    // calculate cone bound in world space.
     static Picking::BoundShapeCone CalculateConeBound(
-        const AZ::Vector3& localPosition, const AZ::Transform& worldFromLocal,
-        const AZ::Vector3& axis, const AZ::Vector3& offset, const float length, const float radius)
+        const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& axis,
+        const AZ::Vector3& offset,
+        const float length,
+        const float radius)
     {
         Picking::BoundShapeCone coneBound;
         coneBound.m_radius = radius;
@@ -156,10 +168,13 @@ namespace AzToolsFramework
         return coneBound;
     }
 
-    /// Calculate box bound in world space.
+    // calculate box bound in world space.
     static Picking::BoundShapeBox CalculateBoxBound(
-        const AZ::Vector3& localPosition, const AZ::Transform& worldFromLocal,
-        const AZ::Quaternion& orientation, const AZ::Vector3& offset, const AZ::Vector3& halfExtents)
+        const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Quaternion& orientation,
+        const AZ::Vector3& offset,
+        const AZ::Vector3& halfExtents)
     {
         Picking::BoundShapeBox boxBound;
         boxBound.m_halfExtents = halfExtents;
@@ -168,10 +183,13 @@ namespace AzToolsFramework
         return boxBound;
     }
 
-    /// Calculate cylinder bound in world space.
+    // calculate cylinder bound in world space.
     static Picking::BoundShapeCylinder CalculateCylinderBound(
-        const AZ::Vector3& localPosition, const AZ::Transform& worldFromLocal,
-        const AZ::Vector3& axis, const float length, const float radius)
+        const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& axis,
+        const float length,
+        const float radius)
     {
         Picking::BoundShapeCylinder boxBound;
         boxBound.m_base = worldFromLocal.TransformPoint(localPosition);
@@ -181,10 +199,9 @@ namespace AzToolsFramework
         return boxBound;
     }
 
-    /// Calculate sphere bound in world space.
+    // calculate sphere bound in world space.
     static Picking::BoundShapeSphere CalculateSphereBound(
-        const AZ::Vector3& localPosition, const ManipulatorState& manipulatorState,
-        const float radius)
+        const AZ::Vector3& localPosition, const ManipulatorState& manipulatorState, const float radius)
     {
         Picking::BoundShapeSphere sphereBound;
         sphereBound.m_center = manipulatorState.TransformPoint(localPosition);
@@ -192,10 +209,13 @@ namespace AzToolsFramework
         return sphereBound;
     }
 
-    /// Calculate torus bound in world space.
+    // calculate torus bound in world space.
     static Picking::BoundShapeTorus CalculateTorusBound(
-        const AZ::Vector3& localPosition, const AZ::Transform& worldFromLocal,
-        const AZ::Vector3& axis, const float radius, const float width)
+        const AZ::Vector3& localPosition,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& axis,
+        const float radius,
+        const float width)
     {
         Picking::BoundShapeTorus torusBound;
         torusBound.m_center = worldFromLocal.TransformPoint(localPosition);
@@ -205,7 +225,7 @@ namespace AzToolsFramework
         return torusBound;
     }
 
-    /// Calculate spline bound in world space.
+    // calculate spline bound in world space.
     static Picking::BoundShapeSpline CalculateSplineBound(
         const AZStd::weak_ptr<const AZ::Spline>& spline, const AZ::Transform& worldFromLocal, const float width)
     {
@@ -224,8 +244,7 @@ namespace AzToolsFramework
         return lineWidth[mouseOver];
     }
 
-    static AZ::Color ViewColor(
-        const bool mouseOver, const AZ::Color& defaultColor, const AZ::Color& mouseOverColor)
+    static AZ::Color ViewColor(const bool mouseOver, const AZ::Color& defaultColor, const AZ::Color& mouseOverColor)
     {
         const AZStd::array<AZ::Color, 2> viewColor = { { defaultColor, mouseOverColor } };
         return viewColor[mouseOver].GetAsVector4();
@@ -250,19 +269,16 @@ namespace AzToolsFramework
 
     void ManipulatorView::SetBoundDirty(const ManipulatorManagerId managerId)
     {
-        ManipulatorManagerRequestBus::Event(
-            managerId, &ManipulatorManagerRequestBus::Events::SetBoundDirty, m_boundId);
+        ManipulatorManagerRequestBus::Event(managerId, &ManipulatorManagerRequestBus::Events::SetBoundDirty, m_boundId);
 
         m_boundDirty = true;
     }
 
     void ManipulatorView::RefreshBound(
-        const ManipulatorManagerId managerId, const ManipulatorId manipulatorId,
-        const Picking::BoundRequestShapeBase& bound)
+        const ManipulatorManagerId managerId, const ManipulatorId manipulatorId, const Picking::BoundRequestShapeBase& bound)
     {
         ManipulatorManagerRequestBus::EventResult(
-            m_boundId, managerId, &ManipulatorManagerRequestBus::Events::UpdateBound,
-            manipulatorId, m_boundId, bound);
+            m_boundId, managerId, &ManipulatorManagerRequestBus::Events::UpdateBound, manipulatorId, m_boundId, bound);
 
         // store the manager id if we know the bound has been registered
         m_managerId = managerId;
@@ -271,8 +287,7 @@ namespace AzToolsFramework
     }
 
     void ManipulatorView::RefreshBoundInternal(
-        const ManipulatorManagerId managerId, const ManipulatorId manipulatorId,
-        const Picking::BoundRequestShapeBase& bound)
+        const ManipulatorManagerId managerId, const ManipulatorId manipulatorId, const Picking::BoundRequestShapeBase& bound)
     {
         // update the manipulator's bounds if necessary
         // if m_screenSizeFixed is true, any camera movement can potentially change the size
@@ -287,8 +302,7 @@ namespace AzToolsFramework
     {
         if (m_boundId != Picking::InvalidBoundId)
         {
-            ManipulatorManagerRequestBus::Event(
-                managerId, &ManipulatorManagerRequestBus::Events::DeleteManipulatorBound, m_boundId);
+            ManipulatorManagerRequestBus::Event(managerId, &ManipulatorManagerRequestBus::Events::DeleteManipulatorBound, m_boundId);
 
             m_boundId = Picking::InvalidBoundId;
         }
@@ -297,33 +311,34 @@ namespace AzToolsFramework
     float ManipulatorView::ManipulatorViewScaleMultiplier(
         const AZ::Vector3& worldPosition, const AzFramework::CameraState& cameraState) const
     {
-        return ScreenSizeFixed()
-            ? CalculateScreenToWorldMultiplier(worldPosition, cameraState)
-            : 1.0f;
+        return ScreenSizeFixed() ? CalculateScreenToWorldMultiplier(worldPosition, cameraState) : 1.0f;
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     void ManipulatorViewQuad::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& managerState,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
         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);
+            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);
+            axis2, m_cameraCorrectedAxis2, 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(
+        const Picking::BoundShapeQuad quadBound = CalculateQuadBound(
+            manipulatorState.m_localPosition, manipulatorState, m_cameraCorrectedAxis1, m_cameraCorrectedAxis2,
+            m_size *
+                ManipulatorViewScaleMultiplier(
                     manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState));
 
         debugDisplay.SetLineWidth(defaultLineWidth(manipulatorState.m_mouseOver));
@@ -339,9 +354,7 @@ namespace AzToolsFramework
             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(quadBound.m_corner1, quadBound.m_corner2, quadBound.m_corner3, quadBound.m_corner4);
             debugDisplay.CullOn();
         }
 
@@ -349,41 +362,46 @@ namespace AzToolsFramework
     }
 
     void ManipulatorViewQuadBillboard::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& /*managerState*/,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& /*managerState*/,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& /*mouseInteraction*/)
     {
-        const Picking::BoundShapeQuad quadBound =
-            CalculateQuadBoundBillboard(manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal,
-                m_size * ManipulatorViewScaleMultiplier(
-                    manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState), cameraState);
+        const Picking::BoundShapeQuad quadBound = CalculateQuadBoundBillboard(
+            manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal,
+            m_size *
+                ManipulatorViewScaleMultiplier(
+                    manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState),
+            cameraState);
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
-        debugDisplay.DrawQuad(
-            quadBound.m_corner1, quadBound.m_corner2,
-            quadBound.m_corner3, quadBound.m_corner4);
+        debugDisplay.DrawQuad(quadBound.m_corner1, quadBound.m_corner2, quadBound.m_corner3, quadBound.m_corner4);
 
         RefreshBoundInternal(managerId, manipulatorId, quadBound);
     }
 
     void ManipulatorViewLine::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& managerState,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
         CameraCorrectAxis(
-            m_axis, m_cameraCorrectedAxis, managerState, mouseInteraction,
-            manipulatorState.m_worldFromLocal, manipulatorState.m_localPosition, cameraState);
+            m_axis, m_cameraCorrectedAxis, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
+            manipulatorState.m_localPosition, cameraState);
 
-        const Picking::BoundShapeLineSegment lineBound =
-            CalculateLineBound(
-                manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal,
-                m_cameraCorrectedAxis, m_length * viewScale, m_width * viewScale);
+        const Picking::BoundShapeLineSegment lineBound = CalculateLineBound(
+            manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_cameraCorrectedAxis, m_length * viewScale,
+            m_width * viewScale);
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
         debugDisplay.SetLineWidth(defaultLineWidth(manipulatorState.m_mouseOver));
@@ -393,13 +411,16 @@ namespace AzToolsFramework
     }
 
     void ManipulatorViewLineSelect::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& /*managerState*/,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& /*managerState*/,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
         const Picking::BoundShapeLineSegment lineBound =
             CalculateLineBound(m_localStart, m_localEnd, manipulatorState, m_width * viewScale);
@@ -407,44 +428,42 @@ namespace AzToolsFramework
         if (manipulatorState.m_mouseOver)
         {
             const LineSegmentSelectionManipulator::Action action = CalculateManipulationDataAction(
-                manipulatorState.m_worldFromLocal, manipulatorState.m_nonUniformScale,
-                mouseInteraction.m_mousePick.m_rayOrigin, mouseInteraction.m_mousePick.m_rayDirection,
-                cameraState.m_farClip, m_localStart, m_localEnd);
+                manipulatorState.m_worldFromLocal, manipulatorState.m_nonUniformScale, mouseInteraction.m_mousePick.m_rayOrigin,
+                mouseInteraction.m_mousePick.m_rayDirection, cameraState.m_farClip, m_localStart, m_localEnd);
 
             const AZ::Vector3 worldLineHitPosition = manipulatorState.TransformPoint(action.m_localLineHitPosition);
             debugDisplay.SetColor(AZ::Vector4(0.0f, 1.0f, 0.0f, 1.0f));
             debugDisplay.DrawBall(
-                worldLineHitPosition, ManipulatorViewScaleMultiplier(worldLineHitPosition, cameraState)
-                    * g_defaultManipulatorSphereRadius, false);
+                worldLineHitPosition, ManipulatorViewScaleMultiplier(worldLineHitPosition, cameraState) * g_defaultManipulatorSphereRadius,
+                false);
         }
 
         RefreshBoundInternal(managerId, manipulatorId, lineBound);
     }
 
     void ManipulatorViewCone::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& managerState,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
         CameraCorrectAxis(
-            m_axis, m_cameraCorrectedAxis, managerState, mouseInteraction,
-            manipulatorState.m_worldFromLocal, manipulatorState.m_localPosition,
-            cameraState, &m_shouldCorrect);
+            m_axis, m_cameraCorrectedAxis, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
+            manipulatorState.m_localPosition, cameraState, &m_shouldCorrect);
 
         CameraCorrectAxis(
-            m_offset, m_cameraCorrectedOffset, managerState, mouseInteraction,
-            manipulatorState.m_worldFromLocal, manipulatorState.m_localPosition, cameraState);
+            m_offset, m_cameraCorrectedOffset, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
+            manipulatorState.m_localPosition, cameraState);
 
-        const Picking::BoundShapeCone coneBound =
-            CalculateConeBound(
-                manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_cameraCorrectedAxis,
-                m_cameraCorrectedOffset * viewScale,
-                m_length * viewScale,
-                m_radius * viewScale);
+        const Picking::BoundShapeCone coneBound = CalculateConeBound(
+            manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_cameraCorrectedAxis, m_cameraCorrectedOffset * viewScale,
+            m_length * viewScale, m_radius * viewScale);
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
         if (m_shouldCorrect)
@@ -460,73 +479,77 @@ namespace AzToolsFramework
     }
 
     void ManipulatorViewBox::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& managerState,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
         const AZ::Quaternion orientation = m_orientation;
 
         CameraCorrectAxis(
-            m_offset, m_cameraCorrectedOffset, managerState, mouseInteraction,
-            manipulatorState.m_worldFromLocal, manipulatorState.m_localPosition,
-            cameraState);
+            m_offset, m_cameraCorrectedOffset, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
+            manipulatorState.m_localPosition, cameraState);
 
-        const Picking::BoundShapeBox boxBound =
-            CalculateBoxBound(manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, orientation,
-                m_cameraCorrectedOffset * viewScale,
-                m_halfExtents * viewScale);
+        const Picking::BoundShapeBox boxBound = CalculateBoxBound(
+            manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, orientation, m_cameraCorrectedOffset * viewScale,
+            m_halfExtents * viewScale);
 
         const AZ::Vector3 xAxis = boxBound.m_orientation.TransformVector(AZ::Vector3::CreateAxisX());
         const AZ::Vector3 yAxis = boxBound.m_orientation.TransformVector(AZ::Vector3::CreateAxisY());
         const AZ::Vector3 zAxis = boxBound.m_orientation.TransformVector(AZ::Vector3::CreateAxisZ());
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
-        debugDisplay.DrawSolidOBB(boxBound.m_center,
-            xAxis, yAxis, zAxis, boxBound.m_halfExtents);
+        debugDisplay.DrawSolidOBB(boxBound.m_center, xAxis, yAxis, zAxis, boxBound.m_halfExtents);
 
         RefreshBoundInternal(managerId, manipulatorId, boxBound);
     }
 
     void ManipulatorViewCylinder::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& managerState,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
         CameraCorrectAxis(
-            m_axis, m_cameraCorrectedAxis, managerState, mouseInteraction,
-            manipulatorState.m_worldFromLocal, manipulatorState.m_localPosition, cameraState);
+            m_axis, m_cameraCorrectedAxis, managerState, mouseInteraction, manipulatorState.m_worldFromLocal,
+            manipulatorState.m_localPosition, cameraState);
 
-        const Picking::BoundShapeCylinder cylinderBound =
-            CalculateCylinderBound(
-                manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_cameraCorrectedAxis,
-                m_length * viewScale,
-                m_radius * viewScale);
+        const Picking::BoundShapeCylinder cylinderBound = CalculateCylinderBound(
+            manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_cameraCorrectedAxis, m_length * viewScale,
+            m_radius * viewScale);
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
-        debugDisplay.DrawSolidCylinder(cylinderBound.m_base + cylinderBound.m_axis * cylinderBound.m_height * 0.5f,
-            cylinderBound.m_axis, cylinderBound.m_radius, cylinderBound.m_height, false);
+        debugDisplay.DrawSolidCylinder(
+            cylinderBound.m_base + cylinderBound.m_axis * cylinderBound.m_height * 0.5f, cylinderBound.m_axis, cylinderBound.m_radius,
+            cylinderBound.m_height, false);
 
         RefreshBoundInternal(managerId, manipulatorId, cylinderBound);
     }
 
     void ManipulatorViewSphere::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& /*managerState*/,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& /*managerState*/,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const Picking::BoundShapeSphere sphereBound =
-            CalculateSphereBound(manipulatorState.m_localPosition, manipulatorState,
-                m_radius * ManipulatorViewScaleMultiplier(
-                    manipulatorState.TransformPoint(manipulatorState.m_localPosition), cameraState));
+        const Picking::BoundShapeSphere sphereBound = CalculateSphereBound(
+            manipulatorState.m_localPosition, manipulatorState,
+            m_radius * ManipulatorViewScaleMultiplier(manipulatorState.TransformPoint(manipulatorState.m_localPosition), cameraState));
 
         if (m_depthTest)
         {
@@ -545,31 +568,32 @@ namespace AzToolsFramework
     }
 
     void ManipulatorViewCircle::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& /*managerState*/,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& /*managerState*/,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& /*mouseInteraction*/)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
-        const Picking::BoundShapeTorus torusBound =
-            CalculateTorusBound(
-                manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_axis,
-                m_radius * viewScale,
-                m_width * viewScale);
+        const Picking::BoundShapeTorus torusBound = CalculateTorusBound(
+            manipulatorState.m_localPosition, manipulatorState.m_worldFromLocal, m_axis, m_radius * viewScale, m_width * viewScale);
 
         // transform circle based on delta between default z up axis and other axes
         const AZ::Transform worldFromLocalWithOrientation =
             AZ::Transform::CreateTranslation(manipulatorState.m_worldFromLocal.GetTranslation()) *
-            AZ::Transform::CreateFromQuaternion(
-                (QuaternionFromTransformNoScaling(manipulatorState.m_worldFromLocal) *
-                AZ::Quaternion::CreateShortestArc(AZ::Vector3::CreateAxisZ(), m_axis)).GetNormalized());
+            AZ::Transform::CreateFromQuaternion((QuaternionFromTransformNoScaling(manipulatorState.m_worldFromLocal) *
+                                                 AZ::Quaternion::CreateShortestArc(AZ::Vector3::CreateAxisZ(), m_axis))
+                                                    .GetNormalized());
 
         debugDisplay.CullOn();
         debugDisplay.PushMatrix(worldFromLocalWithOrientation);
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
-        m_drawCircleFunc(debugDisplay, manipulatorState.m_localPosition, torusBound.m_majorRadius,
+        m_drawCircleFunc(
+            debugDisplay, manipulatorState.m_localPosition, torusBound.m_majorRadius,
             worldFromLocalWithOrientation.GetInverse().TransformPoint(cameraState.m_position));
         debugDisplay.PopMatrix();
         debugDisplay.CullOff();
@@ -578,27 +602,28 @@ namespace AzToolsFramework
     }
 
     void DrawHalfDottedCircle(
-        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position,
-        const float radius, const AZ::Vector3& viewPos)
+        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position, const float radius, const AZ::Vector3& viewPos)
     {
         debugDisplay.DrawHalfDottedCircle(position, radius, viewPos);
     }
 
     void DrawFullCircle(
-        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position,
-        const float radius, const AZ::Vector3& /*viewPos*/)
+        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position, const float radius, const AZ::Vector3& /*viewPos*/)
     {
-         debugDisplay.DrawCircle(position, radius);
+        debugDisplay.DrawCircle(position, radius);
     }
 
     void ManipulatorViewSplineSelect::Draw(
-        const ManipulatorManagerId managerId, const ManipulatorManagerState& /*managerState*/,
-        const ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-        AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+        const ManipulatorManagerId managerId,
+        const ManipulatorManagerState& /*managerState*/,
+        const ManipulatorId manipulatorId,
+        const ManipulatorState& manipulatorState,
+        AzFramework::DebugDisplayRequests& debugDisplay,
+        const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        const float viewScale = ManipulatorViewScaleMultiplier(
-            manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
+        const float viewScale =
+            ManipulatorViewScaleMultiplier(manipulatorState.m_worldFromLocal.TransformPoint(manipulatorState.m_localPosition), cameraState);
 
         const Picking::BoundShapeSpline splineBound =
             CalculateSplineBound(m_spline, manipulatorState.m_worldFromLocal, m_width * viewScale);
@@ -606,16 +631,15 @@ namespace AzToolsFramework
         if (manipulatorState.m_mouseOver)
         {
             const SplineSelectionManipulator::Action action = CalculateManipulationDataAction(
-                manipulatorState.m_worldFromLocal, mouseInteraction.m_mousePick.m_rayOrigin,
-                mouseInteraction.m_mousePick.m_rayDirection, m_spline);
+                manipulatorState.m_worldFromLocal, mouseInteraction.m_mousePick.m_rayOrigin, mouseInteraction.m_mousePick.m_rayDirection,
+                m_spline);
 
-            const AZ::Vector3 worldSplineHitPosition =
-                manipulatorState.m_worldFromLocal.TransformPoint(action.m_localSplineHitPosition);
+            const AZ::Vector3 worldSplineHitPosition = manipulatorState.m_worldFromLocal.TransformPoint(action.m_localSplineHitPosition);
 
             debugDisplay.SetColor(m_color.GetAsVector4());
             debugDisplay.DrawBall(
-                worldSplineHitPosition, ManipulatorViewScaleMultiplier(worldSplineHitPosition, cameraState)
-                    * g_defaultManipulatorSphereRadius, false);
+                worldSplineHitPosition,
+                ManipulatorViewScaleMultiplier(worldSplineHitPosition, cameraState) * g_defaultManipulatorSphereRadius, false);
         }
 
         RefreshBoundInternal(managerId, manipulatorId, splineBound);
@@ -624,8 +648,7 @@ 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 float size)
     {
         AZStd::unique_ptr<ManipulatorViewQuad> viewQuad = AZStd::make_unique<ManipulatorViewQuad>();
         viewQuad->m_axis1 = planarManipulator.GetAxis1();
@@ -636,8 +659,7 @@ namespace AzToolsFramework
         return viewQuad;
     }
 
-    AZStd::unique_ptr<ManipulatorViewQuadBillboard> CreateManipulatorViewQuadBillboard(
-        const AZ::Color& color, const float size)
+    AZStd::unique_ptr<ManipulatorViewQuadBillboard> CreateManipulatorViewQuadBillboard(const AZ::Color& color, const float size)
     {
         AZStd::unique_ptr<ManipulatorViewQuadBillboard> viewQuad = AZStd::make_unique<ManipulatorViewQuadBillboard>();
         viewQuad->m_size = size;
@@ -646,8 +668,7 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewLine> CreateManipulatorViewLine(
-        const LinearManipulator& linearManipulator, const AZ::Color& color,
-        const float length, const float width)
+        const LinearManipulator& linearManipulator, const AZ::Color& color, const float length, const float width)
     {
         AZStd::unique_ptr<ManipulatorViewLine> viewLine = AZStd::make_unique<ManipulatorViewLine>();
         viewLine->m_axis = linearManipulator.GetAxis();
@@ -658,8 +679,7 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewLineSelect> CreateManipulatorViewLineSelect(
-        const LineSegmentSelectionManipulator& lineSegmentManipulator,
-        const AZ::Color& color, const float width)
+        const LineSegmentSelectionManipulator& lineSegmentManipulator, const AZ::Color& color, const float width)
     {
         AZStd::unique_ptr<ManipulatorViewLineSelect> viewLineSelect = AZStd::make_unique<ManipulatorViewLineSelect>();
         viewLineSelect->m_localStart = lineSegmentManipulator.GetStart();
@@ -670,8 +690,11 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewCone> CreateManipulatorViewCone(
-        const LinearManipulator& linearManipulator, const AZ::Color& color,
-        const AZ::Vector3& offset, const float length, const float radius)
+        const LinearManipulator& linearManipulator,
+        const AZ::Color& color,
+        const AZ::Vector3& offset,
+        const float length,
+        const float radius)
     {
         AZStd::unique_ptr<ManipulatorViewCone> viewCone = AZStd::make_unique<ManipulatorViewCone>();
         viewCone->m_axis = linearManipulator.GetAxis();
@@ -683,8 +706,7 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewBox> CreateManipulatorViewBox(
-        const AZ::Transform& transform, const AZ::Color& color,
-        const AZ::Vector3& offset, const AZ::Vector3& halfExtents)
+        const AZ::Transform& transform, const AZ::Color& color, const AZ::Vector3& offset, const AZ::Vector3& halfExtents)
     {
         AZStd::unique_ptr<ManipulatorViewBox> viewBox = AZStd::make_unique<ManipulatorViewBox>();
         viewBox->m_orientation = transform.GetRotation();
@@ -695,8 +717,7 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewCylinder> CreateManipulatorViewCylinder(
-        const LinearManipulator& linearManipulator, const AZ::Color& color,
-        const float length, const float radius)
+        const LinearManipulator& linearManipulator, const AZ::Color& color, const float length, const float radius)
     {
         AZStd::unique_ptr<ManipulatorViewCylinder> viewCylinder = AZStd::make_unique<ManipulatorViewCylinder>();
         viewCylinder->m_axis = linearManipulator.GetAxis();
@@ -718,8 +739,11 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewCircle> CreateManipulatorViewCircle(
-        const AngularManipulator& angularManipulator, const AZ::Color& color,
-        const float radius, const float width, const ManipulatorViewCircle::DrawCircleFunc drawFunc)
+        const AngularManipulator& angularManipulator,
+        const AZ::Color& color,
+        const float radius,
+        const float width,
+        const ManipulatorViewCircle::DrawCircleFunc drawFunc)
     {
         AZStd::unique_ptr<ManipulatorViewCircle> viewCircle = AZStd::make_unique<ManipulatorViewCircle>();
         viewCircle->m_axis = angularManipulator.GetAxis();
@@ -731,8 +755,7 @@ namespace AzToolsFramework
     }
 
     AZStd::unique_ptr<ManipulatorViewSplineSelect> CreateManipulatorViewSplineSelect(
-        const SplineSelectionManipulator& splineManipulator,
-        const AZ::Color& color, const float width)
+        const SplineSelectionManipulator& splineManipulator, const AZ::Color& color, const float width)
     {
         AZStd::unique_ptr<ManipulatorViewSplineSelect> viewSplineSelect = AZStd::make_unique<ManipulatorViewSplineSelect>();
         viewSplineSelect->m_spline = splineManipulator.GetSpline();
@@ -741,16 +764,12 @@ namespace AzToolsFramework
         return viewSplineSelect;
     }
 
-    AZ::Vector3 CalculateViewDirection(
-        const Manipulators& manipulators, const AZ::Vector3& worldViewPosition)
+    AZ::Vector3 CalculateViewDirection(const Manipulators& manipulators, const AZ::Vector3& worldViewPosition)
     {
-        const AZ::Transform worldFromLocalWithTransform =
-            manipulators.GetSpace() * manipulators.GetLocalTransform();
+        const AZ::Transform worldFromLocalWithTransform = manipulators.GetSpace() * manipulators.GetLocalTransform();
 
-        AZ::Vector3 lookDirection =
-            (worldFromLocalWithTransform.GetTranslation() - worldViewPosition).GetNormalized();
+        AZ::Vector3 lookDirection = (worldFromLocalWithTransform.GetTranslation() - worldViewPosition).GetNormalized();
 
-        return TransformDirectionNoScaling(
-            worldFromLocalWithTransform.GetInverse(), lookDirection);
+        return TransformDirectionNoScaling(worldFromLocalWithTransform.GetInverse(), lookDirection);
     }
 } // namespace AzToolsFramework

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -26,13 +26,12 @@ namespace AzToolsFramework
     class LineSegmentSelectionManipulator;
     class SplineSelectionManipulator;
 
-    using DecideColorFn = AZStd::function<AZ::Color(
-        const ViewportInteraction::MouseInteraction&,
-        bool mouseOver, const AZ::Color& defaultColor)>;
+    using DecideColorFn =
+        AZStd::function<AZ::Color(const ViewportInteraction::MouseInteraction&, bool mouseOver, const AZ::Color& defaultColor)>;
 
     extern const float g_defaultManipulatorSphereRadius;
 
-    /// State of an individual manipulator.
+    //! State of an individual manipulator.
     struct ManipulatorState
     {
         AZ::Transform m_worldFromLocal;
@@ -40,18 +39,18 @@ namespace AzToolsFramework
         AZ::Vector3 m_localPosition;
         bool m_mouseOver;
 
-        /// Transforms a point, taking non-uniform scale into account.
+        //! Transforms a point, taking non-uniform scale into account.
         AZ::Vector3 TransformPoint(const AZ::Vector3& point) const;
 
-        /// Rotates a direction into the space of the manipulator and normalizes it.
-        /// Non-uniform scaling and translation are not applied.
+        //! Rotates a direction into the space of the manipulator and normalizes it.
+        //! Non-uniform scaling and translation are not applied.
         AZ::Vector3 TransformDirectionNoScaling(const AZ::Vector3& direction) const;
     };
 
-    /// The base interface for the visual representation of manipulators.
-    /// The View represents the appearance and bounds of the manipulator for
-    /// the user to interact with. Any manipulator can have any view (some may
-    /// be more appropriate than others in certain cases).
+    //! The base interface for the visual representation of manipulators.
+    //! The View represents the appearance and bounds of the manipulator for
+    //! the user to interact with. Any manipulator can have any view (some may
+    //! be more appropriate than others in certain cases).
     class ManipulatorView
     {
     public:
@@ -65,98 +64,107 @@ namespace AzToolsFramework
         ManipulatorView& operator=(ManipulatorView&&) = default;
 
         void SetBoundDirty(ManipulatorManagerId managerId);
-        void RefreshBound(
-            ManipulatorManagerId managerId, ManipulatorId manipulatorId, const Picking::BoundRequestShapeBase& bound);
+        void RefreshBound(ManipulatorManagerId managerId, ManipulatorId manipulatorId, const Picking::BoundRequestShapeBase& bound);
         void Invalidate(ManipulatorManagerId managerId);
 
         virtual void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) = 0;
 
-        bool ScreenSizeFixed() const { return m_screenSizeFixed; }
+        bool ScreenSizeFixed() const
+        {
+            return m_screenSizeFixed;
+        }
 
     protected:
-        AZ::Color m_mouseOverColor = BaseManipulator::s_defaultMouseOverColor; ///< What color should the manipulator
-                                                                               ///< be when the mouse is hovering over it.
-        /// Scale the manipulator based on the distance
-        /// from the camera if m_screenSizeFixed is true.
-        float ManipulatorViewScaleMultiplier(
-            const AZ::Vector3& worldPosition, const AzFramework::CameraState& cameraState) const;
+        AZ::Color m_mouseOverColor = BaseManipulator::s_defaultMouseOverColor; //!< What color should the manipulator
+                                                                               //!< be when the mouse is hovering over it.
+        //! Scale the manipulator based on the distance
+        //! from the camera if m_screenSizeFixed is true.
+        float ManipulatorViewScaleMultiplier(const AZ::Vector3& worldPosition, const AzFramework::CameraState& cameraState) const;
 
-        /// Wrap the logic for updating a bound.
-        /// Should be called at the end of the Draw function once a concrete BoundRequestShape has
-        /// been created to use for dimensions for rendering.
-        void RefreshBoundInternal(
-            ManipulatorManagerId managerId, ManipulatorId manipulatorId, const Picking::BoundRequestShapeBase& bound);
+        //! Wrap the logic for updating a bound.
+        //! Should be called at the end of the Draw function once a concrete BoundRequestShape has
+        //! been created to use for dimensions for rendering.
+        void RefreshBoundInternal(ManipulatorManagerId managerId, ManipulatorId manipulatorId, const Picking::BoundRequestShapeBase& bound);
 
     private:
-        Picking::RegisteredBoundId m_boundId = Picking::InvalidBoundId; ///< Used for hit detection.
-        ManipulatorManagerId m_managerId = InvalidManipulatorManagerId; /// The manipulator manager this view has been registered with.
-        bool m_screenSizeFixed = true; ///< Should manipulator size be adjusted based on camera distance.
-        bool m_boundDirty = true; ///< Do the bounds need to be recalculated.
+        Picking::RegisteredBoundId m_boundId = Picking::InvalidBoundId; //!< Used for hit detection.
+        ManipulatorManagerId m_managerId = InvalidManipulatorManagerId; //! The manipulator manager this view has been registered with.
+        bool m_screenSizeFixed = true; //!< Should manipulator size be adjusted based on camera distance.
+        bool m_boundDirty = true; //!< Do the bounds need to be recalculated.
     };
 
     // A collection of views (a manipulator may have 1 - * views)
     using ManipulatorViews = AZStd::vector<AZStd::shared_ptr<ManipulatorView>>;
 
-    /// Display a quad representing part of a plane, rendered as 4 lines.
-    class ManipulatorViewQuad
-        : public ManipulatorView
+    //! Display a quad representing part of a plane, rendered as 4 lines.
+    class ManipulatorViewQuad : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewQuad, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewQuad, "{D85E1B45-495E-4755-BCF2-6AE45F8BB2B0}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         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::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.
+        float m_size = 0.06f; //!< size to render and do mouse ray intersection tests against.
 
     private:
         AZ::Vector3 m_cameraCorrectedAxis1;
         AZ::Vector3 m_cameraCorrectedAxis2;
     };
 
-    /// A screen aligned quad, centered at the position of the manipulator, display filled.
-    class ManipulatorViewQuadBillboard
-        : public ManipulatorView
+    //! A screen aligned quad, centered at the position of the manipulator, display filled.
+    class ManipulatorViewQuadBillboard : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewQuadBillboard, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewQuadBillboard, "{C205E967-E8C6-4A73-A31B-41EE5529B15B}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Color m_color = AZ::Color(1.0f, 0.0f, 0.0f, 1.0f);
-        float m_size = 0.005f; ///< size to render and do mouse ray intersection tests against.
+        float m_size = 0.005f; //!< size to render and do mouse ray intersection tests against.
     };
 
-    /// Displays a debug style line starting from the manipulator's transform,
-    /// width determines the click area.
-    class ManipulatorViewLine
-        : public ManipulatorView
+    //! Displays a debug style line starting from the manipulator's transform,
+    //! width determines the click area.
+    class ManipulatorViewLine : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewLine, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewLine, "{831EEF66-4A5C-450C-B152-EA4A0BC8A272}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Vector3 m_axis;
@@ -168,19 +176,21 @@ namespace AzToolsFramework
         AZ::Vector3 m_cameraCorrectedAxis;
     };
 
-    /// Variant of ManipulatorViewLine which instead of using an axis, provides begin and end
-    /// points for the line. Used for selection when inserting points along a line.
-    class ManipulatorViewLineSelect
-        : public ManipulatorView
+    //! Variant of ManipulatorViewLine which instead of using an axis, provides begin and end
+    //! points for the line. Used for selection when inserting points along a line.
+    class ManipulatorViewLineSelect : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewLineSelect, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewLineSelect, "{BF26A947-91F8-4595-9A5B-481876EB2C48}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Vector3 m_localStart;
@@ -189,20 +199,22 @@ namespace AzToolsFramework
         float m_width = 0.0f;
     };
 
-    /// Displays a filled cone along the specified axis, offset is local translation from
-    /// the manipulator transform (often used in conjunction with other views to build
-    /// aggregate views such as arrows - e.g. a line and cone).
-    class ManipulatorViewCone
-        : public ManipulatorView
+    //! Displays a filled cone along the specified axis, offset is local translation from
+    //! the manipulator transform (often used in conjunction with other views to build
+    //! aggregate views such as arrows - e.g. a line and cone).
+    class ManipulatorViewCone : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewCone, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewCone, "{BF042887-1F51-4FD8-8CA5-4A649B4AF356}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Vector3 m_offset;
@@ -217,20 +229,22 @@ namespace AzToolsFramework
         bool m_shouldCorrect = false;
     };
 
-    /// Displays a filled box, offset is local translation from the manipulator
-    /// transform, box is often used in conjunction with other views, orientation allows
-    /// the box to be orientated separately from the manipulator transform.
-    class ManipulatorViewBox
-        : public ManipulatorView
+    //! Displays a filled box, offset is local translation from the manipulator
+    //! transform, box is often used in conjunction with other views, orientation allows
+    //! the box to be orientated separately from the manipulator transform.
+    class ManipulatorViewBox : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewBox, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewBox, "{2D082201-7878-4C1B-A3DD-7A629E5AD598}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Vector3 m_offset;
@@ -242,18 +256,20 @@ namespace AzToolsFramework
         AZ::Vector3 m_cameraCorrectedOffset;
     };
 
-    /// Displays a filled cylinder along the axis provided.
-    class ManipulatorViewCylinder
-        : public ManipulatorView
+    //! Displays a filled cylinder along the axis provided.
+    class ManipulatorViewCylinder : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewCylinder, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewCylinder, "{9B8E5EF4-0F85-4CD0-A5FF-3C7097DF58AC}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Vector3 m_axis;
@@ -265,20 +281,22 @@ namespace AzToolsFramework
         AZ::Vector3 m_cameraCorrectedAxis;
     };
 
-    /// Displays a filled sphere at the transform of the manipulator, often used as
-    /// a selection manipulator. DecideColorFn allows more complex logic to be used
-    /// to decide the color of the manipulator (based on hover state etc.)
-    class ManipulatorViewSphere
-        : public ManipulatorView
+    //! Displays a filled sphere at the transform of the manipulator, often used as
+    //! a selection manipulator. DecideColorFn allows more complex logic to be used
+    //! to decide the color of the manipulator (based on hover state etc.)
+    class ManipulatorViewSphere : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewSphere, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewSphere, "{324D8329-6E7B-4A5D-AC8A-8C0E1C984E38}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         float m_radius = 0.0f;
@@ -287,23 +305,24 @@ namespace AzToolsFramework
         bool m_depthTest = false;
     };
 
-    /// Displays a wire circle. DrawCircleFunc can be used to either draw a full
-    /// circle or a half dotted circle where the part of the circle facing away
-    /// from the camera is dotted (useful for angular/rotation manipulators).
-    class ManipulatorViewCircle
-        : public ManipulatorView
+    //! Displays a wire circle. DrawCircleFunc can be used to either draw a full
+    //! circle or a half dotted circle where the part of the circle facing away
+    //! from the camera is dotted (useful for angular/rotation manipulators).
+    class ManipulatorViewCircle : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewCircle, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewCircle, "{26563A03-3E48-49EB-9DCF-30EE4F567FCD}", ManipulatorView)
 
-        using DrawCircleFunc =
-            void(*)(AzFramework::DebugDisplayRequests&, const AZ::Vector3&, float, const AZ::Vector3&);
+        using DrawCircleFunc = void (*)(AzFramework::DebugDisplayRequests&, const AZ::Vector3&, float, const AZ::Vector3&);
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZ::Vector3 m_axis;
@@ -316,26 +335,26 @@ namespace AzToolsFramework
     // helpers to provide consistent function pointer interface for deciding
     // on type of circle to draw (see DrawCircleFunc in ManipulatorViewCircle above)
     void DrawHalfDottedCircle(
-        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position,
-        float radius, const AZ::Vector3& viewPos);
+        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position, float radius, const AZ::Vector3& viewPos);
     void DrawFullCircle(
-        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position,
-        float radius, const AZ::Vector3& viewPos);
+        AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Vector3& position, float radius, const AZ::Vector3& viewPos);
 
-    /// Used for interaction with spline primitive - it will generate a spline bound
-    /// to be interacted with and will display the intersection point on the spline
-    /// where a user may wish to insert a point.
-    class ManipulatorViewSplineSelect
-        : public ManipulatorView
+    //! Used for interaction with spline primitive - it will generate a spline bound
+    //! to be interacted with and will display the intersection point on the spline
+    //! where a user may wish to insert a point.
+    class ManipulatorViewSplineSelect : public ManipulatorView
     {
     public:
         AZ_CLASS_ALLOCATOR(ManipulatorViewSplineSelect, AZ::SystemAllocator, 0)
         AZ_RTTI(ManipulatorViewSplineSelect, "{60996E49-D6BF-4817-BAA3-D27A407DD21A}", ManipulatorView)
 
         void Draw(
-            ManipulatorManagerId managerId, const ManipulatorManagerState& managerState,
-            ManipulatorId manipulatorId, const ManipulatorState& manipulatorState,
-            AzFramework::DebugDisplayRequests& debugDisplay, const AzFramework::CameraState& cameraState,
+            ManipulatorManagerId managerId,
+            const ManipulatorManagerState& managerState,
+            ManipulatorId manipulatorId,
+            const ManipulatorState& manipulatorState,
+            AzFramework::DebugDisplayRequests& debugDisplay,
+            const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
         AZStd::weak_ptr<const AZ::Spline> m_spline;
@@ -343,65 +362,61 @@ namespace AzToolsFramework
         AZ::Color m_color = AZ::Color(0.0f, 1.0f, 0.0f, 1.0f);
     };
 
-    /// Returns true if axis is pointing away from us (we should flip it).
+    //! Returns true if axis is pointing away from us (we should flip it).
     inline bool ShouldFlipCameraAxis(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& localPosition,
-        const AZ::Vector3& axis, const AzFramework::CameraState& cameraState)
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& localPosition,
+        const AZ::Vector3& axis,
+        const AzFramework::CameraState& cameraState)
     {
-        return (worldFromLocal.TransformPoint(localPosition) - cameraState.m_position).Dot(
-                TransformDirectionNoScaling(worldFromLocal, axis)) > 0.0f;
+        return (worldFromLocal.TransformPoint(localPosition) - cameraState.m_position)
+                   .Dot(TransformDirectionNoScaling(worldFromLocal, axis)) > 0.0f;
     }
 
-    /// @brief Return the world transform of the entity with uniform scale - choose
-    /// the largest element.
+    //! @brief Return the world transform of the entity with uniform scale - choose
+    //! the largest element.
     AZ::Transform WorldFromLocalWithUniformScale(AZ::EntityId entityId);
 
-    /// Get the non-uniform scale for this entity id.
+    //! Get the non-uniform scale for this entity id.
     AZ::Vector3 GetNonUniformScale(AZ::EntityId entityId);
 
     // 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, float size);
 
-    AZStd::unique_ptr<ManipulatorViewQuadBillboard> CreateManipulatorViewQuadBillboard(
-        const AZ::Color& color, float size);
+    AZStd::unique_ptr<ManipulatorViewQuadBillboard> CreateManipulatorViewQuadBillboard(const AZ::Color& color, float size);
 
     AZStd::unique_ptr<ManipulatorViewLine> CreateManipulatorViewLine(
-        const LinearManipulator& linearManipulator, const AZ::Color& color,
-        float length, float width);
+        const LinearManipulator& linearManipulator, const AZ::Color& color, float length, float width);
 
     AZStd::unique_ptr<ManipulatorViewLineSelect> CreateManipulatorViewLineSelect(
-        const LineSegmentSelectionManipulator& lineSegmentManipulator, const AZ::Color& color,
-        float width);
+        const LineSegmentSelectionManipulator& lineSegmentManipulator, const AZ::Color& color, float width);
 
     AZStd::unique_ptr<ManipulatorViewCone> CreateManipulatorViewCone(
-        const LinearManipulator& linearManipulator, const AZ::Color& color,
-        const AZ::Vector3& offset, float length, float radius);
+        const LinearManipulator& linearManipulator, const AZ::Color& color, const AZ::Vector3& offset, float length, float radius);
 
     AZStd::unique_ptr<ManipulatorViewBox> CreateManipulatorViewBox(
-        const AZ::Transform& transform, const AZ::Color& color,
-        const AZ::Vector3& offset, const AZ::Vector3& halfExtents);
+        const AZ::Transform& transform, const AZ::Color& color, const AZ::Vector3& offset, const AZ::Vector3& halfExtents);
 
     AZStd::unique_ptr<ManipulatorViewCylinder> CreateManipulatorViewCylinder(
-        const LinearManipulator& linearManipulator, const AZ::Color& color,
-        float length, float radius);
+        const LinearManipulator& linearManipulator, const AZ::Color& color, float length, float radius);
 
     AZStd::unique_ptr<ManipulatorViewSphere> CreateManipulatorViewSphere(
         const AZ::Color& color, float radius, const DecideColorFn& decideColor, bool enableDepthTest = false);
 
     AZStd::unique_ptr<ManipulatorViewCircle> CreateManipulatorViewCircle(
-        const AngularManipulator& angularManipulator, const AZ::Color& color,
-        float radius, float width, ManipulatorViewCircle::DrawCircleFunc drawFunc);
+        const AngularManipulator& angularManipulator,
+        const AZ::Color& color,
+        float radius,
+        float width,
+        ManipulatorViewCircle::DrawCircleFunc drawFunc);
 
     AZStd::unique_ptr<ManipulatorViewSplineSelect> CreateManipulatorViewSplineSelect(
-        const SplineSelectionManipulator& splineManipulator, const AZ::Color& color,
-        float width);
+        const SplineSelectionManipulator& splineManipulator, const AZ::Color& color, float width);
 
-    /// Returns the vector between the view (camera) and the manipulator in the space
-    /// of the Manipulator (manipulator space + local transform).
-    AZ::Vector3 CalculateViewDirection(
-        const Manipulators& manipulators, const AZ::Vector3& worldViewPosition);
+    //! Returns the vector between the view (camera) and the manipulator in the space
+    //! of the Manipulator (manipulator space + local transform).
+    AZ::Vector3 CalculateViewDirection(const Manipulators& manipulators, const AZ::Vector3& worldViewPosition);
 
 } // namespace AzToolsFramework

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "MultiLinearManipulator.h"
 
@@ -56,10 +56,13 @@ namespace AzToolsFramework
     }
 
     static MultiLinearManipulator::Action BuildMultiLinearManipulatorAction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale, const AZ::Transform& localTransform,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
         const ViewportInteraction::MouseInteraction& interaction,
         const AZStd::vector<LinearManipulator::Fixed>& fixedAxes,
-        const AZStd::vector<LinearManipulator::Starter>& starterStates, const GridSnapParameters& gridSnapParams)
+        const AZStd::vector<LinearManipulator::Starter>& starterStates,
+        const GridSnapParameters& gridSnapParams)
     {
         MultiLinearManipulator::Action action;
         action.m_viewportId = interaction.m_interactionId.m_viewportId;
@@ -96,8 +99,8 @@ namespace AzToolsFramework
             const GridSnapParameters gridSnapParams = GridSnapSettings(interaction.m_interactionId.m_viewportId);
             // pass action containing all linear actions for each axis to handler
             m_onLeftMouseDownCallback(BuildMultiLinearManipulatorAction(
-                worldFromLocalUniformScale, GetNonUniformScale(), GetLocalTransform(),
-                interaction, m_fixedAxes, m_starters, gridSnapParams));
+                worldFromLocalUniformScale, GetNonUniformScale(), GetLocalTransform(), interaction, m_fixedAxes, m_starters,
+                gridSnapParams));
         }
     }
 
@@ -108,8 +111,8 @@ namespace AzToolsFramework
             const AZ::Transform worldFromLocalUniformScale = TransformUniformScale(GetSpace());
             const GridSnapParameters gridSnapParams = GridSnapSettings(interaction.m_interactionId.m_viewportId);
             m_onMouseMoveCallback(BuildMultiLinearManipulatorAction(
-                worldFromLocalUniformScale, GetNonUniformScale(), GetLocalTransform(),
-                interaction, m_fixedAxes, m_starters, gridSnapParams));
+                worldFromLocalUniformScale, GetNonUniformScale(), GetLocalTransform(), interaction, m_fixedAxes, m_starters,
+                gridSnapParams));
         }
     }
 
@@ -120,8 +123,8 @@ namespace AzToolsFramework
             const AZ::Transform worldFromLocalUniformScale = TransformUniformScale(GetSpace());
             const GridSnapParameters gridSnapParams = GridSnapSettings(interaction.m_interactionId.m_viewportId);
             m_onLeftMouseUpCallback(BuildMultiLinearManipulatorAction(
-                worldFromLocalUniformScale, GetNonUniformScale(), GetLocalTransform(),
-                interaction, m_fixedAxes, m_starters, gridSnapParams));
+                worldFromLocalUniformScale, GetNonUniformScale(), GetLocalTransform(), interaction, m_fixedAxes, m_starters,
+                gridSnapParams));
 
             m_starters.clear();
         }
@@ -138,36 +141,31 @@ namespace AzToolsFramework
             const AZ::Transform combined = TransformUniformScale(GetSpace()) * GetLocalTransform();
             for (const auto& fixed : m_fixedAxes)
             {
-                DrawAxis(
-                    debugDisplay, combined.GetTranslation(), TransformDirectionNoScaling(combined, fixed.m_axis));
+                DrawAxis(debugDisplay, combined.GetTranslation(), TransformDirectionNoScaling(combined, fixed.m_axis));
             }
         }
 
         for (auto& view : m_manipulatorViews)
         {
             view->Draw(
-                GetManipulatorManagerId(), managerState,
-                GetManipulatorId(), {
-                    ApplySpace(GetLocalTransform()), GetNonUniformScale(),
-                    AZ::Vector3::CreateZero(), MouseOver()
-                },
-                debugDisplay, cameraState, mouseInteraction);
+                GetManipulatorManagerId(), managerState, GetManipulatorId(),
+                { ApplySpace(GetLocalTransform()), GetNonUniformScale(), AZ::Vector3::CreateZero(), MouseOver() }, debugDisplay,
+                cameraState, mouseInteraction);
         }
     }
 
     void MultiLinearManipulator::AddAxis(const AZ::Vector3& axis)
     {
-        m_fixedAxes.push_back(LinearManipulator::Fixed{axis});
+        m_fixedAxes.push_back(LinearManipulator::Fixed{ axis });
     }
 
     void MultiLinearManipulator::AddAxes(const AZStd::vector<AZ::Vector3>& axes)
     {
         AZStd::transform(
-            axes.begin(), axes.end(),
-            AZStd::back_inserter(m_fixedAxes),
+            axes.begin(), axes.end(), AZStd::back_inserter(m_fixedAxes),
             [](const AZ::Vector3& axis)
             {
-                return LinearManipulator::Fixed{axis};
+                return LinearManipulator::Fixed{ axis };
             });
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/MultiLinearManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -80,12 +80,9 @@ namespace AzToolsFramework
         }
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
-        void OnMouseMoveImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
         void SetBoundsDirtyImpl() override;

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "PlanarManipulator.h"
 
@@ -22,12 +22,15 @@
 namespace AzToolsFramework
 {
     PlanarManipulator::StartInternal PlanarManipulator::CalculateManipulationDataStart(
-        const Fixed& fixed, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale, const AZ::Transform& localTransform,
-        const ViewportInteraction::MouseInteraction& interaction, const float intersectionDistance)
+        const Fixed& fixed,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
+        const ViewportInteraction::MouseInteraction& interaction,
+        const float intersectionDistance)
     {
-        const ManipulatorInteraction manipulatorInteraction =
-            BuildManipulatorInteraction(
-                worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
+        const ManipulatorInteraction manipulatorInteraction = BuildManipulatorInteraction(
+            worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
 
         const AZ::Vector3 normal = TransformDirectionNoScaling(localTransform, fixed.m_normal);
 
@@ -37,8 +40,8 @@ namespace AzToolsFramework
 
         StartInternal startInternal;
         Internal::CalculateRayPlaneIntersectingPoint(
-            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection,
-            localIntersectionPoint, normal, startInternal.m_localHitPosition);
+            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection, localIntersectionPoint, normal,
+            startInternal.m_localHitPosition);
 
         startInternal.m_localPosition = localTransform.GetTranslation();
 
@@ -46,13 +49,16 @@ namespace AzToolsFramework
     }
 
     PlanarManipulator::Action PlanarManipulator::CalculateManipulationDataAction(
-        const Fixed& fixed, const StartInternal& startInternal, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-        const AZ::Transform& localTransform, const GridSnapParameters& gridSnapParams,
+        const Fixed& fixed,
+        const StartInternal& startInternal,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& nonUniformScale,
+        const AZ::Transform& localTransform,
+        const GridSnapParameters& gridSnapParams,
         const ViewportInteraction::MouseInteraction& interaction)
     {
-        const ManipulatorInteraction manipulatorInteraction =
-            BuildManipulatorInteraction(
-                worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
+        const ManipulatorInteraction manipulatorInteraction = BuildManipulatorInteraction(
+            worldFromLocal, nonUniformScale, interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection);
 
         const AZ::Vector3 normal = TransformDirectionNoScaling(localTransform, fixed.m_normal);
 
@@ -61,8 +67,8 @@ namespace AzToolsFramework
         // if an invalid ray intersection is attempted
         AZ::Vector3 localHitPosition = startInternal.m_localHitPosition;
         Internal::CalculateRayPlaneIntersectingPoint(
-            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection,
-            startInternal.m_localHitPosition, normal, localHitPosition);
+            manipulatorInteraction.m_localRayOrigin, manipulatorInteraction.m_localRayDirection, startInternal.m_localHitPosition, normal,
+            localHitPosition);
 
         localHitPosition = Internal::TryConstrainHitPositionToView(
             localHitPosition, startInternal.m_localHitPosition, worldFromLocal.GetInverse(),
@@ -126,8 +132,8 @@ namespace AzToolsFramework
         const AZ::Transform worldFromLocalUniformScale = TransformUniformScale(GetSpace());
 
         m_startInternal = CalculateManipulationDataStart(
-            m_fixed, worldFromLocalUniformScale, GetNonUniformScale(), TransformNormalizedScale(GetLocalTransform()),
-            interaction, rayIntersectionDistance);
+            m_fixed, worldFromLocalUniformScale, GetNonUniformScale(), TransformNormalizedScale(GetLocalTransform()), interaction,
+            rayIntersectionDistance);
 
         if (m_onLeftMouseDownCallback)
         {
@@ -180,9 +186,10 @@ namespace AzToolsFramework
 
                 // display the exact hit (ray intersection) of the mouse pick on the manipulator
                 DrawTransformAxes(
-                    debugDisplay, TransformUniformScale(GetSpace()) *
-                    AZ::Transform::CreateTranslation(
-                        action.m_start.m_localHitPosition + GetNonUniformScale() * action.m_current.m_localOffset));
+                    debugDisplay,
+                    TransformUniformScale(GetSpace()) *
+                        AZ::Transform::CreateTranslation(
+                            action.m_start.m_localHitPosition + GetNonUniformScale() * action.m_current.m_localOffset));
             }
 
             AZ::Transform combined = GetLocalTransform();
@@ -191,23 +198,16 @@ namespace AzToolsFramework
 
             DrawTransformAxes(debugDisplay, combined);
 
-            DrawAxis(
-                debugDisplay, combined.GetTranslation(),
-                TransformDirectionNoScaling(GetLocalTransform(), m_fixed.m_axis1));
-            DrawAxis(
-                debugDisplay, combined.GetTranslation(),
-                TransformDirectionNoScaling(GetLocalTransform(), m_fixed.m_axis2));
+            DrawAxis(debugDisplay, combined.GetTranslation(), TransformDirectionNoScaling(GetLocalTransform(), m_fixed.m_axis1));
+            DrawAxis(debugDisplay, combined.GetTranslation(), TransformDirectionNoScaling(GetLocalTransform(), m_fixed.m_axis2));
         }
 
         for (auto& view : m_manipulatorViews)
         {
             view->Draw(
-                GetManipulatorManagerId(), managerState,
-                GetManipulatorId(), {
-                    ApplySpace(GetLocalTransform()), GetNonUniformScale(),
-                    AZ::Vector3::CreateZero(), MouseOver()
-                },
-                debugDisplay, cameraState, mouseInteraction);
+                GetManipulatorManagerId(), managerState, GetManipulatorId(),
+                { ApplySpace(GetLocalTransform()), GetNonUniformScale(), AZ::Vector3::CreateZero(), MouseOver() }, debugDisplay,
+                cameraState, mouseInteraction);
         }
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/PlanarManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -23,13 +23,13 @@ namespace AzToolsFramework
     class ManipulatorView;
     struct GridSnapParameters;
 
-    /// PlanarManipulator serves as a visual tool for users to modify values
-    /// in two dimension in a plane defined two non-collinear axes in 3D space.
+    //! PlanarManipulator serves as a visual tool for users to modify values
+    //! in two dimension in a plane defined two non-collinear axes in 3D space.
     class PlanarManipulator
         : public BaseManipulator
         , public ManipulatorSpaceWithLocalTransform
     {
-        /// Private constructor.
+        //! Private constructor.
         explicit PlanarManipulator(const AZ::Transform& worldFromLocal);
 
     public:
@@ -42,43 +42,51 @@ namespace AzToolsFramework
 
         ~PlanarManipulator() = default;
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
+        //! A Manipulator must only be created and managed through a shared_ptr.
         static AZStd::shared_ptr<PlanarManipulator> MakeShared(const AZ::Transform& worldFromLocal);
 
-        /// Unchanging data set once for the planar manipulator.
+        //! Unchanging data set once for the planar manipulator.
         struct Fixed
         {
-            AZ::Vector3 m_axis1 = AZ::Vector3::CreateAxisX(); ///< m_axis1 and m_axis2 have to be orthogonal, they together define a plane in 3d space.
+            AZ::Vector3 m_axis1 =
+                AZ::Vector3::CreateAxisX(); //!< m_axis1 and m_axis2 have to be orthogonal, they together define a plane in 3d space.
             AZ::Vector3 m_axis2 = AZ::Vector3::CreateAxisY();
-            AZ::Vector3 m_normal = AZ::Vector3::CreateAxisZ(); ///< m_normal is calculated automatically when setting the axes.
+            AZ::Vector3 m_normal = AZ::Vector3::CreateAxisZ(); //!< m_normal is calculated automatically when setting the axes.
         };
 
-        /// The state of the manipulator at the start of an interaction.
+        //! The state of the manipulator at the start of an interaction.
         struct Start
         {
-            AZ::Vector3 m_localPosition; ///< The current position of the manipulator in local space.
-            AZ::Vector3 m_localHitPosition; ///< The intersection point in local space between the ray and the manipulator when the mouse down event happens.
+            AZ::Vector3 m_localPosition; //!< The current position of the manipulator in local space.
+            AZ::Vector3 m_localHitPosition; //!< The intersection point in local space between the ray and the manipulator when the mouse
+                                            //!< down event happens.
         };
 
-        /// The state of the manipulator during an interaction.
+        //! The state of the manipulator during an interaction.
         struct Current
         {
-            AZ::Vector3 m_localOffset; ///< The current position of the manipulator in local space.
+            AZ::Vector3 m_localOffset; //!< The current position of the manipulator in local space.
         };
 
-        /// Mouse action data used by MouseActionCallback (wraps Start and Current manipulator state).
+        //! Mouse action data used by MouseActionCallback (wraps Start and Current manipulator state).
         struct Action
         {
             Fixed m_fixed;
             Start m_start;
             Current m_current;
             ViewportInteraction::KeyboardModifiers m_modifiers;
-            AZ::Vector3 LocalPosition() const { return m_start.m_localPosition + m_current.m_localOffset; }
-            AZ::Vector3 LocalPositionOffset() const { return m_current.m_localOffset; }
+            AZ::Vector3 LocalPosition() const
+            {
+                return m_start.m_localPosition + m_current.m_localOffset;
+            }
+            AZ::Vector3 LocalPositionOffset() const
+            {
+                return m_current.m_localOffset;
+            }
         };
 
-        /// This is the function signature of callbacks that will be invoked whenever a manipulator
-        /// is being clicked on or dragged.
+        //! This is the function signature of callbacks that will be invoked whenever a manipulator
+        //! is being clicked on or dragged.
         using MouseActionCallback = AZStd::function<void(const Action&)>;
 
         void InstallLeftMouseDownCallback(const MouseActionCallback& onMouseDownCallback);
@@ -91,11 +99,17 @@ namespace AzToolsFramework
             const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
-        /// Ensure @param axis1 and @param axis2 are not collinear.
+        //! Ensure @param axis1 and @param axis2 are not collinear.
         void SetAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2);
 
-        const AZ::Vector3& GetAxis1() const { return m_fixed.m_axis1; }
-        const AZ::Vector3& GetAxis2() const { return m_fixed.m_axis2; }
+        const AZ::Vector3& GetAxis1() const
+        {
+            return m_fixed.m_axis1;
+        }
+        const AZ::Vector3& GetAxis2() const
+        {
+            return m_fixed.m_axis2;
+        }
 
         template<typename Views>
         void SetViews(Views&& views)
@@ -104,21 +118,19 @@ namespace AzToolsFramework
         }
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
-        void OnMouseMoveImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
         void SetBoundsDirtyImpl() override;
 
-        /// Initial data recorded when a press first happens with a planar manipulator.
+        //! Initial data recorded when a press first happens with a planar manipulator.
         struct StartInternal
         {
-            AZ::Vector3 m_localPosition; ///< The starting position of the manipulator in local space.
-            AZ::Vector3 m_localHitPosition; ///< The intersection point in world space between the ray and the manipulator when the mouse down event happens.
+            AZ::Vector3 m_localPosition; //!< The starting position of the manipulator in local space.
+            AZ::Vector3 m_localHitPosition; //!< The intersection point in world space between the ray and the manipulator when the mouse
+                                            //!< down event happens.
         };
 
         Fixed m_fixed;
@@ -128,15 +140,23 @@ namespace AzToolsFramework
         MouseActionCallback m_onLeftMouseUpCallback = nullptr;
         MouseActionCallback m_onMouseMoveCallback = nullptr;
 
-        ManipulatorViews m_manipulatorViews; ///< Look of manipulator.
+        ManipulatorViews m_manipulatorViews; //!< Look of manipulator.
 
         static StartInternal CalculateManipulationDataStart(
-            const Fixed& fixed, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-            const AZ::Transform& localTransform, const ViewportInteraction::MouseInteraction& interaction, float intersectionDistance);
+            const Fixed& fixed,
+            const AZ::Transform& worldFromLocal,
+            const AZ::Vector3& nonUniformScale,
+            const AZ::Transform& localTransform,
+            const ViewportInteraction::MouseInteraction& interaction,
+            float intersectionDistance);
 
         static Action CalculateManipulationDataAction(
-            const Fixed& fixed, const StartInternal& startInternal, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale,
-            const AZ::Transform& localTransform, const GridSnapParameters& gridSnapParams,
+            const Fixed& fixed,
+            const StartInternal& startInternal,
+            const AZ::Transform& worldFromLocal,
+            const AZ::Vector3& nonUniformScale,
+            const AZ::Transform& localTransform,
+            const GridSnapParameters& gridSnapParams,
             const ViewportInteraction::MouseInteraction& interaction);
     };
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/RotationManipulators.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "RotationManipulators.h"
 
@@ -28,8 +28,7 @@ namespace AzToolsFramework
         m_manipulatorSpaceWithLocalTransform.SetSpace(worldFromLocal);
     }
 
-    void RotationManipulators::InstallLeftMouseDownCallback(
-        const AngularManipulator::MouseActionCallback& onMouseDownCallback)
+    void RotationManipulators::InstallLeftMouseDownCallback(const AngularManipulator::MouseActionCallback& onMouseDownCallback)
     {
         for (AZStd::shared_ptr<AngularManipulator>& manipulator : m_localAngularManipulators)
         {
@@ -39,8 +38,7 @@ namespace AzToolsFramework
         m_viewAngularManipulator->InstallLeftMouseDownCallback(onMouseDownCallback);
     }
 
-    void RotationManipulators::InstallMouseMoveCallback(
-        const AngularManipulator::MouseActionCallback& onMouseMoveCallback)
+    void RotationManipulators::InstallMouseMoveCallback(const AngularManipulator::MouseActionCallback& onMouseMoveCallback)
     {
         for (AZStd::shared_ptr<AngularManipulator>& manipulator : m_localAngularManipulators)
         {
@@ -50,8 +48,7 @@ namespace AzToolsFramework
         m_viewAngularManipulator->InstallMouseMoveCallback(onMouseMoveCallback);
     }
 
-    void RotationManipulators::InstallLeftMouseUpCallback(
-        const AngularManipulator::MouseActionCallback& onMouseUpCallback)
+    void RotationManipulators::InstallLeftMouseUpCallback(const AngularManipulator::MouseActionCallback& onMouseUpCallback)
     {
         for (AZStd::shared_ptr<AngularManipulator>& manipulator : m_localAngularManipulators)
         {
@@ -109,14 +106,13 @@ namespace AzToolsFramework
         m_viewAngularManipulator->SetSpace(worldFromLocal);
     }
 
-    void RotationManipulators::SetLocalAxes(
-        const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3)
+    void RotationManipulators::SetLocalAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3)
     {
         const AZ::Vector3 axes[] = { axis1, axis2, axis3 };
 
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_localAngularManipulators.size(); ++manipulatorIndex)
         {
-           m_localAngularManipulators[manipulatorIndex]->SetAxis(axes[manipulatorIndex]);
+            m_localAngularManipulators[manipulatorIndex]->SetAxis(axes[manipulatorIndex]);
         }
     }
 
@@ -124,34 +120,25 @@ namespace AzToolsFramework
     {
         m_viewAngularManipulator->SetAxis(axis);
 
-        if (auto circleView = azrtti_cast<ManipulatorViewCircle*>(
-            m_viewAngularManipulator->GetView()))
+        if (auto circleView = azrtti_cast<ManipulatorViewCircle*>(m_viewAngularManipulator->GetView()))
         {
             circleView->m_axis = axis;
         }
     }
 
     void RotationManipulators::ConfigureView(
-        const float radius, const AZ::Color& axis1Color,
-        const AZ::Color& axis2Color, const AZ::Color& axis3Color)
+        const float radius, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const AZ::Color& axis3Color)
     {
-        const AZ::Color colors[] = {
-            axis1Color, axis2Color, axis3Color
-        };
+        const AZ::Color colors[] = { axis1Color, axis2Color, axis3Color };
 
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_localAngularManipulators.size(); ++manipulatorIndex)
         {
-            m_localAngularManipulators[manipulatorIndex]->SetView(
-                CreateManipulatorViewCircle(
-                    *m_localAngularManipulators[manipulatorIndex], colors[manipulatorIndex],
-                    radius, 0.05f, DrawHalfDottedCircle));
+            m_localAngularManipulators[manipulatorIndex]->SetView(CreateManipulatorViewCircle(
+                *m_localAngularManipulators[manipulatorIndex], colors[manipulatorIndex], radius, 0.05f, DrawHalfDottedCircle));
         }
 
-        m_viewAngularManipulator->SetView(
-            CreateManipulatorViewCircle(
-                *m_viewAngularManipulator,
-                AZ::Color(1.0f, 1.0f, 1.0f, 1.0f),
-                radius + (radius * 0.12f), 0.05f, DrawFullCircle));
+        m_viewAngularManipulator->SetView(CreateManipulatorViewCircle(
+            *m_viewAngularManipulator, AZ::Color(1.0f, 1.0f, 1.0f, 1.0f), radius + (radius * 0.12f), 0.05f, DrawFullCircle));
     }
 
     bool RotationManipulators::PerformingActionViewAxis() const

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/RotationManipulators.h

@@ -1,27 +1,26 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
 #include <AzCore/Memory/SystemAllocator.h>
-#include <AzToolsFramework/Manipulators/AngularManipulator.h>
 #include <AzToolsFramework/API/EditorCameraBus.h>
+#include <AzToolsFramework/Manipulators/AngularManipulator.h>
 
 namespace AzToolsFramework
 {
-    /// RotationManipulators is an aggregation of 3 angular manipulators who share the same origin
-    /// in addition to a view aligned angular manipulator (facing the camera).
-    class RotationManipulators
-        : public Manipulators
+    //! RotationManipulators is an aggregation of 3 angular manipulators who share the same origin
+    //! in addition to a view aligned angular manipulator (facing the camera).
+    class RotationManipulators : public Manipulators
     {
     public:
         AZ_RTTI(RotationManipulators, "{5D1F1D47-1D5B-4E42-B47E-23F108F8BF7D}")
@@ -40,12 +39,10 @@ namespace AzToolsFramework
         void SetLocalOrientationImpl(const AZ::Quaternion& localOrientation) override;
         void RefreshView(const AZ::Vector3& worldViewPosition) override;
 
-        void SetLocalAxes(
-            const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3);
+        void SetLocalAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3);
         void SetViewAxis(const AZ::Vector3& axis);
 
-        void ConfigureView(
-            float radius, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const AZ::Color& axis3Color);
+        void ConfigureView(float radius, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const AZ::Color& axis3Color);
 
         bool PerformingActionViewAxis() const;
 

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "ScaleManipulators.h"
 
@@ -28,8 +28,7 @@ namespace AzToolsFramework
         m_manipulatorSpaceWithLocalTransform.SetSpace(worldFromLocal);
     }
 
-    void ScaleManipulators::InstallAxisLeftMouseDownCallback(
-        const LinearManipulator::MouseActionCallback& onMouseDownCallback)
+    void ScaleManipulators::InstallAxisLeftMouseDownCallback(const LinearManipulator::MouseActionCallback& onMouseDownCallback)
     {
         for (AZStd::shared_ptr<LinearManipulator>& manipulator : m_axisScaleManipulators)
         {
@@ -37,8 +36,7 @@ namespace AzToolsFramework
         }
     }
 
-    void ScaleManipulators::InstallAxisMouseMoveCallback(
-        const LinearManipulator::MouseActionCallback& onMouseMoveCallback)
+    void ScaleManipulators::InstallAxisMouseMoveCallback(const LinearManipulator::MouseActionCallback& onMouseMoveCallback)
     {
         for (AZStd::shared_ptr<LinearManipulator>& manipulator : m_axisScaleManipulators)
         {
@@ -46,8 +44,7 @@ namespace AzToolsFramework
         }
     }
 
-    void ScaleManipulators::InstallAxisLeftMouseUpCallback(
-        const LinearManipulator::MouseActionCallback& onMouseUpCallback)
+    void ScaleManipulators::InstallAxisLeftMouseUpCallback(const LinearManipulator::MouseActionCallback& onMouseUpCallback)
     {
         for (AZStd::shared_ptr<LinearManipulator>& manipulator : m_axisScaleManipulators)
         {
@@ -55,22 +52,19 @@ namespace AzToolsFramework
         }
     }
 
-    void ScaleManipulators::InstallUniformLeftMouseDownCallback(
-        const LinearManipulator::MouseActionCallback& onMouseDownCallback)
+    void ScaleManipulators::InstallUniformLeftMouseDownCallback(const LinearManipulator::MouseActionCallback& onMouseDownCallback)
     {
         m_uniformScaleManipulator->InstallLeftMouseDownCallback(onMouseDownCallback);
     }
 
-    void ScaleManipulators::InstallUniformMouseMoveCallback(
-        const LinearManipulator::MouseActionCallback& onMouseMoveCallback)
+    void ScaleManipulators::InstallUniformMouseMoveCallback(const LinearManipulator::MouseActionCallback& onMouseMoveCallback)
     {
-         m_uniformScaleManipulator->InstallMouseMoveCallback(onMouseMoveCallback);
+        m_uniformScaleManipulator->InstallMouseMoveCallback(onMouseMoveCallback);
     }
 
-    void ScaleManipulators::InstallUniformLeftMouseUpCallback(
-        const LinearManipulator::MouseActionCallback& onMouseUpCallback)
+    void ScaleManipulators::InstallUniformLeftMouseUpCallback(const LinearManipulator::MouseActionCallback& onMouseUpCallback)
     {
-         m_uniformScaleManipulator->InstallLeftMouseUpCallback(onMouseUpCallback);
+        m_uniformScaleManipulator->InstallLeftMouseUpCallback(onMouseUpCallback);
     }
 
     void ScaleManipulators::SetLocalTransformImpl(const AZ::Transform& localTransform)
@@ -80,8 +74,7 @@ namespace AzToolsFramework
             manipulator->SetLocalTransform(localTransform);
         }
 
-        m_uniformScaleManipulator->SetVisualOrientationOverride(
-            QuaternionFromTransformNoScaling(localTransform));
+        m_uniformScaleManipulator->SetVisualOrientationOverride(QuaternionFromTransformNoScaling(localTransform));
         m_uniformScaleManipulator->SetLocalOrientation(AZ::Quaternion::CreateIdentity());
     }
 
@@ -113,14 +106,13 @@ namespace AzToolsFramework
         m_uniformScaleManipulator->SetSpace(worldFromLocal);
     }
 
-    void ScaleManipulators::SetAxes(
-        const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3)
+    void ScaleManipulators::SetAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3)
     {
-         AZ::Vector3 axes[] = { axis1, axis2, axis3 };
+        AZ::Vector3 axes[] = { axis1, axis2, axis3 };
 
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_axisScaleManipulators.size(); ++manipulatorIndex)
         {
-           m_axisScaleManipulators[manipulatorIndex]->SetAxis(axes[manipulatorIndex]);
+            m_axisScaleManipulators[manipulatorIndex]->SetAxis(axes[manipulatorIndex]);
         }
 
         // uniform scale manipulator uses Z axis for scaling (always in world space)
@@ -129,32 +121,27 @@ namespace AzToolsFramework
     }
 
     void ScaleManipulators::ConfigureView(
-        const float axisLength, const AZ::Color& axis1Color,
-        const AZ::Color& axis2Color, const AZ::Color& axis3Color)
+        const float axisLength, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const AZ::Color& axis3Color)
     {
         const float boxSize = 0.1f;
         const float lineWidth = 0.05f;
 
-        const AZ::Color colors[] = {
-            axis1Color, axis2Color, axis3Color
-        };
+        const AZ::Color colors[] = { axis1Color, axis2Color, axis3Color };
 
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_axisScaleManipulators.size(); ++manipulatorIndex)
         {
             ManipulatorViews views;
-            views.emplace_back(CreateManipulatorViewLine(
-                *m_axisScaleManipulators[manipulatorIndex], colors[manipulatorIndex], axisLength, lineWidth));
+            views.emplace_back(
+                CreateManipulatorViewLine(*m_axisScaleManipulators[manipulatorIndex], colors[manipulatorIndex], axisLength, lineWidth));
             views.emplace_back(CreateManipulatorViewBox(
                 AZ::Transform::CreateIdentity(), colors[manipulatorIndex],
-                m_axisScaleManipulators[manipulatorIndex]->GetAxis() * (axisLength - boxSize),
-                AZ::Vector3(boxSize)));
+                m_axisScaleManipulators[manipulatorIndex]->GetAxis() * (axisLength - boxSize), AZ::Vector3(boxSize)));
             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(boxSize)));
         m_uniformScaleManipulator->SetViews(AZStd::move(views));
     }
 
@@ -167,4 +154,4 @@ namespace AzToolsFramework
 
         manipulatorFn(m_uniformScaleManipulator.get());
     }
-}
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -17,11 +17,10 @@
 
 namespace AzToolsFramework
 {
-    /// ScaleManipulators is an aggregation of 3 linear manipulators for each basis axis who share
-    /// the same transform, and a single linear manipulator at the center of the transform whose
-    /// axis is world up (z).
-    class ScaleManipulators
-        : public Manipulators
+    //! ScaleManipulators is an aggregation of 3 linear manipulators for each basis axis who share
+    //! the same transform, and a single linear manipulator at the center of the transform whose
+    //! axis is world up (z).
+    class ScaleManipulators : public Manipulators
     {
     public:
         AZ_RTTI(ScaleManipulators, "{C6350CE0-7B7A-46F8-B65F-D4A54DD9A7D9}")
@@ -42,16 +41,9 @@ namespace AzToolsFramework
         void SetLocalPositionImpl(const AZ::Vector3& localPosition) override;
         void SetLocalOrientationImpl(const AZ::Quaternion& localOrientation) override;
 
-        void SetAxes(
-            const AZ::Vector3& axis1,
-            const AZ::Vector3& axis2,
-            const AZ::Vector3& axis3);
+        void SetAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3);
 
-        void ConfigureView(
-            float axisLength,
-            const AZ::Color& axis1Color,
-            const AZ::Color& axis2Color,
-            const AZ::Color& axis3Color);
+        void ConfigureView(float axisLength, const AZ::Color& axis1Color, const AZ::Color& axis2Color, const AZ::Color& axis3Color);
 
     private:
         AZ_DISABLE_COPY_MOVE(ScaleManipulators)

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SelectionManipulator.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "SelectionManipulator.h"
 
@@ -16,8 +16,8 @@
 
 namespace AzToolsFramework
 {
-    AZStd::shared_ptr<SelectionManipulator> SelectionManipulator::MakeShared(const AZ::Transform& worldFromLocal,
-        const AZ::Vector3& nonUniformScale)
+    AZStd::shared_ptr<SelectionManipulator> SelectionManipulator::MakeShared(
+        const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale)
     {
         return AZStd::shared_ptr<SelectionManipulator>(aznew SelectionManipulator(worldFromLocal, nonUniformScale));
     }
@@ -93,12 +93,9 @@ namespace AzToolsFramework
         for (auto& view : m_manipulatorViews)
         {
             view->Draw(
-                GetManipulatorManagerId(), managerState,
-                GetManipulatorId(), {
-                    TransformUniformScale(GetSpace()), GetNonUniformScale(),
-                    GetLocalPosition(), MouseOver()
-                },
-                debugDisplay, cameraState, mouseInteraction);
+                GetManipulatorManagerId(), managerState, GetManipulatorId(),
+                { TransformUniformScale(GetSpace()), GetNonUniformScale(), GetLocalPosition(), MouseOver() }, debugDisplay, cameraState,
+                mouseInteraction);
         }
     }
 
@@ -117,4 +114,4 @@ namespace AzToolsFramework
             view->Invalidate(GetManipulatorManagerId());
         }
     }
-}
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SelectionManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -20,13 +20,13 @@ namespace AzToolsFramework
 {
     class ManipulatorView;
 
-    /// Represents a sphere that can be clicked on to trigger a particular behavior
-    /// For example clicking a preview point to create a translation manipulator.
+    //! Represents a sphere that can be clicked on to trigger a particular behavior.
+    //! For example clicking a preview point to create a translation manipulator.
     class SelectionManipulator
         : public BaseManipulator
         , public ManipulatorSpaceWithLocalPosition
     {
-        /// Private constructor.
+        //! Private constructor.
         SelectionManipulator(const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale = AZ::Vector3::CreateOne());
 
     public:
@@ -39,12 +39,12 @@ namespace AzToolsFramework
 
         ~SelectionManipulator() = default;
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
-        static AZStd::shared_ptr<SelectionManipulator> MakeShared(const AZ::Transform& worldFromLocal,
-            const AZ::Vector3& nonUniformScale = AZ::Vector3::CreateOne());
+        //! A Manipulator must only be created and managed through a shared_ptr.
+        static AZStd::shared_ptr<SelectionManipulator> MakeShared(
+            const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale = AZ::Vector3::CreateOne());
 
-        /// This is the function signature of callbacks that will be invoked
-        /// whenever a selection manipulator is clicked on.
+        //! This is the function signature of callbacks that will be invoked
+        //! whenever a selection manipulator is clicked on.
         using MouseActionCallback = AZStd::function<void(const ViewportInteraction::MouseInteraction&)>;
 
         void InstallLeftMouseDownCallback(const MouseActionCallback& onMouseDownCallback);
@@ -58,10 +58,25 @@ namespace AzToolsFramework
             const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
-        bool Selected() const { return m_selected; }
-        void Select() { m_selected = true; }
-        void Deselect() { m_selected = false; }
-        void ToggleSelected() { m_selected = !m_selected; }
+        bool Selected() const
+        {
+            return m_selected;
+        }
+
+        void Select()
+        {
+            m_selected = true;
+        }
+
+        void Deselect()
+        {
+            m_selected = false;
+        }
+
+        void ToggleSelected()
+        {
+            m_selected = !m_selected;
+        }
 
         template<typename Views>
         void SetViews(Views&& views)
@@ -70,13 +85,9 @@ namespace AzToolsFramework
         }
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction,
-            float rayIntersectionDistance) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
         void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
-        void OnRightMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction,
-            float rayIntersectionDistance) override;
+        void OnRightMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
         void OnRightMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
@@ -89,6 +100,6 @@ namespace AzToolsFramework
         MouseActionCallback m_onRightMouseDownCallback = nullptr;
         MouseActionCallback m_onRightMouseUpCallback = nullptr;
 
-        ManipulatorViews m_manipulatorViews; ///< Look of manipulator.
+        ManipulatorViews m_manipulatorViews; //!< Look of manipulator.
     };
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SplineHoverSelection.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "SplineHoverSelection.h"
 
@@ -20,11 +20,12 @@
 
 namespace AzToolsFramework
 {
-    static const AZ::Color s_splineSelectManipulatorColor = AZ::Color(0.0f, 1.0f, 0.0f, 1.0f);
+    static const AZ::Color SplineSelectManipulatorColor = AZ::Color(0.0f, 1.0f, 0.0f, 1.0f);
 
     SplineHoverSelection::SplineHoverSelection(
         const AZ::EntityComponentIdPair& entityComponentIdPair,
-        const ManipulatorManagerId managerId, const AZStd::shared_ptr<AZ::Spline>& spline)
+        const ManipulatorManagerId managerId,
+        const AZStd::shared_ptr<AZ::Spline>& spline)
     {
         m_splineSelectionManipulator = SplineSelectionManipulator::MakeShared();
         m_splineSelectionManipulator->Register(managerId);
@@ -33,16 +34,14 @@ namespace AzToolsFramework
 
         const float splineWidth = 0.05f;
         m_splineSelectionManipulator->SetSpline(spline);
-        m_splineSelectionManipulator->SetView(CreateManipulatorViewSplineSelect(
-            *m_splineSelectionManipulator, s_splineSelectManipulatorColor, splineWidth));
+        m_splineSelectionManipulator->SetView(
+            CreateManipulatorViewSplineSelect(*m_splineSelectionManipulator, SplineSelectManipulatorColor, splineWidth));
 
         m_splineSelectionManipulator->InstallLeftMouseUpCallback(
             [entityComponentIdPair](const SplineSelectionManipulator::Action& action)
-        {
-            InsertVertexAfter(
-                entityComponentIdPair, action.m_splineAddress.m_segmentIndex,
-                action.m_localSplineHitPosition);
-        });
+            {
+                InsertVertexAfter(entityComponentIdPair, action.m_splineAddress.m_segmentIndex, action.m_localSplineHitPosition);
+            });
     }
 
     SplineHoverSelection::~SplineHoverSelection()

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SplineHoverSelection.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -19,20 +19,20 @@ namespace AZ
 {
     class Spline;
     class EntityComponentIdPair;
-}
+} // namespace AZ
 
 namespace AzToolsFramework
 {
     class SplineSelectionManipulator;
 
-    /// SplineHoverSelection is a concrete implementation of HoverSelection wrapping a Spline and
-    /// SplineManipulator. The underlying manipulators are used to control selection.
-    class SplineHoverSelection
-        : public HoverSelection
+    //! SplineHoverSelection is a concrete implementation of HoverSelection wrapping a Spline and
+    //! SplineManipulator. The underlying manipulators are used to control selection.
+    class SplineHoverSelection : public HoverSelection
     {
     public:
         explicit SplineHoverSelection(
-            const AZ::EntityComponentIdPair& entityComponentIdPair, ManipulatorManagerId managerId,
+            const AZ::EntityComponentIdPair& entityComponentIdPair,
+            ManipulatorManagerId managerId,
             const AZStd::shared_ptr<AZ::Spline>& spline);
         SplineHoverSelection(const SplineHoverSelection&) = delete;
         SplineHoverSelection& operator=(const SplineHoverSelection&) = delete;
@@ -46,6 +46,6 @@ namespace AzToolsFramework
         void SetNonUniformScale(const AZ::Vector3& nonUniformScale) override;
 
     private:
-        AZStd::shared_ptr<SplineSelectionManipulator> m_splineSelectionManipulator; ///< Manipulator for adding points to spline.
+        AZStd::shared_ptr<SplineSelectionManipulator> m_splineSelectionManipulator; //!< Manipulator for adding points to spline.
     };
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SplineSelectionManipulator.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "SplineSelectionManipulator.h"
 
@@ -18,8 +18,10 @@
 namespace AzToolsFramework
 {
     SplineSelectionManipulator::Action CalculateManipulationDataAction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& rayOrigin,
-        const AZ::Vector3& rayDirection, const AZStd::weak_ptr<const AZ::Spline>& spline)
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& rayOrigin,
+        const AZ::Vector3& rayDirection,
+        const AZStd::weak_ptr<const AZ::Spline>& spline)
     {
         SplineSelectionManipulator::Action action;
         if (const AZStd::shared_ptr<const AZ::Spline> splinePtr = spline.lock())
@@ -65,9 +67,7 @@ namespace AzToolsFramework
         if (m_onLeftMouseDownCallback)
         {
             m_onLeftMouseDownCallback(CalculateManipulationDataAction(
-                TransformUniformScale(GetSpace()),
-                interaction.m_mousePick.m_rayOrigin,
-                interaction.m_mousePick.m_rayDirection, m_spline));
+                TransformUniformScale(GetSpace()), interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection, m_spline));
         }
     }
 
@@ -76,9 +76,7 @@ namespace AzToolsFramework
         if (MouseOver() && m_onLeftMouseUpCallback)
         {
             m_onLeftMouseUpCallback(CalculateManipulationDataAction(
-                TransformUniformScale(GetSpace()),
-                interaction.m_mousePick.m_rayOrigin,
-                interaction.m_mousePick.m_rayDirection, m_spline));
+                TransformUniformScale(GetSpace()), interaction.m_mousePick.m_rayOrigin, interaction.m_mousePick.m_rayDirection, m_spline));
         }
     }
 
@@ -99,12 +97,9 @@ namespace AzToolsFramework
         if (mouseInteraction.m_keyboardModifiers.Ctrl() && !mouseInteraction.m_keyboardModifiers.Shift())
         {
             m_manipulatorView->Draw(
-                GetManipulatorManagerId(), managerState,
-                GetManipulatorId(), {
-                    TransformUniformScale(GetSpace()), GetNonUniformScale(),
-                    AZ::Vector3::CreateZero(), MouseOver()
-                },
-                debugDisplay, cameraState, mouseInteraction);
+                GetManipulatorManagerId(), managerState, GetManipulatorId(),
+                { TransformUniformScale(GetSpace()), GetNonUniformScale(), AZ::Vector3::CreateZero(), MouseOver() }, debugDisplay,
+                cameraState, mouseInteraction);
         }
     }
 
@@ -122,4 +117,4 @@ namespace AzToolsFramework
     {
         m_manipulatorView->Invalidate(GetManipulatorManagerId());
     }
-}
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SplineSelectionManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -23,13 +23,13 @@ namespace AzToolsFramework
 {
     class ManipulatorView;
 
-    /// A manipulator to represent selection of a spline. Underlying spline data is
-    /// used to test mouse picking ray against to preview closest point on spline.
+    //! A manipulator to represent selection of a spline. Underlying spline data is
+    //! used to test mouse picking ray against to preview closest point on spline.
     class SplineSelectionManipulator
         : public BaseManipulator
         , public ManipulatorSpace
     {
-        /// Private constructor.
+        //! Private constructor.
         SplineSelectionManipulator();
 
     public:
@@ -41,10 +41,10 @@ namespace AzToolsFramework
 
         ~SplineSelectionManipulator();
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
+        //! A Manipulator must only be created and managed through a shared_ptr.
         static AZStd::shared_ptr<SplineSelectionManipulator> MakeShared();
 
-        /// Mouse action data used by MouseActionCallback.
+        //! Mouse action data used by MouseActionCallback.
         struct Action
         {
             AZ::Vector3 m_localSplineHitPosition;
@@ -62,29 +62,36 @@ namespace AzToolsFramework
             const AzFramework::CameraState& cameraState,
             const ViewportInteraction::MouseInteraction& mouseInteraction) override;
 
-        void SetSpline(AZStd::shared_ptr<const AZ::Spline> spline) { m_spline = AZStd::move(spline); }
-        AZStd::weak_ptr<const AZ::Spline> GetSpline() const { return m_spline; }
+        void SetSpline(AZStd::shared_ptr<const AZ::Spline> spline)
+        {
+            m_spline = AZStd::move(spline);
+        }
+        AZStd::weak_ptr<const AZ::Spline> GetSpline() const
+        {
+            return m_spline;
+        }
 
         void SetView(AZStd::unique_ptr<ManipulatorView>&& view);
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
         void SetBoundsDirtyImpl() override;
 
         AZStd::weak_ptr<const AZ::Spline> m_spline;
-        AZStd::unique_ptr<ManipulatorView> m_manipulatorView = nullptr; ///< Look of manipulator and bounds for interaction.
+        AZStd::unique_ptr<ManipulatorView> m_manipulatorView = nullptr; //!< Look of manipulator and bounds for interaction.
         MouseActionCallback m_onLeftMouseDownCallback = nullptr;
         MouseActionCallback m_onLeftMouseUpCallback = nullptr;
-        ViewportInteraction::KeyboardModifiers m_keyboardModifiers; ///< What modifier keys are pressed when interacting with this manipulator.
+        ViewportInteraction::KeyboardModifiers
+            m_keyboardModifiers; //!< What modifier keys are pressed when interacting with this manipulator.
     };
 
     SplineSelectionManipulator::Action CalculateManipulationDataAction(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& rayOrigin,
-        const AZ::Vector3& rayDirection, const AZStd::weak_ptr<const AZ::Spline>& spline);
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& rayOrigin,
+        const AZ::Vector3& rayDirection,
+        const AZStd::weak_ptr<const AZ::Spline>& spline);
 
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SurfaceManipulator.cpp

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "SurfaceManipulator.h"
 
@@ -18,19 +18,22 @@
 namespace AzToolsFramework
 {
     SurfaceManipulator::StartInternal SurfaceManipulator::CalculateManipulationDataStart(
-        const AZ::Transform& worldFromLocal, const AZ::Vector3& worldSurfacePosition,
-        const AZ::Vector3& localStartPosition, const bool snapping, const float gridSize, const int viewportId)
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& worldSurfacePosition,
+        const AZ::Vector3& localStartPosition,
+        const bool snapping,
+        const float gridSize,
+        const int viewportId)
     {
         const AZ::Transform worldFromLocalUniform = AzToolsFramework::TransformUniformScale(worldFromLocal);
         const AZ::Transform localFromWorldUniform = worldFromLocalUniform.GetInverse();
 
         const AZ::Vector3 localFinalSurfacePosition = snapping
-            ? CalculateSnappedTerrainPosition(
-                // note: gridSize is not scaled by scaleRecip here as localStartPosition is
-                // unscaled itself so the position returned by CalculateSnappedTerrainPosition
-                // must be in the same space (if localStartPosition were also scaled, gridSize
-                // would need to be multiplied by scaleRecip)
-                worldSurfacePosition, worldFromLocalUniform, viewportId, gridSize)
+            // note: gridSize is not scaled by scaleRecip here as localStartPosition is
+            // unscaled itself so the position returned by CalculateSnappedTerrainPosition
+            // must be in the same space (if localStartPosition were also scaled, gridSize
+            // would need to be multiplied by scaleRecip)
+            ? CalculateSnappedTerrainPosition(worldSurfacePosition, worldFromLocalUniform, viewportId, gridSize)
             : localFromWorldUniform.TransformPoint(worldSurfacePosition);
 
         // delta/offset between initial vertex position and terrain pick position
@@ -44,9 +47,13 @@ namespace AzToolsFramework
     }
 
     SurfaceManipulator::Action SurfaceManipulator::CalculateManipulationDataAction(
-        const StartInternal& startInternal, const AZ::Transform& worldFromLocal,
-        const AZ::Vector3& worldSurfacePosition, const bool snapping, const float gridSize,
-        const ViewportInteraction::KeyboardModifiers keyboardModifiers, const int viewportId)
+        const StartInternal& startInternal,
+        const AZ::Transform& worldFromLocal,
+        const AZ::Vector3& worldSurfacePosition,
+        const bool snapping,
+        const float gridSize,
+        const ViewportInteraction::KeyboardModifiers keyboardModifiers,
+        const int viewportId)
     {
         const AZ::Transform worldFromLocalUniform = AzToolsFramework::TransformUniformScale(worldFromLocal);
         const AZ::Transform localFromWorldUniform = worldFromLocalUniform.GetInverse();
@@ -54,8 +61,7 @@ namespace AzToolsFramework
         const float scaleRecip = ScaleReciprocal(worldFromLocalUniform);
 
         const AZ::Vector3 localFinalSurfacePosition = snapping
-            ? CalculateSnappedTerrainPosition(
-                worldSurfacePosition, worldFromLocalUniform, viewportId, gridSize * scaleRecip)
+            ? CalculateSnappedTerrainPosition(worldSurfacePosition, worldFromLocalUniform, viewportId, gridSize * scaleRecip)
             : localFromWorldUniform.TransformPoint(worldSurfacePosition);
 
         Action action;
@@ -106,17 +112,14 @@ namespace AzToolsFramework
             interaction.m_mousePick.m_screenCoordinates);
 
         m_startInternal = CalculateManipulationDataStart(
-            worldFromLocalUniformScale, worldSurfacePosition, GetLocalPosition(),
-            gridSnapParams.m_gridSnap, gridSnapParams.m_gridSize,
+            worldFromLocalUniformScale, worldSurfacePosition, GetLocalPosition(), gridSnapParams.m_gridSnap, gridSnapParams.m_gridSize,
             interaction.m_interactionId.m_viewportId);
 
         if (m_onLeftMouseDownCallback)
         {
             m_onLeftMouseDownCallback(CalculateManipulationDataAction(
-                m_startInternal, worldFromLocalUniformScale, worldSurfacePosition,
-                gridSnapParams.m_gridSnap, gridSnapParams.m_gridSize,
-                interaction.m_keyboardModifiers,
-                interaction.m_interactionId.m_viewportId));
+                m_startInternal, worldFromLocalUniformScale, worldSurfacePosition, gridSnapParams.m_gridSnap, gridSnapParams.m_gridSize,
+                interaction.m_keyboardModifiers, interaction.m_interactionId.m_viewportId));
         }
     }
 
@@ -133,10 +136,8 @@ namespace AzToolsFramework
             const GridSnapParameters gridSnapParams = GridSnapSettings(interaction.m_interactionId.m_viewportId);
 
             m_onLeftMouseUpCallback(CalculateManipulationDataAction(
-                m_startInternal, TransformUniformScale(GetSpace()), worldSurfacePosition,
-                gridSnapParams.m_gridSnap,
-                gridSnapParams.m_gridSize,
-                interaction.m_keyboardModifiers, interaction.m_interactionId.m_viewportId));
+                m_startInternal, TransformUniformScale(GetSpace()), worldSurfacePosition, gridSnapParams.m_gridSnap,
+                gridSnapParams.m_gridSize, interaction.m_keyboardModifiers, interaction.m_interactionId.m_viewportId));
         }
     }
 
@@ -153,10 +154,8 @@ namespace AzToolsFramework
             const GridSnapParameters gridSnapParams = GridSnapSettings(interaction.m_interactionId.m_viewportId);
 
             m_onMouseMoveCallback(CalculateManipulationDataAction(
-                m_startInternal, TransformUniformScale(GetSpace()), worldSurfacePosition,
-                gridSnapParams.m_gridSnap,
-                gridSnapParams.m_gridSize,
-                interaction.m_keyboardModifiers, interaction.m_interactionId.m_viewportId));
+                m_startInternal, TransformUniformScale(GetSpace()), worldSurfacePosition, gridSnapParams.m_gridSnap,
+                gridSnapParams.m_gridSize, interaction.m_keyboardModifiers, interaction.m_interactionId.m_viewportId));
         }
     }
 
@@ -172,12 +171,9 @@ namespace AzToolsFramework
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
         m_manipulatorView->Draw(
-            GetManipulatorManagerId(), managerState,
-            GetManipulatorId(), {
-                TransformUniformScale(GetSpace()), GetNonUniformScale(),
-                GetLocalPosition(), MouseOver()
-            },
-            debugDisplay, cameraState, mouseInteraction);
+            GetManipulatorManagerId(), managerState, GetManipulatorId(),
+            { TransformUniformScale(GetSpace()), GetNonUniformScale(), GetLocalPosition(), MouseOver() }, debugDisplay, cameraState,
+            mouseInteraction);
     }
 
     void SurfaceManipulator::InvalidateImpl()
@@ -189,4 +185,4 @@ namespace AzToolsFramework
     {
         m_manipulatorView = AZStd::move(view);
     }
-}
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/SurfaceManipulator.h

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -21,13 +21,13 @@ namespace AzToolsFramework
 {
     class ManipulatorView;
 
-    /// Surface manipulator will ensure the point(s) it controls snap precisely to the xy grid
-    /// while also staying aligned exactly to the height of the terrain.
+    //! Surface manipulator will ensure the point(s) it controls snap precisely to the xy grid
+    //! while also staying aligned exactly to the height of the terrain.
     class SurfaceManipulator
         : public BaseManipulator
         , public ManipulatorSpaceWithLocalPosition
     {
-        /// Private constructor.
+        //! Private constructor.
         explicit SurfaceManipulator(const AZ::Transform& worldFromLocal);
 
     public:
@@ -40,30 +40,36 @@ namespace AzToolsFramework
 
         ~SurfaceManipulator() = default;
 
-        /// A Manipulator must only be created and managed through a shared_ptr.
+        //! A Manipulator must only be created and managed through a shared_ptr.
         static AZStd::shared_ptr<SurfaceManipulator> MakeShared(const AZ::Transform& worldFromLocal);
 
-        /// The state of the manipulator at the start of an interaction.
+        //! The state of the manipulator at the start of an interaction.
         struct Start
         {
-            AZ::Vector3 m_localPosition; ///< The current position of the manipulator in local space.
-            AZ::Vector3 m_snapOffset; ///< The snap offset amount to ensure manipulator is aligned to the grid.
+            AZ::Vector3 m_localPosition; //!< The current position of the manipulator in local space.
+            AZ::Vector3 m_snapOffset; //!< The snap offset amount to ensure manipulator is aligned to the grid.
         };
 
-        /// The state of the manipulator during an interaction.
+        //! The state of the manipulator during an interaction.
         struct Current
         {
-            AZ::Vector3 m_localOffset; ///< The current offset of the manipulator from its starting position in local space.
+            AZ::Vector3 m_localOffset; //!< The current offset of the manipulator from its starting position in local space.
         };
 
-        /// Mouse action data used by MouseActionCallback (wraps Start and Current manipulator state).
+        //! Mouse action data used by MouseActionCallback (wraps Start and Current manipulator state).
         struct Action
         {
             Start m_start;
             Current m_current;
             ViewportInteraction::KeyboardModifiers m_modifiers;
-            AZ::Vector3 LocalPosition() const { return m_start.m_localPosition + m_current.m_localOffset; }
-            AZ::Vector3 LocalPositionOffset() const { return m_current.m_localOffset; }
+            AZ::Vector3 LocalPosition() const
+            {
+                return m_start.m_localPosition + m_current.m_localOffset;
+            }
+            AZ::Vector3 LocalPositionOffset() const
+            {
+                return m_current.m_localOffset;
+            }
         };
 
         using MouseActionCallback = AZStd::function<void(const Action&)>;
@@ -81,39 +87,44 @@ namespace AzToolsFramework
         void SetView(AZStd::unique_ptr<ManipulatorView>&& view);
 
     private:
-        void OnLeftMouseDownImpl(
-            const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
-        void OnLeftMouseUpImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
-        void OnMouseMoveImpl(
-            const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnLeftMouseDownImpl(const ViewportInteraction::MouseInteraction& interaction, float rayIntersectionDistance) override;
+        void OnLeftMouseUpImpl(const ViewportInteraction::MouseInteraction& interaction) override;
+        void OnMouseMoveImpl(const ViewportInteraction::MouseInteraction& interaction) override;
 
         void InvalidateImpl() override;
         void SetBoundsDirtyImpl() override;
 
-        /// Initial data recorded when a press first happens with a surface manipulator.
+        //! Initial data recorded when a press first happens with a surface manipulator.
         struct StartInternal
         {
-            AZ::Vector3 m_localPosition; ///< The current position of the manipulator in local space.
-            AZ::Vector3 m_localHitPosition; ///< The hit position with the terrain in local space.
-            AZ::Vector3 m_snapOffset; ///< The snap offset amount to ensure manipulator is aligned to the grid.
+            AZ::Vector3 m_localPosition; //!< The current position of the manipulator in local space.
+            AZ::Vector3 m_localHitPosition; //!< The hit position with the terrain in local space.
+            AZ::Vector3 m_snapOffset; //!< The snap offset amount to ensure manipulator is aligned to the grid.
         };
 
-        StartInternal m_startInternal; ///< Internal initial state recorded/created in OnMouseDown.
+        StartInternal m_startInternal; //!< Internal initial state recorded/created in OnMouseDown.
 
-        AZStd::unique_ptr<ManipulatorView> m_manipulatorView = nullptr; ///< Look of manipulator.
+        AZStd::unique_ptr<ManipulatorView> m_manipulatorView = nullptr; //!< Look of manipulator.
 
         MouseActionCallback m_onLeftMouseDownCallback = nullptr;
         MouseActionCallback m_onLeftMouseUpCallback = nullptr;
         MouseActionCallback m_onMouseMoveCallback = nullptr;
 
         static StartInternal CalculateManipulationDataStart(
-            const AZ::Transform& worldFromLocal, const AZ::Vector3& worldSurfacePosition,
-            const AZ::Vector3& localPosition, bool snapping, float gridSize, int viewportId);
+            const AZ::Transform& worldFromLocal,
+            const AZ::Vector3& worldSurfacePosition,
+            const AZ::Vector3& localPosition,
+            bool snapping,
+            float gridSize,
+            int viewportId);
 
         static Action CalculateManipulationDataAction(
-            const StartInternal& startInternal, const AZ::Transform& worldFromLocal,
-            const AZ::Vector3& worldSurfacePosition, bool snapping, float gridSize,
-            ViewportInteraction::KeyboardModifiers keyboardModifiers, int viewportId);
+            const StartInternal& startInternal,
+            const AZ::Transform& worldFromLocal,
+            const AZ::Vector3& worldSurfacePosition,
+            bool snapping,
+            float gridSize,
+            ViewportInteraction::KeyboardModifiers keyboardModifiers,
+            int viewportId);
     };
 } // namespace AzToolsFramework

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include "TranslationManipulators.h"
 
@@ -77,8 +77,7 @@ namespace AzToolsFramework
         }
     }
 
-    void TranslationManipulators::InstallLinearManipulatorMouseUpCallback(
-        const LinearManipulator::MouseActionCallback& onMouseUpCallback)
+    void TranslationManipulators::InstallLinearManipulatorMouseUpCallback(const LinearManipulator::MouseActionCallback& onMouseUpCallback)
     {
         for (AZStd::shared_ptr<LinearManipulator>& manipulator : m_linearManipulators)
         {
@@ -104,8 +103,7 @@ namespace AzToolsFramework
         }
     }
 
-    void TranslationManipulators::InstallPlanarManipulatorMouseUpCallback(
-        const PlanarManipulator::MouseActionCallback& onMouseUpCallback)
+    void TranslationManipulators::InstallPlanarManipulatorMouseUpCallback(const PlanarManipulator::MouseActionCallback& onMouseUpCallback)
     {
         for (AZStd::shared_ptr<PlanarManipulator>& manipulator : m_planarManipulators)
         {
@@ -122,8 +120,7 @@ namespace AzToolsFramework
         }
     }
 
-    void TranslationManipulators::InstallSurfaceManipulatorMouseUpCallback(
-        const SurfaceManipulator::MouseActionCallback& onMouseUpCallback)
+    void TranslationManipulators::InstallSurfaceManipulatorMouseUpCallback(const SurfaceManipulator::MouseActionCallback& onMouseUpCallback)
     {
         if (m_surfaceManipulator)
         {
@@ -242,7 +239,9 @@ namespace AzToolsFramework
     }
 
     void TranslationManipulators::ConfigureLinearView(
-        float axisLength, const AZ::Color& axis1Color, const AZ::Color& axis2Color,
+        float axisLength,
+        const AZ::Color& axis1Color,
+        const AZ::Color& axis2Color,
         const AZ::Color& axis3Color /*= AZ::Color(0.0f, 0.0f, 1.0f, 0.5f)*/)
     {
         const float coneLength = 0.28f;
@@ -251,15 +250,13 @@ namespace AzToolsFramework
 
         const AZ::Color axesColor[] = { axis1Color, axis2Color, axis3Color };
 
-        const auto configureLinearView = [lineWidth, coneLength, axisLength, coneRadius](
-            LinearManipulator* linearManipulator, const AZ::Color& color)
+        const auto configureLinearView =
+            [lineWidth, coneLength, axisLength, coneRadius](LinearManipulator* linearManipulator, const AZ::Color& color)
         {
             ManipulatorViews views;
-            views.emplace_back(CreateManipulatorViewLine(
-                *linearManipulator, color, axisLength, lineWidth));
+            views.emplace_back(CreateManipulatorViewLine(*linearManipulator, color, axisLength, lineWidth));
             views.emplace_back(CreateManipulatorViewCone(
-                *linearManipulator, color, linearManipulator->GetAxis() * (axisLength - coneLength),
-                coneLength, coneRadius));
+                *linearManipulator, color, linearManipulator->GetAxis() * (axisLength - coneLength), coneLength, coneRadius));
             linearManipulator->SetViews(AZStd::move(views));
         };
 
@@ -270,7 +267,8 @@ namespace AzToolsFramework
     }
 
     void TranslationManipulators::ConfigurePlanarView(
-        const AZ::Color& plane1Color, const AZ::Color& plane2Color /*= AZ::Color(0.0f, 1.0f, 0.0f, 0.5f)*/,
+        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;
@@ -278,34 +276,29 @@ namespace AzToolsFramework
 
         for (size_t manipulatorIndex = 0; manipulatorIndex < m_planarManipulators.size(); ++manipulatorIndex)
         {
-            const AZStd::shared_ptr<ManipulatorViewQuad> manipulatorView =
-                CreateManipulatorViewQuad(
-                    *m_planarManipulators[manipulatorIndex], planesColor[manipulatorIndex],
-                    planesColor[(manipulatorIndex + 1) % 3],
-                    planeSize);
+            const AZStd::shared_ptr<ManipulatorViewQuad> manipulatorView = CreateManipulatorViewQuad(
+                *m_planarManipulators[manipulatorIndex], planesColor[manipulatorIndex], planesColor[(manipulatorIndex + 1) % 3], planeSize);
 
-            m_planarManipulators[manipulatorIndex]->SetViews(ManipulatorViews{manipulatorView});
+            m_planarManipulators[manipulatorIndex]->SetViews(ManipulatorViews{ manipulatorView });
         }
     }
 
-    void TranslationManipulators::ConfigureSurfaceView(
-        const float radius, const AZ::Color& color)
+    void TranslationManipulators::ConfigureSurfaceView(const float radius, const AZ::Color& color)
     {
         if (m_surfaceManipulator)
         {
-            m_surfaceManipulator->SetView(CreateManipulatorViewSphere(color, radius,
-                [](const ViewportInteraction::MouseInteraction& /*mouseInteraction*/,
-                    bool mouseOver, const AZ::Color& defaultColor) -> AZ::Color
-            {
-                const AZ::Color color[2] =
+            m_surfaceManipulator->SetView(CreateManipulatorViewSphere(
+                color, radius,
+                [](const ViewportInteraction::MouseInteraction& /*mouseInteraction*/, bool mouseOver,
+                   const AZ::Color& defaultColor) -> AZ::Color
                 {
-                    defaultColor,
-                    Vector3ToVector4(
-                        BaseManipulator::s_defaultMouseOverColor.GetAsVector3(), s_surfaceManipulatorTransparency)
-                };
+                    const AZ::Color color[2] = {
+                        defaultColor,
+                        Vector3ToVector4(BaseManipulator::s_defaultMouseOverColor.GetAsVector3(), s_surfaceManipulatorTransparency)
+                    };
 
-                return color[mouseOver];
-            }));
+                    return color[mouseOver];
+                }));
         }
     }
 
@@ -327,27 +320,17 @@ namespace AzToolsFramework
         }
     }
 
-    void ConfigureTranslationManipulatorAppearance3d(
-        TranslationManipulators* translationManipulators)
+    void ConfigureTranslationManipulatorAppearance3d(TranslationManipulators* translationManipulators)
     {
-        translationManipulators->SetAxes(
-            AZ::Vector3::CreateAxisX(),
-            AZ::Vector3::CreateAxisY(),
-            AZ::Vector3::CreateAxisZ());
-        translationManipulators->ConfigurePlanarView(
-            s_xAxisColor, s_yAxisColor, s_zAxisColor);
-        translationManipulators->ConfigureLinearView(
-            s_axisLength, s_xAxisColor, s_yAxisColor, s_zAxisColor);
-        translationManipulators->ConfigureSurfaceView(
-            s_surfaceManipulatorRadius, s_surfaceManipulatorColor);
+        translationManipulators->SetAxes(AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY(), AZ::Vector3::CreateAxisZ());
+        translationManipulators->ConfigurePlanarView(s_xAxisColor, s_yAxisColor, s_zAxisColor);
+        translationManipulators->ConfigureLinearView(s_axisLength, s_xAxisColor, s_yAxisColor, s_zAxisColor);
+        translationManipulators->ConfigureSurfaceView(s_surfaceManipulatorRadius, s_surfaceManipulatorColor);
     }
 
-    void ConfigureTranslationManipulatorAppearance2d(
-        TranslationManipulators* translationManipulators)
+    void ConfigureTranslationManipulatorAppearance2d(TranslationManipulators* translationManipulators)
     {
-        translationManipulators->SetAxes(
-            AZ::Vector3::CreateAxisX(),
-            AZ::Vector3::CreateAxisY());
+        translationManipulators->SetAxes(AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY());
         translationManipulators->ConfigurePlanarView(s_xAxisColor);
         translationManipulators->ConfigureLinearView(s_axisLength, s_xAxisColor, s_yAxisColor);
     }

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

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
@@ -19,16 +19,15 @@
 
 namespace AzToolsFramework
 {
-    /// TranslationManipulators is an aggregation of 3 linear manipulators, 3 planar manipulators
-    /// and one surface manipulator who share the same transform.
-    class TranslationManipulators
-        : public Manipulators
+    //! TranslationManipulators is an aggregation of 3 linear manipulators, 3 planar manipulators
+    //! and one surface manipulator who share the same transform.
+    class TranslationManipulators : public Manipulators
     {
     public:
         AZ_RTTI(TranslationManipulators, "{D5E49EA2-30E0-42BC-A51D-6A7F87818260}")
         AZ_CLASS_ALLOCATOR(TranslationManipulators, AZ::SystemAllocator, 0)
 
-        /// How many dimensions does this translation manipulator have
+        //! How many dimensions does this translation manipulator have.
         enum class Dimensions
         {
             Two,
@@ -55,9 +54,7 @@ namespace AzToolsFramework
         void SetLocalOrientationImpl(const AZ::Quaternion& localOrientation) override;
         void SetNonUniformScaleImpl(const AZ::Vector3& nonUniformScale) override;
 
-        void SetAxes(
-            const AZ::Vector3& axis1, const AZ::Vector3& axis2,
-            const AZ::Vector3& axis3 = AZ::Vector3::CreateAxisZ());
+        void SetAxes(const AZ::Vector3& axis1, const AZ::Vector3& axis2, const AZ::Vector3& axis3 = AZ::Vector3::CreateAxisZ());
 
         void ConfigurePlanarView(
             const AZ::Color& plane1Color,
@@ -66,11 +63,11 @@ namespace AzToolsFramework
 
         void ConfigureLinearView(
             float axisLength,
-            const AZ::Color& axis1Color, const AZ::Color& axis2Color,
+            const AZ::Color& axis1Color,
+            const AZ::Color& axis2Color,
             const AZ::Color& axis3Color = AZ::Color(0.0f, 0.0f, 1.0f, 0.5f));
 
-        void ConfigureSurfaceView(
-            float radius, const AZ::Color& color);
+        void ConfigureSurfaceView(float radius, const AZ::Color& color);
 
     private:
         AZ_DISABLE_COPY_MOVE(TranslationManipulators)
@@ -78,37 +75,43 @@ namespace AzToolsFramework
         // Manipulators
         void ProcessManipulators(const AZStd::function<void(BaseManipulator*)>&) override;
 
-        const Dimensions m_dimensions; ///< How many dimensions of freedom does this manipulator have.
+        const Dimensions m_dimensions; //!< How many dimensions of freedom does this manipulator have.
 
         AZStd::vector<AZStd::shared_ptr<LinearManipulator>> m_linearManipulators;
         AZStd::vector<AZStd::shared_ptr<PlanarManipulator>> m_planarManipulators;
         AZStd::shared_ptr<SurfaceManipulator> m_surfaceManipulator = nullptr;
     };
 
-    /// IndexedTranslationManipulator wraps a standard TranslationManipulators and allows it to be linked
-    /// to a particular index in a list of vertices/points.
+    //! IndexedTranslationManipulator wraps a standard TranslationManipulators and allows it to be linked
+    //! to a particular index in a list of vertices/points.
     template<typename Vertex>
     struct IndexedTranslationManipulator
     {
         explicit IndexedTranslationManipulator(
-            TranslationManipulators::Dimensions dimensions, AZ::u64 vertIndex,
-            const Vertex& position, const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale)
-                : m_manipulator(dimensions, worldFromLocal, nonUniformScale)
+            TranslationManipulators::Dimensions dimensions,
+            AZ::u64 vertIndex,
+            const Vertex& position,
+            const AZ::Transform& worldFromLocal,
+            const AZ::Vector3& nonUniformScale)
+            : m_manipulator(dimensions, worldFromLocal, nonUniformScale)
         {
             m_vertices.push_back({ position, Vertex::CreateZero(), vertIndex });
         }
 
-        /// Store vertex start position as manipulator event occurs, index refers to location in container.
+        //! Store vertex start position as manipulator event occurs, index refers to location in container.
         struct VertexLookup
         {
             Vertex m_start;
             Vertex m_offset;
             AZ::u64 m_index;
 
-            Vertex CurrentPosition() const { return m_start + m_offset; }
+            Vertex CurrentPosition() const
+            {
+                return m_start + m_offset;
+            }
         };
 
-        /// Helper to iterate over all vertices stored by the manipulator.
+        //! Helper to iterate over all vertices stored by the manipulator.
         void Process(AZStd::function<void(VertexLookup&)> fn)
         {
             for (VertexLookup& vertex : m_vertices)
@@ -117,16 +120,14 @@ namespace AzToolsFramework
             }
         }
 
-        AZStd::vector<VertexLookup> m_vertices; ///< List of vertices currently associated with this translation manipulator.
+        AZStd::vector<VertexLookup> m_vertices; //!< List of vertices currently associated with this translation manipulator.
         TranslationManipulators m_manipulator;
     };
 
-    /// Function pointer to configure how a translation manipulator should look and behave (dimensions/axes/views).
-    using TranslationManipulatorConfiguratorFn = void(*)(TranslationManipulators*);
+    //! Function pointer to configure how a translation manipulator should look and behave (dimensions/axes/views).
+    using TranslationManipulatorConfiguratorFn = void (*)(TranslationManipulators*);
 
-    void ConfigureTranslationManipulatorAppearance3d(
-        TranslationManipulators* translationManipulators);
-    void ConfigureTranslationManipulatorAppearance2d(
-        TranslationManipulators* translationManipulators);
+    void ConfigureTranslationManipulatorAppearance3d(TranslationManipulators* translationManipulators);
+    void ConfigureTranslationManipulatorAppearance2d(TranslationManipulators* translationManipulators);
 
 } // namespace AzToolsFramework