Merge pull request #7618 from aws-lumberyard-dev/Atom/guthadam/move_viewport_input_controller_from_material_editor_to_atf

Atom Tools: Extracted the viewport input controller from ME to ATF

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/DollyCameraBehavior.h

@@ -5,19 +5,20 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
-#include <Viewport/InputController/Behavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
     //! Moves(zooms) camera back and forth towards the target
-    class DollyCameraBehavior final
-        : public Behavior
+    class DollyCameraBehavior final : public ViewportInputBehavior
     {
     public:
-        DollyCameraBehavior() = default;
+        DollyCameraBehavior(ViewportInputBehaviorControllerInterface* controller);
         virtual ~DollyCameraBehavior() = default;
+
     protected:
         void TickInternal(float x, float y, float z) override;
         float GetSensitivityX() override;
@@ -27,4 +28,4 @@ namespace MaterialEditor
         static constexpr float SensitivityX = 0;
         static constexpr float SensitivityY = 0.005f;
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/MoveCameraBehavior.h

@@ -5,18 +5,18 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
-#include <Viewport/InputController/Behavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
     //! Moves camera along its vertical and horizontal axis
-    class MoveCameraBehavior final
-        : public Behavior
+    class MoveCameraBehavior final : public ViewportInputBehavior
     {
     public:
-        MoveCameraBehavior() = default;
+        MoveCameraBehavior(ViewportInputBehaviorControllerInterface* controller);
         virtual ~MoveCameraBehavior() = default;
         void End() override;
 
@@ -29,4 +29,4 @@ namespace MaterialEditor
         static constexpr float SensitivityX = 0.01f;
         static constexpr float SensitivityY = 0.01f;
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/OrbitCameraBehavior.h

@@ -5,19 +5,19 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
-#include <Viewport/InputController/Behavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
     //! Rotates the camera around target position,
     //! this can either be model center or any position in world
-    class OrbitCameraBehavior final
-        : public Behavior
+    class OrbitCameraBehavior final : public ViewportInputBehavior
     {
     public:
-        OrbitCameraBehavior() = default;
+        OrbitCameraBehavior(ViewportInputBehaviorControllerInterface* controller);
         virtual ~OrbitCameraBehavior() = default;
 
     protected:
@@ -30,7 +30,6 @@ namespace MaterialEditor
 
         static constexpr float SensitivityX = 0.005f;
         static constexpr float SensitivityY = 0.005f;
-        
         bool m_aligned = false;
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/PanCameraBehavior.h

@@ -5,20 +5,20 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
-#include <Viewport/InputController/Behavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
     //! Rotates camera around its own axis, allowing to look up/down/left/right
-    class PanCameraBehavior final
-        : public Behavior
+    class PanCameraBehavior final : public ViewportInputBehavior
     {
     public:
-        PanCameraBehavior() = default;
+        PanCameraBehavior(ViewportInputBehaviorControllerInterface* controller);
         virtual ~PanCameraBehavior() = default;
-        
+
         void End() override;
 
     protected:
@@ -30,4 +30,4 @@ namespace MaterialEditor
         static constexpr float SensitivityX = 0.005f;
         static constexpr float SensitivityY = 0.005f;
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateEnvironmentBehavior.h

@@ -5,9 +5,10 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
-#include <Viewport/InputController/Behavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
 
 namespace AZ
 {
@@ -15,16 +16,15 @@ namespace AZ
     {
         class SkyBoxFeatureProcessorInterface;
     }
-}
+} // namespace AZ
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
     //! Rotates lighting and skybox around vertical axis
-    class RotateEnvironmentBehavior final
-        : public Behavior
+    class RotateEnvironmentBehavior final : public ViewportInputBehavior
     {
     public:
-        RotateEnvironmentBehavior() = default;
+        RotateEnvironmentBehavior(ViewportInputBehaviorControllerInterface* controller);
         virtual ~RotateEnvironmentBehavior() = default;
 
         void Start() override;
@@ -38,8 +38,8 @@ namespace MaterialEditor
         static constexpr float SensitivityX = 0.01f;
         static constexpr float SensitivityY = 0;
 
-        AZ::EntityId m_iblEntityId;
-        AZ::Render::SkyBoxFeatureProcessorInterface* m_skyBoxFeatureProcessorInterface = nullptr;
-        float m_rotation = 0;
+        AZ::EntityId m_environmentEntityId;
+        AZ::Render::SkyBoxFeatureProcessorInterface* m_skyBoxFeatureProcessor = {};
+        float m_rotation = {};
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateModelBehavior.h

@@ -5,18 +5,18 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
-#include <Viewport/InputController/Behavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
     //! Rotates target model in viewport
-    class RotateModelBehavior final
-        : public Behavior
+    class RotateModelBehavior final : public ViewportInputBehavior
     {
     public:
-        RotateModelBehavior() = default;
+        RotateModelBehavior(ViewportInputBehaviorControllerInterface* controller);
         virtual ~RotateModelBehavior() = default;
 
         void Start() override;
@@ -33,4 +33,4 @@ namespace MaterialEditor
         AZ::EntityId m_targetEntityId;
         AZ::Vector3 m_cameraRight = AZ::Vector3::CreateAxisX();
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h

@@ -5,22 +5,24 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
 #include <AzCore/Component/EntityId.h>
-#include <AzCore/Math/Quaternion.h>
 #include <AzCore/Component/TickBus.h>
+#include <AzCore/Math/Quaternion.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
-    //! Performs a single type of action for MaterialEditorViewportInputController based on input
+    class ViewportInputBehaviorControllerInterface;
+
+    //! Performs a single type of action for ViewportInputBehaviorController based on input
     //! See derived behaviors for specific details
-    class Behavior
-        : public AZ::TickBus::Handler
+    class ViewportInputBehavior : public AZ::TickBus::Handler
     {
     public:
-        Behavior();
-        virtual ~Behavior();
+        ViewportInputBehavior(ViewportInputBehaviorControllerInterface* controller);
+        virtual ~ViewportInputBehavior();
 
         virtual void Start();
         virtual void End();
@@ -45,20 +47,21 @@ namespace MaterialEditor
         //! If delta transform less than this, snap instantly
         static constexpr float SnapInterval = 0.01f;
         //! delta x movement accumulated during current frame
-        float m_x = 0;
+        float m_x = {};
         //! delta y movement accumulated during current frame
-        float m_y = 0;
+        float m_y = {};
         //! delta scroll wheel accumulated during current frame
-        float m_z = 0;
+        float m_z = {};
         //! Model radius
         float m_radius = 1.0f;
 
         AZ::EntityId m_cameraEntityId;
         AZ::Vector3 m_targetPosition = AZ::Vector3::CreateZero();
-        float m_distanceToTarget = 0;
+        float m_distanceToTarget = {};
+        ViewportInputBehaviorControllerInterface* m_controller = {};
 
     private:
         // AZ::TickBus::Handler interface overrides...
         void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorController.h

@@ -7,36 +7,51 @@
  */
 #pragma once
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzFramework/Input/Events/InputChannelEventListener.h>
 #include <AzFramework/Viewport/SingleViewportController.h>
-#include <Viewport/InputController/Behavior.h>
-#include <Viewport/InputController/MaterialEditorViewportInputControllerBus.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
-    class Behavior;
+    class ViewportInputBehavior;
 
     //! Provides controls for manipulating camera, model, and environment in Material Editor
-    class MaterialEditorViewportInputController
+    class ViewportInputBehaviorController
         : public AzFramework::SingleViewportController
-        , public MaterialEditorViewportInputControllerRequestBus::Handler
+        , public ViewportInputBehaviorControllerInterface
     {
     public:
+        AZ_TYPE_INFO(ViewportInputBehaviorController, "{569A0544-7654-4DCE-8156-00A71B408374}");
+        AZ_CLASS_ALLOCATOR(ViewportInputBehaviorController, AZ::SystemAllocator, 0)
+        AZ_DISABLE_COPY_MOVE(ViewportInputBehaviorController);
 
-        AZ_TYPE_INFO(MaterialEditorViewportInputController, "{569A0544-7654-4DCE-8156-00A71B408374}");
-        AZ_CLASS_ALLOCATOR(MaterialEditorViewportInputController, AZ::SystemAllocator, 0)
+        using KeyMask = uint32_t;
 
-        MaterialEditorViewportInputController();
-        virtual ~MaterialEditorViewportInputController();
+        enum Keys
+        {
+            None = 0,
+            Lmb = 1 << 0,
+            Mmb = 1 << 1,
+            Rmb = 1 << 2,
+            Alt = 1 << 3,
+            Ctrl = 1 << 4,
+            Shift = 1 << 5
+        };
+
+        ViewportInputBehaviorController(
+            const AZ::EntityId& cameraEntityId, const AZ::EntityId& targetEntityId, const AZ::EntityId& environmentEntityId);
+        virtual ~ViewportInputBehaviorController();
 
-        void Init(const AZ::EntityId& cameraEntityId, const AZ::EntityId& targetEntityId, const AZ::EntityId& iblEntityId);
+        void AddBehavior(KeyMask mask, AZStd::shared_ptr<ViewportInputBehavior> behavior);
 
-        // MaterialEditorViewportInputControllerRequestBus::Handler interface overrides...
+        // ViewportInputBehaviorControllerInterface overrides...
         const AZ::EntityId& GetCameraEntityId() const override;
         const AZ::EntityId& GetTargetEntityId() const override;
-        const AZ::EntityId& GetIblEntityId() const override;
+        const AZ::EntityId& GetEnvironmentEntityId() const override;
         const AZ::Vector3& GetTargetPosition() const override;
         void SetTargetPosition(const AZ::Vector3& targetPosition) override;
+        void SetTargetBounds(const AZ::Aabb& targetBounds) override;
         float GetDistanceToTarget() const override;
         void GetExtents(float& distanceMin, float& distanceMax) const override;
         float GetRadius() const override;
@@ -44,31 +59,16 @@ namespace MaterialEditor
         void SetFieldOfView(float value) override;
         bool IsCameraCentered() const override;
 
-        // AzFramework::ViewportControllerInstance interface overrides...
+        // AzFramework::ViewportControllerInstance overrides...
         bool HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event) override;
         void UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event) override;
 
     private:
-        using KeyMask = uint32_t;
-
-        enum Keys
-        {
-            None = 0,
-            Lmb = 1 << 0,
-            Mmb = 1 << 1,
-            Rmb = 1 << 2,
-            Alt = 1 << 3,
-            Ctrl = 1 << 4,
-            Shift = 1 << 5
-        };
-
         //! Calculate min and max dist and center based on mesh size of target model
         void CalculateExtents();
         //! Determine which behavior to set based on mouse/keyboard input
         void EvaluateControlBehavior();
 
-        bool m_initialized = false;
-
         //! Input keys currently pressed
         KeyMask m_keys = None;
         //! Input key sequence changed
@@ -77,16 +77,18 @@ namespace MaterialEditor
         float m_timeToBehaviorSwitchMs = 0;
 
         //! Current behavior of the controller
-        AZStd::shared_ptr<Behavior> m_behavior;
-        AZStd::unordered_map<KeyMask, AZStd::shared_ptr<Behavior>> m_behaviorMap;
+        AZStd::shared_ptr<ViewportInputBehavior> m_behavior;
+        AZStd::unordered_map<KeyMask, AZStd::shared_ptr<ViewportInputBehavior>> m_behaviorMap;
 
         AZ::EntityId m_cameraEntityId;
         //! Target entity is looking at
         AZ::EntityId m_targetEntityId;
         //! IBL entity for rotating environment lighting
-        AZ::EntityId m_iblEntityId;
+        AZ::EntityId m_environmentEntityId;
         //! Target position camera is pointed towards
         AZ::Vector3 m_targetPosition;
+        //! Target bounds
+        AZ::Aabb m_targetBounds = AZ::Aabb::CreateFromPoint(AZ::Vector3::CreateZero());
         //! Center of the model observed
         AZ::Vector3 m_modelCenter;
         //! Minimum distance from camera to target
@@ -106,4 +108,4 @@ namespace MaterialEditor
         //! e.g. pressing RMB+LMB shouldn't switch into RMB behavior (or LMB behavior) first because it's virtually impossible to press both mouse buttons on the same frame
         static constexpr float BehaviorSwitchDelayMs = 0.1f;
     };
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h

@@ -8,16 +8,15 @@
 #pragma once
 
 #include <AzCore/EBus/EBus.h>
+#include <AzCore/Math/Aabb.h>
 #include <AzCore/Math/Vector3.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
-    class MaterialEditorViewportInputControllerRequests
-        : public AZ::EBusTraits
+    class ViewportInputBehaviorControllerInterface
     {
     public:
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        virtual ~ViewportInputBehaviorControllerInterface() = default;
 
         //! Get entityId of viewport camera
         virtual const AZ::EntityId& GetCameraEntityId() const = 0;
@@ -26,7 +25,7 @@ namespace MaterialEditor
         virtual const AZ::EntityId& GetTargetEntityId() const = 0;
 
         //! Get entityId of scene's IBL entity
-        virtual const AZ::EntityId& GetIblEntityId() const = 0;
+        virtual const AZ::EntityId& GetEnvironmentEntityId() const = 0;
 
         //! Get actual position where the camera is facing
         virtual const AZ::Vector3& GetTargetPosition() const = 0;
@@ -35,6 +34,10 @@ namespace MaterialEditor
         //! @param targetPosition world space position to point camera at
         virtual void SetTargetPosition(const AZ::Vector3& targetPosition) = 0;
 
+        //! Set camera target bounds
+        //! @param targetBounds AABB of target
+        virtual void SetTargetBounds(const AZ::Aabb& targetBounds) = 0;
+
         //! Get distance between camera and its target
         virtual float GetDistanceToTarget() const = 0;
 
@@ -56,6 +59,4 @@ namespace MaterialEditor
         //! Check if camera is looking directly at a model
         virtual bool IsCameraCentered() const = 0;
     };
-
-    using MaterialEditorViewportInputControllerRequestBus = AZ::EBus<MaterialEditorViewportInputControllerRequests>;
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/DollyCameraBehavior.cpp

@@ -6,21 +6,25 @@
  *
  */
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/DollyCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Math/MathUtils.h>
 #include <AzCore/Math/Vector3.h>
-#include <Viewport/InputController/DollyCameraBehavior.h>
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
+    DollyCameraBehavior::DollyCameraBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : ViewportInputBehavior(controller)
+    {
+    }
+
     void DollyCameraBehavior::TickInternal([[maybe_unused]] float x, float y, [[maybe_unused]] float z)
     {
         m_distanceToTarget = m_distanceToTarget + y;
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(transform, m_cameraEntityId, &AZ::TransformBus::Events::GetLocalTM);
-        AZ::Vector3 position = m_targetPosition -
-            transform.GetRotation().TransformVector(AZ::Vector3::CreateAxisY(m_distanceToTarget));
+        AZ::Vector3 position = m_targetPosition - transform.GetRotation().TransformVector(AZ::Vector3::CreateAxisY(m_distanceToTarget));
         AZ::TransformBus::Event(m_cameraEntityId, &AZ::TransformBus::Events::SetLocalTranslation, position);
     }
 
@@ -33,4 +37,4 @@ namespace MaterialEditor
     {
         return SensitivityY;
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/MoveCameraBehavior.cpp

@@ -6,27 +6,25 @@
  *
  */
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/MoveCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Math/Vector3.h>
-#include <Viewport/InputController/MaterialEditorViewportInputControllerBus.h>
-#include <Viewport/InputController/MoveCameraBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
+    MoveCameraBehavior::MoveCameraBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : ViewportInputBehavior(controller)
+    {
+    }
+
     void MoveCameraBehavior::End()
     {
-        float distanceToTarget;
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            distanceToTarget,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetDistanceToTarget);
+        float distanceToTarget = m_controller->GetDistanceToTarget();
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(transform, m_cameraEntityId, &AZ::TransformBus::Events::GetLocalTM);
-        AZ::Vector3 targetPosition =
-            transform.GetTranslation() +
-            transform.GetBasisY() * distanceToTarget;
-        MaterialEditorViewportInputControllerRequestBus::Broadcast(
-            &MaterialEditorViewportInputControllerRequestBus::Handler::SetTargetPosition,
-            targetPosition);
+        AZ::Vector3 targetPosition = transform.GetTranslation() + transform.GetBasisY() * distanceToTarget;
+        m_controller->SetTargetPosition(targetPosition);
     }
 
     void MoveCameraBehavior::TickInternal(float x, float y, float z)
@@ -41,7 +39,7 @@ namespace MaterialEditor
         m_targetPosition += deltaPosition;
         AZ::TransformBus::Event(m_cameraEntityId, &AZ::TransformBus::Events::SetLocalTranslation, position);
 
-        Behavior::TickInternal(x, y, z);
+        ViewportInputBehavior::TickInternal(x, y, z);
     }
 
     float MoveCameraBehavior::GetSensitivityX()
@@ -53,4 +51,4 @@ namespace MaterialEditor
     {
         return SensitivityY;
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/OrbitCameraBehavior.cpp

@@ -6,15 +6,20 @@
  *
  */
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/OrbitCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzCore/Component/TransformBus.h>
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
-#include <Viewport/InputController/OrbitCameraBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
+    OrbitCameraBehavior::OrbitCameraBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : ViewportInputBehavior(controller)
+    {
+    }
+
     void OrbitCameraBehavior::TickInternal(float x, float y, float z)
     {
-        Behavior::TickInternal(x, y, z);
+        ViewportInputBehavior::TickInternal(x, y, z);
 
         // don't align camera until a movement has been made so that accidental right-click doesn't reset camera
         if (!m_aligned)
@@ -27,12 +32,9 @@ namespace MaterialEditor
         AZ::Quaternion rotation = transform.GetRotation();
         AZ::Vector3 right = transform.GetBasisX();
         rotation =
-            AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), -x) *
-            AZ::Quaternion::CreateFromAxisAngle(right, -y) *
-            rotation;
+            AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), -x) * AZ::Quaternion::CreateFromAxisAngle(right, -y) * rotation;
         rotation.Normalize();
-        AZ::Vector3 position =
-            rotation.TransformVector(AZ::Vector3(0, -m_distanceToTarget, 0)) + m_targetPosition;
+        AZ::Vector3 position = rotation.TransformVector(AZ::Vector3(0, -m_distanceToTarget, 0)) + m_targetPosition;
         transform = AZ::Transform::CreateFromQuaternionAndTranslation(rotation, position);
         AZ::TransformBus::Event(m_cameraEntityId, &AZ::TransformBus::Events::SetLocalTM, transform);
     }
