From 125bcc1b473f98ffa87d858985486d25e1ac5e59 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 12:13:19 +0100 Subject: [PATCH 01/27] Provisional impl and testing of central state tracker. Signed-off-by: John --- .../ViewportEditorModeStateTrackerInterface.h | 42 ++ ...ortEditorModeStateTrackerNotificationBus.h | 65 +++ .../EditorInteractionInterface.h | 33 ++ .../ViewportEditorModeStateTracker.cpp | 121 +++++ .../ViewportEditorModeStateTracker.h | 62 +++ .../aztoolsframework_files.cmake | 4 + .../Viewport/ViewportEditorModeTests.cpp | 492 ++++++++++++++++++ .../Tests/aztoolsframeworktests_files.cmake | 1 + 8 files changed, 820 insertions(+) create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h create mode 100644 Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h new file mode 100644 index 0000000000..4f8b800215 --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h @@ -0,0 +1,42 @@ +/* + * 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 +#include + +namespace AzToolsFramework +{ + //! The AZ::Interface of the central editor mode state tracker for all viewports. + class ViewportEditorModeStateTrackerInterface + { + public: + AZ_RTTI(ViewportEditorModeStateTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); + + virtual ~ViewportEditorModeStateTrackerInterface() = default; + + //! Enters the specified editor mode for the specified viewport. + virtual void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + + //! Exits the specified editor mode for the specified viewport. + virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + + //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. + virtual const ViewportEditorModeStateInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + + //! Returns the number of viewports currently being tracked. + virtual size_t GetNumTrackedViewports() const = 0; + + //! Returns true if the specified viewport is being tracked, otherwise false. + virtual bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + + private: + }; +} // namespace AzToolsFramework + diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h new file mode 100644 index 0000000000..7b95ebc6cc --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h @@ -0,0 +1,65 @@ +/* + * 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 +#include +#include + +namespace AzToolsFramework +{ + //! Enumeration of each viewport editor state. + enum class ViewportEditorMode : AZ::u8 + { + Default, + Component, + Focus, + Pick + }; + + //! Viewport identifier and other relevant viewport data. + struct ViewportEditorModeInfo + { + using IdType = AzFramework::ViewportId; + IdType m_id = ViewportUi::DefaultViewportId; //!< The unique identifier for a given viewport. + }; + + //! Interface for the editor mode state of a given viewport. + class ViewportEditorModeStateInterface + { + public: + virtual ~ViewportEditorModeStateInterface() = default; + + //! Returns true if the specified editor mode is active, otherwise false. + virtual bool IsModeActive(ViewportEditorMode mode) const = 0; + }; + + //! Provides a bus to notify when the different editor modes are entered/exit. + class ViewportEditorModeNotifications + : public AZ::EBusTraits + { + public: + ////////////////////////////////////////////////////////////////////////// + // EBusTraits overrides + static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple; + static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById; + using BusIdType = ViewportEditorModeInfo::IdType; + ////////////////////////////////////////////////////////////////////////// + + //! Notifies subscribers of the a given viewport to the entering of the specified editor mode. + virtual void OnEditorModeEnter([[maybe_unused]] const ViewportEditorModeStateInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + { + } + + //! Notifies subscribers of the a given viewport to the exiting of the specified editor mode. + virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModeStateInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + { + } + }; + using ViewportEditorModeNotificationsBus = AZ::EBus; +} diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h new file mode 100644 index 0000000000..70cbfd09ec --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h @@ -0,0 +1,33 @@ +/* + * 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 +#include + +namespace AzToolsFramework +{ + /*! + * EditorInteractionInterface + * Allows systems to alter the behavior of viewport selection. + */ + class EditorInteractionInterface + { + public: + AZ_RTTI(EditorInteractionInterface, "{09276E3C-9AA6-40FF-A0B5-3D33A33F0E5A}"); + + /*! + * Allows the entity system to redirect the selection of an entity to another entity. + * It can be used to select a container when clicking on its content. + */ + virtual AZ::EntityId RedirectEntitySelection(AZ::EntityId entityId) = 0; + }; + +} // namespace AzToolsFramework + diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp new file mode 100644 index 0000000000..64e8c2bbd1 --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp @@ -0,0 +1,121 @@ +/* + * 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 +#include + +namespace AzToolsFramework +{ + static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; + + void ViewportEditorModeState::SetModeActive(ViewportEditorMode mode) + { + if (const AZ::u32 modeIndex = static_cast(mode); + modeIndex < NumEditorModes) + { + m_editorModes[modeIndex] = true; + } + else + { + AZ_Error(ViewportEditorModeLogWindow, false, "Cannot activate mode %u, mode is not recognized", modeIndex) + } + } + + void ViewportEditorModeState::SetModeInactive(ViewportEditorMode mode) + { + if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) + { + m_editorModes[modeIndex] = false; + } + else + { + AZ_Error(ViewportEditorModeLogWindow, false, "Cannot deactivate mode %u, mode is not recognized", modeIndex) + } + } + + bool ViewportEditorModeState::IsModeActive(ViewportEditorMode mode) const + { + return m_editorModes[static_cast(mode)]; + } + + void ViewportEditorModeStateTracker::RegisterInterface() + { + if (AZ::Interface::Get() == nullptr) + { + AZ::Interface::Register(this); + } + } + + void ViewportEditorModeStateTracker::UnregisterInterface() + { + if (AZ::Interface::Get() != nullptr) + { + AZ::Interface::Unregister(this); + } + } + + void ViewportEditorModeStateTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + { + auto& editorModeStates = m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; + AZ_Warning( + ViewportEditorModeLogWindow, !editorModeStates.IsModeActive(mode), + AZStd::string::format( + "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + editorModeStates.SetModeActive(mode); + ViewportEditorModeNotificationsBus::Event( + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModeStates, mode); + } + + void ViewportEditorModeStateTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + { + ViewportEditorModeState* editorModeStates = nullptr; + if (m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id)) + { + editorModeStates = &m_viewportEditorModeStates.at(viewportEditorModeInfo.m_id); + AZ_Warning( + ViewportEditorModeLogWindow, editorModeStates->IsModeActive(mode), + AZStd::string::format( + "Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + } + else + { + AZ_Warning( + ViewportEditorModeLogWindow, false, "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", + static_cast(mode), viewportEditorModeInfo.m_id); + + editorModeStates = &m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; + } + + editorModeStates->SetModeInactive(mode); + ViewportEditorModeNotificationsBus::Event( + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); + } + + const ViewportEditorModeStateInterface* ViewportEditorModeStateTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const + { + if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); + editorModeStates != m_viewportEditorModeStates.end()) + { + return &editorModeStates->second; + } + else + { + return nullptr; + } + } + + size_t ViewportEditorModeStateTracker::GetNumTrackedViewports() const + { + return m_viewportEditorModeStates.size(); + } + + bool ViewportEditorModeStateTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const + { + return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; + } +} // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h new file mode 100644 index 0000000000..30eabdf16e --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h @@ -0,0 +1,62 @@ +/* + * 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 +#include +#include +#include +#include + +namespace AzToolsFramework +{ + //! The encapsulation of the editor modes for a given viewport. + class ViewportEditorModeState + : public ViewportEditorModeStateInterface + { + public: + + //! The number of currently supported viewport editor modes. + static constexpr AZ::u8 NumEditorModes = 4; + + //! Sets the specified mode as active. + void SetModeActive(ViewportEditorMode mode); + + // Sets the specified mode as inactive. + void SetModeInactive(ViewportEditorMode mode); + + // ViewportEditorModeStateInterface ... + bool IsModeActive(ViewportEditorMode mode) const override; + private: + AZStd::array m_editorModes{}; //!< State flags to track active/inactive status of viewport editor modes. + }; + + //! The implementation of the central editor mode state tracker for all viewports. + class ViewportEditorModeStateTracker + : public ViewportEditorModeStateTrackerInterface + { + public: + //! Registers this object with the AZ::Interface. + void RegisterInterface(); + + //! Unregisters this object with the AZ::Interface. + void UnregisterInterface(); + + // ViewportEditorModeStateTrackerInterface ... + void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + const ViewportEditorModeStateInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + size_t GetNumTrackedViewports() const override; + bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + + private: + using ViewportEditorModeStates = AZStd::unordered_map; + ViewportEditorModeStates m_viewportEditorModeStates; //!< Editor mode state per viewport. + }; +} // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake b/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake index 2d9e75a115..9b7394a6e7 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake @@ -34,6 +34,7 @@ set(FILES API/EditorAnimationSystemRequestBus.h API/EditorEntityAPI.h API/EditorLevelNotificationBus.h + API/ViewportEditorModeStateTrackerNotificationBus.h API/EditorVegetationRequestsBus.h API/EditorPythonConsoleBus.h API/EditorPythonRunnerRequestsBus.h @@ -44,6 +45,7 @@ set(FILES API/EntityCompositionNotificationBus.h API/EditorViewportIconDisplayInterface.h API/ViewPaneOptions.h + API/ViewportEditorModeStateTrackerInterface.h Application/Ticker.h Application/Ticker.cpp Application/EditorEntityManager.cpp @@ -538,6 +540,8 @@ set(FILES ViewportSelection/EditorTransformComponentSelectionRequestBus.cpp ViewportSelection/EditorVisibleEntityDataCache.h ViewportSelection/EditorVisibleEntityDataCache.cpp + ViewportSelection/ViewportEditorModeStateTracker.cpp + ViewportSelection/ViewportEditorModeStateTracker.h ToolsFileUtils/ToolsFileUtils.h AssetBrowser/AssetBrowserBus.h AssetBrowser/AssetBrowserSourceDropBus.h diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp new file mode 100644 index 0000000000..7718c596d5 --- /dev/null +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -0,0 +1,492 @@ +/* + * 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 +#include +#include + +namespace UnitTest +{ + using ViewportEditorMode = AzToolsFramework::ViewportEditorMode; + using ViewportEditorModeState = AzToolsFramework::ViewportEditorModeState; + using ViewportEditorModeStateTracker = AzToolsFramework::ViewportEditorModeStateTracker; + using ViewportEditorModeInfo = AzToolsFramework::ViewportEditorModeInfo; + using ViewportId = ViewportEditorModeInfo::IdType; + using ViewportEditorModeStateInterface = AzToolsFramework::ViewportEditorModeStateInterface; + + void SetAllModesActive(ViewportEditorModeState& editorModeState) + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + editorModeState.SetModeActive(static_cast(mode)); + } + } + + void SetAllModesInactive(ViewportEditorModeState& editorModeState) + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + editorModeState.SetModeInactive(static_cast(mode)); + } + } + + // Fixture for testing editor mode states + class ViewportEditorModeStateTestsFixture + : public ::testing::Test + { + public: + ViewportEditorModeState m_editorModeState; + }; + + // Fixture for testing editor mode states with parameterized test arguments + class ViewportEditorModeStateTestsFixtureWithParams + : public ViewportEditorModeStateTestsFixture + , public ::testing::WithParamInterface + { + public: + void SetUp() override + { + m_selectedEditorMode = GetParam(); + } + + ViewportEditorMode m_selectedEditorMode; + }; + + // Fixture for testing the viewport editor mode state tracker + class ViewportEditorModeStateTrackerTestFixture + : public ToolsApplicationFixture + { + public: + ViewportEditorModeStateTracker m_viewportEditorModeStteTracker; + }; + + // Subscriber of viewport editor mode notifications for a single viewport that expects a single mode to be activated/deactivated + class ViewportEditorModeNotificationsBusHandler + : private AzToolsFramework::ViewportEditorModeNotificationsBus::Handler + { + public: + struct ReceivedEvents + { + bool m_onEnter = false; + bool m_onLeave = false; + }; + + using EditModeTracker = AZStd::unordered_map; + + ViewportEditorModeNotificationsBusHandler(ViewportId viewportId) + : m_viewportSubscription(viewportId) + { + AzToolsFramework::ViewportEditorModeNotificationsBus::Handler::BusConnect(m_viewportSubscription); + } + + ~ViewportEditorModeNotificationsBusHandler() + { + AzToolsFramework::ViewportEditorModeNotificationsBus::Handler::BusDisconnect(); + } + + ViewportId GetViewportSubscription() const + { + return m_viewportSubscription; + } + + const EditModeTracker& GetEditorModes() const + { + return m_editorModes; + } + + void OnEditorModeEnter([[maybe_unused]]const ViewportEditorModeStateInterface& editorModeState, ViewportEditorMode mode) override + { + m_editorModes[mode].m_onEnter = true; + } + + virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModeStateInterface& editorModeState, ViewportEditorMode mode) override + { + m_editorModes[mode].m_onLeave = true; + } + + private: + ViewportId m_viewportSubscription; + EditModeTracker m_editorModes; + + }; + + // Fixture for testing viewport editor mode notifications publishing + class ViewportEditorModePublisherTestFixture + : public ViewportEditorModeStateTrackerTestFixture + { + public: + + void SetUpEditorFixtureImpl() override + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + m_editorModeHandlers[mode] = AZStd::make_unique(mode); + } + } + + void TearDownEditorFixtureImpl() override + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + m_editorModeHandlers[mode].reset(); + } + } + + AZStd::array, ViewportEditorModeState::NumEditorModes> m_editorModeHandlers; + }; + + TEST_F(ViewportEditorModeStateTestsFixture, NumberOfEditorModesIsEqualTo4) + { + EXPECT_EQ(ViewportEditorModeState::NumEditorModes, 4); + } + + TEST_F(ViewportEditorModeStateTestsFixture, InitialEditorModeStateHasAllInactiveModes) + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + EXPECT_FALSE(m_editorModeState.IsModeActive(static_cast(mode))); + } + } + + TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) + { + m_editorModeState.SetModeActive(m_selectedEditorMode); + + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + const auto editorMode = static_cast(mode); + if (editorMode == m_selectedEditorMode) + { + EXPECT_TRUE(m_editorModeState.IsModeActive(static_cast(editorMode))); + } + else + { + EXPECT_FALSE(m_editorModeState.IsModeActive(static_cast(editorMode))); + } + } + } + + TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) + { + SetAllModesActive(m_editorModeState); + m_editorModeState.SetModeInactive(m_selectedEditorMode); + + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + const auto editorMode = static_cast(mode); + if (editorMode == m_selectedEditorMode) + { + EXPECT_FALSE(m_editorModeState.IsModeActive(editorMode)); + } + else + { + EXPECT_TRUE(m_editorModeState.IsModeActive(editorMode)); + } + } + } + + TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingMultipleModesActiveActivatesAllThoseModesNonMutuallyExclusively) + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes - 1; mode++) + { + // Given only the selected mode active + SetAllModesInactive(m_editorModeState); + m_editorModeState.SetModeActive(m_selectedEditorMode); + + const auto editorMode = static_cast(mode); + if (editorMode == m_selectedEditorMode) + { + continue; + } + + // When other modes are activated + m_editorModeState.SetModeActive(editorMode); + + for (auto expectedMode = 0; expectedMode < ViewportEditorModeState::NumEditorModes; expectedMode++) + { + const auto expectedEditorMode = static_cast(expectedMode); + if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode) + { + // Expect the activated modes to be active + EXPECT_TRUE(m_editorModeState.IsModeActive(expectedEditorMode)); + } + else + { + // Expect the modes not active to be inactive + EXPECT_FALSE(m_editorModeState.IsModeActive(expectedEditorMode)); + } + } + } + } + + TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingMultipleModesInactiveInactivatesAllThoseModesNonMutuallyExclusively) + { + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes - 1; mode++) + { + // Given only the selected mode inactive + SetAllModesActive(m_editorModeState); + m_editorModeState.SetModeInactive(m_selectedEditorMode); + + const auto editorMode = static_cast(mode); + if (editorMode == m_selectedEditorMode) + { + continue; + } + + // When other modes are deactivated + m_editorModeState.SetModeInactive(editorMode); + + for (auto expectedMode = 0; expectedMode < ViewportEditorModeState::NumEditorModes; expectedMode++) + { + const auto expectedEditorMode = static_cast(expectedMode); + if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode) + { + // Expect the deactivated modes to be inactive + EXPECT_FALSE(m_editorModeState.IsModeActive(expectedEditorMode)); + } + else + { + // Expects the modes not deactivated to still be active + EXPECT_TRUE(m_editorModeState.IsModeActive(expectedEditorMode)); + } + } + } + } + + INSTANTIATE_TEST_CASE_P( + AllEditorModes, + ViewportEditorModeStateTestsFixtureWithParams, + ::testing::Values( + AzToolsFramework::ViewportEditorMode::Default, + AzToolsFramework::ViewportEditorMode::Component, + AzToolsFramework::ViewportEditorMode::Focus, + AzToolsFramework::ViewportEditorMode::Pick)); + + TEST_F(ViewportEditorModeStateTestsFixture, SettingOutOfBoundsModeActiveIssuesErrorMsg) + { + UnitTest::TestRunner::Instance().StartAssertTests(); + m_editorModeState.SetModeActive(static_cast(ViewportEditorModeState::NumEditorModes)); + EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); + } + + TEST_F(ViewportEditorModeStateTestsFixture, SettingOutOfBoundsModeInactiveIssuesErrorMsg) + { + UnitTest::TestRunner::Instance().StartAssertTests(); + m_editorModeState.SetModeInactive(static_cast(ViewportEditorModeState::NumEditorModes)); + EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); + } + + TEST_F(ViewportEditorModeStateTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModeStates) + { + EXPECT_EQ(m_viewportEditorModeStteTracker.GetNumTrackedViewports(), 0); + } + + TEST_F(ViewportEditorModeStateTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModeStateForThatId) + { + // Given a viewport not currently being tracked + const ViewportId viewportid = 0; + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + + // When a mode is activated for that viewport + const auto editorMode = ViewportEditorMode::Default; + m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + + // Expect that viewport to now be tracked + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_NE(viewportEditorModeState, nullptr); + + // Expect the mode for that viewport to be active + EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); + } + + TEST_F(ViewportEditorModeStateTrackerTestFixture, ExitingViewportEditorModeForNonExistentIdCreatesViewportEditorModeStateForThatIdButIssuesErrorMsg) + { + // Given a viewport not currently being tracked + const ViewportId viewportid = 0; + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + + // When a mode is deactivated for that viewport + const auto editorMode = ViewportEditorMode::Default; + UnitTest::ErrorHandler errorHandler(AZStd::string::format( + "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", static_cast(editorMode), viewportid).c_str()); + m_viewportEditorModeStteTracker.ExitMode({ viewportid }, editorMode); + + // Expect a warning to be issued due to no precursor activation of that mode + EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); + + // Expect that viewport to now be tracked + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + + // Expect the mode for that viewport to be inactive + EXPECT_NE(viewportEditorModeState, nullptr); + EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); + } + + TEST_F(ViewportEditorModeStateTrackerTestFixture, GettingNonExistentViewportEditorModeStateForIdReturnsNull) + { + const ViewportId viewportid = 0; + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + } + + TEST_F(ViewportEditorModeStateTrackerTestFixture, EnteringViewportEditorModeStateForExistingIdInThatStateIssuesWarningMsg) + { + // Given a viewport not currently tracked + const ViewportId viewportid = 0; + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + + const auto editorMode = ViewportEditorMode::Default; + const auto expectedWarning = AZStd::string::format( + "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + + { + UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); + + // When the mode is activated for the viewport + m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); + + // Expect no warning to be issued as there is no duplicate activation + EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); + + // Expect the mode to be active for the viewport + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_NE(viewportEditorModeState, nullptr); + EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); + } + { + // When the mode is activated again for the viewport + UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); + m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); + + // Expect a warning to be issued for the duplicate activation + EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); + + // Expect the mode to still be active for the viewport + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_NE(viewportEditorModeState, nullptr); + EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); + } + } + + TEST_F(ViewportEditorModeStateTrackerTestFixture, ExitingViewportEditorModeStateForExistingIdNotInThatStateIssuesWarningMsg) + { + // Given a viewport not currently tracked + const ViewportId viewportid = 0; + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + + const auto editorMode = ViewportEditorMode::Default; + const auto expectedWarning = + AZStd::string::format("Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + + { + UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); + + // When the mode is activated and then deactivated for the viewport + m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeStteTracker.ExitMode({ viewportid }, editorMode); + + // Expect no warning to be issued as there is no duplicate deactivation + EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); + + // Expect the mode to be inctive for the viewport + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_NE(viewportEditorModeState, nullptr); + EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); + } + { + UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); + + // When the mode is deactivated again for the viewport + m_viewportEditorModeStteTracker.ExitMode({ viewportid }, editorMode); + + // Expect a warning to be issued for the duplicate deactivation + EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); + + // Expect the mode to still be inactive for the viewport + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_NE(viewportEditorModeState, nullptr); + EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); + } + } + + TEST_F( + ViewportEditorModePublisherTestFixture, + EnteringViewportEditorModeStateForExistingIdPublishesOnViewportEditorModeEnterEventForAllSubscribers) + { + // Given a set of subscribers tracking the editor modes for their exclusive viewport + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + // Expect each subscriber to have received no editor mode state changes + EXPECT_EQ(m_editorModeHandlers[mode]->GetEditorModes().size(), 0); + } + + // When each editor mode is activated by the state tracker for a specific viewport + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + const ViewportId viewportId = mode; + const ViewportEditorMode editorMode = static_cast(mode); + m_viewportEditorModeStteTracker.EnterMode({ mode }, editorMode); + } + + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + // Expect only the subscribers of each viewport to have received the editor mode activated event + const ViewportEditorMode editorMode = static_cast(mode); + const auto& editorModes = m_editorModeHandlers[mode]->GetEditorModes(); + EXPECT_EQ(editorModes.size(), 1); + EXPECT_EQ(editorModes.count(editorMode), 1); + const auto& expectedEditorModeSet = editorModes.find(editorMode); + EXPECT_NE(expectedEditorModeSet, editorModes.end()); + EXPECT_TRUE(expectedEditorModeSet->second.m_onEnter); + EXPECT_FALSE(expectedEditorModeSet->second.m_onLeave); + } + } + + TEST_F( + ViewportEditorModePublisherTestFixture, + ExitingViewportEditorModeStateForExistingIdPublishesOnViewportEditorModeExitEventForAllSubscribers) + { + // Given a set of subscribers tracking the editor modes for their exclusive viewport + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + EXPECT_EQ(m_editorModeHandlers[mode]->GetEditorModes().size(), 0); + } + + // When each editor mode is activated deactivated by the state tracker for a specific viewport + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + const ViewportId viewportId = mode; + const ViewportEditorMode editorMode = static_cast(mode); + m_viewportEditorModeStteTracker.EnterMode({ mode }, editorMode); + m_viewportEditorModeStteTracker.ExitMode({ mode }, editorMode); + } + + for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + { + // Expect only the subscribers of each viewport to have received the editor mode activated and deactivated event + const ViewportEditorMode editorMode = static_cast(mode); + const auto& editorModes = m_editorModeHandlers[mode]->GetEditorModes(); + EXPECT_EQ(editorModes.size(), 1); + EXPECT_EQ(editorModes.count(editorMode), 1); + const auto& expectedEditorModeSet = editorModes.find(editorMode); + EXPECT_NE(expectedEditorModeSet, editorModes.end()); + EXPECT_TRUE(expectedEditorModeSet->second.m_onEnter); + EXPECT_TRUE(expectedEditorModeSet->second.m_onLeave); + } + } +} diff --git a/Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake b/Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake index 5ff41d9e6c..764afce266 100644 --- a/Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake +++ b/Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake @@ -110,6 +110,7 @@ set(FILES UI/EntityPropertyEditorTests.cpp UndoStack.cpp Viewport/ClusterTests.cpp + Viewport/ViewportEditorModeTests.cpp Viewport/ViewportScreenTests.cpp Viewport/ViewportUiClusterTests.cpp Viewport/ViewportUiDisplayTests.cpp From 02425f85772fdc31a72834669b9695ec78e0b378 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 12:21:36 +0100 Subject: [PATCH 02/27] Add missing namespace comment. Signed-off-by: John --- .../AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 7718c596d5..cae7092a8a 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -489,4 +489,4 @@ namespace UnitTest EXPECT_TRUE(expectedEditorModeSet->second.m_onLeave); } } -} +} // namespace UnitTest From 199d857c8a447796176b959d3c5f5134ad74b1df Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 17:51:23 +0100 Subject: [PATCH 03/27] ViewportEditorModeState -> ViewportEditorModes Signed-off-by: John --- ... => ViewportEditorModesTrackerInterface.h} | 10 +- ...ewportEditorModesTrackerNotificationBus.h} | 8 +- ...ker.cpp => ViewportEditorModesTracker.cpp} | 34 +++--- ...Tracker.h => ViewportEditorModesTracker.h} | 22 ++-- .../aztoolsframework_files.cmake | 8 +- .../Viewport/ViewportEditorModeTests.cpp | 106 +++++++++--------- 6 files changed, 94 insertions(+), 94 deletions(-) rename Code/Framework/AzToolsFramework/AzToolsFramework/API/{ViewportEditorModeStateTrackerInterface.h => ViewportEditorModesTrackerInterface.h} (74%) rename Code/Framework/AzToolsFramework/AzToolsFramework/API/{ViewportEditorModeStateTrackerNotificationBus.h => ViewportEditorModesTrackerNotificationBus.h} (88%) rename Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/{ViewportEditorModeStateTracker.cpp => ViewportEditorModesTracker.cpp} (68%) rename Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/{ViewportEditorModeStateTracker.h => ViewportEditorModesTracker.h} (68%) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerInterface.h similarity index 74% rename from Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h rename to Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerInterface.h index 4f8b800215..b13085bc83 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerInterface.h @@ -9,17 +9,17 @@ #pragma once #include -#include +#include namespace AzToolsFramework { //! The AZ::Interface of the central editor mode state tracker for all viewports. - class ViewportEditorModeStateTrackerInterface + class ViewportEditorModesTrackerInterface { public: - AZ_RTTI(ViewportEditorModeStateTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); + AZ_RTTI(ViewportEditorModesTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); - virtual ~ViewportEditorModeStateTrackerInterface() = default; + virtual ~ViewportEditorModesTrackerInterface() = default; //! Enters the specified editor mode for the specified viewport. virtual void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; @@ -28,7 +28,7 @@ namespace AzToolsFramework virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. - virtual const ViewportEditorModeStateInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + virtual const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; //! Returns the number of viewports currently being tracked. virtual size_t GetNumTrackedViewports() const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerNotificationBus.h similarity index 88% rename from Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h rename to Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerNotificationBus.h index 7b95ebc6cc..b9b5c80f39 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerNotificationBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerNotificationBus.h @@ -30,10 +30,10 @@ namespace AzToolsFramework }; //! Interface for the editor mode state of a given viewport. - class ViewportEditorModeStateInterface + class ViewportEditorModesInterface { public: - virtual ~ViewportEditorModeStateInterface() = default; + virtual ~ViewportEditorModesInterface() = default; //! Returns true if the specified editor mode is active, otherwise false. virtual bool IsModeActive(ViewportEditorMode mode) const = 0; @@ -52,12 +52,12 @@ namespace AzToolsFramework ////////////////////////////////////////////////////////////////////////// //! Notifies subscribers of the a given viewport to the entering of the specified editor mode. - virtual void OnEditorModeEnter([[maybe_unused]] const ViewportEditorModeStateInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + virtual void OnEditorModeEnter([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) { } //! Notifies subscribers of the a given viewport to the exiting of the specified editor mode. - virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModeStateInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) { } }; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.cpp similarity index 68% rename from Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp rename to Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.cpp index 64e8c2bbd1..5e6f73f963 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.cpp @@ -6,14 +6,14 @@ * */ -#include -#include +#include +#include namespace AzToolsFramework { static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; - void ViewportEditorModeState::SetModeActive(ViewportEditorMode mode) + void ViewportEditorModes::SetModeActive(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) @@ -26,7 +26,7 @@ namespace AzToolsFramework } } - void ViewportEditorModeState::SetModeInactive(ViewportEditorMode mode) + void ViewportEditorModes::SetModeInactive(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) { @@ -38,28 +38,28 @@ namespace AzToolsFramework } } - bool ViewportEditorModeState::IsModeActive(ViewportEditorMode mode) const + bool ViewportEditorModes::IsModeActive(ViewportEditorMode mode) const { return m_editorModes[static_cast(mode)]; } - void ViewportEditorModeStateTracker::RegisterInterface() + void ViewportEditorModesTracker::RegisterInterface() { - if (AZ::Interface::Get() == nullptr) + if (AZ::Interface::Get() == nullptr) { - AZ::Interface::Register(this); + AZ::Interface::Register(this); } } - void ViewportEditorModeStateTracker::UnregisterInterface() + void ViewportEditorModesTracker::UnregisterInterface() { - if (AZ::Interface::Get() != nullptr) + if (AZ::Interface::Get() != nullptr) { - AZ::Interface::Unregister(this); + AZ::Interface::Unregister(this); } } - void ViewportEditorModeStateTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + void ViewportEditorModesTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { auto& editorModeStates = m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; AZ_Warning( @@ -71,9 +71,9 @@ namespace AzToolsFramework viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModeStates, mode); } - void ViewportEditorModeStateTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + void ViewportEditorModesTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { - ViewportEditorModeState* editorModeStates = nullptr; + ViewportEditorModes* editorModeStates = nullptr; if (m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id)) { editorModeStates = &m_viewportEditorModeStates.at(viewportEditorModeInfo.m_id); @@ -96,7 +96,7 @@ namespace AzToolsFramework viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); } - const ViewportEditorModeStateInterface* ViewportEditorModeStateTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const + const ViewportEditorModesInterface* ViewportEditorModesTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const { if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); editorModeStates != m_viewportEditorModeStates.end()) @@ -109,12 +109,12 @@ namespace AzToolsFramework } } - size_t ViewportEditorModeStateTracker::GetNumTrackedViewports() const + size_t ViewportEditorModesTracker::GetNumTrackedViewports() const { return m_viewportEditorModeStates.size(); } - bool ViewportEditorModeStateTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const + bool ViewportEditorModesTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const { return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.h similarity index 68% rename from Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h rename to Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.h index 30eabdf16e..4acd7f09b6 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.h @@ -11,14 +11,14 @@ #include #include #include -#include -#include +#include +#include namespace AzToolsFramework { //! The encapsulation of the editor modes for a given viewport. - class ViewportEditorModeState - : public ViewportEditorModeStateInterface + class ViewportEditorModes + : public ViewportEditorModesInterface { public: @@ -31,15 +31,15 @@ namespace AzToolsFramework // Sets the specified mode as inactive. void SetModeInactive(ViewportEditorMode mode); - // ViewportEditorModeStateInterface ... + // ViewportEditorModesInterface ... bool IsModeActive(ViewportEditorMode mode) const override; private: AZStd::array m_editorModes{}; //!< State flags to track active/inactive status of viewport editor modes. }; //! The implementation of the central editor mode state tracker for all viewports. - class ViewportEditorModeStateTracker - : public ViewportEditorModeStateTrackerInterface + class ViewportEditorModesTracker + : public ViewportEditorModesTrackerInterface { public: //! Registers this object with the AZ::Interface. @@ -48,15 +48,15 @@ namespace AzToolsFramework //! Unregisters this object with the AZ::Interface. void UnregisterInterface(); - // ViewportEditorModeStateTrackerInterface ... + // ViewportEditorModesTrackerInterface ... void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - const ViewportEditorModeStateInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetNumTrackedViewports() const override; bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; private: - using ViewportEditorModeStates = AZStd::unordered_map; - ViewportEditorModeStates m_viewportEditorModeStates; //!< Editor mode state per viewport. + using ViewportEditorModess = AZStd::unordered_map; + ViewportEditorModess m_viewportEditorModeStates; //!< Editor mode state per viewport. }; } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake b/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake index 9b7394a6e7..65bc4e6b50 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake @@ -34,7 +34,7 @@ set(FILES API/EditorAnimationSystemRequestBus.h API/EditorEntityAPI.h API/EditorLevelNotificationBus.h - API/ViewportEditorModeStateTrackerNotificationBus.h + API/ViewportEditorModesTrackerNotificationBus.h API/EditorVegetationRequestsBus.h API/EditorPythonConsoleBus.h API/EditorPythonRunnerRequestsBus.h @@ -45,7 +45,7 @@ set(FILES API/EntityCompositionNotificationBus.h API/EditorViewportIconDisplayInterface.h API/ViewPaneOptions.h - API/ViewportEditorModeStateTrackerInterface.h + API/ViewportEditorModesTrackerInterface.h Application/Ticker.h Application/Ticker.cpp Application/EditorEntityManager.cpp @@ -540,8 +540,8 @@ set(FILES ViewportSelection/EditorTransformComponentSelectionRequestBus.cpp ViewportSelection/EditorVisibleEntityDataCache.h ViewportSelection/EditorVisibleEntityDataCache.cpp - ViewportSelection/ViewportEditorModeStateTracker.cpp - ViewportSelection/ViewportEditorModeStateTracker.h + ViewportSelection/ViewportEditorModesTracker.cpp + ViewportSelection/ViewportEditorModesTracker.h ToolsFileUtils/ToolsFileUtils.h AssetBrowser/AssetBrowserBus.h AssetBrowser/AssetBrowserSourceDropBus.h diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index cae7092a8a..777fbe0585 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -8,44 +8,44 @@ #include #include -#include +#include namespace UnitTest { using ViewportEditorMode = AzToolsFramework::ViewportEditorMode; - using ViewportEditorModeState = AzToolsFramework::ViewportEditorModeState; - using ViewportEditorModeStateTracker = AzToolsFramework::ViewportEditorModeStateTracker; + using ViewportEditorModes = AzToolsFramework::ViewportEditorModes; + using ViewportEditorModesTracker = AzToolsFramework::ViewportEditorModesTracker; using ViewportEditorModeInfo = AzToolsFramework::ViewportEditorModeInfo; using ViewportId = ViewportEditorModeInfo::IdType; - using ViewportEditorModeStateInterface = AzToolsFramework::ViewportEditorModeStateInterface; + using ViewportEditorModesInterface = AzToolsFramework::ViewportEditorModesInterface; - void SetAllModesActive(ViewportEditorModeState& editorModeState) + void SetAllModesActive(ViewportEditorModes& editorModeState) { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { editorModeState.SetModeActive(static_cast(mode)); } } - void SetAllModesInactive(ViewportEditorModeState& editorModeState) + void SetAllModesInactive(ViewportEditorModes& editorModeState) { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { editorModeState.SetModeInactive(static_cast(mode)); } } // Fixture for testing editor mode states - class ViewportEditorModeStateTestsFixture + class ViewportEditorModesTestsFixture : public ::testing::Test { public: - ViewportEditorModeState m_editorModeState; + ViewportEditorModes m_editorModeState; }; // Fixture for testing editor mode states with parameterized test arguments - class ViewportEditorModeStateTestsFixtureWithParams - : public ViewportEditorModeStateTestsFixture + class ViewportEditorModesTestsFixtureWithParams + : public ViewportEditorModesTestsFixture , public ::testing::WithParamInterface { public: @@ -58,11 +58,11 @@ namespace UnitTest }; // Fixture for testing the viewport editor mode state tracker - class ViewportEditorModeStateTrackerTestFixture + class ViewportEditorModesTrackerTestFixture : public ToolsApplicationFixture { public: - ViewportEditorModeStateTracker m_viewportEditorModeStteTracker; + ViewportEditorModesTracker m_viewportEditorModeStteTracker; }; // Subscriber of viewport editor mode notifications for a single viewport that expects a single mode to be activated/deactivated @@ -99,12 +99,12 @@ namespace UnitTest return m_editorModes; } - void OnEditorModeEnter([[maybe_unused]]const ViewportEditorModeStateInterface& editorModeState, ViewportEditorMode mode) override + void OnEditorModeEnter([[maybe_unused]]const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onEnter = true; } - virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModeStateInterface& editorModeState, ViewportEditorMode mode) override + virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onLeave = true; } @@ -117,13 +117,13 @@ namespace UnitTest // Fixture for testing viewport editor mode notifications publishing class ViewportEditorModePublisherTestFixture - : public ViewportEditorModeStateTrackerTestFixture + : public ViewportEditorModesTrackerTestFixture { public: void SetUpEditorFixtureImpl() override { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { m_editorModeHandlers[mode] = AZStd::make_unique(mode); } @@ -131,33 +131,33 @@ namespace UnitTest void TearDownEditorFixtureImpl() override { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { m_editorModeHandlers[mode].reset(); } } - AZStd::array, ViewportEditorModeState::NumEditorModes> m_editorModeHandlers; + AZStd::array, ViewportEditorModes::NumEditorModes> m_editorModeHandlers; }; - TEST_F(ViewportEditorModeStateTestsFixture, NumberOfEditorModesIsEqualTo4) + TEST_F(ViewportEditorModesTestsFixture, NumberOfEditorModesIsEqualTo4) { - EXPECT_EQ(ViewportEditorModeState::NumEditorModes, 4); + EXPECT_EQ(ViewportEditorModes::NumEditorModes, 4); } - TEST_F(ViewportEditorModeStateTestsFixture, InitialEditorModeStateHasAllInactiveModes) + TEST_F(ViewportEditorModesTestsFixture, InitialEditorModeStateHasAllInactiveModes) { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { EXPECT_FALSE(m_editorModeState.IsModeActive(static_cast(mode))); } } - TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) + TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) { m_editorModeState.SetModeActive(m_selectedEditorMode); - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -171,12 +171,12 @@ namespace UnitTest } } - TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) + TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) { SetAllModesActive(m_editorModeState); m_editorModeState.SetModeInactive(m_selectedEditorMode); - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -190,9 +190,9 @@ namespace UnitTest } } - TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingMultipleModesActiveActivatesAllThoseModesNonMutuallyExclusively) + TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingMultipleModesActiveActivatesAllThoseModesNonMutuallyExclusively) { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes - 1; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes - 1; mode++) { // Given only the selected mode active SetAllModesInactive(m_editorModeState); @@ -207,7 +207,7 @@ namespace UnitTest // When other modes are activated m_editorModeState.SetModeActive(editorMode); - for (auto expectedMode = 0; expectedMode < ViewportEditorModeState::NumEditorModes; expectedMode++) + for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { const auto expectedEditorMode = static_cast(expectedMode); if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode) @@ -224,9 +224,9 @@ namespace UnitTest } } - TEST_P(ViewportEditorModeStateTestsFixtureWithParams, SettingMultipleModesInactiveInactivatesAllThoseModesNonMutuallyExclusively) + TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingMultipleModesInactiveInactivatesAllThoseModesNonMutuallyExclusively) { - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes - 1; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes - 1; mode++) { // Given only the selected mode inactive SetAllModesActive(m_editorModeState); @@ -241,7 +241,7 @@ namespace UnitTest // When other modes are deactivated m_editorModeState.SetModeInactive(editorMode); - for (auto expectedMode = 0; expectedMode < ViewportEditorModeState::NumEditorModes; expectedMode++) + for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { const auto expectedEditorMode = static_cast(expectedMode); if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode) @@ -260,33 +260,33 @@ namespace UnitTest INSTANTIATE_TEST_CASE_P( AllEditorModes, - ViewportEditorModeStateTestsFixtureWithParams, + ViewportEditorModesTestsFixtureWithParams, ::testing::Values( AzToolsFramework::ViewportEditorMode::Default, AzToolsFramework::ViewportEditorMode::Component, AzToolsFramework::ViewportEditorMode::Focus, AzToolsFramework::ViewportEditorMode::Pick)); - TEST_F(ViewportEditorModeStateTestsFixture, SettingOutOfBoundsModeActiveIssuesErrorMsg) + TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeActiveIssuesErrorMsg) { UnitTest::TestRunner::Instance().StartAssertTests(); - m_editorModeState.SetModeActive(static_cast(ViewportEditorModeState::NumEditorModes)); + m_editorModeState.SetModeActive(static_cast(ViewportEditorModes::NumEditorModes)); EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); } - TEST_F(ViewportEditorModeStateTestsFixture, SettingOutOfBoundsModeInactiveIssuesErrorMsg) + TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeInactiveIssuesErrorMsg) { UnitTest::TestRunner::Instance().StartAssertTests(); - m_editorModeState.SetModeInactive(static_cast(ViewportEditorModeState::NumEditorModes)); + m_editorModeState.SetModeInactive(static_cast(ViewportEditorModes::NumEditorModes)); EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); } - TEST_F(ViewportEditorModeStateTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModeStates) + TEST_F(ViewportEditorModesTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess) { EXPECT_EQ(m_viewportEditorModeStteTracker.GetNumTrackedViewports(), 0); } - TEST_F(ViewportEditorModeStateTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModeStateForThatId) + TEST_F(ViewportEditorModesTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -306,7 +306,7 @@ namespace UnitTest EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModeStateTrackerTestFixture, ExitingViewportEditorModeForNonExistentIdCreatesViewportEditorModeStateForThatIdButIssuesErrorMsg) + TEST_F(ViewportEditorModesTrackerTestFixture, ExitingViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButIssuesErrorMsg) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -331,14 +331,14 @@ namespace UnitTest EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModeStateTrackerTestFixture, GettingNonExistentViewportEditorModeStateForIdReturnsNull) + TEST_F(ViewportEditorModesTrackerTestFixture, GettingNonExistentViewportEditorModesForIdReturnsNull) { const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); } - TEST_F(ViewportEditorModeStateTrackerTestFixture, EnteringViewportEditorModeStateForExistingIdInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModesTrackerTestFixture, EnteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -380,7 +380,7 @@ namespace UnitTest } } - TEST_F(ViewportEditorModeStateTrackerTestFixture, ExitingViewportEditorModeStateForExistingIdNotInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModesTrackerTestFixture, ExitingViewportEditorModesForExistingIdNotInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -426,24 +426,24 @@ namespace UnitTest TEST_F( ViewportEditorModePublisherTestFixture, - EnteringViewportEditorModeStateForExistingIdPublishesOnViewportEditorModeEnterEventForAllSubscribers) + EnteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeEnterEventForAllSubscribers) { // Given a set of subscribers tracking the editor modes for their exclusive viewport - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { // Expect each subscriber to have received no editor mode state changes EXPECT_EQ(m_editorModeHandlers[mode]->GetEditorModes().size(), 0); } // When each editor mode is activated by the state tracker for a specific viewport - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); m_viewportEditorModeStteTracker.EnterMode({ mode }, editorMode); } - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { // Expect only the subscribers of each viewport to have received the editor mode activated event const ViewportEditorMode editorMode = static_cast(mode); @@ -459,16 +459,16 @@ namespace UnitTest TEST_F( ViewportEditorModePublisherTestFixture, - ExitingViewportEditorModeStateForExistingIdPublishesOnViewportEditorModeExitEventForAllSubscribers) + ExitingViewportEditorModesForExistingIdPublishesOnViewportEditorModeExitEventForAllSubscribers) { // Given a set of subscribers tracking the editor modes for their exclusive viewport - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { EXPECT_EQ(m_editorModeHandlers[mode]->GetEditorModes().size(), 0); } // When each editor mode is activated deactivated by the state tracker for a specific viewport - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); @@ -476,7 +476,7 @@ namespace UnitTest m_viewportEditorModeStteTracker.ExitMode({ mode }, editorMode); } - for (auto mode = 0; mode < ViewportEditorModeState::NumEditorModes; mode++) + for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { // Expect only the subscribers of each viewport to have received the editor mode activated and deactivated event const ViewportEditorMode editorMode = static_cast(mode); From 9553f4cc0f3d66578b85bc64d9dd12dfd541f51d Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 18:56:41 +0100 Subject: [PATCH 04/27] ViewportEditorModesTracker -> ViewportEditorModeTracker Signed-off-by: John --- ...ViewportEditorModeStateTrackerInterface.h} | 8 +- .../API/ViewportEditorModeTrackerInterface.h | 42 ++++++ ...iewportEditorModeTrackerNotificationBus.h} | 0 ...cpp => ViewportEditorModeStateTracker.cpp} | 26 ++-- ...ker.h => ViewportEditorModeStateTracker.h} | 10 +- .../ViewportEditorModeTracker.cpp | 121 ++++++++++++++++++ .../ViewportEditorModeTracker.h | 62 +++++++++ .../aztoolsframework_files.cmake | 8 +- .../Viewport/ViewportEditorModeTests.cpp | 22 ++-- 9 files changed, 262 insertions(+), 37 deletions(-) rename Code/Framework/AzToolsFramework/AzToolsFramework/API/{ViewportEditorModesTrackerInterface.h => ViewportEditorModeStateTrackerInterface.h} (83%) create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h rename Code/Framework/AzToolsFramework/AzToolsFramework/API/{ViewportEditorModesTrackerNotificationBus.h => ViewportEditorModeTrackerNotificationBus.h} (100%) rename Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/{ViewportEditorModesTracker.cpp => ViewportEditorModeStateTracker.cpp} (76%) rename Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/{ViewportEditorModesTracker.h => ViewportEditorModeStateTracker.h} (88%) create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp create mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h similarity index 83% rename from Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerInterface.h rename to Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h index b13085bc83..09a39b1ec1 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h @@ -9,17 +9,17 @@ #pragma once #include -#include +#include namespace AzToolsFramework { //! The AZ::Interface of the central editor mode state tracker for all viewports. - class ViewportEditorModesTrackerInterface + class ViewportEditorModeTrackerInterface { public: - AZ_RTTI(ViewportEditorModesTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); + AZ_RTTI(ViewportEditorModeTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); - virtual ~ViewportEditorModesTrackerInterface() = default; + virtual ~ViewportEditorModeTrackerInterface() = default; //! Enters the specified editor mode for the specified viewport. virtual void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h new file mode 100644 index 0000000000..09a39b1ec1 --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -0,0 +1,42 @@ +/* + * 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 +#include + +namespace AzToolsFramework +{ + //! The AZ::Interface of the central editor mode state tracker for all viewports. + class ViewportEditorModeTrackerInterface + { + public: + AZ_RTTI(ViewportEditorModeTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); + + virtual ~ViewportEditorModeTrackerInterface() = default; + + //! Enters the specified editor mode for the specified viewport. + virtual void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + + //! Exits the specified editor mode for the specified viewport. + virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + + //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. + virtual const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + + //! Returns the number of viewports currently being tracked. + virtual size_t GetNumTrackedViewports() const = 0; + + //! Returns true if the specified viewport is being tracked, otherwise false. + virtual bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + + private: + }; +} // namespace AzToolsFramework + diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h similarity index 100% rename from Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModesTrackerNotificationBus.h rename to Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp similarity index 76% rename from Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.cpp rename to Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp index 5e6f73f963..5c9104ab18 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp @@ -6,8 +6,8 @@ * */ -#include -#include +#include +#include namespace AzToolsFramework { @@ -43,23 +43,23 @@ namespace AzToolsFramework return m_editorModes[static_cast(mode)]; } - void ViewportEditorModesTracker::RegisterInterface() + void ViewportEditorModeTracker::RegisterInterface() { - if (AZ::Interface::Get() == nullptr) + if (AZ::Interface::Get() == nullptr) { - AZ::Interface::Register(this); + AZ::Interface::Register(this); } } - void ViewportEditorModesTracker::UnregisterInterface() + void ViewportEditorModeTracker::UnregisterInterface() { - if (AZ::Interface::Get() != nullptr) + if (AZ::Interface::Get() != nullptr) { - AZ::Interface::Unregister(this); + AZ::Interface::Unregister(this); } } - void ViewportEditorModesTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + void ViewportEditorModeTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { auto& editorModeStates = m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; AZ_Warning( @@ -71,7 +71,7 @@ namespace AzToolsFramework viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModeStates, mode); } - void ViewportEditorModesTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + void ViewportEditorModeTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { ViewportEditorModes* editorModeStates = nullptr; if (m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id)) @@ -96,7 +96,7 @@ namespace AzToolsFramework viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); } - const ViewportEditorModesInterface* ViewportEditorModesTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const + const ViewportEditorModesInterface* ViewportEditorModeTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const { if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); editorModeStates != m_viewportEditorModeStates.end()) @@ -109,12 +109,12 @@ namespace AzToolsFramework } } - size_t ViewportEditorModesTracker::GetNumTrackedViewports() const + size_t ViewportEditorModeTracker::GetNumTrackedViewports() const { return m_viewportEditorModeStates.size(); } - bool ViewportEditorModesTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const + bool ViewportEditorModeTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const { return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h similarity index 88% rename from Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.h rename to Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h index 4acd7f09b6..23c02dbcdf 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModesTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h @@ -11,8 +11,8 @@ #include #include #include -#include -#include +#include +#include namespace AzToolsFramework { @@ -38,8 +38,8 @@ namespace AzToolsFramework }; //! The implementation of the central editor mode state tracker for all viewports. - class ViewportEditorModesTracker - : public ViewportEditorModesTrackerInterface + class ViewportEditorModeTracker + : public ViewportEditorModeTrackerInterface { public: //! Registers this object with the AZ::Interface. @@ -48,7 +48,7 @@ namespace AzToolsFramework //! Unregisters this object with the AZ::Interface. void UnregisterInterface(); - // ViewportEditorModesTrackerInterface ... + // ViewportEditorModeTrackerInterface ... void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp new file mode 100644 index 0000000000..5c9104ab18 --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -0,0 +1,121 @@ +/* + * 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 +#include + +namespace AzToolsFramework +{ + static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; + + void ViewportEditorModes::SetModeActive(ViewportEditorMode mode) + { + if (const AZ::u32 modeIndex = static_cast(mode); + modeIndex < NumEditorModes) + { + m_editorModes[modeIndex] = true; + } + else + { + AZ_Error(ViewportEditorModeLogWindow, false, "Cannot activate mode %u, mode is not recognized", modeIndex) + } + } + + void ViewportEditorModes::SetModeInactive(ViewportEditorMode mode) + { + if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) + { + m_editorModes[modeIndex] = false; + } + else + { + AZ_Error(ViewportEditorModeLogWindow, false, "Cannot deactivate mode %u, mode is not recognized", modeIndex) + } + } + + bool ViewportEditorModes::IsModeActive(ViewportEditorMode mode) const + { + return m_editorModes[static_cast(mode)]; + } + + void ViewportEditorModeTracker::RegisterInterface() + { + if (AZ::Interface::Get() == nullptr) + { + AZ::Interface::Register(this); + } + } + + void ViewportEditorModeTracker::UnregisterInterface() + { + if (AZ::Interface::Get() != nullptr) + { + AZ::Interface::Unregister(this); + } + } + + void ViewportEditorModeTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + { + auto& editorModeStates = m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; + AZ_Warning( + ViewportEditorModeLogWindow, !editorModeStates.IsModeActive(mode), + AZStd::string::format( + "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + editorModeStates.SetModeActive(mode); + ViewportEditorModeNotificationsBus::Event( + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModeStates, mode); + } + + void ViewportEditorModeTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + { + ViewportEditorModes* editorModeStates = nullptr; + if (m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id)) + { + editorModeStates = &m_viewportEditorModeStates.at(viewportEditorModeInfo.m_id); + AZ_Warning( + ViewportEditorModeLogWindow, editorModeStates->IsModeActive(mode), + AZStd::string::format( + "Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + } + else + { + AZ_Warning( + ViewportEditorModeLogWindow, false, "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", + static_cast(mode), viewportEditorModeInfo.m_id); + + editorModeStates = &m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; + } + + editorModeStates->SetModeInactive(mode); + ViewportEditorModeNotificationsBus::Event( + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); + } + + const ViewportEditorModesInterface* ViewportEditorModeTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const + { + if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); + editorModeStates != m_viewportEditorModeStates.end()) + { + return &editorModeStates->second; + } + else + { + return nullptr; + } + } + + size_t ViewportEditorModeTracker::GetNumTrackedViewports() const + { + return m_viewportEditorModeStates.size(); + } + + bool ViewportEditorModeTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const + { + return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; + } +} // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h new file mode 100644 index 0000000000..23c02dbcdf --- /dev/null +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -0,0 +1,62 @@ +/* + * 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 +#include +#include +#include +#include + +namespace AzToolsFramework +{ + //! The encapsulation of the editor modes for a given viewport. + class ViewportEditorModes + : public ViewportEditorModesInterface + { + public: + + //! The number of currently supported viewport editor modes. + static constexpr AZ::u8 NumEditorModes = 4; + + //! Sets the specified mode as active. + void SetModeActive(ViewportEditorMode mode); + + // Sets the specified mode as inactive. + void SetModeInactive(ViewportEditorMode mode); + + // ViewportEditorModesInterface ... + bool IsModeActive(ViewportEditorMode mode) const override; + private: + AZStd::array m_editorModes{}; //!< State flags to track active/inactive status of viewport editor modes. + }; + + //! The implementation of the central editor mode state tracker for all viewports. + class ViewportEditorModeTracker + : public ViewportEditorModeTrackerInterface + { + public: + //! Registers this object with the AZ::Interface. + void RegisterInterface(); + + //! Unregisters this object with the AZ::Interface. + void UnregisterInterface(); + + // ViewportEditorModeTrackerInterface ... + void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + size_t GetNumTrackedViewports() const override; + bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + + private: + using ViewportEditorModess = AZStd::unordered_map; + ViewportEditorModess m_viewportEditorModeStates; //!< Editor mode state per viewport. + }; +} // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake b/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake index 65bc4e6b50..3932190d8e 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake @@ -34,7 +34,7 @@ set(FILES API/EditorAnimationSystemRequestBus.h API/EditorEntityAPI.h API/EditorLevelNotificationBus.h - API/ViewportEditorModesTrackerNotificationBus.h + API/ViewportEditorModeTrackerNotificationBus.h API/EditorVegetationRequestsBus.h API/EditorPythonConsoleBus.h API/EditorPythonRunnerRequestsBus.h @@ -45,7 +45,7 @@ set(FILES API/EntityCompositionNotificationBus.h API/EditorViewportIconDisplayInterface.h API/ViewPaneOptions.h - API/ViewportEditorModesTrackerInterface.h + API/ViewportEditorModeTrackerInterface.h Application/Ticker.h Application/Ticker.cpp Application/EditorEntityManager.cpp @@ -540,8 +540,8 @@ set(FILES ViewportSelection/EditorTransformComponentSelectionRequestBus.cpp ViewportSelection/EditorVisibleEntityDataCache.h ViewportSelection/EditorVisibleEntityDataCache.cpp - ViewportSelection/ViewportEditorModesTracker.cpp - ViewportSelection/ViewportEditorModesTracker.h + ViewportSelection/ViewportEditorModeTracker.cpp + ViewportSelection/ViewportEditorModeTracker.h ToolsFileUtils/ToolsFileUtils.h AssetBrowser/AssetBrowserBus.h AssetBrowser/AssetBrowserSourceDropBus.h diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 777fbe0585..63f975acdc 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -8,13 +8,13 @@ #include #include -#include +#include namespace UnitTest { using ViewportEditorMode = AzToolsFramework::ViewportEditorMode; using ViewportEditorModes = AzToolsFramework::ViewportEditorModes; - using ViewportEditorModesTracker = AzToolsFramework::ViewportEditorModesTracker; + using ViewportEditorModeTracker = AzToolsFramework::ViewportEditorModeTracker; using ViewportEditorModeInfo = AzToolsFramework::ViewportEditorModeInfo; using ViewportId = ViewportEditorModeInfo::IdType; using ViewportEditorModesInterface = AzToolsFramework::ViewportEditorModesInterface; @@ -58,11 +58,11 @@ namespace UnitTest }; // Fixture for testing the viewport editor mode state tracker - class ViewportEditorModesTrackerTestFixture + class ViewportEditorModeTrackerTestFixture : public ToolsApplicationFixture { public: - ViewportEditorModesTracker m_viewportEditorModeStteTracker; + ViewportEditorModeTracker m_viewportEditorModeStteTracker; }; // Subscriber of viewport editor mode notifications for a single viewport that expects a single mode to be activated/deactivated @@ -117,7 +117,7 @@ namespace UnitTest // Fixture for testing viewport editor mode notifications publishing class ViewportEditorModePublisherTestFixture - : public ViewportEditorModesTrackerTestFixture + : public ViewportEditorModeTrackerTestFixture { public: @@ -281,12 +281,12 @@ namespace UnitTest EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); } - TEST_F(ViewportEditorModesTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess) + TEST_F(ViewportEditorModeTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess) { EXPECT_EQ(m_viewportEditorModeStteTracker.GetNumTrackedViewports(), 0); } - TEST_F(ViewportEditorModesTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) + TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -306,7 +306,7 @@ namespace UnitTest EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModesTrackerTestFixture, ExitingViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButIssuesErrorMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, ExitingViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButIssuesErrorMsg) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -331,14 +331,14 @@ namespace UnitTest EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModesTrackerTestFixture, GettingNonExistentViewportEditorModesForIdReturnsNull) + TEST_F(ViewportEditorModeTrackerTestFixture, GettingNonExistentViewportEditorModesForIdReturnsNull) { const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); } - TEST_F(ViewportEditorModesTrackerTestFixture, EnteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -380,7 +380,7 @@ namespace UnitTest } } - TEST_F(ViewportEditorModesTrackerTestFixture, ExitingViewportEditorModesForExistingIdNotInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, ExitingViewportEditorModesForExistingIdNotInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; From 35a228b08f988bc219a67fc78f63253e69a65984 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 18:57:36 +0100 Subject: [PATCH 05/27] GetEditorModeState ->GetViewportEditorModes Signed-off-by: John --- .../ViewportEditorModeStateTrackerInterface.h | 2 +- .../API/ViewportEditorModeTrackerInterface.h | 2 +- .../ViewportEditorModeStateTracker.cpp | 2 +- .../ViewportEditorModeStateTracker.h | 2 +- .../ViewportEditorModeTracker.cpp | 2 +- .../ViewportEditorModeTracker.h | 2 +- .../Viewport/ViewportEditorModeTests.cpp | 22 +++++++++---------- 7 files changed, 17 insertions(+), 17 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h index 09a39b1ec1..706fd98c5e 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h @@ -28,7 +28,7 @@ namespace AzToolsFramework virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. - virtual const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; //! Returns the number of viewports currently being tracked. virtual size_t GetNumTrackedViewports() const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index 09a39b1ec1..706fd98c5e 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -28,7 +28,7 @@ namespace AzToolsFramework virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. - virtual const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; //! Returns the number of viewports currently being tracked. virtual size_t GetNumTrackedViewports() const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp index 5c9104ab18..e78f564c9d 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp @@ -96,7 +96,7 @@ namespace AzToolsFramework viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); } - const ViewportEditorModesInterface* ViewportEditorModeTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const + const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const { if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); editorModeStates != m_viewportEditorModeStates.end()) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h index 23c02dbcdf..be090e6f1f 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h @@ -51,7 +51,7 @@ namespace AzToolsFramework // ViewportEditorModeTrackerInterface ... void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetNumTrackedViewports() const override; bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 5c9104ab18..e78f564c9d 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -96,7 +96,7 @@ namespace AzToolsFramework viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); } - const ViewportEditorModesInterface* ViewportEditorModeTracker::GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const + const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const { if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); editorModeStates != m_viewportEditorModeStates.end()) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index 23c02dbcdf..be090e6f1f 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -51,7 +51,7 @@ namespace AzToolsFramework // ViewportEditorModeTrackerInterface ... void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - const ViewportEditorModesInterface* GetEditorModeState(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetNumTrackedViewports() const override; bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 63f975acdc..d59e017579 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -291,12 +291,12 @@ namespace UnitTest // Given a viewport not currently being tracked const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); // When a mode is activated for that viewport const auto editorMode = ViewportEditorMode::Default; m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); // Expect that viewport to now be tracked EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); @@ -311,7 +311,7 @@ namespace UnitTest // Given a viewport not currently being tracked const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); // When a mode is deactivated for that viewport const auto editorMode = ViewportEditorMode::Default; @@ -323,7 +323,7 @@ namespace UnitTest EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); // Expect that viewport to now be tracked - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); // Expect the mode for that viewport to be inactive @@ -335,7 +335,7 @@ namespace UnitTest { const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); } TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) @@ -343,7 +343,7 @@ namespace UnitTest // Given a viewport not currently tracked const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; const auto expectedWarning = AZStd::string::format( @@ -359,7 +359,7 @@ namespace UnitTest EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); // Expect the mode to be active for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); @@ -373,7 +373,7 @@ namespace UnitTest EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); // Expect the mode to still be active for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); @@ -385,7 +385,7 @@ namespace UnitTest // Given a viewport not currently tracked const ViewportId viewportid = 0; EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }), nullptr); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; const auto expectedWarning = @@ -402,7 +402,7 @@ namespace UnitTest EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); // Expect the mode to be inctive for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); @@ -417,7 +417,7 @@ namespace UnitTest EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); // Expect the mode to still be inactive for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetEditorModeState({ viewportid }); + const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); From 3b47d9c5a659972759b3147ab38e313489ba14a9 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 19:15:18 +0100 Subject: [PATCH 06/27] GetNumTrackedViewports -> GetTrackedViewportCount Signed-off-by: John --- .../API/ViewportEditorModeStateTrackerInterface.h | 2 +- .../AzToolsFramework/API/ViewportEditorModeTrackerInterface.h | 2 +- .../ViewportSelection/ViewportEditorModeStateTracker.cpp | 2 +- .../ViewportSelection/ViewportEditorModeStateTracker.h | 2 +- .../ViewportSelection/ViewportEditorModeTracker.cpp | 2 +- .../ViewportSelection/ViewportEditorModeTracker.h | 2 +- .../AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h index 706fd98c5e..7d51dd64a1 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h @@ -31,7 +31,7 @@ namespace AzToolsFramework virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; //! Returns the number of viewports currently being tracked. - virtual size_t GetNumTrackedViewports() const = 0; + virtual size_t GetTrackedViewportCount() const = 0; //! Returns true if the specified viewport is being tracked, otherwise false. virtual bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index 706fd98c5e..7d51dd64a1 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -31,7 +31,7 @@ namespace AzToolsFramework virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; //! Returns the number of viewports currently being tracked. - virtual size_t GetNumTrackedViewports() const = 0; + virtual size_t GetTrackedViewportCount() const = 0; //! Returns true if the specified viewport is being tracked, otherwise false. virtual bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp index e78f564c9d..3d88d7d93e 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp @@ -109,7 +109,7 @@ namespace AzToolsFramework } } - size_t ViewportEditorModeTracker::GetNumTrackedViewports() const + size_t ViewportEditorModeTracker::GetTrackedViewportCount() const { return m_viewportEditorModeStates.size(); } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h index be090e6f1f..12a64cbbf9 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h @@ -52,7 +52,7 @@ namespace AzToolsFramework void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; - size_t GetNumTrackedViewports() const override; + size_t GetTrackedViewportCount() const override; bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; private: diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index e78f564c9d..3d88d7d93e 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -109,7 +109,7 @@ namespace AzToolsFramework } } - size_t ViewportEditorModeTracker::GetNumTrackedViewports() const + size_t ViewportEditorModeTracker::GetTrackedViewportCount() const { return m_viewportEditorModeStates.size(); } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index be090e6f1f..12a64cbbf9 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -52,7 +52,7 @@ namespace AzToolsFramework void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; - size_t GetNumTrackedViewports() const override; + size_t GetTrackedViewportCount() const override; bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; private: diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index d59e017579..8e9b1ba59b 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -283,7 +283,7 @@ namespace UnitTest TEST_F(ViewportEditorModeTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess) { - EXPECT_EQ(m_viewportEditorModeStteTracker.GetNumTrackedViewports(), 0); + EXPECT_EQ(m_viewportEditorModeStteTracker.GetTrackedViewportCount(), 0); } TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) From 7960c68b487622f0e99ed8f0f7d72699276d85b5 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 19:16:22 +0100 Subject: [PATCH 07/27] IsViewportStateBeingTracked -> IsViewportModeTracked Signed-off-by: John --- .../ViewportEditorModeStateTrackerInterface.h | 2 +- .../API/ViewportEditorModeTrackerInterface.h | 2 +- .../ViewportEditorModeStateTracker.cpp | 2 +- .../ViewportEditorModeStateTracker.h | 2 +- .../ViewportEditorModeTracker.cpp | 2 +- .../ViewportEditorModeTracker.h | 2 +- .../Viewport/ViewportEditorModeTests.cpp | 22 +++++++++---------- 7 files changed, 17 insertions(+), 17 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h index 7d51dd64a1..53b0729bac 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h @@ -34,7 +34,7 @@ namespace AzToolsFramework virtual size_t GetTrackedViewportCount() const = 0; //! Returns true if the specified viewport is being tracked, otherwise false. - virtual bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + virtual bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; private: }; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index 7d51dd64a1..53b0729bac 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -34,7 +34,7 @@ namespace AzToolsFramework virtual size_t GetTrackedViewportCount() const = 0; //! Returns true if the specified viewport is being tracked, otherwise false. - virtual bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; + virtual bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; private: }; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp index 3d88d7d93e..2eb8cdb9d8 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp @@ -114,7 +114,7 @@ namespace AzToolsFramework return m_viewportEditorModeStates.size(); } - bool ViewportEditorModeTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const + bool ViewportEditorModeTracker::IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const { return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h index 12a64cbbf9..0ec5a31ddd 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h @@ -53,7 +53,7 @@ namespace AzToolsFramework void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetTrackedViewportCount() const override; - bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; private: using ViewportEditorModess = AZStd::unordered_map; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 3d88d7d93e..2eb8cdb9d8 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -114,7 +114,7 @@ namespace AzToolsFramework return m_viewportEditorModeStates.size(); } - bool ViewportEditorModeTracker::IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const + bool ViewportEditorModeTracker::IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const { return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index 12a64cbbf9..0ec5a31ddd 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -53,7 +53,7 @@ namespace AzToolsFramework void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetTrackedViewportCount() const override; - bool IsViewportStateBeingTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; + bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; private: using ViewportEditorModess = AZStd::unordered_map; diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 8e9b1ba59b..7603f68b64 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -290,7 +290,7 @@ namespace UnitTest { // Given a viewport not currently being tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); // When a mode is activated for that viewport @@ -299,7 +299,7 @@ namespace UnitTest const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); // Expect that viewport to now be tracked - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); // Expect the mode for that viewport to be active @@ -310,7 +310,7 @@ namespace UnitTest { // Given a viewport not currently being tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); // When a mode is deactivated for that viewport @@ -324,7 +324,7 @@ namespace UnitTest // Expect that viewport to now be tracked const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); // Expect the mode for that viewport to be inactive EXPECT_NE(viewportEditorModeState, nullptr); @@ -334,7 +334,7 @@ namespace UnitTest TEST_F(ViewportEditorModeTrackerTestFixture, GettingNonExistentViewportEditorModesForIdReturnsNull) { const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); } @@ -342,7 +342,7 @@ namespace UnitTest { // Given a viewport not currently tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; @@ -360,7 +360,7 @@ namespace UnitTest // Expect the mode to be active for the viewport const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } @@ -374,7 +374,7 @@ namespace UnitTest // Expect the mode to still be active for the viewport const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } @@ -384,7 +384,7 @@ namespace UnitTest { // Given a viewport not currently tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; @@ -403,7 +403,7 @@ namespace UnitTest // Expect the mode to be inctive for the viewport const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } @@ -418,7 +418,7 @@ namespace UnitTest // Expect the mode to still be inactive for the viewport const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportStateBeingTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } From 9dfc91cb77ad66c7a3c79135d7f8d43cd3d11330 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 14 Sep 2021 19:26:50 +0100 Subject: [PATCH 08/27] Fix API comments. Signed-off-by: John --- ...ViewportEditorModeTrackerNotificationBus.h | 5 +-- .../EditorInteractionInterface.h | 33 ------------------- 2 files changed, 3 insertions(+), 35 deletions(-) delete mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h index b9b5c80f39..cdb50e30e7 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h @@ -5,6 +5,7 @@ * SPDX-License-Identifier: Apache-2.0 OR MIT * */ + #pragma once #include @@ -13,7 +14,7 @@ namespace AzToolsFramework { - //! Enumeration of each viewport editor state. + //! Enumeration of each viewport editor mode. enum class ViewportEditorMode : AZ::u8 { Default, @@ -62,4 +63,4 @@ namespace AzToolsFramework } }; using ViewportEditorModeNotificationsBus = AZ::EBus; -} +} // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h deleted file mode 100644 index 70cbfd09ec..0000000000 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionInterface.h +++ /dev/null @@ -1,33 +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 -#include - -namespace AzToolsFramework -{ - /*! - * EditorInteractionInterface - * Allows systems to alter the behavior of viewport selection. - */ - class EditorInteractionInterface - { - public: - AZ_RTTI(EditorInteractionInterface, "{09276E3C-9AA6-40FF-A0B5-3D33A33F0E5A}"); - - /*! - * Allows the entity system to redirect the selection of an entity to another entity. - * It can be used to select a container when clicking on its content. - */ - virtual AZ::EntityId RedirectEntitySelection(AZ::EntityId entityId) = 0; - }; - -} // namespace AzToolsFramework - From 82fbbb79664be8a4054d0d48752e20ab34f866eb Mon Sep 17 00:00:00 2001 From: John Date: Wed, 15 Sep 2021 08:53:59 +0100 Subject: [PATCH 09/27] Delete hangover file. Signed-off-by: John --- .../ViewportEditorModeStateTrackerInterface.h | 42 ------------------- 1 file changed, 42 deletions(-) delete mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h deleted file mode 100644 index 53b0729bac..0000000000 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeStateTrackerInterface.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) Contributors to the Open 3D Engine Project. - * For complete copyright and license terms please see the LICENSE at the root of this distribution. - * - * SPDX-License-Identifier: Apache-2.0 OR MIT - * - */ - -#pragma once - -#include -#include - -namespace AzToolsFramework -{ - //! The AZ::Interface of the central editor mode state tracker for all viewports. - class ViewportEditorModeTrackerInterface - { - public: - AZ_RTTI(ViewportEditorModeTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}"); - - virtual ~ViewportEditorModeTrackerInterface() = default; - - //! Enters the specified editor mode for the specified viewport. - virtual void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; - - //! Exits the specified editor mode for the specified viewport. - virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; - - //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. - virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; - - //! Returns the number of viewports currently being tracked. - virtual size_t GetTrackedViewportCount() const = 0; - - //! Returns true if the specified viewport is being tracked, otherwise false. - virtual bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; - - private: - }; -} // namespace AzToolsFramework - From 00497ad9959694ee48c6dfdb6ace16da3cd2bdad Mon Sep 17 00:00:00 2001 From: John Date: Wed, 15 Sep 2021 09:05:56 +0100 Subject: [PATCH 10/27] Delete more hangover files. Signed-off-by: John --- .../ViewportEditorModeStateTracker.cpp | 121 ------------------ .../ViewportEditorModeStateTracker.h | 62 --------- 2 files changed, 183 deletions(-) delete mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp delete mode 100644 Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp deleted file mode 100644 index 2eb8cdb9d8..0000000000 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.cpp +++ /dev/null @@ -1,121 +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 -#include - -namespace AzToolsFramework -{ - static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; - - void ViewportEditorModes::SetModeActive(ViewportEditorMode mode) - { - if (const AZ::u32 modeIndex = static_cast(mode); - modeIndex < NumEditorModes) - { - m_editorModes[modeIndex] = true; - } - else - { - AZ_Error(ViewportEditorModeLogWindow, false, "Cannot activate mode %u, mode is not recognized", modeIndex) - } - } - - void ViewportEditorModes::SetModeInactive(ViewportEditorMode mode) - { - if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) - { - m_editorModes[modeIndex] = false; - } - else - { - AZ_Error(ViewportEditorModeLogWindow, false, "Cannot deactivate mode %u, mode is not recognized", modeIndex) - } - } - - bool ViewportEditorModes::IsModeActive(ViewportEditorMode mode) const - { - return m_editorModes[static_cast(mode)]; - } - - void ViewportEditorModeTracker::RegisterInterface() - { - if (AZ::Interface::Get() == nullptr) - { - AZ::Interface::Register(this); - } - } - - void ViewportEditorModeTracker::UnregisterInterface() - { - if (AZ::Interface::Get() != nullptr) - { - AZ::Interface::Unregister(this); - } - } - - void ViewportEditorModeTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) - { - auto& editorModeStates = m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; - AZ_Warning( - ViewportEditorModeLogWindow, !editorModeStates.IsModeActive(mode), - AZStd::string::format( - "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); - editorModeStates.SetModeActive(mode); - ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModeStates, mode); - } - - void ViewportEditorModeTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) - { - ViewportEditorModes* editorModeStates = nullptr; - if (m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id)) - { - editorModeStates = &m_viewportEditorModeStates.at(viewportEditorModeInfo.m_id); - AZ_Warning( - ViewportEditorModeLogWindow, editorModeStates->IsModeActive(mode), - AZStd::string::format( - "Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); - } - else - { - AZ_Warning( - ViewportEditorModeLogWindow, false, "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", - static_cast(mode), viewportEditorModeInfo.m_id); - - editorModeStates = &m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; - } - - editorModeStates->SetModeInactive(mode); - ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); - } - - const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const - { - if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); - editorModeStates != m_viewportEditorModeStates.end()) - { - return &editorModeStates->second; - } - else - { - return nullptr; - } - } - - size_t ViewportEditorModeTracker::GetTrackedViewportCount() const - { - return m_viewportEditorModeStates.size(); - } - - bool ViewportEditorModeTracker::IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const - { - return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; - } -} // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h deleted file mode 100644 index 0ec5a31ddd..0000000000 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeStateTracker.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright (c) Contributors to the Open 3D Engine Project. - * For complete copyright and license terms please see the LICENSE at the root of this distribution. - * - * SPDX-License-Identifier: Apache-2.0 OR MIT - * - */ - -#pragma once - -#include -#include -#include -#include -#include - -namespace AzToolsFramework -{ - //! The encapsulation of the editor modes for a given viewport. - class ViewportEditorModes - : public ViewportEditorModesInterface - { - public: - - //! The number of currently supported viewport editor modes. - static constexpr AZ::u8 NumEditorModes = 4; - - //! Sets the specified mode as active. - void SetModeActive(ViewportEditorMode mode); - - // Sets the specified mode as inactive. - void SetModeInactive(ViewportEditorMode mode); - - // ViewportEditorModesInterface ... - bool IsModeActive(ViewportEditorMode mode) const override; - private: - AZStd::array m_editorModes{}; //!< State flags to track active/inactive status of viewport editor modes. - }; - - //! The implementation of the central editor mode state tracker for all viewports. - class ViewportEditorModeTracker - : public ViewportEditorModeTrackerInterface - { - public: - //! Registers this object with the AZ::Interface. - void RegisterInterface(); - - //! Unregisters this object with the AZ::Interface. - void UnregisterInterface(); - - // ViewportEditorModeTrackerInterface ... - void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; - size_t GetTrackedViewportCount() const override; - bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; - - private: - using ViewportEditorModess = AZStd::unordered_map; - ViewportEditorModess m_viewportEditorModeStates; //!< Editor mode state per viewport. - }; -} // namespace AzToolsFramework From 66f78889e656a2569a3d3c36663bb2714f2faeec Mon Sep 17 00:00:00 2001 From: John Date: Wed, 15 Sep 2021 09:26:16 +0100 Subject: [PATCH 11/27] Minor member name refactor. Signed-off-by: John --- .../Viewport/ViewportEditorModeTests.cpp | 110 +++++++++--------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 7603f68b64..7eb4f68d87 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -40,7 +40,7 @@ namespace UnitTest : public ::testing::Test { public: - ViewportEditorModes m_editorModeState; + ViewportEditorModes m_editorModes; }; // Fixture for testing editor mode states with parameterized test arguments @@ -62,7 +62,7 @@ namespace UnitTest : public ToolsApplicationFixture { public: - ViewportEditorModeTracker m_viewportEditorModeStteTracker; + ViewportEditorModeTracker m_viewportEditorModeTracker; }; // Subscriber of viewport editor mode notifications for a single viewport that expects a single mode to be activated/deactivated @@ -149,43 +149,43 @@ namespace UnitTest { for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { - EXPECT_FALSE(m_editorModeState.IsModeActive(static_cast(mode))); + EXPECT_FALSE(m_editorModes.IsModeActive(static_cast(mode))); } } TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) { - m_editorModeState.SetModeActive(m_selectedEditorMode); + m_editorModes.SetModeActive(m_selectedEditorMode); for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) { - EXPECT_TRUE(m_editorModeState.IsModeActive(static_cast(editorMode))); + EXPECT_TRUE(m_editorModes.IsModeActive(static_cast(editorMode))); } else { - EXPECT_FALSE(m_editorModeState.IsModeActive(static_cast(editorMode))); + EXPECT_FALSE(m_editorModes.IsModeActive(static_cast(editorMode))); } } } TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) { - SetAllModesActive(m_editorModeState); - m_editorModeState.SetModeInactive(m_selectedEditorMode); + SetAllModesActive(m_editorModes); + m_editorModes.SetModeInactive(m_selectedEditorMode); for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) { - EXPECT_FALSE(m_editorModeState.IsModeActive(editorMode)); + EXPECT_FALSE(m_editorModes.IsModeActive(editorMode)); } else { - EXPECT_TRUE(m_editorModeState.IsModeActive(editorMode)); + EXPECT_TRUE(m_editorModes.IsModeActive(editorMode)); } } } @@ -195,8 +195,8 @@ namespace UnitTest for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes - 1; mode++) { // Given only the selected mode active - SetAllModesInactive(m_editorModeState); - m_editorModeState.SetModeActive(m_selectedEditorMode); + SetAllModesInactive(m_editorModes); + m_editorModes.SetModeActive(m_selectedEditorMode); const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -205,7 +205,7 @@ namespace UnitTest } // When other modes are activated - m_editorModeState.SetModeActive(editorMode); + m_editorModes.SetModeActive(editorMode); for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { @@ -213,12 +213,12 @@ namespace UnitTest if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode) { // Expect the activated modes to be active - EXPECT_TRUE(m_editorModeState.IsModeActive(expectedEditorMode)); + EXPECT_TRUE(m_editorModes.IsModeActive(expectedEditorMode)); } else { // Expect the modes not active to be inactive - EXPECT_FALSE(m_editorModeState.IsModeActive(expectedEditorMode)); + EXPECT_FALSE(m_editorModes.IsModeActive(expectedEditorMode)); } } } @@ -229,8 +229,8 @@ namespace UnitTest for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes - 1; mode++) { // Given only the selected mode inactive - SetAllModesActive(m_editorModeState); - m_editorModeState.SetModeInactive(m_selectedEditorMode); + SetAllModesActive(m_editorModes); + m_editorModes.SetModeInactive(m_selectedEditorMode); const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -239,7 +239,7 @@ namespace UnitTest } // When other modes are deactivated - m_editorModeState.SetModeInactive(editorMode); + m_editorModes.SetModeInactive(editorMode); for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { @@ -247,12 +247,12 @@ namespace UnitTest if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode) { // Expect the deactivated modes to be inactive - EXPECT_FALSE(m_editorModeState.IsModeActive(expectedEditorMode)); + EXPECT_FALSE(m_editorModes.IsModeActive(expectedEditorMode)); } else { // Expects the modes not deactivated to still be active - EXPECT_TRUE(m_editorModeState.IsModeActive(expectedEditorMode)); + EXPECT_TRUE(m_editorModes.IsModeActive(expectedEditorMode)); } } } @@ -270,36 +270,36 @@ namespace UnitTest TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeActiveIssuesErrorMsg) { UnitTest::TestRunner::Instance().StartAssertTests(); - m_editorModeState.SetModeActive(static_cast(ViewportEditorModes::NumEditorModes)); + m_editorModes.SetModeActive(static_cast(ViewportEditorModes::NumEditorModes)); EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); } TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeInactiveIssuesErrorMsg) { UnitTest::TestRunner::Instance().StartAssertTests(); - m_editorModeState.SetModeInactive(static_cast(ViewportEditorModes::NumEditorModes)); + m_editorModes.SetModeInactive(static_cast(ViewportEditorModes::NumEditorModes)); EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); } TEST_F(ViewportEditorModeTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess) { - EXPECT_EQ(m_viewportEditorModeStteTracker.GetTrackedViewportCount(), 0); + EXPECT_EQ(m_viewportEditorModeTracker.GetTrackedViewportCount(), 0); } TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); + EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); // When a mode is activated for that viewport const auto editorMode = ViewportEditorMode::Default; - m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); + m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); + const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); // Expect that viewport to now be tracked - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); + EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); // Expect the mode for that viewport to be active @@ -310,21 +310,21 @@ namespace UnitTest { // Given a viewport not currently being tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); + EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); // When a mode is deactivated for that viewport const auto editorMode = ViewportEditorMode::Default; UnitTest::ErrorHandler errorHandler(AZStd::string::format( "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", static_cast(editorMode), viewportid).c_str()); - m_viewportEditorModeStteTracker.ExitMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.ExitMode({ viewportid }, editorMode); // Expect a warning to be issued due to no precursor activation of that mode EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); // Expect that viewport to now be tracked - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); + const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); // Expect the mode for that viewport to be inactive EXPECT_NE(viewportEditorModeState, nullptr); @@ -334,16 +334,16 @@ namespace UnitTest TEST_F(ViewportEditorModeTrackerTestFixture, GettingNonExistentViewportEditorModesForIdReturnsNull) { const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); + EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); } TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); + EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; const auto expectedWarning = AZStd::string::format( @@ -353,28 +353,28 @@ namespace UnitTest UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); // When the mode is activated for the viewport - m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); // Expect no warning to be issued as there is no duplicate activation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); // Expect the mode to be active for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); + const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } { // When the mode is activated again for the viewport UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); - m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); // Expect a warning to be issued for the duplicate activation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); // Expect the mode to still be active for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); + const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } @@ -384,8 +384,8 @@ namespace UnitTest { // Given a viewport not currently tracked const ViewportId viewportid = 0; - EXPECT_FALSE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); - EXPECT_EQ(m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }), nullptr); + EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); + EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; const auto expectedWarning = @@ -395,15 +395,15 @@ namespace UnitTest UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); // When the mode is activated and then deactivated for the viewport - m_viewportEditorModeStteTracker.EnterMode({ viewportid }, editorMode); - m_viewportEditorModeStteTracker.ExitMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.ExitMode({ viewportid }, editorMode); // Expect no warning to be issued as there is no duplicate deactivation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); // Expect the mode to be inctive for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); + const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } @@ -411,14 +411,14 @@ namespace UnitTest UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); // When the mode is deactivated again for the viewport - m_viewportEditorModeStteTracker.ExitMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.ExitMode({ viewportid }, editorMode); // Expect a warning to be issued for the duplicate deactivation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); // Expect the mode to still be inactive for the viewport - const auto* viewportEditorModeState = m_viewportEditorModeStteTracker.GetViewportEditorModes({ viewportid }); - EXPECT_TRUE(m_viewportEditorModeStteTracker.IsViewportModeTracked({ viewportid })); + const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); + EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid })); EXPECT_NE(viewportEditorModeState, nullptr); EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } @@ -440,7 +440,7 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeStteTracker.EnterMode({ mode }, editorMode); + m_viewportEditorModeTracker.EnterMode({ mode }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -472,8 +472,8 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeStteTracker.EnterMode({ mode }, editorMode); - m_viewportEditorModeStteTracker.ExitMode({ mode }, editorMode); + m_viewportEditorModeTracker.EnterMode({ mode }, editorMode); + m_viewportEditorModeTracker.ExitMode({ mode }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) From 15ae8c2c064d6f43c3a1da7877e4973ebef4bbb9 Mon Sep 17 00:00:00 2001 From: John Date: Wed, 15 Sep 2021 11:00:59 +0100 Subject: [PATCH 12/27] Refactor nonclemanture. Signed-off-by: John --- .../API/ViewportEditorModeTrackerInterface.h | 4 +-- ...ViewportEditorModeTrackerNotificationBus.h | 2 +- .../ViewportEditorModeTracker.cpp | 32 +++++++++---------- .../ViewportEditorModeTracker.h | 4 +-- 4 files changed, 20 insertions(+), 22 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index 53b0729bac..4bafdc3d01 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -13,7 +13,7 @@ namespace AzToolsFramework { - //! The AZ::Interface of the central editor mode state tracker for all viewports. + //! The AZ::Interface of the central editor mode tracker for all viewports. class ViewportEditorModeTrackerInterface { public: @@ -35,8 +35,6 @@ namespace AzToolsFramework //! Returns true if the specified viewport is being tracked, otherwise false. virtual bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; - - private: }; } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h index cdb50e30e7..caa762241c 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h @@ -30,7 +30,7 @@ namespace AzToolsFramework IdType m_id = ViewportUi::DefaultViewportId; //!< The unique identifier for a given viewport. }; - //! Interface for the editor mode state of a given viewport. + //! Interface for the editor modes of a given viewport. class ViewportEditorModesInterface { public: diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 2eb8cdb9d8..511024daed 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -61,24 +61,24 @@ namespace AzToolsFramework void ViewportEditorModeTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { - auto& editorModeStates = m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; + auto& editorModes = m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; AZ_Warning( - ViewportEditorModeLogWindow, !editorModeStates.IsModeActive(mode), + ViewportEditorModeLogWindow, !editorModes.IsModeActive(mode), AZStd::string::format( "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); - editorModeStates.SetModeActive(mode); + editorModes.SetModeActive(mode); ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModeStates, mode); + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModes, mode); } void ViewportEditorModeTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { - ViewportEditorModes* editorModeStates = nullptr; - if (m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id)) + ViewportEditorModes* editorModes = nullptr; + if (m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id)) { - editorModeStates = &m_viewportEditorModeStates.at(viewportEditorModeInfo.m_id); + editorModes = &m_viewportEditorModesMap.at(viewportEditorModeInfo.m_id); AZ_Warning( - ViewportEditorModeLogWindow, editorModeStates->IsModeActive(mode), + ViewportEditorModeLogWindow, editorModes->IsModeActive(mode), AZStd::string::format( "Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); } @@ -88,20 +88,20 @@ namespace AzToolsFramework ViewportEditorModeLogWindow, false, "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", static_cast(mode), viewportEditorModeInfo.m_id); - editorModeStates = &m_viewportEditorModeStates[viewportEditorModeInfo.m_id]; + editorModes = &m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; } - editorModeStates->SetModeInactive(mode); + editorModes->SetModeInactive(mode); ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModeStates, mode); + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModes, mode); } const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const { - if (auto editorModeStates = m_viewportEditorModeStates.find(viewportEditorModeInfo.m_id); - editorModeStates != m_viewportEditorModeStates.end()) + if (auto editorModes = m_viewportEditorModesMap.find(viewportEditorModeInfo.m_id); + editorModes != m_viewportEditorModesMap.end()) { - return &editorModeStates->second; + return &editorModes->second; } else { @@ -111,11 +111,11 @@ namespace AzToolsFramework size_t ViewportEditorModeTracker::GetTrackedViewportCount() const { - return m_viewportEditorModeStates.size(); + return m_viewportEditorModesMap.size(); } bool ViewportEditorModeTracker::IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const { - return m_viewportEditorModeStates.count(viewportEditorModeInfo.m_id) > 0; + return m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id) > 0; } } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index 0ec5a31ddd..222e5af829 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -56,7 +56,7 @@ namespace AzToolsFramework bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; private: - using ViewportEditorModess = AZStd::unordered_map; - ViewportEditorModess m_viewportEditorModeStates; //!< Editor mode state per viewport. + using ViewportEditorModesMap = AZStd::unordered_map; + ViewportEditorModesMap m_viewportEditorModesMap; //!< Editor mode state per viewport. }; } // namespace AzToolsFramework From c713077e070e0109254a4abb6bacc881eef01df5 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 17 Sep 2021 17:02:28 +0100 Subject: [PATCH 13/27] Rename Enter/ExitMode to Register/UnregisterMode. Signed-off-by: John --- .../API/ViewportEditorModeTrackerInterface.h | 8 ++-- .../ViewportEditorModeTracker.cpp | 10 ++-- .../ViewportEditorModeTracker.h | 6 +-- .../Viewport/ViewportEditorModeTests.cpp | 46 +++++++++---------- 4 files changed, 35 insertions(+), 35 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index 4bafdc3d01..062d326046 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -21,11 +21,11 @@ namespace AzToolsFramework virtual ~ViewportEditorModeTrackerInterface() = default; - //! Enters the specified editor mode for the specified viewport. - virtual void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + //! Registers the specified editor mode as active for the specified viewport. + virtual void RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; - //! Exits the specified editor mode for the specified viewport. - virtual void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + //! Unregisters the specified editor mode as active for the specified viewport. + virtual void UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 511024daed..1dfc4ac035 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -59,19 +59,19 @@ namespace AzToolsFramework } } - void ViewportEditorModeTracker::EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + void ViewportEditorModeTracker::RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { auto& editorModes = m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; AZ_Warning( ViewportEditorModeLogWindow, !editorModes.IsModeActive(mode), AZStd::string::format( - "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); editorModes.SetModeActive(mode); ViewportEditorModeNotificationsBus::Event( viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModes, mode); } - void ViewportEditorModeTracker::ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + void ViewportEditorModeTracker::UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { ViewportEditorModes* editorModes = nullptr; if (m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id)) @@ -80,12 +80,12 @@ namespace AzToolsFramework AZ_Warning( ViewportEditorModeLogWindow, editorModes->IsModeActive(mode), AZStd::string::format( - "Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + "Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); } else { AZ_Warning( - ViewportEditorModeLogWindow, false, "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", + ViewportEditorModeLogWindow, false, "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(mode), viewportEditorModeInfo.m_id); editorModes = &m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index 222e5af829..e766bd29b9 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -48,9 +48,9 @@ namespace AzToolsFramework //! Unregisters this object with the AZ::Interface. void UnregisterInterface(); - // ViewportEditorModeTrackerInterface ... - void EnterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - void ExitMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + // ViewportEditorModeTrackerInterface overrides ... + void RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + void UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetTrackedViewportCount() const override; bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 7eb4f68d87..ac61a20bf6 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -73,7 +73,7 @@ namespace UnitTest struct ReceivedEvents { bool m_onEnter = false; - bool m_onLeave = false; + bool m_onExit = false; }; using EditModeTracker = AZStd::unordered_map; @@ -106,7 +106,7 @@ namespace UnitTest virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { - m_editorModes[mode].m_onLeave = true; + m_editorModes[mode].m_onExit = true; } private: @@ -286,7 +286,7 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetTrackedViewportCount(), 0); } - TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) + TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -295,7 +295,7 @@ namespace UnitTest // When a mode is activated for that viewport const auto editorMode = ViewportEditorMode::Default; - m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); // Expect that viewport to now be tracked @@ -306,7 +306,7 @@ namespace UnitTest EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModeTrackerTestFixture, ExitingViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButIssuesErrorMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButIssuesErrorMsg) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -316,8 +316,8 @@ namespace UnitTest // When a mode is deactivated for that viewport const auto editorMode = ViewportEditorMode::Default; UnitTest::ErrorHandler errorHandler(AZStd::string::format( - "Call to ExitMode for mode '%u' on id '%i' without precursor call to EnterMode", static_cast(editorMode), viewportid).c_str()); - m_viewportEditorModeTracker.ExitMode({ viewportid }, editorMode); + "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(editorMode), viewportid).c_str()); + m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); // Expect a warning to be issued due to no precursor activation of that mode EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); @@ -338,7 +338,7 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); } - TEST_F(ViewportEditorModeTrackerTestFixture, EnteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -347,13 +347,13 @@ namespace UnitTest const auto editorMode = ViewportEditorMode::Default; const auto expectedWarning = AZStd::string::format( - "Duplicate call to EnterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); { UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); // When the mode is activated for the viewport - m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); // Expect no warning to be issued as there is no duplicate activation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); @@ -367,7 +367,7 @@ namespace UnitTest { // When the mode is activated again for the viewport UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); - m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); // Expect a warning to be issued for the duplicate activation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); @@ -380,7 +380,7 @@ namespace UnitTest } } - TEST_F(ViewportEditorModeTrackerTestFixture, ExitingViewportEditorModesForExistingIdNotInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModesForExistingIdNotInThatStateIssuesWarningMsg) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -389,14 +389,14 @@ namespace UnitTest const auto editorMode = ViewportEditorMode::Default; const auto expectedWarning = - AZStd::string::format("Duplicate call to ExitMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + AZStd::string::format("Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); { UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); // When the mode is activated and then deactivated for the viewport - m_viewportEditorModeTracker.EnterMode({ viewportid }, editorMode); - m_viewportEditorModeTracker.ExitMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); // Expect no warning to be issued as there is no duplicate deactivation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); @@ -411,7 +411,7 @@ namespace UnitTest UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); // When the mode is deactivated again for the viewport - m_viewportEditorModeTracker.ExitMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); // Expect a warning to be issued for the duplicate deactivation EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); @@ -426,7 +426,7 @@ namespace UnitTest TEST_F( ViewportEditorModePublisherTestFixture, - EnteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeEnterEventForAllSubscribers) + RegisteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeRegisterEventForAllSubscribers) { // Given a set of subscribers tracking the editor modes for their exclusive viewport for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -440,7 +440,7 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeTracker.EnterMode({ mode }, editorMode); + m_viewportEditorModeTracker.RegisterMode({ mode }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -453,13 +453,13 @@ namespace UnitTest const auto& expectedEditorModeSet = editorModes.find(editorMode); EXPECT_NE(expectedEditorModeSet, editorModes.end()); EXPECT_TRUE(expectedEditorModeSet->second.m_onEnter); - EXPECT_FALSE(expectedEditorModeSet->second.m_onLeave); + EXPECT_FALSE(expectedEditorModeSet->second.m_onExit); } } TEST_F( ViewportEditorModePublisherTestFixture, - ExitingViewportEditorModesForExistingIdPublishesOnViewportEditorModeExitEventForAllSubscribers) + UnregisteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeUnregisterEventForAllSubscribers) { // Given a set of subscribers tracking the editor modes for their exclusive viewport for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -472,8 +472,8 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeTracker.EnterMode({ mode }, editorMode); - m_viewportEditorModeTracker.ExitMode({ mode }, editorMode); + m_viewportEditorModeTracker.RegisterMode({ mode }, editorMode); + m_viewportEditorModeTracker.UnregisterMode({ mode }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -486,7 +486,7 @@ namespace UnitTest const auto& expectedEditorModeSet = editorModes.find(editorMode); EXPECT_NE(expectedEditorModeSet, editorModes.end()); EXPECT_TRUE(expectedEditorModeSet->second.m_onEnter); - EXPECT_TRUE(expectedEditorModeSet->second.m_onLeave); + EXPECT_TRUE(expectedEditorModeSet->second.m_onExit); } } } // namespace UnitTest From 0c79bbd7800c49b01ca9cc8051d5dfb63b2cb9f8 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 17 Sep 2021 17:38:45 +0100 Subject: [PATCH 14/27] Error and warning msgs now return AZ::Outcomes. Signed-off-by: John --- .../API/ViewportEditorModeTrackerInterface.h | 7 +- .../ViewportEditorModeTracker.cpp | 70 ++++++++---- .../ViewportEditorModeTracker.h | 8 +- .../Viewport/ViewportEditorModeTests.cpp | 104 +++++++++--------- 4 files changed, 114 insertions(+), 75 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index 062d326046..ae4f3424eb 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -9,6 +9,7 @@ #pragma once #include +#include #include namespace AzToolsFramework @@ -22,10 +23,12 @@ namespace AzToolsFramework virtual ~ViewportEditorModeTrackerInterface() = default; //! Registers the specified editor mode as active for the specified viewport. - virtual void RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + virtual AZ::Outcome RegisterMode( + const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Unregisters the specified editor mode as active for the specified viewport. - virtual void UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; + virtual AZ::Outcome UnregisterMode( + const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 1dfc4ac035..36c1b09be7 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -13,28 +13,32 @@ namespace AzToolsFramework { static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; - void ViewportEditorModes::SetModeActive(ViewportEditorMode mode) + AZ::Outcome ViewportEditorModes::SetModeActive(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) { m_editorModes[modeIndex] = true; + return AZ::Success(); } else { - AZ_Error(ViewportEditorModeLogWindow, false, "Cannot activate mode %u, mode is not recognized", modeIndex) + return AZ::Failure( + AZStd::string::format(ViewportEditorModeLogWindow, false, "Cannot activate mode %u, mode is not recognized", modeIndex)); } } - void ViewportEditorModes::SetModeInactive(ViewportEditorMode mode) + AZ::Outcome ViewportEditorModes::SetModeInactive(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) { m_editorModes[modeIndex] = false; + return AZ::Success(); } else { - AZ_Error(ViewportEditorModeLogWindow, false, "Cannot deactivate mode %u, mode is not recognized", modeIndex) + return AZ::Failure( + AZStd::string::format(ViewportEditorModeLogWindow, false, "Cannot deactivate mode %u, mode is not recognized", modeIndex)); } } @@ -59,41 +63,67 @@ namespace AzToolsFramework } } - void ViewportEditorModeTracker::RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + AZ::Outcome ViewportEditorModeTracker::RegisterMode( + const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { auto& editorModes = m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; - AZ_Warning( - ViewportEditorModeLogWindow, !editorModes.IsModeActive(mode), - AZStd::string::format( - "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); - editorModes.SetModeActive(mode); + if (editorModes.IsModeActive(mode)) + { + return AZ::Failure(AZStd::string::format( + "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id)); + } + + if (const auto result = editorModes.SetModeActive(mode); + !result.IsSuccess()) + { + return result; + } + ViewportEditorModeNotificationsBus::Event( viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModes, mode); + + return AZ::Success(); } - void ViewportEditorModeTracker::UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) + AZ::Outcome ViewportEditorModeTracker::UnregisterMode( + const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { ViewportEditorModes* editorModes = nullptr; + bool modeWasActive = true; if (m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id)) { editorModes = &m_viewportEditorModesMap.at(viewportEditorModeInfo.m_id); - AZ_Warning( - ViewportEditorModeLogWindow, editorModes->IsModeActive(mode), - AZStd::string::format( - "Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id).c_str()); + if (!editorModes->IsModeActive(mode)) + { + return AZ::Failure(AZStd::string::format( + "Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id)); + } } else { - AZ_Warning( - ViewportEditorModeLogWindow, false, "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", - static_cast(mode), viewportEditorModeInfo.m_id); - + modeWasActive = false; editorModes = &m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; } - editorModes->SetModeInactive(mode); + if(const auto result = editorModes->SetModeInactive(mode); + !result.IsSuccess()) + { + return result; + } + ViewportEditorModeNotificationsBus::Event( viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModes, mode); + + if (modeWasActive) + { + return AZ::Success(); + } + else + { + return AZ::Failure(AZStd::string::format( + "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(mode), + viewportEditorModeInfo.m_id)); + } } const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index e766bd29b9..d67ea5d725 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -26,10 +26,10 @@ namespace AzToolsFramework static constexpr AZ::u8 NumEditorModes = 4; //! Sets the specified mode as active. - void SetModeActive(ViewportEditorMode mode); + AZ::Outcome SetModeActive(ViewportEditorMode mode); // Sets the specified mode as inactive. - void SetModeInactive(ViewportEditorMode mode); + AZ::Outcome SetModeInactive(ViewportEditorMode mode); // ViewportEditorModesInterface ... bool IsModeActive(ViewportEditorMode mode) const override; @@ -49,8 +49,8 @@ namespace AzToolsFramework void UnregisterInterface(); // ViewportEditorModeTrackerInterface overrides ... - void RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - void UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + AZ::Outcome RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + AZ::Outcome UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetTrackedViewportCount() const override; bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index ac61a20bf6..6103482f05 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -19,11 +19,23 @@ namespace UnitTest using ViewportId = ViewportEditorModeInfo::IdType; using ViewportEditorModesInterface = AzToolsFramework::ViewportEditorModesInterface; + void SetModeActiveAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) + { + const auto result = editorModeState.SetModeActive(mode); + EXPECT_TRUE(result.IsSuccess()); + } + + void SetModeInactiveAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) + { + const auto result = editorModeState.SetModeInactive(mode); + EXPECT_TRUE(result.IsSuccess()); + } + void SetAllModesActive(ViewportEditorModes& editorModeState) { for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { - editorModeState.SetModeActive(static_cast(mode)); + SetModeActiveAndExpectSuccess(editorModeState, static_cast(mode)); } } @@ -31,7 +43,7 @@ namespace UnitTest { for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { - editorModeState.SetModeInactive(static_cast(mode)); + SetModeInactiveAndExpectSuccess(editorModeState, static_cast(mode)); } } @@ -155,7 +167,7 @@ namespace UnitTest TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) { - m_editorModes.SetModeActive(m_selectedEditorMode); + SetModeActiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { @@ -174,7 +186,7 @@ namespace UnitTest TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) { SetAllModesActive(m_editorModes); - m_editorModes.SetModeInactive(m_selectedEditorMode); + SetModeInactiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { @@ -196,7 +208,9 @@ namespace UnitTest { // Given only the selected mode active SetAllModesInactive(m_editorModes); - m_editorModes.SetModeActive(m_selectedEditorMode); + { + SetModeActiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); + } const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -205,7 +219,7 @@ namespace UnitTest } // When other modes are activated - m_editorModes.SetModeActive(editorMode); + SetModeActiveAndExpectSuccess(m_editorModes, editorMode); for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { @@ -230,7 +244,7 @@ namespace UnitTest { // Given only the selected mode inactive SetAllModesActive(m_editorModes); - m_editorModes.SetModeInactive(m_selectedEditorMode); + SetModeInactiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -239,7 +253,7 @@ namespace UnitTest } // When other modes are deactivated - m_editorModes.SetModeInactive(editorMode); + SetModeInactiveAndExpectSuccess(m_editorModes, editorMode); for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { @@ -267,18 +281,16 @@ namespace UnitTest AzToolsFramework::ViewportEditorMode::Focus, AzToolsFramework::ViewportEditorMode::Pick)); - TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeActiveIssuesErrorMsg) + TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeActiveReturnsError) { - UnitTest::TestRunner::Instance().StartAssertTests(); - m_editorModes.SetModeActive(static_cast(ViewportEditorModes::NumEditorModes)); - EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); + const auto result = m_editorModes.SetModeActive(static_cast(ViewportEditorModes::NumEditorModes)); + EXPECT_FALSE(result.IsSuccess()); } - TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeInactiveIssuesErrorMsg) + TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeInactiveReturnsError) { - UnitTest::TestRunner::Instance().StartAssertTests(); - m_editorModes.SetModeInactive(static_cast(ViewportEditorModes::NumEditorModes)); - EXPECT_EQ(1, UnitTest::TestRunner::Instance().StopAssertTests()); + const auto result = m_editorModes.SetModeInactive(static_cast(ViewportEditorModes::NumEditorModes)); + EXPECT_FALSE(result.IsSuccess()); } TEST_F(ViewportEditorModeTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess) @@ -306,7 +318,7 @@ namespace UnitTest EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButIssuesErrorMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButReturnsError) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -315,12 +327,13 @@ namespace UnitTest // When a mode is deactivated for that viewport const auto editorMode = ViewportEditorMode::Default; - UnitTest::ErrorHandler errorHandler(AZStd::string::format( - "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(editorMode), viewportid).c_str()); - m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); + const auto expectedErrorMsg = AZStd::string::format( + "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(editorMode), viewportid); + const auto result = m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); - // Expect a warning to be issued due to no precursor activation of that mode - EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); + // Expect an error due to no precursor activation of that mode + EXPECT_FALSE(result.IsSuccess()); + EXPECT_EQ(result.GetError(), expectedErrorMsg); // Expect that viewport to now be tracked const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); @@ -338,7 +351,7 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); } - TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModesForExistingIdInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModesForExistingIdInThatStateReturnsError) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -346,17 +359,12 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; - const auto expectedWarning = AZStd::string::format( - "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); - { - UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); - // When the mode is activated for the viewport - m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); - // Expect no warning to be issued as there is no duplicate activation - EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); + // Expect no error as there is no duplicate activation + EXPECT_TRUE(result.IsSuccess()); // Expect the mode to be active for the viewport const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); @@ -366,11 +374,13 @@ namespace UnitTest } { // When the mode is activated again for the viewport - UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); - m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); - // Expect a warning to be issued for the duplicate activation - EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); + // Expect an error for the duplicate activation + const auto expectedErrorMsg = AZStd::string::format( + "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + EXPECT_FALSE(result.IsSuccess()); + EXPECT_EQ(result.GetError(), expectedErrorMsg); // Expect the mode to still be active for the viewport const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); @@ -380,7 +390,7 @@ namespace UnitTest } } - TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModesForExistingIdNotInThatStateIssuesWarningMsg) + TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModesForExistingIdNotInThatStateReturnssError) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -388,18 +398,13 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); const auto editorMode = ViewportEditorMode::Default; - const auto expectedWarning = - AZStd::string::format("Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); - { - UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); - // When the mode is activated and then deactivated for the viewport m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); - m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); - // Expect no warning to be issued as there is no duplicate deactivation - EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 0); + // Expect no error as there is no duplicate deactivation + EXPECT_TRUE(result.IsSuccess()); // Expect the mode to be inctive for the viewport const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); @@ -408,13 +413,14 @@ namespace UnitTest EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode)); } { - UnitTest::ErrorHandler errorHandler(expectedWarning.c_str()); - // When the mode is deactivated again for the viewport - m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); - // Expect a warning to be issued for the duplicate deactivation - EXPECT_EQ(errorHandler.GetExpectedWarningCount(), 1); + // Expect an error for the duplicate deactivation + const auto expectedErrorMsg = AZStd::string::format( + "Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + EXPECT_FALSE(result.IsSuccess()); + EXPECT_EQ(result.GetError(), expectedErrorMsg); // Expect the mode to still be inactive for the viewport const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); From acd7d3c27766d929e46acf09479437f067065483 Mon Sep 17 00:00:00 2001 From: John Date: Mon, 20 Sep 2021 12:43:50 +0100 Subject: [PATCH 15/27] Change all nomenclature to Activate/Deactivate for consistency. Signed-off-by: John --- .../API/ViewportEditorModeTrackerInterface.h | 8 +-- ...ViewportEditorModeTrackerNotificationBus.h | 8 +-- .../ViewportEditorModeTracker.cpp | 22 +++---- .../ViewportEditorModeTracker.h | 9 ++- .../Viewport/ViewportEditorModeTests.cpp | 58 +++++++++---------- 5 files changed, 52 insertions(+), 53 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h index ae4f3424eb..bcc8afbe6a 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h @@ -22,12 +22,12 @@ namespace AzToolsFramework virtual ~ViewportEditorModeTrackerInterface() = default; - //! Registers the specified editor mode as active for the specified viewport. - virtual AZ::Outcome RegisterMode( + //! Activates the specified editor mode for the specified viewport. + virtual AZ::Outcome ActivateMode( const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; - //! Unregisters the specified editor mode as active for the specified viewport. - virtual AZ::Outcome UnregisterMode( + //! Deactivates the specified editor mode for the specified viewport. + virtual AZ::Outcome DeactivateMode( const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0; //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr. diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h index caa762241c..d4e5dd4fbb 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h @@ -52,13 +52,13 @@ namespace AzToolsFramework using BusIdType = ViewportEditorModeInfo::IdType; ////////////////////////////////////////////////////////////////////////// - //! Notifies subscribers of the a given viewport to the entering of the specified editor mode. - virtual void OnEditorModeEnter([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + //! Notifies subscribers of the a given viewport to the activation of the specified editor mode. + virtual void OnEditorModeActivate([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) { } - //! Notifies subscribers of the a given viewport to the exiting of the specified editor mode. - virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + //! Notifies subscribers of the a given viewport to the deactivation of the specified editor mode. + virtual void OnEditorModeDeactivate([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) { } }; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 36c1b09be7..26f724b0aa 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -13,7 +13,7 @@ namespace AzToolsFramework { static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; - AZ::Outcome ViewportEditorModes::SetModeActive(ViewportEditorMode mode) + AZ::Outcome ViewportEditorModes::ActivateMode(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) @@ -28,7 +28,7 @@ namespace AzToolsFramework } } - AZ::Outcome ViewportEditorModes::SetModeInactive(ViewportEditorMode mode) + AZ::Outcome ViewportEditorModes::DeactivateMode(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); modeIndex < NumEditorModes) { @@ -63,29 +63,29 @@ namespace AzToolsFramework } } - AZ::Outcome ViewportEditorModeTracker::RegisterMode( + AZ::Outcome ViewportEditorModeTracker::ActivateMode( const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { auto& editorModes = m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; if (editorModes.IsModeActive(mode)) { return AZ::Failure(AZStd::string::format( - "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id)); + "Duplicate call to ActivateMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id)); } - if (const auto result = editorModes.SetModeActive(mode); + if (const auto result = editorModes.ActivateMode(mode); !result.IsSuccess()) { return result; } ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeEnter, editorModes, mode); + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeActivate, editorModes, mode); return AZ::Success(); } - AZ::Outcome ViewportEditorModeTracker::UnregisterMode( + AZ::Outcome ViewportEditorModeTracker::DeactivateMode( const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { ViewportEditorModes* editorModes = nullptr; @@ -96,7 +96,7 @@ namespace AzToolsFramework if (!editorModes->IsModeActive(mode)) { return AZ::Failure(AZStd::string::format( - "Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id)); + "Duplicate call to DeactivateMode for mode '%u' on id '%i'", static_cast(mode), viewportEditorModeInfo.m_id)); } } else @@ -105,14 +105,14 @@ namespace AzToolsFramework editorModes = &m_viewportEditorModesMap[viewportEditorModeInfo.m_id]; } - if(const auto result = editorModes->SetModeInactive(mode); + if(const auto result = editorModes->DeactivateMode(mode); !result.IsSuccess()) { return result; } ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeExit, *editorModes, mode); + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeDeactivate, *editorModes, mode); if (modeWasActive) { @@ -121,7 +121,7 @@ namespace AzToolsFramework else { return AZ::Failure(AZStd::string::format( - "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(mode), + "Call to DeactivateMode for mode '%u' on id '%i' without precursor call to ActivateMode", static_cast(mode), viewportEditorModeInfo.m_id)); } } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index d67ea5d725..6ae68b39b2 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -21,15 +21,14 @@ namespace AzToolsFramework : public ViewportEditorModesInterface { public: - //! The number of currently supported viewport editor modes. static constexpr AZ::u8 NumEditorModes = 4; //! Sets the specified mode as active. - AZ::Outcome SetModeActive(ViewportEditorMode mode); + AZ::Outcome ActivateMode(ViewportEditorMode mode); // Sets the specified mode as inactive. - AZ::Outcome SetModeInactive(ViewportEditorMode mode); + AZ::Outcome DeactivateMode(ViewportEditorMode mode); // ViewportEditorModesInterface ... bool IsModeActive(ViewportEditorMode mode) const override; @@ -49,8 +48,8 @@ namespace AzToolsFramework void UnregisterInterface(); // ViewportEditorModeTrackerInterface overrides ... - AZ::Outcome RegisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; - AZ::Outcome UnregisterMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + AZ::Outcome ActivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; + AZ::Outcome DeactivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; size_t GetTrackedViewportCount() const override; bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override; diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 6103482f05..b3acd91bfe 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -19,15 +19,15 @@ namespace UnitTest using ViewportId = ViewportEditorModeInfo::IdType; using ViewportEditorModesInterface = AzToolsFramework::ViewportEditorModesInterface; - void SetModeActiveAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) + void ActivateModeAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) { - const auto result = editorModeState.SetModeActive(mode); + const auto result = editorModeState.ActivateMode(mode); EXPECT_TRUE(result.IsSuccess()); } - void SetModeInactiveAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) + void DeactivateModeAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) { - const auto result = editorModeState.SetModeInactive(mode); + const auto result = editorModeState.DeactivateMode(mode); EXPECT_TRUE(result.IsSuccess()); } @@ -35,7 +35,7 @@ namespace UnitTest { for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { - SetModeActiveAndExpectSuccess(editorModeState, static_cast(mode)); + ActivateModeAndExpectSuccess(editorModeState, static_cast(mode)); } } @@ -43,7 +43,7 @@ namespace UnitTest { for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { - SetModeInactiveAndExpectSuccess(editorModeState, static_cast(mode)); + DeactivateModeAndExpectSuccess(editorModeState, static_cast(mode)); } } @@ -111,12 +111,12 @@ namespace UnitTest return m_editorModes; } - void OnEditorModeEnter([[maybe_unused]]const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override + void OnEditorModeActivate([[maybe_unused]]const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onEnter = true; } - virtual void OnEditorModeExit([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override + virtual void OnEditorModeDeactivate([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onExit = true; } @@ -167,7 +167,7 @@ namespace UnitTest TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) { - SetModeActiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); + ActivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode); for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { @@ -186,7 +186,7 @@ namespace UnitTest TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) { SetAllModesActive(m_editorModes); - SetModeInactiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); + DeactivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode); for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) { @@ -209,7 +209,7 @@ namespace UnitTest // Given only the selected mode active SetAllModesInactive(m_editorModes); { - SetModeActiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); + ActivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode); } const auto editorMode = static_cast(mode); @@ -219,7 +219,7 @@ namespace UnitTest } // When other modes are activated - SetModeActiveAndExpectSuccess(m_editorModes, editorMode); + ActivateModeAndExpectSuccess(m_editorModes, editorMode); for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { @@ -244,7 +244,7 @@ namespace UnitTest { // Given only the selected mode inactive SetAllModesActive(m_editorModes); - SetModeInactiveAndExpectSuccess(m_editorModes, m_selectedEditorMode); + DeactivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode); const auto editorMode = static_cast(mode); if (editorMode == m_selectedEditorMode) @@ -253,7 +253,7 @@ namespace UnitTest } // When other modes are deactivated - SetModeInactiveAndExpectSuccess(m_editorModes, editorMode); + DeactivateModeAndExpectSuccess(m_editorModes, editorMode); for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++) { @@ -283,13 +283,13 @@ namespace UnitTest TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeActiveReturnsError) { - const auto result = m_editorModes.SetModeActive(static_cast(ViewportEditorModes::NumEditorModes)); + const auto result = m_editorModes.ActivateMode(static_cast(ViewportEditorModes::NumEditorModes)); EXPECT_FALSE(result.IsSuccess()); } TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeInactiveReturnsError) { - const auto result = m_editorModes.SetModeInactive(static_cast(ViewportEditorModes::NumEditorModes)); + const auto result = m_editorModes.DeactivateMode(static_cast(ViewportEditorModes::NumEditorModes)); EXPECT_FALSE(result.IsSuccess()); } @@ -307,7 +307,7 @@ namespace UnitTest // When a mode is activated for that viewport const auto editorMode = ViewportEditorMode::Default; - m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode); const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }); // Expect that viewport to now be tracked @@ -328,8 +328,8 @@ namespace UnitTest // When a mode is deactivated for that viewport const auto editorMode = ViewportEditorMode::Default; const auto expectedErrorMsg = AZStd::string::format( - "Call to UnregisterMode for mode '%u' on id '%i' without precursor call to RegisterMode", static_cast(editorMode), viewportid); - const auto result = m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); + "Call to DeactivateMode for mode '%u' on id '%i' without precursor call to ActivateMode", static_cast(editorMode), viewportid); + const auto result = m_viewportEditorModeTracker.DeactivateMode({ viewportid }, editorMode); // Expect an error due to no precursor activation of that mode EXPECT_FALSE(result.IsSuccess()); @@ -361,7 +361,7 @@ namespace UnitTest const auto editorMode = ViewportEditorMode::Default; { // When the mode is activated for the viewport - const auto result = m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode); // Expect no error as there is no duplicate activation EXPECT_TRUE(result.IsSuccess()); @@ -374,11 +374,11 @@ namespace UnitTest } { // When the mode is activated again for the viewport - const auto result = m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode); // Expect an error for the duplicate activation const auto expectedErrorMsg = AZStd::string::format( - "Duplicate call to RegisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + "Duplicate call to ActivateMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); EXPECT_FALSE(result.IsSuccess()); EXPECT_EQ(result.GetError(), expectedErrorMsg); @@ -400,8 +400,8 @@ namespace UnitTest const auto editorMode = ViewportEditorMode::Default; { // When the mode is activated and then deactivated for the viewport - m_viewportEditorModeTracker.RegisterMode({ viewportid }, editorMode); - const auto result = m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); + m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.DeactivateMode({ viewportid }, editorMode); // Expect no error as there is no duplicate deactivation EXPECT_TRUE(result.IsSuccess()); @@ -414,11 +414,11 @@ namespace UnitTest } { // When the mode is deactivated again for the viewport - const auto result = m_viewportEditorModeTracker.UnregisterMode({ viewportid }, editorMode); + const auto result = m_viewportEditorModeTracker.DeactivateMode({ viewportid }, editorMode); // Expect an error for the duplicate deactivation const auto expectedErrorMsg = AZStd::string::format( - "Duplicate call to UnregisterMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); + "Duplicate call to DeactivateMode for mode '%u' on id '%i'", static_cast(editorMode), viewportid); EXPECT_FALSE(result.IsSuccess()); EXPECT_EQ(result.GetError(), expectedErrorMsg); @@ -446,7 +446,7 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeTracker.RegisterMode({ mode }, editorMode); + m_viewportEditorModeTracker.ActivateMode({ mode }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -478,8 +478,8 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeTracker.RegisterMode({ mode }, editorMode); - m_viewportEditorModeTracker.UnregisterMode({ mode }, editorMode); + m_viewportEditorModeTracker.ActivateMode({ mode }, editorMode); + m_viewportEditorModeTracker.DeactivateMode({ mode }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) From 5a25511432fe3c9ad4272034c378356d6d3a651e Mon Sep 17 00:00:00 2001 From: John Date: Mon, 20 Sep 2021 13:06:01 +0100 Subject: [PATCH 16/27] Change tense of notification bus methods. Signed-off-by: John --- .../API/ViewportEditorModeTrackerNotificationBus.h | 4 ++-- .../ViewportSelection/ViewportEditorModeTracker.cpp | 4 ++-- .../Tests/Viewport/ViewportEditorModeTests.cpp | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h index d4e5dd4fbb..42a1cb0113 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h @@ -53,12 +53,12 @@ namespace AzToolsFramework ////////////////////////////////////////////////////////////////////////// //! Notifies subscribers of the a given viewport to the activation of the specified editor mode. - virtual void OnEditorModeActivate([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + virtual void OnEditorModeActivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) { } //! Notifies subscribers of the a given viewport to the deactivation of the specified editor mode. - virtual void OnEditorModeDeactivate([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) + virtual void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode) { } }; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 26f724b0aa..05d21fbf41 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -80,7 +80,7 @@ namespace AzToolsFramework } ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeActivate, editorModes, mode); + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeActivated, editorModes, mode); return AZ::Success(); } @@ -112,7 +112,7 @@ namespace AzToolsFramework } ViewportEditorModeNotificationsBus::Event( - viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeDeactivate, *editorModes, mode); + viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeDeactivated, *editorModes, mode); if (modeWasActive) { diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index b3acd91bfe..527f77b9b0 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -111,12 +111,12 @@ namespace UnitTest return m_editorModes; } - void OnEditorModeActivate([[maybe_unused]]const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override + void OnEditorModeActivated([[maybe_unused]]const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onEnter = true; } - virtual void OnEditorModeDeactivate([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override + virtual void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onExit = true; } From 1dc38518afb4d60f6a472aaa93515be1baef310b Mon Sep 17 00:00:00 2001 From: John Date: Mon, 20 Sep 2021 14:48:39 +0100 Subject: [PATCH 17/27] Fix malformed string format. Signed-off-by: John --- .../ViewportSelection/ViewportEditorModeTracker.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 05d21fbf41..fc16bf3384 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -24,7 +24,7 @@ namespace AzToolsFramework else { return AZ::Failure( - AZStd::string::format(ViewportEditorModeLogWindow, false, "Cannot activate mode %u, mode is not recognized", modeIndex)); + AZStd::string::format(ViewportEditorModeLogWindow, "Cannot activate mode %u, mode is not recognized", modeIndex)); } } @@ -38,7 +38,7 @@ namespace AzToolsFramework else { return AZ::Failure( - AZStd::string::format(ViewportEditorModeLogWindow, false, "Cannot deactivate mode %u, mode is not recognized", modeIndex)); + AZStd::string::format(ViewportEditorModeLogWindow, "Cannot deactivate mode %u, mode is not recognized", modeIndex)); } } From 7f3872f41b3c0f903dfe270419c88a0c6e5ac7cb Mon Sep 17 00:00:00 2001 From: John Date: Mon, 20 Sep 2021 15:27:34 +0100 Subject: [PATCH 18/27] Fix malformed string format (again). Signed-off-by: John --- .../ViewportSelection/ViewportEditorModeTracker.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index fc16bf3384..4adddb02e1 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -11,8 +11,6 @@ namespace AzToolsFramework { - static constexpr const char* ViewportEditorModeLogWindow = "ViewportEditorMode"; - AZ::Outcome ViewportEditorModes::ActivateMode(ViewportEditorMode mode) { if (const AZ::u32 modeIndex = static_cast(mode); @@ -24,7 +22,7 @@ namespace AzToolsFramework else { return AZ::Failure( - AZStd::string::format(ViewportEditorModeLogWindow, "Cannot activate mode %u, mode is not recognized", modeIndex)); + AZStd::string::format("Cannot activate mode %u, mode is not recognized", modeIndex)); } } @@ -38,7 +36,7 @@ namespace AzToolsFramework else { return AZ::Failure( - AZStd::string::format(ViewportEditorModeLogWindow, "Cannot deactivate mode %u, mode is not recognized", modeIndex)); + AZStd::string::format("Cannot deactivate mode %u, mode is not recognized", modeIndex)); } } From 5a36a375a6f0ab0183662dff0769483f401ccea8 Mon Sep 17 00:00:00 2001 From: John Date: Mon, 20 Sep 2021 15:44:18 +0100 Subject: [PATCH 19/27] Fix Linux warning. Signed-off-by: John --- .../Tests/Viewport/ViewportEditorModeTests.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 527f77b9b0..3954ef6dc6 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -446,7 +446,7 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeTracker.ActivateMode({ mode }, editorMode); + m_viewportEditorModeTracker.ActivateMode({ viewportId }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -478,8 +478,8 @@ namespace UnitTest { const ViewportId viewportId = mode; const ViewportEditorMode editorMode = static_cast(mode); - m_viewportEditorModeTracker.ActivateMode({ mode }, editorMode); - m_viewportEditorModeTracker.DeactivateMode({ mode }, editorMode); + m_viewportEditorModeTracker.ActivateMode({ viewportId }, editorMode); + m_viewportEditorModeTracker.DeactivateMode({ viewportId }, editorMode); } for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) From beaa90a96886baace124f79267354d8e60e14c37 Mon Sep 17 00:00:00 2001 From: John Date: Wed, 22 Sep 2021 16:24:33 +0100 Subject: [PATCH 20/27] Call sites for editor mode activate/deactivate. Signed-off-by: John --- AutomatedTesting/Levels/Floof/Floof.ly | 3 ++ AutomatedTesting/Levels/Floof/filelist.xml | 6 ++++ AutomatedTesting/Levels/Floof/level.pak | 3 ++ AutomatedTesting/Levels/Floof/tags.txt | 12 +++++++ .../ComponentMode/ComponentModeCollection.cpp | 4 +-- .../PropertyEditor/PropertyEntityIdCtrl.cpp | 5 +-- .../UnitTest/AzToolsFrameworkTestHelpers.h | 4 ++- .../EditorDefaultSelection.cpp | 32 +++++++++++++++++++ .../EditorDefaultSelection.h | 5 +++ .../EditorInteractionSystemComponent.cpp | 28 +++++++++++++--- .../EditorInteractionSystemComponent.h | 15 +++++++++ ...ractionSystemViewportSelectionRequestBus.h | 5 +-- .../EditorPickEntitySelection.cpp | 17 ++++++++++ .../EditorPickEntitySelection.h | 7 +++- .../ViewportEditorModeTracker.cpp | 16 ---------- .../ViewportEditorModeTracker.h | 6 ---- ...EditorTransformComponentSelectionTests.cpp | 3 +- .../Viewport/ViewportEditorModeTests.cpp | 22 +++++++++---- 18 files changed, 152 insertions(+), 41 deletions(-) create mode 100644 AutomatedTesting/Levels/Floof/Floof.ly create mode 100644 AutomatedTesting/Levels/Floof/filelist.xml create mode 100644 AutomatedTesting/Levels/Floof/level.pak create mode 100644 AutomatedTesting/Levels/Floof/tags.txt diff --git a/AutomatedTesting/Levels/Floof/Floof.ly b/AutomatedTesting/Levels/Floof/Floof.ly new file mode 100644 index 0000000000..aa7ed0d9db --- /dev/null +++ b/AutomatedTesting/Levels/Floof/Floof.ly @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3473284ee7f390280fb71090da8c1754791a3753fc1532e6b6a69842f2d4e23f +size 8605 diff --git a/AutomatedTesting/Levels/Floof/filelist.xml b/AutomatedTesting/Levels/Floof/filelist.xml new file mode 100644 index 0000000000..82409c84cd --- /dev/null +++ b/AutomatedTesting/Levels/Floof/filelist.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/AutomatedTesting/Levels/Floof/level.pak b/AutomatedTesting/Levels/Floof/level.pak new file mode 100644 index 0000000000..e9374fe73f --- /dev/null +++ b/AutomatedTesting/Levels/Floof/level.pak @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9577257254e5938790ec3445689a9b59bc1715c7f1aaaad81150b9468e72cbfa +size 1346 diff --git a/AutomatedTesting/Levels/Floof/tags.txt b/AutomatedTesting/Levels/Floof/tags.txt new file mode 100644 index 0000000000..0d6c1880e7 --- /dev/null +++ b/AutomatedTesting/Levels/Floof/tags.txt @@ -0,0 +1,12 @@ +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp index 0259142135..5527a35f88 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp @@ -8,8 +8,8 @@ #include "ComponentModeCollection.h" -#include #include +#include namespace AzToolsFramework { @@ -17,7 +17,7 @@ namespace AzToolsFramework { AZ_CLASS_ALLOCATOR_IMPL(ComponentModeCollection, AZ::SystemAllocator, 0) - static const char* const s_nextActiveComponentModeTitle = "Edit Next"; + static const char* const s_nextActiveComponentModeTitle = "Edit Next"; static const char* const s_previousActiveComponentModeTitle = "Edit Previous"; static const char* const s_nextActiveComponentModeDesc = "Move to the next component"; static const char* const s_prevActiveComponentModeDesc = "Move to the previous component"; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEntityIdCtrl.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEntityIdCtrl.cpp index f98638fd69..7a9a5a4d7a 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEntityIdCtrl.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEntityIdCtrl.cpp @@ -119,11 +119,12 @@ namespace AzToolsFramework // replace the default input handler with one specific for dealing with // entity selection in the viewport + EditorInteractionSystemViewportSelectionRequestBus::Event( GetEntityContextId(), &EditorInteractionSystemViewportSelection::SetHandler, - [](const EditorVisibleEntityDataCache* entityDataCache) + [](const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) { - return AZStd::make_unique(entityDataCache); + return AZStd::make_unique(entityDataCache, viewportEditorModeTracker); }); if (!pickModeEntityContextId.IsNull()) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h b/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h index b3a660d0f2..a67562af76 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -166,7 +167,8 @@ namespace UnitTest m_editorActions.Connect(); const auto viewportHandlerBuilder = - [this](const AzToolsFramework::EditorVisibleEntityDataCache* entityDataCache) + [this](const AzToolsFramework::EditorVisibleEntityDataCache* entityDataCache, + [[maybe_unused]] AzToolsFramework::ViewportEditorModeTrackerInterface* viewportEditorModeTracker) { // create the default viewport (handles ComponentMode) AZStd::unique_ptr defaultSelection = diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp index 7903668409..0b23756365 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp @@ -9,6 +9,7 @@ #include "EditorDefaultSelection.h" #include +#include #include #include #include @@ -30,10 +31,25 @@ namespace AzToolsFramework m_transformComponentSelection = AZStd::make_unique(entityDataCache); } + EditorDefaultSelection::EditorDefaultSelection( + const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) + : EditorDefaultSelection(entityDataCache) + { + m_viewportEditorModeTracker = viewportEditorModeTracker; + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Default); + } + } + EditorDefaultSelection::~EditorDefaultSelection() { ComponentModeFramework::ComponentModeSystemRequestBus::Handler::BusDisconnect(); ActionOverrideRequestBus::Handler::BusDisconnect(); + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Default); + } } void EditorDefaultSelection::SetOverridePhantomWidget(QWidget* phantomOverrideWidget) @@ -91,6 +107,14 @@ namespace AzToolsFramework m_componentModeCollection.BeginComponentMode(); + // this call to activate the component mode editor state should eventually replace the bus call in + // ComponentModeCollection::BeginComponentMode() to EditorComponentModeNotifications::EnteredComponentMode + // such that all of the notifications for activating/deactivating the different editor modes are in a central location + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); + } + // refresh button ui ToolsApplicationEvents::Bus::Broadcast( &ToolsApplicationEvents::Bus::Events::InvalidatePropertyDisplay, PropertyModificationRefreshLevel::Refresh_EntireTree); @@ -100,6 +124,14 @@ namespace AzToolsFramework { m_componentModeCollection.EndComponentMode(); + // this call to deactivate the component mode editor state should eventually replace the bus call in + // ComponentModeCollection::EndComponentMode() to EditorComponentModeNotifications::LeftComponentMode + // such that all of the notifications for activating/deactivating the different editor modes are in a central location + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); + } + if (m_transformComponentSelection) { // safe to show manipulators again diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h index 5763bf227c..6a53a2b186 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h @@ -15,6 +15,8 @@ namespace AzToolsFramework { + class ViewportEditorModeTrackerInterface; + //! The default selection/input handler for the editor (includes handling ComponentMode). class EditorDefaultSelection : public ViewportInteraction::InternalViewportSelectionRequests @@ -26,6 +28,7 @@ namespace AzToolsFramework //! @cond explicit EditorDefaultSelection(const EditorVisibleEntityDataCache* entityDataCache); + explicit EditorDefaultSelection(const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker); EditorDefaultSelection(const EditorDefaultSelection&) = delete; EditorDefaultSelection& operator=(const EditorDefaultSelection&) = delete; virtual ~EditorDefaultSelection(); @@ -110,5 +113,7 @@ namespace AzToolsFramework AZStd::shared_ptr m_manipulatorManager; //!< The default manipulator manager. ViewportInteraction::MouseInteraction m_currentInteraction; //!< Current mouse interaction to be used for drawing manipulators. + ViewportEditorModeTrackerInterface* m_viewportEditorModeTracker = nullptr; //!< Tracker for activating/deactivating viewport editor modes. + }; } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp index 7002436d13..7f84038ace 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp @@ -10,9 +10,28 @@ #include #include +#include namespace AzToolsFramework { + EditorInteractionSystemComponent::EditorInteractionSystemComponent() + : m_viewportEditorMode(AZStd::make_unique()) + { + if (AZ::Interface::Get() == nullptr) + { + AZ::Interface::Register(m_viewportEditorMode.get()); + } + } + + EditorInteractionSystemComponent::~EditorInteractionSystemComponent() + { + m_interactionRequests.reset(); + if (AZ::Interface::Get() != nullptr) + { + AZ::Interface::Unregister(m_viewportEditorMode.get()); + } + } + void EditorInteractionSystemComponent::Activate() { EditorInteractionSystemViewportSelectionRequestBus::Handler::BusConnect(GetEntityContextId()); @@ -41,7 +60,8 @@ namespace AzToolsFramework return m_interactionRequests->InternalHandleMouseManipulatorInteraction(mouseInteraction); } - void EditorInteractionSystemComponent::SetHandler(const ViewportSelectionRequestsBuilderFn& interactionRequestsBuilder) + void EditorInteractionSystemComponent::SetHandler( + const ViewportSelectionRequestsBuilderFn& interactionRequestsBuilder) { // when setting a handler, make sure we're connected to the ViewportDebugDisplayEventBus so we // can forward calls to the specific type implementing ViewportSelectionRequests @@ -59,7 +79,7 @@ namespace AzToolsFramework m_entityDataCache = AZStd::make_unique(); m_interactionRequests.reset(); // BusConnect/Disconnect in constructor/destructor, // so have to reset before assigning the new one - m_interactionRequests = interactionRequestsBuilder(m_entityDataCache.get()); + m_interactionRequests = interactionRequestsBuilder(m_entityDataCache.get(), m_viewportEditorMode.get()); } EditorInteractionSystemViewportSelectionRequestBus::Handler::BusConnect(GetEntityContextId()); @@ -68,9 +88,9 @@ namespace AzToolsFramework void EditorInteractionSystemComponent::SetDefaultHandler() { SetHandler( - [](const EditorVisibleEntityDataCache* entityDataCache) + [](const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) { - return AZStd::make_unique(entityDataCache); + return AZStd::make_unique(entityDataCache, viewportEditorModeTracker); }); } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h index 17521eab14..7bbc0ee009 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h @@ -12,8 +12,18 @@ #include #include + + + + + + +#include + namespace AzToolsFramework { + //class ViewportEditorModeTracker; + //! System Component to wrap active input handler. //! EditorInteractionSystemComponent is notified of viewport mouse events from RenderViewport //! and forwards them to a concrete implementation of ViewportSelectionRequests. @@ -26,6 +36,9 @@ namespace AzToolsFramework public: AZ_COMPONENT(EditorInteractionSystemComponent, "{146D0317-AF42-45AB-A953-F54198525DD5}") + EditorInteractionSystemComponent(); + ~EditorInteractionSystemComponent(); + static void Reflect(AZ::ReflectContext* context); // EditorInteractionSystemViewportSelectionRequestBus @@ -54,5 +67,7 @@ namespace AzToolsFramework AZStd::unique_ptr m_interactionRequests; //!< Hold a concrete implementation of //!< ViewportSelectionRequests to handle viewport //!< input and drawing for the Editor. + + AZStd::unique_ptr m_viewportEditorMode; //!< Editor mode tracker for each viewport. }; } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemViewportSelectionRequestBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemViewportSelectionRequestBus.h index ee3f83f74d..3579460ca0 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemViewportSelectionRequestBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemViewportSelectionRequestBus.h @@ -17,6 +17,7 @@ namespace AzToolsFramework { class EditorVisibleEntityDataCache; + class ViewportEditorModeTrackerInterface; //! Bus to handle all mouse events originating from the viewport. //! Coordinated by the EditorInteractionSystemComponent @@ -32,8 +33,8 @@ namespace AzToolsFramework }; //! Alias for factory function to create a new type implementing the ViewportSelectionRequests interface. - using ViewportSelectionRequestsBuilderFn = - AZStd::function(const EditorVisibleEntityDataCache*)>; + using ViewportSelectionRequestsBuilderFn = AZStd::function( + const EditorVisibleEntityDataCache*, ViewportEditorModeTrackerInterface*)>; //! Interface for system component implementing the ViewportSelectionRequests interface. //! This interface also includes a setter to set a custom handler also implementing diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp index ea1bc73056..9306deb69d 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp @@ -8,6 +8,7 @@ #include "EditorPickEntitySelection.h" +#include #include #include @@ -20,12 +21,28 @@ namespace AzToolsFramework { } + EditorPickEntitySelection::EditorPickEntitySelection( + const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) + : EditorPickEntitySelection(entityDataCache) + { + m_viewportEditorModeTracker = viewportEditorModeTracker; + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Pick); + } + } + EditorPickEntitySelection::~EditorPickEntitySelection() { if (m_hoveredEntityId.IsValid()) { ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequests::SetEntityHighlighted, m_hoveredEntityId, false); } + + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Pick); + } } // note: entityIdUnderCursor is the authoritative entityId we get each frame by querying diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h index e8d83af932..511111743a 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h @@ -13,6 +13,8 @@ namespace AzToolsFramework { + class ViewportEditorModeTrackerInterface; + //! Viewport interaction that will handle assigning an entity in the viewport to //! an entity field in the entity inspector. class EditorPickEntitySelection : public ViewportInteraction::InternalViewportSelectionRequests @@ -20,7 +22,9 @@ namespace AzToolsFramework public: AZ_CLASS_ALLOCATOR_DECL - EditorPickEntitySelection(const EditorVisibleEntityDataCache* entityDataCache); + explicit EditorPickEntitySelection(const EditorVisibleEntityDataCache* entityDataCache); + explicit EditorPickEntitySelection( + const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker); ~EditorPickEntitySelection(); private: @@ -32,5 +36,6 @@ namespace AzToolsFramework AZStd::unique_ptr m_editorHelpers; //!< Editor visualization of entities (icons, shapes, debug visuals etc). AZ::EntityId m_hoveredEntityId; //!< What EntityId is the mouse currently hovering over (if any). AZ::EntityId m_cachedEntityIdUnderCursor; //!< Store the EntityId on each mouse move for use in Display. + ViewportEditorModeTrackerInterface* m_viewportEditorModeTracker = nullptr; //!< Tracker for activating/deactivating viewport editor modes. }; } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp index 4adddb02e1..105712c789 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp @@ -45,22 +45,6 @@ namespace AzToolsFramework return m_editorModes[static_cast(mode)]; } - void ViewportEditorModeTracker::RegisterInterface() - { - if (AZ::Interface::Get() == nullptr) - { - AZ::Interface::Register(this); - } - } - - void ViewportEditorModeTracker::UnregisterInterface() - { - if (AZ::Interface::Get() != nullptr) - { - AZ::Interface::Unregister(this); - } - } - AZ::Outcome ViewportEditorModeTracker::ActivateMode( const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) { diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h index 6ae68b39b2..5b382c44e7 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h @@ -41,12 +41,6 @@ namespace AzToolsFramework : public ViewportEditorModeTrackerInterface { public: - //! Registers this object with the AZ::Interface. - void RegisterInterface(); - - //! Unregisters this object with the AZ::Interface. - void UnregisterInterface(); - // ViewportEditorModeTrackerInterface overrides ... AZ::Outcome ActivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; AZ::Outcome DeactivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override; diff --git a/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp b/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp index 449c4549be..1316523f29 100644 --- a/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp @@ -343,7 +343,8 @@ namespace UnitTest using AzToolsFramework::EditorInteractionSystemViewportSelectionRequestBus; EditorInteractionSystemViewportSelectionRequestBus::Event( AzToolsFramework::GetEntityContextId(), &EditorInteractionSystemViewportSelectionRequestBus::Events::SetHandler, - [](const AzToolsFramework::EditorVisibleEntityDataCache* entityDataCache) + [](const AzToolsFramework::EditorVisibleEntityDataCache* entityDataCache, + [[maybe_unused]] AzToolsFramework::ViewportEditorModeTrackerInterface* viewportEditorModeTracker) { return AZStd::make_unique(entityDataCache); }); diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 3954ef6dc6..b2b75e22a7 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -152,6 +152,12 @@ namespace UnitTest AZStd::array, ViewportEditorModes::NumEditorModes> m_editorModeHandlers; }; + // Fixture for testing the integration of viewport editor mode state tracker + class ViewportEditorModeTrackerIntegrationTestFixture + : public ToolsApplicationFixture + { + }; + TEST_F(ViewportEditorModesTestsFixture, NumberOfEditorModesIsEqualTo4) { EXPECT_EQ(ViewportEditorModes::NumEditorModes, 4); @@ -298,7 +304,7 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetTrackedViewportCount(), 0); } - TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) + TEST_F(ViewportEditorModeTrackerTestFixture, ActivatingViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -318,7 +324,7 @@ namespace UnitTest EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode)); } - TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButReturnsError) + TEST_F(ViewportEditorModeTrackerTestFixture, DeactivatingViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButReturnsError) { // Given a viewport not currently being tracked const ViewportId viewportid = 0; @@ -351,7 +357,7 @@ namespace UnitTest EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr); } - TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModesForExistingIdInThatStateReturnsError) + TEST_F(ViewportEditorModeTrackerTestFixture, ActivatingViewportEditorModesForExistingIdInThatStateReturnsError) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -390,7 +396,7 @@ namespace UnitTest } } - TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModesForExistingIdNotInThatStateReturnssError) + TEST_F(ViewportEditorModeTrackerTestFixture, DeactivatingViewportEditorModesForExistingIdNotInThatStateReturnssError) { // Given a viewport not currently tracked const ViewportId viewportid = 0; @@ -432,7 +438,7 @@ namespace UnitTest TEST_F( ViewportEditorModePublisherTestFixture, - RegisteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeRegisterEventForAllSubscribers) + ActivatingViewportEditorModesForExistingIdPublishesOnViewportEditorModeActivateEventForAllSubscribers) { // Given a set of subscribers tracking the editor modes for their exclusive viewport for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -465,7 +471,7 @@ namespace UnitTest TEST_F( ViewportEditorModePublisherTestFixture, - UnregisteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeUnregisterEventForAllSubscribers) + DeactivatingViewportEditorModesForExistingIdPublishesOnViewportEditorModeDeactivatingEventForAllSubscribers) { // Given a set of subscribers tracking the editor modes for their exclusive viewport for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) @@ -495,4 +501,8 @@ namespace UnitTest EXPECT_TRUE(expectedEditorModeSet->second.m_onExit); } } + + TEST_F(ViewportEditorModeTrackerIntegrationTestFixture, FOO) + { + } } // namespace UnitTest From 4909c91614389d48db63e4216a3f4a4ed2ae8389 Mon Sep 17 00:00:00 2001 From: John Date: Wed, 22 Sep 2021 16:46:44 +0100 Subject: [PATCH 21/27] Move Component editor mode logic to ComponentModeCollection. Signed-off-by: John --- .../ComponentMode/ComponentModeCollection.cpp | 21 +++++++++++++++++++ .../ComponentMode/ComponentModeCollection.h | 3 +++ .../EditorDefaultSelection.cpp | 16 -------------- 3 files changed, 24 insertions(+), 16 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp index 5527a35f88..dddaa679bf 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp @@ -9,6 +9,7 @@ #include "ComponentModeCollection.h" #include +#include #include namespace AzToolsFramework @@ -119,6 +120,11 @@ namespace AzToolsFramework } }; + ComponentModeCollection::ComponentModeCollection(ViewportEditorModeTrackerInterface* viewportEditorModeTracker) + : m_viewportEditorModeTracker(viewportEditorModeTracker) + { + } + void ComponentModeCollection::AddComponentMode( const AZ::EntityComponentIdPair& entityComponentIdPair, const AZ::Uuid componentType, const ComponentModeFactoryFunction& componentModeBuilder) @@ -209,6 +215,14 @@ namespace AzToolsFramework GetEntityContextId(), &EditorComponentModeNotifications::EnteredComponentMode, m_activeComponentTypes); + // this call to activate the component mode editor state should eventually replace the bus call in + // ComponentModeCollection::BeginComponentMode() to EditorComponentModeNotifications::EnteredComponentMode + // such that all of the notifications for activating/deactivating the different editor modes are in a central location + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); + } + // enable actions for the first/primary ComponentMode // note: if multiple ComponentModes are activated at the same time, actions // are not available together, the 'active' mode will bind its actions one at a time @@ -282,6 +296,13 @@ namespace AzToolsFramework &EditorComponentModeNotifications::LeftComponentMode, m_activeComponentTypes); + // this call to deactivate the component mode editor state should eventually replace the bus call in + // ComponentModeCollection::EndComponentMode() to EditorComponentModeNotifications::LeftComponentMode + // such that all of the notifications for activating/deactivating the different editor modes are in a central location + if (m_viewportEditorModeTracker) + { + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); + } // clear stored modes and builders for this ComponentMode // TLDR: avoid 'use after free' error diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h index 7dd97dc0c9..b295d6103b 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h @@ -15,6 +15,7 @@ namespace AzToolsFramework { class EditorMetricsEventsBusTraits; + class ViewportEditorModeTrackerInterface; namespace ComponentModeFramework { @@ -26,6 +27,7 @@ namespace AzToolsFramework /// @cond ComponentModeCollection() = default; + ComponentModeCollection(ViewportEditorModeTrackerInterface* viewportEditorModeTracker); ~ComponentModeCollection() = default; ComponentModeCollection(const ComponentModeCollection&) = delete; ComponentModeCollection& operator=(const ComponentModeCollection&) = delete; @@ -101,6 +103,7 @@ namespace AzToolsFramework size_t m_selectedComponentModeIndex = 0; ///< Index into the array of active ComponentModes, current index is 'selected' ComponentMode. bool m_adding = false; ///< Are we currently adding individual ComponentModes to the Editor wide ComponentMode. bool m_componentMode = false; ///< Editor (global) ComponentMode flag - is ComponentMode active or not. + ViewportEditorModeTrackerInterface* m_viewportEditorModeTracker = nullptr; //!< Tracker for activating/deactivating viewport editor modes. }; } // namespace ComponentModeFramework } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp index 0b23756365..321549585a 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp @@ -107,14 +107,6 @@ namespace AzToolsFramework m_componentModeCollection.BeginComponentMode(); - // this call to activate the component mode editor state should eventually replace the bus call in - // ComponentModeCollection::BeginComponentMode() to EditorComponentModeNotifications::EnteredComponentMode - // such that all of the notifications for activating/deactivating the different editor modes are in a central location - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); - } - // refresh button ui ToolsApplicationEvents::Bus::Broadcast( &ToolsApplicationEvents::Bus::Events::InvalidatePropertyDisplay, PropertyModificationRefreshLevel::Refresh_EntireTree); @@ -124,14 +116,6 @@ namespace AzToolsFramework { m_componentModeCollection.EndComponentMode(); - // this call to deactivate the component mode editor state should eventually replace the bus call in - // ComponentModeCollection::EndComponentMode() to EditorComponentModeNotifications::LeftComponentMode - // such that all of the notifications for activating/deactivating the different editor modes are in a central location - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); - } - if (m_transformComponentSelection) { // safe to show manipulators again From 071d3eaa311046d2850a7957b74e5d475c220a54 Mon Sep 17 00:00:00 2001 From: John Date: Wed, 22 Sep 2021 16:49:22 +0100 Subject: [PATCH 22/27] Delete non-source data. Signed-off-by: John --- AutomatedTesting/Levels/Floof/Floof.ly | 3 --- AutomatedTesting/Levels/Floof/filelist.xml | 6 ------ AutomatedTesting/Levels/Floof/level.pak | 3 --- AutomatedTesting/Levels/Floof/tags.txt | 12 ------------ 4 files changed, 24 deletions(-) delete mode 100644 AutomatedTesting/Levels/Floof/Floof.ly delete mode 100644 AutomatedTesting/Levels/Floof/filelist.xml delete mode 100644 AutomatedTesting/Levels/Floof/level.pak delete mode 100644 AutomatedTesting/Levels/Floof/tags.txt diff --git a/AutomatedTesting/Levels/Floof/Floof.ly b/AutomatedTesting/Levels/Floof/Floof.ly deleted file mode 100644 index aa7ed0d9db..0000000000 --- a/AutomatedTesting/Levels/Floof/Floof.ly +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:3473284ee7f390280fb71090da8c1754791a3753fc1532e6b6a69842f2d4e23f -size 8605 diff --git a/AutomatedTesting/Levels/Floof/filelist.xml b/AutomatedTesting/Levels/Floof/filelist.xml deleted file mode 100644 index 82409c84cd..0000000000 --- a/AutomatedTesting/Levels/Floof/filelist.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/AutomatedTesting/Levels/Floof/level.pak b/AutomatedTesting/Levels/Floof/level.pak deleted file mode 100644 index e9374fe73f..0000000000 --- a/AutomatedTesting/Levels/Floof/level.pak +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:9577257254e5938790ec3445689a9b59bc1715c7f1aaaad81150b9468e72cbfa -size 1346 diff --git a/AutomatedTesting/Levels/Floof/tags.txt b/AutomatedTesting/Levels/Floof/tags.txt deleted file mode 100644 index 0d6c1880e7..0000000000 --- a/AutomatedTesting/Levels/Floof/tags.txt +++ /dev/null @@ -1,12 +0,0 @@ -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 -0,0,0,0,0,0 From 15e6d999c2a61f97b56f5b79f4db0e21eac62c8a Mon Sep 17 00:00:00 2001 From: John Date: Wed, 22 Sep 2021 16:53:01 +0100 Subject: [PATCH 23/27] Remove line breaks and forward declare class. Signed-off-by: John --- .../EditorInteractionSystemComponent.h | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h index 7bbc0ee009..856fd2e326 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.h @@ -12,17 +12,9 @@ #include #include - - - - - - -#include - namespace AzToolsFramework { - //class ViewportEditorModeTracker; + class ViewportEditorModeTracker; //! System Component to wrap active input handler. //! EditorInteractionSystemComponent is notified of viewport mouse events from RenderViewport From a94f7c222dee3317d942292b60041051ad0e7202 Mon Sep 17 00:00:00 2001 From: John Date: Mon, 27 Sep 2021 09:23:26 +0100 Subject: [PATCH 24/27] Remove constructors without ViewportEditorModeTrackerInterface ptr. Signed-off-by: John --- .../ComponentMode/ComponentModeCollection.cpp | 10 ++------- .../ComponentMode/ComponentModeCollection.h | 3 +-- .../UnitTest/AzToolsFrameworkTestHelpers.h | 2 +- .../EditorDefaultSelection.cpp | 22 +++++-------------- .../EditorDefaultSelection.h | 3 +-- .../EditorPickEntitySelection.cpp | 18 +++------------ .../EditorPickEntitySelection.h | 3 +-- ...EditorTransformComponentSelectionTests.cpp | 2 +- 8 files changed, 16 insertions(+), 47 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp index dddaa679bf..4d849466ee 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp @@ -218,10 +218,7 @@ namespace AzToolsFramework // this call to activate the component mode editor state should eventually replace the bus call in // ComponentModeCollection::BeginComponentMode() to EditorComponentModeNotifications::EnteredComponentMode // such that all of the notifications for activating/deactivating the different editor modes are in a central location - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); - } + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); // enable actions for the first/primary ComponentMode // note: if multiple ComponentModes are activated at the same time, actions @@ -299,10 +296,7 @@ namespace AzToolsFramework // this call to deactivate the component mode editor state should eventually replace the bus call in // ComponentModeCollection::EndComponentMode() to EditorComponentModeNotifications::LeftComponentMode // such that all of the notifications for activating/deactivating the different editor modes are in a central location - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); - } + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Component); // clear stored modes and builders for this ComponentMode // TLDR: avoid 'use after free' error diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h index b295d6103b..9e299d2323 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h @@ -26,8 +26,7 @@ namespace AzToolsFramework AZ_CLASS_ALLOCATOR_DECL /// @cond - ComponentModeCollection() = default; - ComponentModeCollection(ViewportEditorModeTrackerInterface* viewportEditorModeTracker); + explicit ComponentModeCollection(ViewportEditorModeTrackerInterface* viewportEditorModeTracker); ~ComponentModeCollection() = default; ComponentModeCollection(const ComponentModeCollection&) = delete; ComponentModeCollection& operator=(const ComponentModeCollection&) = delete; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h b/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h index a67562af76..c4aefecce5 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h @@ -172,7 +172,7 @@ namespace UnitTest { // create the default viewport (handles ComponentMode) AZStd::unique_ptr defaultSelection = - AZStd::make_unique(entityDataCache); + AZStd::make_unique(entityDataCache, viewportEditorModeTracker); // override the phantom widget so we can use out custom test widget defaultSelection->SetOverridePhantomWidget(&m_editorActions.m_componentModeWidget); diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp index 321549585a..30958cfbc1 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp @@ -20,36 +20,26 @@ namespace AzToolsFramework { AZ_CLASS_ALLOCATOR_IMPL(EditorDefaultSelection, AZ::SystemAllocator, 0) - EditorDefaultSelection::EditorDefaultSelection(const EditorVisibleEntityDataCache* entityDataCache) + EditorDefaultSelection::EditorDefaultSelection( + const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) : m_phantomWidget(nullptr) , m_entityDataCache(entityDataCache) + , m_viewportEditorModeTracker(viewportEditorModeTracker) + , m_componentModeCollection(viewportEditorModeTracker) { ActionOverrideRequestBus::Handler::BusConnect(GetEntityContextId()); ComponentModeFramework::ComponentModeSystemRequestBus::Handler::BusConnect(); m_manipulatorManager = AZStd::make_shared(AzToolsFramework::g_mainManipulatorManagerId); m_transformComponentSelection = AZStd::make_unique(entityDataCache); - } - - EditorDefaultSelection::EditorDefaultSelection( - const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) - : EditorDefaultSelection(entityDataCache) - { - m_viewportEditorModeTracker = viewportEditorModeTracker; - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Default); - } + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Default); } EditorDefaultSelection::~EditorDefaultSelection() { ComponentModeFramework::ComponentModeSystemRequestBus::Handler::BusDisconnect(); ActionOverrideRequestBus::Handler::BusDisconnect(); - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Default); - } + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Default); } void EditorDefaultSelection::SetOverridePhantomWidget(QWidget* phantomOverrideWidget) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h index 6a53a2b186..e4c794e99e 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h @@ -27,8 +27,7 @@ namespace AzToolsFramework AZ_CLASS_ALLOCATOR_DECL //! @cond - explicit EditorDefaultSelection(const EditorVisibleEntityDataCache* entityDataCache); - explicit EditorDefaultSelection(const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker); + EditorDefaultSelection(const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker); EditorDefaultSelection(const EditorDefaultSelection&) = delete; EditorDefaultSelection& operator=(const EditorDefaultSelection&) = delete; virtual ~EditorDefaultSelection(); diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp index 9306deb69d..1e0f42d01a 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp @@ -16,20 +16,11 @@ namespace AzToolsFramework { AZ_CLASS_ALLOCATOR_IMPL(EditorPickEntitySelection, AZ::SystemAllocator, 0) - EditorPickEntitySelection::EditorPickEntitySelection(const EditorVisibleEntityDataCache* entityDataCache) - : m_editorHelpers(AZStd::make_unique(entityDataCache)) - { - } - EditorPickEntitySelection::EditorPickEntitySelection( const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker) - : EditorPickEntitySelection(entityDataCache) + : m_editorHelpers(AZStd::make_unique(entityDataCache)) + , m_viewportEditorModeTracker(viewportEditorModeTracker) { - m_viewportEditorModeTracker = viewportEditorModeTracker; - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Pick); - } } EditorPickEntitySelection::~EditorPickEntitySelection() @@ -39,10 +30,7 @@ namespace AzToolsFramework ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequests::SetEntityHighlighted, m_hoveredEntityId, false); } - if (m_viewportEditorModeTracker) - { - m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Pick); - } + m_viewportEditorModeTracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Pick); } // note: entityIdUnderCursor is the authoritative entityId we get each frame by querying diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h index 511111743a..62fa4161b7 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.h @@ -22,8 +22,7 @@ namespace AzToolsFramework public: AZ_CLASS_ALLOCATOR_DECL - explicit EditorPickEntitySelection(const EditorVisibleEntityDataCache* entityDataCache); - explicit EditorPickEntitySelection( + EditorPickEntitySelection( const EditorVisibleEntityDataCache* entityDataCache, ViewportEditorModeTrackerInterface* viewportEditorModeTracker); ~EditorPickEntitySelection(); diff --git a/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp b/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp index 1316523f29..b6170e4b89 100644 --- a/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp @@ -346,7 +346,7 @@ namespace UnitTest [](const AzToolsFramework::EditorVisibleEntityDataCache* entityDataCache, [[maybe_unused]] AzToolsFramework::ViewportEditorModeTrackerInterface* viewportEditorModeTracker) { - return AZStd::make_unique(entityDataCache); + return AZStd::make_unique(entityDataCache, viewportEditorModeTracker); }); // When From 5ebe66c5b686b820b80c38b0be8a29240285cdb6 Mon Sep 17 00:00:00 2001 From: John Date: Mon, 27 Sep 2021 13:10:47 +0100 Subject: [PATCH 25/27] Add integration tests for viewport editor modes. Signed-off-by: John --- .../EditorPickEntitySelection.cpp | 1 + .../Viewport/ViewportEditorModeTests.cpp | 111 +++++++++++++----- 2 files changed, 84 insertions(+), 28 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp index 1e0f42d01a..18eda140a0 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp @@ -21,6 +21,7 @@ namespace AzToolsFramework : m_editorHelpers(AZStd::make_unique(entityDataCache)) , m_viewportEditorModeTracker(viewportEditorModeTracker) { + m_viewportEditorModeTracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Pick); } EditorPickEntitySelection::~EditorPickEntitySelection() diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index b2b75e22a7..371bfb2648 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -7,7 +7,9 @@ */ #include +#include #include +#include #include namespace UnitTest @@ -18,6 +20,7 @@ namespace UnitTest using ViewportEditorModeInfo = AzToolsFramework::ViewportEditorModeInfo; using ViewportId = ViewportEditorModeInfo::IdType; using ViewportEditorModesInterface = AzToolsFramework::ViewportEditorModesInterface; + using ViewportEditorModeTrackerInterface = AzToolsFramework::ViewportEditorModeTrackerInterface; void ActivateModeAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode) { @@ -47,6 +50,26 @@ namespace UnitTest } } + void ExpectOnlyModeActive(const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) + { + for (auto modeIndex = 0; modeIndex < ViewportEditorModes::NumEditorModes; modeIndex++) + { + const auto currentMode = static_cast(modeIndex); + const bool expectedActive = (mode == currentMode); + EXPECT_EQ(editorModeState.IsModeActive(currentMode), expectedActive); + } + } + + void ExpectOnlyModeInactive(const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) + { + for (auto modeIndex = 0; modeIndex < ViewportEditorModes::NumEditorModes; modeIndex++) + { + const auto currentMode = static_cast(modeIndex); + const bool expectedActive = (mode != currentMode); + EXPECT_EQ(editorModeState.IsModeActive(currentMode), expectedActive); + } + } + // Fixture for testing editor mode states class ViewportEditorModesTestsFixture : public ::testing::Test @@ -116,7 +139,7 @@ namespace UnitTest m_editorModes[mode].m_onEnter = true; } - virtual void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override + void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override { m_editorModes[mode].m_onExit = true; } @@ -156,6 +179,16 @@ namespace UnitTest class ViewportEditorModeTrackerIntegrationTestFixture : public ToolsApplicationFixture { + public: + void SetUpEditorFixtureImpl() override + { + m_viewportEditorModeTracker = AZ::Interface::Get(); + ASSERT_NE(m_viewportEditorModeTracker, nullptr); + m_viewportEditorModes = m_viewportEditorModeTracker->GetViewportEditorModes({}); + } + + ViewportEditorModeTrackerInterface* m_viewportEditorModeTracker = nullptr; + const ViewportEditorModesInterface* m_viewportEditorModes = nullptr; }; TEST_F(ViewportEditorModesTestsFixture, NumberOfEditorModesIsEqualTo4) @@ -174,38 +207,14 @@ namespace UnitTest TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode) { ActivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode); - - for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) - { - const auto editorMode = static_cast(mode); - if (editorMode == m_selectedEditorMode) - { - EXPECT_TRUE(m_editorModes.IsModeActive(static_cast(editorMode))); - } - else - { - EXPECT_FALSE(m_editorModes.IsModeActive(static_cast(editorMode))); - } - } + ExpectOnlyModeActive(m_editorModes, m_selectedEditorMode); } TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode) { SetAllModesActive(m_editorModes); DeactivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode); - - for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++) - { - const auto editorMode = static_cast(mode); - if (editorMode == m_selectedEditorMode) - { - EXPECT_FALSE(m_editorModes.IsModeActive(editorMode)); - } - else - { - EXPECT_TRUE(m_editorModes.IsModeActive(editorMode)); - } - } + ExpectOnlyModeInactive(m_editorModes, m_selectedEditorMode); } TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingMultipleModesActiveActivatesAllThoseModesNonMutuallyExclusively) @@ -502,7 +511,53 @@ namespace UnitTest } } - TEST_F(ViewportEditorModeTrackerIntegrationTestFixture, FOO) + TEST_F(ViewportEditorModeTrackerIntegrationTestFixture, InitialViewportEditorModeIsDefault) { + ExpectOnlyModeActive(*m_viewportEditorModes, ViewportEditorMode::Default); } + + TEST_F( + ViewportEditorModeTrackerIntegrationTestFixture, EnteringComponentModeAfterInitialStateHasViewportEditorModesDefaultAndComponentModeActive) + { + // When component mode is entered + AzToolsFramework::ComponentModeFramework::ComponentModeSystemRequestBus::Broadcast( + &AzToolsFramework::ComponentModeFramework::ComponentModeSystemRequests::BeginComponentMode, + AZStd::vector{}); + + bool inComponentMode = false; + AzToolsFramework::ComponentModeFramework::ComponentModeSystemRequestBus::BroadcastResult( + inComponentMode, &AzToolsFramework::ComponentModeFramework::ComponentModeSystemRequests::InComponentMode); + + // Expect to be in component mode + EXPECT_TRUE(inComponentMode); + + // Expect the default and component viewport editor modes to be active + EXPECT_TRUE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Default)); + EXPECT_TRUE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Component)); + + // ExpeDo not expect ct the pick and focus viewport editor modes to be active + EXPECT_FALSE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Pick)); + EXPECT_FALSE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Focus)); + } + + TEST_F( + ViewportEditorModeTrackerIntegrationTestFixture, + EnteringEditorPickEntitySelectionAfterInitialStateHasOnlyViewportEditorModePickModeActive) + { + // When entering pick mode + using AzToolsFramework::EditorInteractionSystemViewportSelectionRequestBus; + EditorInteractionSystemViewportSelectionRequestBus::Event( + AzToolsFramework::GetEntityContextId(), &EditorInteractionSystemViewportSelectionRequestBus::Events::SetHandler, + [](const AzToolsFramework::EditorVisibleEntityDataCache* entityDataCache, + [[maybe_unused]] AzToolsFramework::ViewportEditorModeTrackerInterface* viewportEditorModeTracker) + { + return AZStd::make_unique(entityDataCache, viewportEditorModeTracker); + }); + + // Expect only the pick viewport editor mode to be active + ExpectOnlyModeActive(*m_viewportEditorModes, ViewportEditorMode::Pick); + } + + // FocusMode integration tests will follow (LYN-6995) + } // namespace UnitTest From 75e7758eedab7142137fd816a6e8a3971655bbd7 Mon Sep 17 00:00:00 2001 From: John Date: Tue, 28 Sep 2021 08:57:14 +0100 Subject: [PATCH 26/27] Address PR comments. Signed-off-by: John --- .../EditorInteractionSystemComponent.cpp | 12 ++++-------- .../Tests/Viewport/ViewportEditorModeTests.cpp | 2 +- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp index 7f84038ace..5d03231aab 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp @@ -17,19 +17,15 @@ namespace AzToolsFramework EditorInteractionSystemComponent::EditorInteractionSystemComponent() : m_viewportEditorMode(AZStd::make_unique()) { - if (AZ::Interface::Get() == nullptr) - { - AZ::Interface::Register(m_viewportEditorMode.get()); - } + AZ_Assert(AZ::Interface::Get() == nullptr, "Unexpected registration of viewport editor mode tracker.") + AZ::Interface::Register(m_viewportEditorMode.get()); } EditorInteractionSystemComponent::~EditorInteractionSystemComponent() { m_interactionRequests.reset(); - if (AZ::Interface::Get() != nullptr) - { - AZ::Interface::Unregister(m_viewportEditorMode.get()); - } + AZ_Assert(AZ::Interface::Get() != nullptr, "Unexpected unregistration of viewport editor mode tracker.") + AZ::Interface::Unregister(m_viewportEditorMode.get()); } void EditorInteractionSystemComponent::Activate() diff --git a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp index 371bfb2648..866d88b7ba 100644 --- a/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp @@ -535,7 +535,7 @@ namespace UnitTest EXPECT_TRUE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Default)); EXPECT_TRUE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Component)); - // ExpeDo not expect ct the pick and focus viewport editor modes to be active + // Do not expect the pick and focus viewport editor modes to be active EXPECT_FALSE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Pick)); EXPECT_FALSE(m_viewportEditorModes->IsModeActive(ViewportEditorMode::Focus)); } From cfbe76fdf639814abb92ad8d1ea30c5b21042165 Mon Sep 17 00:00:00 2001 From: John Date: Thu, 30 Sep 2021 17:29:32 +0100 Subject: [PATCH 27/27] Add call site for activating/deactivating Focus. Signed-off-by: John --- .../FocusMode/FocusModeSystemComponent.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeSystemComponent.cpp index e1c04fcb93..3fafb4db81 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeSystemComponent.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeSystemComponent.cpp @@ -10,6 +10,7 @@ #include #include +#include namespace AzToolsFramework { @@ -66,7 +67,18 @@ namespace AzToolsFramework { m_focusRoot = entityId; - // TODO - If m_focusRoot != AZ::EntityId(), activate focus mode via ViewportEditorModeTrackerInterface; else, deactivate focus mode + if (auto tracker = AZ::Interface::Get(); + tracker != nullptr) + { + if (!m_focusRoot.IsValid() && entityId.IsValid()) + { + tracker->ActivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Focus); + } + else if (m_focusRoot.IsValid() && !entityId.IsValid()) + { + tracker->DeactivateMode({ /* DefaultViewportId */ }, ViewportEditorMode::Focus); + } + } } void FocusModeSystemComponent::ClearFocusRoot()