@@ -56,4 +58,4 @@ namespace MaterialEditor
         AZ::TransformBus::Event(m_cameraEntityId, &AZ::TransformBus::Events::SetLocalRotationQuaternion, targetRotation);
         m_aligned = true;
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/PanCameraBehavior.cpp

@@ -6,28 +6,26 @@
  *
  */
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/PanCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Math/Quaternion.h>
 #include <AzCore/Math/Vector3.h>
-#include <Viewport/InputController/MaterialEditorViewportInputControllerBus.h>
-#include <Viewport/InputController/PanCameraBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
+    PanCameraBehavior::PanCameraBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : ViewportInputBehavior(controller)
+    {
+    }
+
     void PanCameraBehavior::End()
     {
-        float distanceToTarget;
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            distanceToTarget,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetDistanceToTarget);
+        float distanceToTarget = m_controller->GetDistanceToTarget();
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(transform, m_cameraEntityId, &AZ::TransformBus::Events::GetLocalTM);
-        AZ::Vector3 targetPosition =
-            transform.GetTranslation() +
-            transform.GetBasisY() * distanceToTarget;
-        MaterialEditorViewportInputControllerRequestBus::Broadcast(
-            &MaterialEditorViewportInputControllerRequestBus::Handler::SetTargetPosition,
-            targetPosition);
+        AZ::Vector3 targetPosition = transform.GetTranslation() + transform.GetBasisY() * distanceToTarget;
+        m_controller->SetTargetPosition(targetPosition);
     }
 
     void PanCameraBehavior::TickInternal(float x, float y, [[maybe_unused]] float z)
@@ -37,9 +35,7 @@ namespace MaterialEditor
         AZ::Quaternion rotation = transform.GetRotation();
         const AZ::Vector3 right = transform.GetBasisX();
         rotation =
-            AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), -x) *
-            AZ::Quaternion::CreateFromAxisAngle(right, -y) *
-            rotation;
+            AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), -x) * AZ::Quaternion::CreateFromAxisAngle(right, -y) * rotation;
         rotation.Normalize();
         AZ::TransformBus::Event(m_cameraEntityId, &AZ::TransformBus::Events::SetLocalRotationQuaternion, rotation);
     }
@@ -53,4 +49,4 @@ namespace MaterialEditor
     {
         return SensitivityY;
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/RotateEnvironmentBehavior.cpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <Atom/Feature/SkyBox/SkyBoxFeatureProcessorInterface.h>
+#include <Atom/RPI.Public/RPISystemInterface.h>
+#include <Atom/RPI.Public/Scene.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateEnvironmentBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
+#include <AzCore/Component/TransformBus.h>
+
+namespace AtomToolsFramework
+{
+    RotateEnvironmentBehavior::RotateEnvironmentBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : ViewportInputBehavior(controller)
+    {
+    }
+
+    void RotateEnvironmentBehavior::Start()
+    {
+        ViewportInputBehavior::Start();
+
+        m_environmentEntityId = m_controller->GetEnvironmentEntityId();
+        AZ_Assert(m_environmentEntityId.IsValid(), "Failed to find m_environmentEntityId");
+        m_skyBoxFeatureProcessor =
+            AZ::RPI::Scene::GetFeatureProcessorForEntity<AZ::Render::SkyBoxFeatureProcessorInterface>(m_environmentEntityId);
+    }
+
+    void RotateEnvironmentBehavior::TickInternal(float x, float y, float z)
+    {
+        ViewportInputBehavior::TickInternal(x, y, z);
+
+        m_rotation += x;
+        AZ::Quaternion rotation = AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), m_rotation);
+        AZ::TransformBus::Event(m_environmentEntityId, &AZ::TransformBus::Events::SetLocalRotationQuaternion, rotation);
+        const AZ::Matrix4x4 rotationMatrix = AZ::Matrix4x4::CreateFromQuaternion(rotation);
+        m_skyBoxFeatureProcessor->SetCubemapRotationMatrix(rotationMatrix);
+    }
+
+    float RotateEnvironmentBehavior::GetSensitivityX()
+    {
+        return SensitivityX;
+    }
+
+    float RotateEnvironmentBehavior::GetSensitivityY()
+    {
+        return SensitivityY;
+    }
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/RotateModelBehavior.cpp

@@ -6,25 +6,27 @@
  *
  */
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateModelBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzCore/Component/TransformBus.h>
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
-#include <Viewport/InputController/RotateModelBehavior.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
+    RotateModelBehavior::RotateModelBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : ViewportInputBehavior(controller)
+    {
+    }
+
     void RotateModelBehavior::Start()
     {
-        Behavior::Start();
+        ViewportInputBehavior::Start();
 
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            m_targetEntityId,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetTargetEntityId);
+        m_targetEntityId = m_controller->GetTargetEntityId();
         AZ_Assert(m_targetEntityId.IsValid(), "Failed to find m_targetEntityId");
-        AZ::EntityId cameraEntityId;
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            cameraEntityId,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetCameraEntityId);
+
+        AZ::EntityId cameraEntityId = m_controller->GetCameraEntityId();
         AZ_Assert(cameraEntityId.IsValid(), "Failed to find cameraEntityId");
+
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(transform, cameraEntityId, &AZ::TransformBus::Events::GetLocalTM);
         m_cameraRight = transform.GetBasisX();
@@ -32,16 +34,14 @@ namespace MaterialEditor
 
     void RotateModelBehavior::TickInternal(float x, float y, float z)
     {
-        Behavior::TickInternal(x, y, z);
+        ViewportInputBehavior::TickInternal(x, y, z);
 
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(transform, m_targetEntityId, &AZ::TransformBus::Events::GetLocalTM);
 
         AZ::Quaternion rotation = transform.GetRotation();
-        rotation =
-            AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), x) *
-            AZ::Quaternion::CreateFromAxisAngle(m_cameraRight, y) *
-            rotation;
+        rotation = AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), x) *
+            AZ::Quaternion::CreateFromAxisAngle(m_cameraRight, y) * rotation;
         rotation.Normalize();
 
         AZ::TransformBus::Event(m_targetEntityId, &AZ::TransformBus::Events::SetLocalRotationQuaternion, rotation);
@@ -56,4 +56,4 @@ namespace MaterialEditor
     {
         return SensitivityY;
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.cpp

@@ -6,78 +6,67 @@
  *
  */
 
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Math/Vector3.h>
-#include <Viewport/InputController/Behavior.h>
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
-    Behavior::Behavior()
+    ViewportInputBehavior::ViewportInputBehavior(ViewportInputBehaviorControllerInterface* controller)
+        : m_controller(controller)
     {
         AZ::TickBus::Handler::BusConnect();
     }
 
-    Behavior::~Behavior()
+    ViewportInputBehavior::~ViewportInputBehavior()
     {
         AZ::TickBus::Handler::BusDisconnect();
     }
 
-    void Behavior::Start()
+    void ViewportInputBehavior::Start()
     {
-        m_x = 0;
-        m_y = 0;
-        m_z = 0;
+        m_x = {};
+        m_y = {};
+        m_z = {};
 
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            m_cameraEntityId,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetCameraEntityId);
+        m_cameraEntityId = m_controller->GetCameraEntityId();
         AZ_Assert(m_cameraEntityId.IsValid(), "Failed to find m_cameraEntityId");
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            m_distanceToTarget,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetDistanceToTarget);
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            m_targetPosition,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetTargetPosition);
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            m_radius, &MaterialEditorViewportInputControllerRequestBus::Handler::GetRadius);
+        m_distanceToTarget = m_controller->GetDistanceToTarget();
+        m_targetPosition = m_controller->GetTargetPosition();
+        m_radius = m_controller->GetRadius();
     }
 
-    void Behavior::End()
+    void ViewportInputBehavior::End()
     {
     }
 
-    void Behavior::MoveX(float value)
+    void ViewportInputBehavior::MoveX(float value)
     {
         m_x += value * GetSensitivityX();
     }
 
-    void Behavior::MoveY(float value)
+    void ViewportInputBehavior::MoveY(float value)
     {
         m_y += value * GetSensitivityY();
     }
 
-    void Behavior::MoveZ(float value)
+    void ViewportInputBehavior::MoveZ(float value)
     {
         m_z += value * GetSensitivityZ();
     }
 
-    bool Behavior::HasDelta() const
+    bool ViewportInputBehavior::HasDelta() const
     {
-        return
-            AZ::GetAbs(m_x) > std::numeric_limits<float>::min() ||
-            AZ::GetAbs(m_y) > std::numeric_limits<float>::min() ||
+        return AZ::GetAbs(m_x) > std::numeric_limits<float>::min() || AZ::GetAbs(m_y) > std::numeric_limits<float>::min() ||
             AZ::GetAbs(m_z) > std::numeric_limits<float>::min();
     }
 
-    void Behavior::TickInternal([[maybe_unused]] float x, [[maybe_unused]] float y, float z)
+    void ViewportInputBehavior::TickInternal([[maybe_unused]] float x, [[maybe_unused]] float y, float z)
     {
         m_distanceToTarget = m_distanceToTarget - z;
 
-        bool isCameraCentered = false;
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            isCameraCentered,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::IsCameraCentered);
+        bool isCameraCentered = m_controller->IsCameraCentered();
 
         // if camera is looking at the model (locked to the model) we don't want to zoom past the model's center
         if (isCameraCentered)
@@ -87,40 +76,35 @@ namespace MaterialEditor
 
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(transform, m_cameraEntityId, &AZ::TransformBus::Events::GetLocalTM);
-        AZ::Vector3 position = m_targetPosition -
-            transform.GetRotation().TransformVector(AZ::Vector3::CreateAxisY(m_distanceToTarget));
+        AZ::Vector3 position = m_targetPosition - transform.GetRotation().TransformVector(AZ::Vector3::CreateAxisY(m_distanceToTarget));
         AZ::TransformBus::Event(m_cameraEntityId, &AZ::TransformBus::Events::SetLocalTranslation, position);
 
         // if camera is not locked to the model, move its focal point so we can free look
         if (!isCameraCentered)
         {
             m_targetPosition += transform.GetRotation().TransformVector(AZ::Vector3::CreateAxisY(z));
-            MaterialEditorViewportInputControllerRequestBus::Broadcast(
-                &MaterialEditorViewportInputControllerRequestBus::Handler::SetTargetPosition,
-                m_targetPosition);
-            MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-                m_distanceToTarget,
-                &MaterialEditorViewportInputControllerRequestBus::Handler::GetDistanceToTarget);
+            m_controller->SetTargetPosition(m_targetPosition);
+            m_distanceToTarget = m_controller->GetDistanceToTarget();
         }
     }
 
-    float Behavior::GetSensitivityX()
+    float ViewportInputBehavior::GetSensitivityX()
     {
         return 0;
     }
 
-    float Behavior::GetSensitivityY()
+    float ViewportInputBehavior::GetSensitivityY()
     {
         return 0;
     }
 
-    float Behavior::GetSensitivityZ()
+    float ViewportInputBehavior::GetSensitivityZ()
     {
         // adjust zooming sensitivity by model size, so that large models zoom at the same speed as smaller ones
         return 0.001f * AZ::GetMax(0.5f, m_radius);
     }
 
-    AZ::Quaternion Behavior::LookRotation(AZ::Vector3 forward)
+    AZ::Quaternion ViewportInputBehavior::LookRotation(AZ::Vector3 forward)
     {
         forward.Normalize();
         AZ::Vector3 right = forward.CrossZAxis();
@@ -132,7 +116,7 @@ namespace MaterialEditor
         return rotation;
     }
 
-    float Behavior::TakeStep(float& value, float t)
+    float ViewportInputBehavior::TakeStep(float& value, float t)
     {
         const float absValue = AZ::GetAbs(value);
         float step;
@@ -148,7 +132,7 @@ namespace MaterialEditor
         return step;
     }
 
-    void Behavior::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
+    void ViewportInputBehavior::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
     {
         // delta x and y values are accumulated in MoveX and MoveY functions (by dragging the mouse)
         // in the Tick function we then lerp them down to 0 over short time and apply delta transform to an entity
@@ -163,4 +147,4 @@ namespace MaterialEditor
             TickInternal(x, y, z);
         }
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorController.cpp

@@ -6,120 +6,94 @@
  *
  */
 
-#include <QApplication>
-#include <QWidget>
-
+#include <Atom/Feature/SkyBox/SkyBoxFeatureProcessorInterface.h>
+#include <Atom/RPI.Public/RPISystemInterface.h>
+#include <Atom/RPI.Public/Scene.h>
+#include <Atom/RPI.Reflect/Model/ModelAsset.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorController.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Math/Matrix4x4.h>
 #include <AzCore/Serialization/SerializeContext.h>
-
 #include <AzFramework/Components/CameraBus.h>
 #include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
 #include <AzFramework/Input/Devices/Mouse/InputDeviceMouse.h>
 #include <AzFramework/Viewport/ScreenGeometry.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
 
-#include <Atom/Feature/SkyBox/SkyBoxFeatureProcessorInterface.h>
-#include <Atom/RPI.Public/RPISystemInterface.h>
-#include <Atom/RPI.Public/Scene.h>
-#include <Atom/RPI.Reflect/Model/ModelAsset.h>
-#include <AtomLyIntegration/CommonFeatures/Mesh/MeshComponentBus.h>
-
-#include <Viewport/InputController/DollyCameraBehavior.h>
-#include <Viewport/InputController/IdleBehavior.h>
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
-#include <Viewport/InputController/MoveCameraBehavior.h>
-#include <Viewport/InputController/OrbitCameraBehavior.h>
-#include <Viewport/InputController/PanCameraBehavior.h>
-#include <Viewport/InputController/RotateEnvironmentBehavior.h>
-#include <Viewport/InputController/RotateModelBehavior.h>
-
-namespace MaterialEditor
+#include <QApplication>
+#include <QWidget>
+
+namespace AtomToolsFramework
 {
-    MaterialEditorViewportInputController::MaterialEditorViewportInputController()
+    ViewportInputBehaviorController::ViewportInputBehaviorController(
+        const AZ::EntityId& cameraEntityId, const AZ::EntityId& targetEntityId, const AZ::EntityId& environmentEntityId)
         : AzFramework::SingleViewportController()
+        , m_cameraEntityId(cameraEntityId)
+        , m_targetEntityId(targetEntityId)
+        , m_environmentEntityId(environmentEntityId)
         , m_targetPosition(AZ::Vector3::CreateZero())
     {
-        m_behaviorMap[None] = AZStd::make_shared<IdleBehavior>();
-        m_behaviorMap[Lmb] = AZStd::make_shared<PanCameraBehavior>();
-        m_behaviorMap[Mmb] = AZStd::make_shared<MoveCameraBehavior>();
-        m_behaviorMap[Rmb] = AZStd::make_shared<OrbitCameraBehavior>();
-        m_behaviorMap[Alt ^ Lmb] = AZStd::make_shared<OrbitCameraBehavior>();
-        m_behaviorMap[Alt ^ Mmb] = AZStd::make_shared<MoveCameraBehavior>();
-        m_behaviorMap[Alt ^ Rmb] = AZStd::make_shared<DollyCameraBehavior>();
-        m_behaviorMap[Lmb ^ Rmb] = AZStd::make_shared<DollyCameraBehavior>();
-        m_behaviorMap[Ctrl ^ Lmb] = AZStd::make_shared<RotateModelBehavior>();
-        m_behaviorMap[Shift ^ Lmb] = AZStd::make_shared<RotateEnvironmentBehavior>();
     }
 
-    MaterialEditorViewportInputController::~MaterialEditorViewportInputController()
+    ViewportInputBehaviorController::~ViewportInputBehaviorController()
     {
-        if (m_initialized)
-        {
-            MaterialEditorViewportInputControllerRequestBus::Handler::BusDisconnect();
-        }
     }
 
-    void MaterialEditorViewportInputController::Init(const AZ::EntityId& cameraEntityId, const AZ::EntityId& targetEntityId, const AZ::EntityId& iblEntityId)
+    void ViewportInputBehaviorController::AddBehavior(KeyMask mask, AZStd::shared_ptr<ViewportInputBehavior> behavior)
     {
-        if (m_initialized)
-        {
-            AZ_Error("MaterialEditorViewportInputController", false, "Controller already initialized.");
-            return;
-        }
-        m_initialized = true;
-        m_cameraEntityId = cameraEntityId;
-        m_targetEntityId = targetEntityId;
-        m_iblEntityId = iblEntityId;
-
-        MaterialEditorViewportInputControllerRequestBus::Handler::BusConnect();
+        m_behaviorMap[mask] = behavior;
     }
 
-    const AZ::EntityId& MaterialEditorViewportInputController::GetCameraEntityId() const
+    const AZ::EntityId& ViewportInputBehaviorController::GetCameraEntityId() const
     {
         return m_cameraEntityId;
     }
 
-    const AZ::EntityId& MaterialEditorViewportInputController::GetTargetEntityId() const
+    const AZ::EntityId& ViewportInputBehaviorController::GetTargetEntityId() const
     {
         return m_targetEntityId;
     }
 
-    const AZ::EntityId& MaterialEditorViewportInputController::GetIblEntityId() const
+    const AZ::EntityId& ViewportInputBehaviorController::GetEnvironmentEntityId() const
     {
-        return m_iblEntityId;
+        return m_environmentEntityId;
     }
 
-    const AZ::Vector3& MaterialEditorViewportInputController::GetTargetPosition() const
+    const AZ::Vector3& ViewportInputBehaviorController::GetTargetPosition() const
     {
         return m_targetPosition;
     }
 
-    void MaterialEditorViewportInputController::SetTargetPosition(const AZ::Vector3& targetPosition)
+    void ViewportInputBehaviorController::SetTargetPosition(const AZ::Vector3& targetPosition)
     {
         m_targetPosition = targetPosition;
         m_isCameraCentered = false;
     }
 
-    float MaterialEditorViewportInputController::GetDistanceToTarget() const
+    void ViewportInputBehaviorController::SetTargetBounds(const AZ::Aabb& targetBounds)
+    {
+        m_targetBounds = targetBounds;
+    }
+
+    float ViewportInputBehaviorController::GetDistanceToTarget() const
     {
         AZ::Vector3 cameraPosition;
         AZ::TransformBus::EventResult(cameraPosition, m_cameraEntityId, &AZ::TransformBus::Events::GetLocalTranslation);
         return cameraPosition.GetDistance(m_targetPosition);
     }
 
-    void MaterialEditorViewportInputController::GetExtents(float& distanceMin, float& distanceMax) const
+    void ViewportInputBehaviorController::GetExtents(float& distanceMin, float& distanceMax) const
     {
         distanceMin = m_distanceMin;
         distanceMax = m_distanceMax;
     }
 
-    float MaterialEditorViewportInputController::GetRadius() const
+    float ViewportInputBehaviorController::GetRadius() const
     {
         return m_radius;
     }
 
-    void MaterialEditorViewportInputController::UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event)
+    void ViewportInputBehaviorController::UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event)
     {
         if (m_keysChanged)
         {
@@ -135,7 +109,7 @@ namespace MaterialEditor
         }
     }
 
-    bool MaterialEditorViewportInputController::HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event)
+    bool ViewportInputBehaviorController::HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event)
     {
         using namespace AzFramework;
 
@@ -145,8 +119,7 @@ namespace MaterialEditor
 
         bool mouseOver = false;
         AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::EventResult(
-            mouseOver, GetViewportId(),
-            &AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::IsMouseOver);
+            mouseOver, GetViewportId(), &AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::IsMouseOver);
 
         if (!m_behavior)
         {
@@ -180,20 +153,17 @@ namespace MaterialEditor
             {
                 m_keys |= Shift;
             }
-            if (inputChannelId == InputDeviceMouse::Movement::X)
+            if (m_behavior && inputChannelId == InputDeviceMouse::Movement::X)
             {
                 m_behavior->MoveX(event.m_inputChannel.GetValue());
             }
-            else if (inputChannelId == InputDeviceMouse::Movement::Y)
+            else if (m_behavior && inputChannelId == InputDeviceMouse::Movement::Y)
             {
                 m_behavior->MoveY(event.m_inputChannel.GetValue());
             }
-            else if (inputChannelId == InputDeviceMouse::Movement::Z)
+            else if (m_behavior && inputChannelId == InputDeviceMouse::Movement::Z && mouseOver)
             {
-                if (mouseOver)
-                {
-                    m_behavior->MoveZ(event.m_inputChannel.GetValue());
-                }
+                m_behavior->MoveZ(event.m_inputChannel.GetValue());
             }
             break;
         case InputChannel::State::Ended:
@@ -232,20 +202,17 @@ namespace MaterialEditor
             }
             break;
         case InputChannel::State::Updated:
-            if (inputChannelId == InputDeviceMouse::Movement::X)
+            if (m_behavior && inputChannelId == InputDeviceMouse::Movement::X)
             {
                 m_behavior->MoveX(event.m_inputChannel.GetValue());
             }
-            else if (inputChannelId == InputDeviceMouse::Movement::Y)
+            else if (m_behavior && inputChannelId == InputDeviceMouse::Movement::Y)
             {
                 m_behavior->MoveY(event.m_inputChannel.GetValue());
             }
-            else if (inputChannelId == InputDeviceMouse::Movement::Z)
+            else if (m_behavior && inputChannelId == InputDeviceMouse::Movement::Z && mouseOver)
             {
-                if (mouseOver)
-                {
-                    m_behavior->MoveZ(event.m_inputChannel.GetValue());
-                }
+                m_behavior->MoveZ(event.m_inputChannel.GetValue());
             }
             break;
         }
@@ -258,7 +225,7 @@ namespace MaterialEditor
         return false;
     }
 
-    void MaterialEditorViewportInputController::Reset()
+    void ViewportInputBehaviorController::Reset()
     {
         CalculateExtents();
 
@@ -277,12 +244,13 @@ namespace MaterialEditor
         AZ::TransformBus::Event(m_targetEntityId, &AZ::TransformBus::Events::SetLocalTM, modelTransform);
 
         // reset environment
-        AZ::Transform iblTransform = AZ::Transform::CreateIdentity();
-        AZ::TransformBus::Event(m_iblEntityId, &AZ::TransformBus::Events::SetLocalTM, iblTransform);
+        AZ::Transform environmentTransform = AZ::Transform::CreateIdentity();
+        AZ::TransformBus::Event(m_environmentEntityId, &AZ::TransformBus::Events::SetLocalTM, environmentTransform);
 
         const AZ::Matrix4x4 rotationMatrix = AZ::Matrix4x4::CreateIdentity();
-        auto skyBoxFeatureProcessorInterface = AZ::RPI::Scene::GetFeatureProcessorForEntity<AZ::Render::SkyBoxFeatureProcessorInterface>(m_iblEntityId);
-        skyBoxFeatureProcessorInterface->SetCubemapRotationMatrix(rotationMatrix);
+        auto skyBoxFeatureProcessor =
+            AZ::RPI::Scene::GetFeatureProcessorForEntity<AZ::Render::SkyBoxFeatureProcessorInterface>(m_environmentEntityId);
+        skyBoxFeatureProcessor->SetCubemapRotationMatrix(rotationMatrix);
 
         if (m_behavior)
         {
@@ -291,62 +259,42 @@ namespace MaterialEditor
         }
     }
 
-    void MaterialEditorViewportInputController::SetFieldOfView(float value)
+    void ViewportInputBehaviorController::SetFieldOfView(float value)
     {
         Camera::CameraRequestBus::Event(m_cameraEntityId, &Camera::CameraRequestBus::Events::SetFovDegrees, value);
     }
 
-    bool MaterialEditorViewportInputController::IsCameraCentered() const
+    bool ViewportInputBehaviorController::IsCameraCentered() const
     {
         return m_isCameraCentered;
     }
 
-    void MaterialEditorViewportInputController::CalculateExtents()
+    void ViewportInputBehaviorController::CalculateExtents()
     {
         AZ::TransformBus::EventResult(m_modelCenter, m_targetEntityId, &AZ::TransformBus::Events::GetLocalTranslation);
-
-        AZ::Data::AssetId modelAssetId;
-        AZ::Render::MeshComponentRequestBus::EventResult(modelAssetId, m_targetEntityId,
-            &AZ::Render::MeshComponentRequestBus::Events::GetModelAssetId);
-
-        if (modelAssetId.IsValid())
-        {
-            AZ::Data::Asset<AZ::RPI::ModelAsset> modelAsset = AZ::Data::AssetManager::Instance().GetAsset(modelAssetId, azrtti_typeid<AZ::RPI::ModelAsset>(), AZ::Data::AssetLoadBehavior::PreLoad);
-            modelAsset.BlockUntilLoadComplete();
-            if (modelAsset.IsReady())
-            {
-                const AZ::Aabb& aabb = modelAsset->GetAabb();
-                aabb.GetAsSphere(m_modelCenter, m_radius);
-
-                m_distanceMin = 0.5f * AZ::GetMin(AZ::GetMin(aabb.GetExtents().GetX(), aabb.GetExtents().GetY()), aabb.GetExtents().GetZ()) + DepthNear;
-                m_distanceMax = m_radius * MaxDistanceMultiplier;
-            }
-        }
+        m_targetBounds.GetAsSphere(m_modelCenter, m_radius);
+        m_distanceMin = m_targetBounds.GetExtents().GetMinElement() * 0.5f + DepthNear;
+        m_distanceMax = m_radius * MaxDistanceMultiplier;
     }
 
-    void MaterialEditorViewportInputController::EvaluateControlBehavior()
+    void ViewportInputBehaviorController::EvaluateControlBehavior()
     {
-        AZStd::shared_ptr<Behavior> nextBehavior;
         auto it = m_behaviorMap.find(m_keys);
-        if (it == m_behaviorMap.end())
+        AZStd::shared_ptr<ViewportInputBehavior> nextBehavior =
+            it != m_behaviorMap.end() ? it->second : AZStd::shared_ptr<ViewportInputBehavior>();
+        if (m_behavior != nextBehavior)
         {
-            nextBehavior = m_behaviorMap[None];
-        }
-        else
-        {
-            nextBehavior = it->second;
-        }
+            if (m_behavior)
+            {
+                m_behavior->End();
+            }
 
-        if (nextBehavior == m_behavior)
-        {
-            return;
-        }
+            m_behavior = nextBehavior;
 
-        if (m_behavior)
-        {
-            m_behavior->End();
+            if (m_behavior)
+            {
+                m_behavior->Start();
+            }
         }
-        m_behavior = nextBehavior;
-        m_behavior->Start();
     }
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake

@@ -88,4 +88,21 @@ set(FILES
     Source/PreviewRenderer/PreviewRendererCaptureState.h
     Source/PreviewRenderer/PreviewRendererSystemComponent.cpp
     Source/PreviewRenderer/PreviewRendererSystemComponent.h
+    Source/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorController.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorController.h
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorControllerInterface.h
+    Source/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehavior.h
+    Source/Viewport/ViewportInputBehaviorController/DollyCameraBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/DollyCameraBehavior.h
+    Source/Viewport/ViewportInputBehaviorController/MoveCameraBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/MoveCameraBehavior.h
+    Source/Viewport/ViewportInputBehaviorController/PanCameraBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/PanCameraBehavior.h
+    Source/Viewport/ViewportInputBehaviorController/OrbitCameraBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/OrbitCameraBehavior.h
+    Source/Viewport/ViewportInputBehaviorController/RotateEnvironmentBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateEnvironmentBehavior.h
+    Source/Viewport/ViewportInputBehaviorController/RotateModelBehavior.cpp
+    Include/AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateModelBehavior.h
 )

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/InputController/IdleBehavior.cpp

@@ -1,13 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <Viewport/InputController/IdleBehavior.h>
-
-namespace MaterialEditor
-{
-} // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/InputController/IdleBehavior.h

@@ -1,22 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <Viewport/InputController/Behavior.h>
-
-namespace MaterialEditor
-{
-    //! No action taken
-    class IdleBehavior final
-        : public Behavior
-    {
-    public:
-        IdleBehavior() = default;
-        virtual ~IdleBehavior() = default;
-    };
-} // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/InputController/RotateEnvironmentBehavior.cpp

@@ -1,51 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/Component/TransformBus.h>
-
-#include <Atom/Feature/SkyBox/SkyBoxFeatureProcessorInterface.h>
-#include <Atom/RPI.Public/RPISystemInterface.h>
-#include <Atom/RPI.Public/Scene.h>
-
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
-#include <Viewport/InputController/RotateEnvironmentBehavior.h>
-
-namespace MaterialEditor
-{
-    void RotateEnvironmentBehavior::Start()
-    {
-        Behavior::Start();
-
-        MaterialEditorViewportInputControllerRequestBus::BroadcastResult(
-            m_iblEntityId,
-            &MaterialEditorViewportInputControllerRequestBus::Handler::GetIblEntityId);
-        AZ_Assert(m_iblEntityId.IsValid(), "Failed to find m_iblEntityId");
-        m_skyBoxFeatureProcessorInterface = AZ::RPI::Scene::GetFeatureProcessorForEntity<AZ::Render::SkyBoxFeatureProcessorInterface>(m_iblEntityId);
-    }
-
-    void RotateEnvironmentBehavior::TickInternal(float x, float y, float z)
-    {
-        Behavior::TickInternal(x, y, z);
-
-        m_rotation += x;
-        AZ::Quaternion rotation = AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), m_rotation);
-        AZ::TransformBus::Event(m_iblEntityId, &AZ::TransformBus::Events::SetLocalRotationQuaternion, rotation);
-        const AZ::Matrix4x4 rotationMatrix = AZ::Matrix4x4::CreateFromQuaternion(rotation);
-        m_skyBoxFeatureProcessorInterface->SetCubemapRotationMatrix(rotationMatrix);
-    }
-
-    float RotateEnvironmentBehavior::GetSensitivityX()
-    {
-        return SensitivityX;
-    }
-
-    float RotateEnvironmentBehavior::GetSensitivityY()
-    {
-        return SensitivityY;
-    }
-} // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportComponent.cpp

@@ -394,7 +394,7 @@ namespace MaterialEditor
         return m_viewportSettings->m_displayMapperOperationType;
     }
 
-    inline void MaterialViewportComponent::OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset)
+    void MaterialViewportComponent::OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset)
     {
         if (AZ::Data::Asset<AZ::RPI::AnyAsset> anyAsset = asset)
         {

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportWidget.cpp

@@ -40,6 +40,12 @@
 #include <AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlBus.h>
 #include <AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlComponentConstants.h>
 #include <AtomLyIntegration/CommonFeatures/PostProcess/PostFxLayerComponentConstants.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/DollyCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/MoveCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/OrbitCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/PanCameraBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateEnvironmentBehavior.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/RotateModelBehavior.h>
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/Entity.h>
 #include <AzFramework/Components/NonUniformScaleComponent.h>
@@ -64,7 +70,6 @@ namespace MaterialEditor
         : AtomToolsFramework::RenderViewportWidget(parent)
         , m_ui(new Ui::MaterialViewportWidget)
         , m_toolId(toolId)
-        , m_viewportController(AZStd::make_shared<MaterialEditorViewportInputController>())
     {
         m_ui->setupUi(this);
 
@@ -117,31 +122,24 @@ namespace MaterialEditor
             entityContextId, &AzFramework::GameEntityContextRequestBus::Events::GetGameEntityContextId);
 
         // Configure camera
-        AzFramework::EntityContextRequestBus::EventResult(
-            m_cameraEntity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, "Cameraentity");
-        AZ_Assert(m_cameraEntity != nullptr, "Failed to create camera entity.");
+        m_cameraEntity =
+            CreateEntity("Cameraentity", { azrtti_typeid<AzFramework::TransformComponent>(), azrtti_typeid<AZ::Debug::CameraComponent>() });
 
-        // Add debug camera and controller components
         AZ::Debug::CameraComponentConfig cameraConfig(GetViewportContext()->GetWindowContext());
         cameraConfig.m_fovY = AZ::Constants::HalfPi;
         cameraConfig.m_depthNear = DepthNear;
-        m_cameraComponent = m_cameraEntity->CreateComponent(azrtti_typeid<AZ::Debug::CameraComponent>());
-        m_cameraComponent->SetConfiguration(cameraConfig);
-        m_cameraEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
+        m_cameraEntity->Deactivate();
+        m_cameraEntity->FindComponent(azrtti_typeid<AZ::Debug::CameraComponent>())->SetConfiguration(cameraConfig);
         m_cameraEntity->Activate();
 
         // Connect camera to pipeline's default view after camera entity activated
         m_renderPipeline->SetDefaultViewFromEntity(m_cameraEntity->GetId());
 
         // Configure tone mapper
-        AzFramework::EntityContextRequestBus::EventResult(
-            m_postProcessEntity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, "postProcessEntity");
-        AZ_Assert(m_postProcessEntity != nullptr, "Failed to create post process entity.");
-
-        m_postProcessEntity->CreateComponent(AZ::Render::PostFxLayerComponentTypeId);
-        m_postProcessEntity->CreateComponent(AZ::Render::ExposureControlComponentTypeId);
-        m_postProcessEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
-        m_postProcessEntity->Activate();
+        m_postProcessEntity = CreateEntity(
+            "PostProcessEntity",
+            { AZ::Render::PostFxLayerComponentTypeId, AZ::Render::ExposureControlComponentTypeId,
+              azrtti_typeid<AzFramework::TransformComponent>() });
 
         // Init directional light processor
         m_directionalLightFeatureProcessor = m_scene->GetFeatureProcessor<AZ::Render::DirectionalLightFeatureProcessorInterface>();
@@ -155,33 +153,19 @@ namespace MaterialEditor
         m_skyboxFeatureProcessor->SetSkyboxMode(AZ::Render::SkyBoxMode::Cubemap);
 
         // Create IBL
-        AzFramework::EntityContextRequestBus::EventResult(
-            m_iblEntity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, "IblEntity");
-        AZ_Assert(m_iblEntity != nullptr, "Failed to create ibl entity.");
-
-        m_iblEntity->CreateComponent(AZ::Render::ImageBasedLightComponentTypeId);
-        m_iblEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
-        m_iblEntity->Activate();
+        m_iblEntity =
+            CreateEntity("IblEntity", { AZ::Render::ImageBasedLightComponentTypeId, azrtti_typeid<AzFramework::TransformComponent>() });
 
         // Create model
-        AzFramework::EntityContextRequestBus::EventResult(
-            m_modelEntity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, "ViewportModel");
-        AZ_Assert(m_modelEntity != nullptr, "Failed to create model entity.");
-
-        m_modelEntity->CreateComponent(AZ::Render::MeshComponentTypeId);
-        m_modelEntity->CreateComponent(AZ::Render::MaterialComponentTypeId);
-        m_modelEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
-        m_modelEntity->Activate();
+        m_modelEntity = CreateEntity(
+            "ViewportModel",
+            { AZ::Render::MeshComponentTypeId, AZ::Render::MaterialComponentTypeId, azrtti_typeid<AzFramework::TransformComponent>() });
 
         // Create shadow catcher
-        AzFramework::EntityContextRequestBus::EventResult(
-            m_shadowCatcherEntity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, "ViewportShadowCatcher");
-        AZ_Assert(m_shadowCatcherEntity != nullptr, "Failed to create shadow catcher entity.");
-        m_shadowCatcherEntity->CreateComponent(AZ::Render::MeshComponentTypeId);
-        m_shadowCatcherEntity->CreateComponent(AZ::Render::MaterialComponentTypeId);
-        m_shadowCatcherEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
-        m_shadowCatcherEntity->CreateComponent(azrtti_typeid<AzFramework::NonUniformScaleComponent>());
-        m_shadowCatcherEntity->Activate();
+        m_shadowCatcherEntity = CreateEntity(
+            "ViewportShadowCatcher",
+            { AZ::Render::MeshComponentTypeId, AZ::Render::MaterialComponentTypeId, azrtti_typeid<AzFramework::TransformComponent>(),
+              azrtti_typeid<AzFramework::NonUniformScaleComponent>() });
 
         AZ::NonUniformScaleRequestBus::Event(
             m_shadowCatcherEntity->GetId(), &AZ::NonUniformScaleRequests::SetScale, AZ::Vector3{ 100, 100, 1.0 });
@@ -214,21 +198,19 @@ namespace MaterialEditor
         }
 
         // Create grid
-        AzFramework::EntityContextRequestBus::EventResult(
-            m_gridEntity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, "ViewportGrid");
-        AZ_Assert(m_gridEntity != nullptr, "Failed to create grid entity.");
+        m_gridEntity = CreateEntity("ViewportGrid", { AZ::Render::GridComponentTypeId, azrtti_typeid<AzFramework::TransformComponent>() });
 
         AZ::Render::GridComponentConfig gridConfig;
         gridConfig.m_gridSize = 4.0f;
         gridConfig.m_axisColor = AZ::Color(0.1f, 0.1f, 0.1f, 1.0f);
         gridConfig.m_primaryColor = AZ::Color(0.1f, 0.1f, 0.1f, 1.0f);
         gridConfig.m_secondaryColor = AZ::Color(0.1f, 0.1f, 0.1f, 1.0f);
-        auto gridComponent = m_gridEntity->CreateComponent(AZ::Render::GridComponentTypeId);
-        gridComponent->SetConfiguration(gridConfig);
-
-        m_gridEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
+        m_gridEntity->Deactivate();
+        m_gridEntity->FindComponent(AZ::Render::GridComponentTypeId)->SetConfiguration(gridConfig);
         m_gridEntity->Activate();
 
+        SetupInputController();
+
         OnDocumentOpened(AZ::Uuid::CreateNull());
 
         // Attempt to apply the default lighting preset
@@ -241,8 +223,6 @@ namespace MaterialEditor
         MaterialViewportRequestBus::BroadcastResult(modelPreset, &MaterialViewportRequestBus::Events::GetModelPresetSelection);
         OnModelPresetSelected(modelPreset);
 
-        m_viewportController->Init(m_cameraEntity->GetId(), m_modelEntity->GetId(), m_iblEntity->GetId());
-
         // Apply user settinngs restored since last run
         AZStd::intrusive_ptr<MaterialViewportSettings> viewportSettings =
             AZ::UserSettings::CreateFind<MaterialViewportSettings>(AZ::Crc32("MaterialViewportSettings"), AZ::UserSettings::CT_GLOBAL);
@@ -257,8 +237,6 @@ namespace MaterialEditor
         MaterialViewportNotificationBus::Handler::BusConnect();
         AZ::TickBus::Handler::BusConnect();
         AZ::TransformNotificationBus::MultiHandler::BusConnect(m_cameraEntity->GetId());
-
-        GetControllerList()->Add(m_viewportController);
     }
 
     MaterialViewportWidget::~MaterialViewportWidget()
@@ -269,33 +247,12 @@ namespace MaterialEditor
         MaterialViewportNotificationBus::Handler::BusDisconnect();
         AZ::Data::AssetBus::Handler::BusDisconnect();
 
-        AzFramework::EntityContextId entityContextId;
-        AzFramework::GameEntityContextRequestBus::BroadcastResult(
-            entityContextId, &AzFramework::GameEntityContextRequestBus::Events::GetGameEntityContextId);
-
-        AzFramework::EntityContextRequestBus::Event(
-            entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, m_iblEntity);
-        m_iblEntity = nullptr;
-
-        AzFramework::EntityContextRequestBus::Event(
-            entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, m_modelEntity);
-        m_modelEntity = nullptr;
-
-        AzFramework::EntityContextRequestBus::Event(
-            entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, m_shadowCatcherEntity);
-        m_shadowCatcherEntity = nullptr;
-
-        AzFramework::EntityContextRequestBus::Event(
-            entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, m_gridEntity);
-        m_gridEntity = nullptr;
-
-        AzFramework::EntityContextRequestBus::Event(
-            entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, m_cameraEntity);
-        m_cameraEntity = nullptr;
-
-        AzFramework::EntityContextRequestBus::Event(
-            entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, m_postProcessEntity);
-        m_postProcessEntity = nullptr;
+        DestroyEntity(m_iblEntity);
+        DestroyEntity(m_modelEntity);
+        DestroyEntity(m_shadowCatcherEntity);
+        DestroyEntity(m_gridEntity);
+        DestroyEntity(m_cameraEntity);
+        DestroyEntity(m_postProcessEntity);
 
         for (DirectionalLightHandle& handle : m_lightHandles)
         {
@@ -315,6 +272,74 @@ namespace MaterialEditor
         m_scene = nullptr;
     }
 
+    AZ::Entity* MaterialViewportWidget::CreateEntity(const AZStd::string& name, const AZStd::vector<AZ::Uuid>& componentTypeIds)
+    {
+        AzFramework::EntityContextId entityContextId;
+        AzFramework::GameEntityContextRequestBus::BroadcastResult(
+            entityContextId, &AzFramework::GameEntityContextRequestBus::Events::GetGameEntityContextId);
+
+        AZ::Entity* entity = {};
+        AzFramework::EntityContextRequestBus::EventResult(
+            entity, entityContextId, &AzFramework::EntityContextRequestBus::Events::CreateEntity, name.c_str());
+        AZ_Assert(entity != nullptr, "Failed to create post process entity: %s.", name.c_str());
+
+        if (entity)
+        {
+            for (const auto& componentTypeId : componentTypeIds)
+            {
+                entity->CreateComponent(componentTypeId);
+            }
+            entity->Activate();
+        }
+
+        return entity;
+    }
+
+    void MaterialViewportWidget::DestroyEntity(AZ::Entity*& entity)
+    {
+        AzFramework::EntityContextId entityContextId;
+        AzFramework::GameEntityContextRequestBus::BroadcastResult(
+            entityContextId, &AzFramework::GameEntityContextRequestBus::Events::GetGameEntityContextId);
+
+        AzFramework::EntityContextRequestBus::Event(entityContextId, &AzFramework::EntityContextRequestBus::Events::DestroyEntity, entity);
+        entity = nullptr;
+    }
+
+    void MaterialViewportWidget::SetupInputController()
+    {
+        using namespace AtomToolsFramework;
+
+        // Create viewport input controller and regioster its behaviors
+        m_viewportController.reset(
+            aznew ViewportInputBehaviorController(m_cameraEntity->GetId(), m_modelEntity->GetId(), m_iblEntity->GetId()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Lmb, AZStd::make_shared<PanCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Mmb, AZStd::make_shared<MoveCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Rmb, AZStd::make_shared<OrbitCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Alt ^ ViewportInputBehaviorController::Lmb,
+            AZStd::make_shared<OrbitCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Alt ^ ViewportInputBehaviorController::Mmb,
+            AZStd::make_shared<MoveCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Alt ^ ViewportInputBehaviorController::Rmb,
+            AZStd::make_shared<DollyCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Lmb ^ ViewportInputBehaviorController::Rmb,
+            AZStd::make_shared<DollyCameraBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Ctrl ^ ViewportInputBehaviorController::Lmb,
+            AZStd::make_shared<RotateModelBehavior>(m_viewportController.get()));
+        m_viewportController->AddBehavior(
+            ViewportInputBehaviorController::Shift ^ ViewportInputBehaviorController::Lmb,
+            AZStd::make_shared<RotateEnvironmentBehavior>(m_viewportController.get()));
+
+        GetControllerList()->Add(m_viewportController);
+    }
+
     void MaterialViewportWidget::OnDocumentOpened(const AZ::Uuid& documentId)
     {
         AZ::Data::Instance<AZ::RPI::Material> materialInstance;
@@ -436,8 +461,7 @@ namespace MaterialEditor
 
     void MaterialViewportWidget::OnFieldOfViewChanged(float fieldOfView)
     {
-        MaterialEditorViewportInputControllerRequestBus::Broadcast(
-            &MaterialEditorViewportInputControllerRequestBus::Handler::SetFieldOfView, fieldOfView);
+        m_viewportController->SetFieldOfView(fieldOfView);
     }
 
     void MaterialViewportWidget::OnDisplayMapperOperationTypeChanged(AZ::Render::DisplayMapperOperationType operationType)
@@ -451,7 +475,9 @@ namespace MaterialEditor
     {
         if (m_modelAssetId == asset.GetId())
         {
-            MaterialEditorViewportInputControllerRequestBus::Broadcast(&MaterialEditorViewportInputControllerRequestBus::Handler::Reset);
+            AZ::Data::Asset<AZ::RPI::ModelAsset> modelAsset = asset;
+            m_viewportController->SetTargetBounds(modelAsset->GetAabb());
+            m_viewportController->Reset();
             AZ::Data::AssetBus::Handler::BusDisconnect(asset.GetId());
         }
     }

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportWidget.h

@@ -15,9 +15,9 @@
 #include <AtomCore/Instance/Instance.h>
 #include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AtomToolsFramework/Viewport/RenderViewportWidget.h>
+#include <AtomToolsFramework/Viewport/ViewportInputBehaviorController/ViewportInputBehaviorController.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzFramework/Windowing/WindowBus.h>
-#include <Viewport/InputController/MaterialEditorViewportInputController.h>
 #include <Viewport/MaterialViewportNotificationBus.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
@@ -61,6 +61,10 @@ namespace MaterialEditor
         ~MaterialViewportWidget();
 
     private:
+        AZ::Entity* CreateEntity(const AZStd::string& name, const AZStd::vector<AZ::Uuid>& componentTypeIds);
+        void DestroyEntity(AZ::Entity*& entity);
+        void SetupInputController();
+
         // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler interface overrides...
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
 
@@ -96,8 +100,6 @@ namespace MaterialEditor
         AZ::Render::DisplayMapperFeatureProcessorInterface* m_displayMapperFeatureProcessor = {};
 
         AZ::Entity* m_cameraEntity = {};
-        AZ::Component* m_cameraComponent = {};
-
         AZ::Entity* m_postProcessEntity = {};
 
         AZ::Entity* m_modelEntity = {};
@@ -114,7 +116,7 @@ namespace MaterialEditor
         AZ::Entity* m_iblEntity = {};
         AZ::Render::SkyBoxFeatureProcessorInterface* m_skyboxFeatureProcessor = {};
 
-        AZStd::shared_ptr<MaterialEditorViewportInputController> m_viewportController;
+        AZStd::shared_ptr<AtomToolsFramework::ViewportInputBehaviorController> m_viewportController;
 
         QScopedPointer<Ui::MaterialViewportWidget> m_ui;
     };

Gems/Atom/Tools/MaterialEditor/Code/materialeditor_files.cmake

@@ -17,28 +17,9 @@ set(FILES
 
     Source/Viewport/MaterialViewportModule.h
     Source/Viewport/MaterialViewportModule.cpp
-    Source/Viewport/InputController/MaterialEditorViewportInputControllerBus.h
     Source/Viewport/MaterialViewportSettings.h
     Source/Viewport/MaterialViewportRequestBus.h
     Source/Viewport/MaterialViewportNotificationBus.h
-    Source/Viewport/InputController/MaterialEditorViewportInputController.cpp
-    Source/Viewport/InputController/MaterialEditorViewportInputController.h
-    Source/Viewport/InputController/Behavior.cpp
-    Source/Viewport/InputController/Behavior.h
-    Source/Viewport/InputController/DollyCameraBehavior.cpp
-    Source/Viewport/InputController/DollyCameraBehavior.h
-    Source/Viewport/InputController/IdleBehavior.cpp
-    Source/Viewport/InputController/IdleBehavior.h
-    Source/Viewport/InputController/MoveCameraBehavior.cpp
-    Source/Viewport/InputController/MoveCameraBehavior.h
-    Source/Viewport/InputController/PanCameraBehavior.cpp
-    Source/Viewport/InputController/PanCameraBehavior.h
-    Source/Viewport/InputController/OrbitCameraBehavior.cpp
-    Source/Viewport/InputController/OrbitCameraBehavior.h
-    Source/Viewport/InputController/RotateEnvironmentBehavior.cpp
-    Source/Viewport/InputController/RotateEnvironmentBehavior.h
-    Source/Viewport/InputController/RotateModelBehavior.cpp
-    Source/Viewport/InputController/RotateModelBehavior.h
     Source/Viewport/MaterialViewportSettings.cpp
     Source/Viewport/MaterialViewportComponent.cpp
     Source/Viewport/MaterialViewportComponent.h