From 01786b29664b623b0bd8a9c23ed96010f035d3d6 Mon Sep 17 00:00:00 2001 From: Guthrie Adams Date: Thu, 17 Feb 2022 23:09:06 -0600 Subject: [PATCH] Atom Tools: Saving tool settings, made inspector configurable, moved to ATF Changed material editor inspector into generic, configurable, document inspector and moved to atom tools framework Renamed atom tools framework settings registry utility functions Added more settings registry utility functions to get, set, and save values and objects Added saving tool settings to atom tools application Signed-off-by: Guthrie Adams --- .../Document/AtomToolsDocumentInspector.h | 72 ++++++++ .../Inspector/InspectorWidget.h | 17 +- .../Util/MaterialPropertyUtil.h | 19 --- .../Include/AtomToolsFramework/Util/Util.h | 74 +++++++- .../Window/AtomToolsMainWindow.h | 1 + .../Application/AtomToolsApplication.cpp | 14 +- .../AssetBrowser/AtomToolsAssetBrowser.cpp | 4 +- .../AssetGridDialog/AssetGridDialog.cpp | 6 +- .../AtomToolsFrameworkSystemComponent.cpp | 2 + .../Document/AtomToolsDocumentInspector.cpp | 120 +++++++++++++ .../Document/AtomToolsDocumentMainWindow.cpp | 2 +- .../Document/AtomToolsDocumentSystem.cpp | 4 +- .../Code/Source/Inspector/InspectorWidget.cpp | 72 +++++++- .../Code/Source/Util/MaterialPropertyUtil.cpp | 95 +---------- .../Code/Source/Util/Util.cpp | 112 +++++++++++- .../Code/Tests/AtomToolsFrameworkTest.cpp | 2 +- .../Code/atomtoolsframework_files.cmake | 2 + .../Code/Source/Document/MaterialDocument.cpp | 1 + .../CreateMaterialDialog.cpp | 2 +- .../Source/Window/MaterialEditorWindow.cpp | 23 ++- .../Code/Source/Window/MaterialEditorWindow.h | 7 + .../Window/MaterialEditorWindowSettings.cpp | 1 - .../Window/MaterialEditorWindowSettings.h | 1 - .../MaterialInspector/MaterialInspector.cpp | 159 ------------------ .../MaterialInspector/MaterialInspector.h | 71 -------- .../Window/SettingsDialog/SettingsWidget.cpp | 5 +- .../ViewportSettingsInspector.cpp | 27 +-- .../ViewportSettingsInspector.h | 5 - .../Code/materialeditor_files.cmake | 2 - .../EditorMaterialComponentInspector.cpp | 18 +- .../Material/EditorMaterialComponentUtil.cpp | 3 +- .../EditorMaterialModelUvNameMapInspector.cpp | 30 ++-- .../SharedPreview/SharedThumbnailRenderer.cpp | 12 +- 33 files changed, 538 insertions(+), 447 deletions(-) create mode 100644 Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentInspector.h create mode 100644 Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentInspector.cpp delete mode 100644 Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.cpp delete mode 100644 Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.h diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentInspector.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentInspector.h new file mode 100644 index 0000000000..59d12ef89a --- /dev/null +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentInspector.h @@ -0,0 +1,72 @@ +/* + * 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 + +#if !defined(Q_MOC_RUN) +#include +#include +#include +#include +#endif + +namespace AtomToolsFramework +{ + //! This is a specialized inspector widget that populates itself by inspecting document reflected object info. + //! Each element of an AtomToolsDocument object info vector will be displayed in a collapsible RPE group in the inspector. + //! Property changes emitted from each RPE will be tracked and used to signal undo/redo events in the document. + class AtomToolsDocumentInspector + : public InspectorWidget + , public AtomToolsDocumentNotificationBus::Handler + , public AzToolsFramework::IPropertyEditorNotify + { + Q_OBJECT + public: + AZ_CLASS_ALLOCATOR(AtomToolsDocumentInspector, AZ::SystemAllocator, 0); + + AtomToolsDocumentInspector(const AZ::Crc32& toolId, QWidget* parent = nullptr); + ~AtomToolsDocumentInspector() override; + + //! Set the ID of the document that will be used to populate the inspector + void SetDocumentId(const AZ::Uuid& documentId); + + //! Set a prefix string for storing registry settings + void SetDocumentSettingsPrefix(const AZStd::string& prefix); + + using NodeIndicatorFunction = AZStd::function; + + //! Set a function that will be used to determine what, if any, icon should be displayed next to a property in the inspector + void SetIndicatorFunction(const NodeIndicatorFunction& indicatorFunction); + + // InspectorRequestBus::Handler overrides... + void Reset() override; + + private: + // AtomToolsDocumentNotificationBus::Handler implementation + void OnDocumentObjectInfoChanged(const AZ::Uuid& documentId, const DocumentObjectInfo& objectInfo, bool rebuilt) override; + + // AzToolsFramework::IPropertyEditorNotify overrides... + void BeforePropertyModified(AzToolsFramework::InstanceDataNode* pNode) override; + void AfterPropertyModified([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode) override {} + void SetPropertyEditingActive([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode) override {} + void SetPropertyEditingComplete(AzToolsFramework::InstanceDataNode* pNode) override; + void SealUndoStack() override {} + void RequestPropertyContextMenu([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode, const QPoint&) override {} + void PropertySelectionChanged([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode, bool) override {} + + const AZ::Crc32 m_toolId = {}; + + bool m_editInProgress = {}; + + AZ::Uuid m_documentId = AZ::Uuid::CreateNull(); + + NodeIndicatorFunction m_nodeIndicatorFunction; + + AZStd::string m_documentSettingsPrefix = "/O3DE/AtomToolsFramework/AtomToolsDocumentInspector"; + }; +} // namespace AtomToolsFramework diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Inspector/InspectorWidget.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Inspector/InspectorWidget.h index 7e655d978e..baa8ac4c57 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Inspector/InspectorWidget.h +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Inspector/InspectorWidget.h @@ -9,8 +9,12 @@ #pragma once #if !defined(Q_MOC_RUN) -#include #include +#include +#include +#include +#include +#include AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT #include @@ -36,8 +40,10 @@ namespace AtomToolsFramework Q_OBJECT public: AZ_CLASS_ALLOCATOR(InspectorWidget, AZ::SystemAllocator, 0); + AZ_RTTI(AtomToolsFramework::InspectorWidget, "{D77A5F5F-0536-4249-916F-328B272E1AAB}"); + static void Reflect(AZ::ReflectContext* context); - explicit InspectorWidget(QWidget* parent = nullptr); + InspectorWidget(QWidget* parent = nullptr); ~InspectorWidget() override; // InspectorRequestBus::Handler overrides... @@ -74,6 +80,8 @@ namespace AtomToolsFramework void ExpandAll() override; void CollapseAll() override; + void SetGroupSettingsPrefix(const AZStd::string& prefix); + protected: virtual bool ShouldGroupAutoExpanded(const AZStd::string& groupName) const; virtual void OnGroupExpanded(const AZStd::string& groupName); @@ -81,14 +89,15 @@ namespace AtomToolsFramework virtual void OnHeaderClicked(const AZStd::string& groupName, QMouseEvent* event); private: - QScopedPointer m_ui; - struct GroupWidgetPair { InspectorGroupHeaderWidget* m_header; QWidget* m_panel; }; + QScopedPointer m_ui; + AZStd::string m_collapsedGroupSettingName; + AZStd::unordered_set m_collapsedGroups; AZStd::unordered_map m_groups; }; } // namespace AtomToolsFramework diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/MaterialPropertyUtil.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/MaterialPropertyUtil.h index 961febf0f4..ec7f73c890 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/MaterialPropertyUtil.h +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/MaterialPropertyUtil.h @@ -11,14 +11,8 @@ #include #include #include -#include #include -namespace AzToolsFramework -{ - class InstanceDataNode; -} - namespace AtomToolsFramework { //! Convert an editor property stored in a AZStd::any into a material property value @@ -39,9 +33,6 @@ namespace AtomToolsFramework //! Convert and assign editor dynamic property configuration fields to material property meta data void ConvertToPropertyMetaData(AZ::RPI::MaterialPropertyDynamicMetadata& propertyMetaData, const AtomToolsFramework::DynamicPropertyConfig& propertyConfig); - //! Compare equality of data types and values of editor property stored in AZStd::any - bool ArePropertyValuesEqual(const AZStd::any& valueA, const AZStd::any& valueB); - //! Convert the property value into the format that will be stored in the source data //! This is primarily needed to support conversions of special types like enums and images //! @param exportPath absolute path of the file being saved @@ -52,14 +43,4 @@ namespace AtomToolsFramework [[maybe_unused]] const AZ::Name& propertyId, const AZ::RPI::MaterialTypeSourceData::PropertyDefinition& propertyDefinition, AZ::RPI::MaterialPropertyValue& propertyValue); - - //! Generate a file path that is relative to either the source asset root or the export path - //! @param exportPath absolute path of the file being saved - //! @param referencePath absolute path of a file that will be treated as an external reference - //! @param relativeToExportPath specifies if the path is relative to the source asset root or the export path - AZStd::string GetExteralReferencePath( - const AZStd::string& exportPath, const AZStd::string& referencePath, const bool relativeToExportPath = false); - - //! Traverse up the instance data node hierarchy to find the containing dynamic property object - const AtomToolsFramework::DynamicProperty* FindDynamicPropertyForInstanceDataNode(const AzToolsFramework::InstanceDataNode* pNode); } // namespace AtomToolsFramework diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/Util.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/Util.h index 57355e4f56..243abaf19a 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/Util.h +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/Util.h @@ -9,9 +9,12 @@ #pragma once #include +#include #include #include +#include #include +#include AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT #include @@ -23,14 +26,6 @@ class QImage; namespace AtomToolsFramework { - template - T GetSettingOrDefault(AZStd::string_view path, const T& defaultValue) - { - T result; - auto settingsRegistry = AZ::SettingsRegistry::Get(); - return (settingsRegistry && settingsRegistry->Get(result, path)) ? result : defaultValue; - } - using LoadImageAsyncCallback = AZStd::function; void LoadImageAsync(const AZStd::string& path, LoadImageAsyncCallback callback); @@ -39,4 +34,67 @@ namespace AtomToolsFramework QFileInfo GetUniqueFileInfo(const QString& initialPath); QFileInfo GetDuplicationFileInfo(const QString& initialPath); bool LaunchTool(const QString& baseName, const QStringList& arguments); + + //! Generate a file path that is relative to either the source asset root or the export path + //! @param exportPath absolute path of the file being saved + //! @param referencePath absolute path of a file that will be treated as an external reference + //! @param relativeToExportPath specifies if the path is relative to the source asset root or the export path + AZStd::string GetExteralReferencePath( + const AZStd::string& exportPath, const AZStd::string& referencePath, const bool relativeToExportPath = false); + + //! Compare equality of data types and values of editor property stored in AZStd::any + bool ArePropertyValuesEqual(const AZStd::any& valueA, const AZStd::any& valueB); + + //! Traverse up the instance data hierarchy to find a node containing the corresponding type + template + const T* FindAncestorInstanceDataNodeByType(const AzToolsFramework::InstanceDataNode* pNode) + { + // Traverse up the hierarchy from the input node to search for an instance matching the specified type + for (const auto* currentNode = pNode; currentNode; currentNode = currentNode->GetParent()) + { + const auto* context = currentNode->GetSerializeContext(); + const auto* classData = currentNode->GetClassMetadata(); + if (context && classData) + { + if (context->CanDowncast(classData->m_typeId, azrtti_typeid(), classData->m_azRtti, nullptr)) + { + return static_cast(currentNode->FirstInstance()); + } + } + } + + return nullptr; + } + + template + T GetSettingsValue(AZStd::string_view path, const T& defaultValue = {}) + { + T result; + auto settingsRegistry = AZ::SettingsRegistry::Get(); + return (settingsRegistry && settingsRegistry->Get(result, path)) ? result : defaultValue; + } + + template + bool SetSettingsValue(AZStd::string_view path, const T& value) + { + auto settingsRegistry = AZ::SettingsRegistry::Get(); + return settingsRegistry && settingsRegistry->Set(path, value); + } + + template + T GetSettingsObject(AZStd::string_view path, const T& defaultValue = {}) + { + T result; + auto settingsRegistry = AZ::SettingsRegistry::Get(); + return (settingsRegistry && settingsRegistry->GetObject(result, path)) ? result : defaultValue; + } + + template + bool SetSettingsObject(AZStd::string_view path, const T& value) + { + auto settingsRegistry = AZ::SettingsRegistry::Get(); + return settingsRegistry && settingsRegistry->SetObject(path, value); + } + + bool SaveSettingsToFile(const AZ::IO::FixedMaxPath& savePath, const AZStd::vector& filters); } // namespace AtomToolsFramework diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Window/AtomToolsMainWindow.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Window/AtomToolsMainWindow.h index 558447998b..2d4e7206fe 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Window/AtomToolsMainWindow.h +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Window/AtomToolsMainWindow.h @@ -29,6 +29,7 @@ namespace AtomToolsFramework ~AtomToolsMainWindow(); protected: + // AtomToolsMainWindowRequestBus::Handler overrides... void ActivateWindow() override; bool AddDockWidget(const AZStd::string& name, QWidget* widget, uint32_t area, uint32_t orientation) override; void RemoveDockWidget(const AZStd::string& name) override; diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Application/AtomToolsApplication.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Application/AtomToolsApplication.cpp index e35e120fbe..ca5bb3310f 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Application/AtomToolsApplication.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Application/AtomToolsApplication.cpp @@ -70,9 +70,9 @@ namespace AtomToolsFramework m_styleManager->initialize(this, engineRootPath); const int updateIntervalWhenActive = - aznumeric_cast(GetSettingOrDefault("/O3DE/AtomToolsFramework/Application/UpdateIntervalWhenActive", 1)); + aznumeric_cast(GetSettingsValue("/O3DE/AtomToolsFramework/Application/UpdateIntervalWhenActive", 1)); const int updateIntervalWhenNotActive = - aznumeric_cast(GetSettingOrDefault("/O3DE/AtomToolsFramework/Application/UpdateIntervalWhenNotActive", 64)); + aznumeric_cast(GetSettingsValue("/O3DE/AtomToolsFramework/Application/UpdateIntervalWhenNotActive", 64)); m_timer.setInterval(updateIntervalWhenActive); connect(&m_timer, &QTimer::timeout, this, [this]() @@ -188,7 +188,7 @@ namespace AtomToolsFramework Base::StartCommon(systemEntity); - const bool clearLogFile = GetSettingOrDefault("/O3DE/AtomToolsFramework/Application/ClearLogOnStart", false); + const bool clearLogFile = GetSettingsValue("/O3DE/AtomToolsFramework/Application/ClearLogOnStart", false); m_traceLogger.OpenLogFile(m_targetName + ".log", clearLogFile); ConnectToAssetProcessor(); @@ -197,7 +197,7 @@ namespace AtomToolsFramework AzToolsFramework::AssetBrowser::AssetDatabaseLocationNotificationBus::Broadcast( &AzToolsFramework::AssetBrowser::AssetDatabaseLocationNotifications::OnDatabaseInitialized); - const bool enableSourceControl = GetSettingOrDefault("/O3DE/AtomToolsFramework/Application/EnableSourceControl", true); + const bool enableSourceControl = GetSettingsValue("/O3DE/AtomToolsFramework/Application/EnableSourceControl", true); AzToolsFramework::SourceControlConnectionRequestBus::Broadcast( &AzToolsFramework::SourceControlConnectionRequests::EnableSourceControl, enableSourceControl); @@ -238,6 +238,12 @@ namespace AtomToolsFramework void AtomToolsApplication::Destroy() { m_styleManager.reset(); + + // Save application settings to settings registry file + AZ::IO::FixedMaxPath savePath = AZ::Utils::GetProjectPath(); + savePath /= AZStd::string::format("user/Registry/%s.setreg", m_targetName.c_str()); + SaveSettingsToFile(savePath, { "/O3DE/AtomToolsFramework", AZStd::string::format("/O3DE/Atom/%s", m_targetName.c_str()) }); + UnloadSettings(); AzToolsFramework::EditorPythonConsoleNotificationBus::Handler::BusDisconnect(); diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetBrowser/AtomToolsAssetBrowser.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetBrowser/AtomToolsAssetBrowser.cpp index 81bdaf380f..1f38c2a8f7 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetBrowser/AtomToolsAssetBrowser.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetBrowser/AtomToolsAssetBrowser.cpp @@ -106,9 +106,9 @@ namespace AtomToolsFramework const AZStd::vector entries = m_ui->m_assetBrowserTreeViewWidget->GetSelectedAssets(); const bool promptToOpenMultipleFiles = - GetSettingOrDefault("/O3DE/AtomToolsFramework/AssetBrowser/PromptToOpenMultipleFiles", true); + GetSettingsValue("/O3DE/AtomToolsFramework/AssetBrowser/PromptToOpenMultipleFiles", true); const AZ::u64 promptToOpenMultipleFilesThreshold = - GetSettingOrDefault("/O3DE/AtomToolsFramework/AssetBrowser/PromptToOpenMultipleFilesThreshold", 10); + GetSettingsValue("/O3DE/AtomToolsFramework/AssetBrowser/PromptToOpenMultipleFilesThreshold", 10); if (promptToOpenMultipleFiles && promptToOpenMultipleFilesThreshold <= entries.size()) { diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetGridDialog/AssetGridDialog.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetGridDialog/AssetGridDialog.cpp index 806c5fddbc..f676c4e802 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetGridDialog/AssetGridDialog.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AssetGridDialog/AssetGridDialog.cpp @@ -71,11 +71,11 @@ namespace AtomToolsFramework QListWidgetItem* AssetGridDialog::CreateListItem(const SelectableAsset& selectableAsset) { const int itemBorder = aznumeric_cast( - AtomToolsFramework::GetSettingOrDefault("/O3DE/Atom/AtomToolsFramework/AssetGridDialog/ItemBorder", 4)); + AtomToolsFramework::GetSettingsValue("/O3DE/AtomToolsFramework/AssetGridDialog/ItemBorder", 4)); const int itemSpacing = aznumeric_cast( - AtomToolsFramework::GetSettingOrDefault("/O3DE/Atom/AtomToolsFramework/AssetGridDialog/ItemSpacing", 10)); + AtomToolsFramework::GetSettingsValue("/O3DE/AtomToolsFramework/AssetGridDialog/ItemSpacing", 10)); const int headerHeight = aznumeric_cast( - AtomToolsFramework::GetSettingOrDefault("/O3DE/Atom/AtomToolsFramework/AssetGridDialog/HeaderHeight", 15)); + AtomToolsFramework::GetSettingsValue("/O3DE/AtomToolsFramework/AssetGridDialog/HeaderHeight", 15)); const QSize gridSize = m_ui->m_assetList->gridSize(); m_ui->m_assetList->setGridSize(QSize( diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AtomToolsFrameworkSystemComponent.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AtomToolsFrameworkSystemComponent.cpp index 840d00aa6c..84eb2c9999 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AtomToolsFrameworkSystemComponent.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/AtomToolsFrameworkSystemComponent.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include namespace AtomToolsFramework @@ -23,6 +24,7 @@ namespace AtomToolsFramework DynamicPropertyGroup::Reflect(context); AtomToolsDocument::Reflect(context); AtomToolsDocumentSystem::Reflect(context); + InspectorWidget::Reflect(context); if (auto serialize = azrtti_cast(context)) { diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentInspector.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentInspector.cpp new file mode 100644 index 0000000000..35c517b4fd --- /dev/null +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentInspector.cpp @@ -0,0 +1,120 @@ +/* + * 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 AtomToolsFramework +{ + AtomToolsDocumentInspector::AtomToolsDocumentInspector(const AZ::Crc32& toolId, QWidget* parent) + : InspectorWidget(parent) + , m_toolId(toolId) + { + AtomToolsDocumentNotificationBus::Handler::BusConnect(m_toolId); + } + + AtomToolsDocumentInspector::~AtomToolsDocumentInspector() + { + AtomToolsDocumentNotificationBus::Handler::BusDisconnect(); + } + + void AtomToolsDocumentInspector::SetDocumentId(const AZ::Uuid& documentId) + { + AddGroupsBegin(); + + m_documentId = documentId; + + AtomToolsDocumentRequestBus::Event( + m_documentId, + [&](AtomToolsDocumentRequests* documentRequests) + { + if (documentRequests->IsOpen()) + { + // Create a unique settings prefix string per document using a CRC of the document path + const AZStd::string groupSettingsPrefix = m_documentSettingsPrefix + + AZStd::string::format("/%08x/GroupSettings", aznumeric_cast(AZ::Crc32(documentRequests->GetAbsolutePath()))); + SetGroupSettingsPrefix(groupSettingsPrefix); + + // This will automatically expose all document contents to an inspector with a collapsible group per object. + // In the case of the material editor, this will be one inspector group per property group. + for (auto& objectInfo : documentRequests->GetObjectInfo()) + { + // Passing in same main and comparison instance to enable custom value comparison + const AZ::Crc32 groupSaveStateKey( + AZStd::string::format("%s/%s", groupSettingsPrefix.c_str(), objectInfo.m_name.c_str())); + auto propertyGroupWidget = new InspectorPropertyGroupWidget( + objectInfo.m_objectPtr, objectInfo.m_objectPtr, objectInfo.m_objectType, this, this, groupSaveStateKey, {}, + m_nodeIndicatorFunction, 0); + + AddGroup(objectInfo.m_name, objectInfo.m_displayName, objectInfo.m_description, propertyGroupWidget); + SetGroupVisible(objectInfo.m_name, objectInfo.m_visible); + } + } + + InspectorRequestBus::Handler::BusConnect(m_documentId); + }); + + AddGroupsEnd(); + } + + void AtomToolsDocumentInspector::SetDocumentSettingsPrefix(const AZStd::string& prefix) + { + m_documentSettingsPrefix = prefix; + } + + void AtomToolsDocumentInspector::SetIndicatorFunction(const NodeIndicatorFunction& indicatorFunction) + { + m_nodeIndicatorFunction = indicatorFunction; + } + + void AtomToolsDocumentInspector::Reset() + { + m_documentId = AZ::Uuid::CreateNull(); + m_editInProgress = false; + + InspectorWidget::Reset(); + } + + void AtomToolsDocumentInspector::OnDocumentObjectInfoChanged( + [[maybe_unused]] const AZ::Uuid& documentId, const DocumentObjectInfo& objectInfo, bool rebuilt) + { + if (m_documentId == documentId) + { + SetGroupVisible(objectInfo.m_name, objectInfo.m_visible); + if (rebuilt) + { + RebuildGroup(objectInfo.m_name); + } + else + { + RefreshGroup(objectInfo.m_name); + } + } + } + + void AtomToolsDocumentInspector::BeforePropertyModified([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode) + { + if (!m_editInProgress) + { + m_editInProgress = true; + AtomToolsDocumentRequestBus::Event(m_documentId, &AtomToolsDocumentRequestBus::Events::BeginEdit); + } + } + + void AtomToolsDocumentInspector::SetPropertyEditingComplete([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode) + { + if (m_editInProgress) + { + m_editInProgress = false; + AtomToolsDocumentRequestBus::Event(m_documentId, &AtomToolsDocumentRequestBus::Events::EndEdit); + } + } +} // namespace AtomToolsFramework + +//#include diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentMainWindow.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentMainWindow.cpp index f2db527ea8..53c798d48c 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentMainWindow.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentMainWindow.cpp @@ -500,4 +500,4 @@ namespace AtomToolsFramework } } // namespace AtomToolsFramework -//#include +//#include diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystem.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystem.cpp index 674c9c80a0..18b283480c 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystem.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystem.cpp @@ -368,7 +368,7 @@ namespace AtomToolsFramework void AtomToolsDocumentSystem::ReopenDocuments() { - const bool enableHotReload = GetSettingOrDefault("/O3DE/AtomToolsFramework/AtomToolsDocumentSystem/EnableHotReload", true); + const bool enableHotReload = GetSettingsValue("/O3DE/AtomToolsFramework/AtomToolsDocumentSystem/EnableHotReload", true); if (!enableHotReload) { m_documentIdsWithDependencyChanges.clear(); @@ -377,7 +377,7 @@ namespace AtomToolsFramework } const bool enableHotReloadPrompts = - GetSettingOrDefault("/O3DE/AtomToolsFramework/AtomToolsDocumentSystem/EnableHotReloadPrompts", true); + GetSettingsValue("/O3DE/AtomToolsFramework/AtomToolsDocumentSystem/EnableHotReloadPrompts", true); for (const AZ::Uuid& documentId : m_documentIdsWithExternalChanges) { diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Inspector/InspectorWidget.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Inspector/InspectorWidget.cpp index 89f7e9d3bf..c5f84d70fa 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Inspector/InspectorWidget.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Inspector/InspectorWidget.cpp @@ -6,27 +6,69 @@ * */ -#include -#include -#include -#include - #include #include #include +#include +#include +#include +#include #include +#include +#include +#include +#include + namespace AtomToolsFramework { + void InspectorWidget::Reflect(AZ::ReflectContext* context) + { + if (auto serialize = azrtti_cast(context)) + { + serialize->RegisterGenericType>(); + + serialize->Class() + ->Version(0); + } + + if (auto behaviorContext = azrtti_cast(context)) + { + behaviorContext->EBus("InspectorRequestBus") + ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common) + ->Attribute(AZ::Script::Attributes::Category, "Editor") + ->Attribute(AZ::Script::Attributes::Module, "atomtools") + ->Event("ClearHeading", &InspectorRequestBus::Events::ClearHeading) + ->Event("Reset", &InspectorRequestBus::Events::Reset) + ->Event("AddGroupsBegin", &InspectorRequestBus::Events::AddGroupsBegin) + ->Event("AddGroupsEnd", &InspectorRequestBus::Events::AddGroupsEnd) + ->Event("SetGroupVisible", &InspectorRequestBus::Events::SetGroupVisible) + ->Event("IsGroupVisible", &InspectorRequestBus::Events::IsGroupVisible) + ->Event("IsGroupHidden", &InspectorRequestBus::Events::IsGroupHidden) + ->Event("RefreshGroup", &InspectorRequestBus::Events::RefreshGroup) + ->Event("RebuildGroup", &InspectorRequestBus::Events::RebuildGroup) + ->Event("RefreshAll", &InspectorRequestBus::Events::RefreshAll) + ->Event("RebuildAll", &InspectorRequestBus::Events::RebuildAll) + ->Event("ExpandGroup", &InspectorRequestBus::Events::ExpandGroup) + ->Event("CollapseGroup", &InspectorRequestBus::Events::CollapseGroup) + ->Event("IsGroupExpanded", &InspectorRequestBus::Events::IsGroupExpanded) + ->Event("ExpandAll", &InspectorRequestBus::Events::ExpandAll) + ->Event("CollapseAll", &InspectorRequestBus::Events::CollapseAll) + ; + } + } InspectorWidget::InspectorWidget(QWidget* parent) : QWidget(parent) , m_ui(new Ui::InspectorWidget) { m_ui->setupUi(this); + SetGroupSettingsPrefix("/O3DE/AtomToolsFramework/InspectorWidget"); } InspectorWidget::~InspectorWidget() { + SetSettingsObject(m_collapsedGroupSettingName, m_collapsedGroups); + InspectorRequestBus::Handler::BusDisconnect(); } void InspectorWidget::AddHeading(QWidget* headingWidget) @@ -52,6 +94,7 @@ namespace AtomToolsFramework delete child; } m_groups.clear(); + InspectorRequestBus::Handler::BusDisconnect(); } void InspectorWidget::AddGroupsBegin() @@ -202,20 +245,31 @@ namespace AtomToolsFramework } } + void InspectorWidget::SetGroupSettingsPrefix(const AZStd::string& prefix) + { + if (!m_collapsedGroupSettingName.empty()) + { + SetSettingsObject(m_collapsedGroupSettingName, m_collapsedGroups); + } + + m_collapsedGroupSettingName = prefix + "/CollapsedGroups"; + m_collapsedGroups = GetSettingsObject>(m_collapsedGroupSettingName); + } + bool InspectorWidget::ShouldGroupAutoExpanded(const AZStd::string& groupName) const { - AZ_UNUSED(groupName); - return true; + auto stateItr = m_collapsedGroups.find(AZ::Crc32(groupName)); + return stateItr == m_collapsedGroups.end(); } void InspectorWidget::OnGroupExpanded(const AZStd::string& groupName) { - AZ_UNUSED(groupName); + m_collapsedGroups.erase(AZ::Crc32(groupName)); } void InspectorWidget::OnGroupCollapsed(const AZStd::string& groupName) { - AZ_UNUSED(groupName); + m_collapsedGroups.insert(AZ::Crc32(groupName)); } void InspectorWidget::OnHeaderClicked(const AZStd::string& groupName, QMouseEvent* event) diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/MaterialPropertyUtil.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/MaterialPropertyUtil.cpp index 377fd46d69..cb1227fb1a 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/MaterialPropertyUtil.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/MaterialPropertyUtil.cpp @@ -6,21 +6,14 @@ * */ -#include -#include - #include #include #include #include #include - -#include -#include -#include -#include -#include -#include +#include +#include +#include namespace AtomToolsFramework { @@ -132,41 +125,6 @@ namespace AtomToolsFramework } } - template - bool ComparePropertyValues(const AZStd::any& valueA, const AZStd::any& valueB) - { - return valueA.is() && valueB.is() && *AZStd::any_cast(&valueA) == *AZStd::any_cast(&valueB); - } - - bool ArePropertyValuesEqual(const AZStd::any& valueA, const AZStd::any& valueB) - { - if (valueA.type() != valueB.type()) - { - return false; - } - - if (ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues(valueA, valueB) || - ComparePropertyValues>(valueA, valueB) || - ComparePropertyValues>(valueA, valueB) || - ComparePropertyValues>(valueA, valueB) || - ComparePropertyValues>(valueA, valueB) || - ComparePropertyValues>(valueA, valueB) || - ComparePropertyValues(valueA, valueB)) - { - return true; - } - - return false; - } - bool ConvertToExportFormat( const AZStd::string& exportPath, [[maybe_unused]] const AZ::Name& propertyId, @@ -223,51 +181,4 @@ namespace AtomToolsFramework return true; } - - AZStd::string GetExteralReferencePath( - const AZStd::string& exportPath, const AZStd::string& referencePath, const bool relativeToExportPath) - { - if (referencePath.empty()) - { - return {}; - } - - if (!relativeToExportPath) - { - AZStd::string watchFolder; - AZ::Data::AssetInfo assetInfo; - bool sourceInfoFound = false; - AzToolsFramework::AssetSystemRequestBus::BroadcastResult( - sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, referencePath.c_str(), - assetInfo, watchFolder); - if (sourceInfoFound) - { - return assetInfo.m_relativePath; - } - } - - AZ::IO::BasicPath exportFolder(exportPath); - exportFolder.RemoveFilename(); - return AZ::IO::PathView(referencePath).LexicallyRelative(exportFolder).StringAsPosix(); - } - - const AtomToolsFramework::DynamicProperty* FindDynamicPropertyForInstanceDataNode(const AzToolsFramework::InstanceDataNode* pNode) - { - // Traverse up the hierarchy from the input node to search for an instance corresponding to material inspector property - for (const AzToolsFramework::InstanceDataNode* currentNode = pNode; currentNode; currentNode = currentNode->GetParent()) - { - const AZ::SerializeContext* context = currentNode->GetSerializeContext(); - const AZ::SerializeContext::ClassData* classData = currentNode->GetClassMetadata(); - if (context && classData) - { - if (context->CanDowncast( - classData->m_typeId, azrtti_typeid(), classData->m_azRtti, nullptr)) - { - return static_cast(currentNode->FirstInstance()); - } - } - } - - return nullptr; - } } // namespace AtomToolsFramework diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/Util.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/Util.cpp index 89a5407260..f51f37910d 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/Util.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/Util.cpp @@ -9,12 +9,20 @@ #include #include #include +#include #include #include +#include +#include +#include +#include +#include +#include #include #include #include #include +#include #include #include #include @@ -27,6 +35,49 @@ AZ_POP_DISABLE_WARNING namespace AtomToolsFramework { + bool SaveSettingsToFile(const AZ::IO::FixedMaxPath& savePath, const AZStd::vector& filters) + { + auto registry = AZ::SettingsRegistry::Get(); + if (registry == nullptr) + { + AZ_Warning("AtomToolsFramework", false, "Unable to access global settings registry."); + return false; + } + + AZ::SettingsRegistryMergeUtils::DumperSettings dumperSettings; + dumperSettings.m_prettifyOutput = true; + dumperSettings.m_includeFilter = [filters](AZStd::string_view path) + { + for (const auto& filter : filters) + { + if (filter.starts_with(path.substr(0, filter.size()))) + { + return true; + } + } + return false; + }; + + AZStd::string stringBuffer; + AZ::IO::ByteContainerStream stringStream(&stringBuffer); + if (!AZ::SettingsRegistryMergeUtils::DumpSettingsRegistryToStream(*registry, "", stringStream, dumperSettings)) + { + AZ_Warning("AtomToolsFramework", false, R"(Unable to save changes to the registry file at "%s"\n)", savePath.c_str()); + return false; + } + + bool saved = false; + constexpr auto configurationMode = + AZ::IO::SystemFile::SF_OPEN_CREATE | AZ::IO::SystemFile::SF_OPEN_CREATE_PATH | AZ::IO::SystemFile::SF_OPEN_WRITE_ONLY; + if (AZ::IO::SystemFile outputFile; outputFile.Open(savePath.c_str(), configurationMode)) + { + saved = outputFile.Write(stringBuffer.data(), stringBuffer.size()) == stringBuffer.size(); + } + + AZ_Warning("AtomToolsFramework", saved, R"(Unable to save registry file to path "%s"\n)", savePath.c_str()); + return saved; + } + void LoadImageAsync(const AZStd::string& path, LoadImageAsyncCallback callback) { AZ::Job* job = AZ::CreateJobFunction( @@ -178,4 +229,63 @@ namespace AtomToolsFramework return QProcess::startDetached(launchPath.c_str(), arguments, engineRoot.c_str()); } -} + + AZStd::string GetExteralReferencePath( + const AZStd::string& exportPath, const AZStd::string& referencePath, const bool relativeToExportPath) + { + if (referencePath.empty()) + { + return {}; + } + + if (!relativeToExportPath) + { + AZStd::string watchFolder; + AZ::Data::AssetInfo assetInfo; + bool sourceInfoFound = false; + AzToolsFramework::AssetSystemRequestBus::BroadcastResult( + sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, referencePath.c_str(), + assetInfo, watchFolder); + if (sourceInfoFound) + { + return assetInfo.m_relativePath; + } + } + + AZ::IO::BasicPath exportFolder(exportPath); + exportFolder.RemoveFilename(); + return AZ::IO::PathView(referencePath).LexicallyRelative(exportFolder).StringAsPosix(); + } + + template + bool ComparePropertyValues(const AZStd::any& valueA, const AZStd::any& valueB) + { + return valueA.is() && valueB.is() && *AZStd::any_cast(&valueA) == *AZStd::any_cast(&valueB); + } + + bool ArePropertyValuesEqual(const AZStd::any& valueA, const AZStd::any& valueB) + { + if (valueA.type() != valueB.type()) + { + return false; + } + + if (ComparePropertyValues(valueA, valueB) || ComparePropertyValues(valueA, valueB) || + ComparePropertyValues(valueA, valueB) || ComparePropertyValues(valueA, valueB) || + ComparePropertyValues(valueA, valueB) || ComparePropertyValues(valueA, valueB) || + ComparePropertyValues(valueA, valueB) || ComparePropertyValues(valueA, valueB) || + ComparePropertyValues(valueA, valueB) || + ComparePropertyValues>(valueA, valueB) || + ComparePropertyValues>(valueA, valueB) || + ComparePropertyValues>(valueA, valueB) || + ComparePropertyValues>(valueA, valueB) || + ComparePropertyValues>(valueA, valueB) || + ComparePropertyValues(valueA, valueB)) + { + return true; + } + + return false; + } + +} // namespace AtomToolsFramework diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Tests/AtomToolsFrameworkTest.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Tests/AtomToolsFrameworkTest.cpp index bdd166192f..7ee4c768cc 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/Tests/AtomToolsFrameworkTest.cpp +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Tests/AtomToolsFrameworkTest.cpp @@ -8,7 +8,7 @@ #include #include -#include +#include namespace UnitTest { diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake b/Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake index 5046e28145..ce622cab5e 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake +++ b/Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake @@ -15,6 +15,7 @@ set(FILES Include/AtomToolsFramework/Communication/LocalSocket.h Include/AtomToolsFramework/Debug/TraceRecorder.h Include/AtomToolsFramework/Document/AtomToolsDocument.h + Include/AtomToolsFramework/Document/AtomToolsDocumentInspector.h Include/AtomToolsFramework/Document/AtomToolsDocumentSystem.h Include/AtomToolsFramework/Document/AtomToolsDocumentApplication.h Include/AtomToolsFramework/Document/AtomToolsDocumentMainWindow.h @@ -51,6 +52,7 @@ set(FILES Source/Communication/LocalSocket.cpp Source/Debug/TraceRecorder.cpp Source/Document/AtomToolsDocument.cpp + Source/Document/AtomToolsDocumentInspector.cpp Source/Document/AtomToolsDocumentApplication.cpp Source/Document/AtomToolsDocumentMainWindow.cpp Source/Document/AtomToolsDocumentSystem.cpp diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.cpp index 0f750ba647..64499a47bc 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp index dead08dde9..fed685ee12 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp @@ -64,7 +64,7 @@ namespace MaterialEditor m_ui->m_materialTypeComboBox->model()->sort(0, Qt::AscendingOrder); - const AZStd::string defaultMaterialType = AtomToolsFramework::GetSettingOrDefault( + const AZStd::string defaultMaterialType = AtomToolsFramework::GetSettingsValue( "/O3DE/Atom/MaterialEditor/CreateMaterialDialog/DefaultMaterialType", "StandardPBR"); const int index = m_ui->m_materialTypeComboBox->findText(defaultMaterialType.c_str()); diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.cpp index 3b9aba86e8..ff6ea6be74 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -17,7 +18,6 @@ #include #include #include -#include #include #include @@ -78,7 +78,20 @@ namespace MaterialEditor QDesktopServices::openUrl(QUrl::fromLocalFile(absolutePath.c_str())); }); - AddDockWidget("Inspector", new MaterialInspector(m_toolId), Qt::RightDockWidgetArea, Qt::Vertical); + m_materialInspector = new AtomToolsFramework::AtomToolsDocumentInspector(m_toolId, this); + m_materialInspector->SetDocumentSettingsPrefix("/O3DE/Atom/MaterialEditor/MaterialInspector"); + m_materialInspector->SetIndicatorFunction( + [](const AzToolsFramework::InstanceDataNode* node) + { + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(node); + if (property && !AtomToolsFramework::ArePropertyValuesEqual(property->GetValue(), property->GetConfig().m_parentValue)) + { + return ":/Icons/changed_property.svg"; + } + return ":/Icons/blank.png"; + }); + + AddDockWidget("Inspector", m_materialInspector, Qt::RightDockWidgetArea, Qt::Vertical); AddDockWidget("Viewport Settings", new ViewportSettingsInspector, Qt::LeftDockWidgetArea, Qt::Vertical); SetDockWidgetVisible("Viewport Settings", false); @@ -98,6 +111,12 @@ namespace MaterialEditor OnDocumentOpened(AZ::Uuid::CreateNull()); } + void MaterialEditorWindow::OnDocumentOpened(const AZ::Uuid& documentId) + { + Base::OnDocumentOpened(documentId); + m_materialInspector->SetDocumentId(documentId); + } + void MaterialEditorWindow::ResizeViewportRenderTarget(uint32_t width, uint32_t height) { QSize requestedViewportSize = QSize(width, height) / devicePixelRatioF(); diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.h b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.h index 0e98e3ac84..b0ee6b7e0c 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.h +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.h @@ -9,6 +9,7 @@ #pragma once #if !defined(Q_MOC_RUN) +#include #include AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT @@ -35,10 +36,15 @@ namespace MaterialEditor MaterialEditorWindow(const AZ::Crc32& toolId, QWidget* parent = 0); protected: + // AtomToolsFramework::AtomToolsMainWindowRequestBus::Handler overrides... void ResizeViewportRenderTarget(uint32_t width, uint32_t height) override; void LockViewportRenderTargetSize(uint32_t width, uint32_t height) override; void UnlockViewportRenderTargetSize() override; + // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler overrides... + void OnDocumentOpened(const AZ::Uuid& documentId) override; + + // AtomToolsFramework::AtomToolsDocumentMainWindow overrides... bool GetCreateDocumentParams(AZStd::string& openPath, AZStd::string& savePath) override; bool GetOpenDocumentParams(AZStd::string& openPath) override; void OpenSettings() override; @@ -47,6 +53,7 @@ namespace MaterialEditor void closeEvent(QCloseEvent* closeEvent) override; + AtomToolsFramework::AtomToolsDocumentInspector* m_materialInspector = {}; MaterialViewportWidget* m_materialViewport = {}; MaterialEditorToolBar* m_toolBar = {}; }; diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.cpp index 5ab17d7b26..4382ef5fd6 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.cpp @@ -19,7 +19,6 @@ namespace MaterialEditor serializeContext->Class() ->Version(1) ->Field("mainWindowState", &MaterialEditorWindowSettings::m_mainWindowState) - ->Field("inspectorCollapsedGroups", &MaterialEditorWindowSettings::m_inspectorCollapsedGroups) ; if (auto editContext = serializeContext->GetEditContext()) diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.h b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.h index c56da58ff1..dea7800a9c 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.h +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.h @@ -27,6 +27,5 @@ namespace MaterialEditor static void Reflect(AZ::ReflectContext* context); AZStd::vector m_mainWindowState; - AZStd::unordered_set m_inspectorCollapsedGroups; }; } // namespace MaterialEditor diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.cpp deleted file mode 100644 index c22e65df2e..0000000000 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.cpp +++ /dev/null @@ -1,159 +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 -#include -#include -#include -#include - -namespace MaterialEditor -{ - MaterialInspector::MaterialInspector(const AZ::Crc32& toolId, QWidget* parent) - : AtomToolsFramework::InspectorWidget(parent) - , m_toolId(toolId) - { - m_windowSettings = AZ::UserSettings::CreateFind( - AZ::Crc32("MaterialEditorWindowSettings"), AZ::UserSettings::CT_GLOBAL); - - AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect(m_toolId); - } - - MaterialInspector::~MaterialInspector() - { - AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect(); - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); - } - - void MaterialInspector::Reset() - { - m_documentPath.clear(); - m_documentId = AZ::Uuid::CreateNull(); - m_activeProperty = {}; - - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); - AtomToolsFramework::InspectorWidget::Reset(); - } - - bool MaterialInspector::ShouldGroupAutoExpanded(const AZStd::string& groupName) const - { - auto stateItr = m_windowSettings->m_inspectorCollapsedGroups.find(GetGroupSaveStateKey(groupName)); - return stateItr == m_windowSettings->m_inspectorCollapsedGroups.end(); - } - - void MaterialInspector::OnGroupExpanded(const AZStd::string& groupName) - { - m_windowSettings->m_inspectorCollapsedGroups.erase(GetGroupSaveStateKey(groupName)); - } - - void MaterialInspector::OnGroupCollapsed(const AZStd::string& groupName) - { - m_windowSettings->m_inspectorCollapsedGroups.insert(GetGroupSaveStateKey(groupName)); - } - - void MaterialInspector::OnDocumentOpened(const AZ::Uuid& documentId) - { - AddGroupsBegin(); - - m_documentId = documentId; - - bool isOpen = false; - AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult( - isOpen, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsOpen); - - AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult( - m_documentPath, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath); - - if (!m_documentId.IsNull() && isOpen) - { - // This will automatically expose all document contents to an inspector with a collapsible group per object. In the case of the - // material editor, this will be one inspector group per property group. - AZStd::vector objects; - AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult( - objects, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetObjectInfo); - - for (auto& objectInfo : objects) - { - // Passing in same main and comparison instance to enable custom value comparison for highlighting modified properties - auto propertyGroupWidget = new AtomToolsFramework::InspectorPropertyGroupWidget( - objectInfo.m_objectPtr, objectInfo.m_objectPtr, objectInfo.m_objectType, this, this, - GetGroupSaveStateKey(objectInfo.m_name), {}, - [this](const auto node) { return GetInstanceNodePropertyIndicator(node); }, 0); - - AddGroup(objectInfo.m_name, objectInfo.m_displayName, objectInfo.m_description, propertyGroupWidget); - SetGroupVisible(objectInfo.m_name, objectInfo.m_visible); - } - - AtomToolsFramework::InspectorRequestBus::Handler::BusConnect(m_documentId); - } - - AddGroupsEnd(); - } - - AZ::Crc32 MaterialInspector::GetGroupSaveStateKey(const AZStd::string& groupName) const - { - return AZ::Crc32(AZStd::string::format("MaterialInspector::PropertyGroup::%s::%s", m_documentPath.c_str(), groupName.c_str())); - } - - bool MaterialInspector::IsInstanceNodePropertyModifed(const AzToolsFramework::InstanceDataNode* node) const - { - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(node); - return property && !AtomToolsFramework::ArePropertyValuesEqual(property->GetValue(), property->GetConfig().m_parentValue); - } - - const char* MaterialInspector::GetInstanceNodePropertyIndicator(const AzToolsFramework::InstanceDataNode* node) const - { - if (IsInstanceNodePropertyModifed(node)) - { - return ":/Icons/changed_property.svg"; - } - return ":/Icons/blank.png"; - } - - void MaterialInspector::OnDocumentObjectInfoChanged( - [[maybe_unused]] const AZ::Uuid& documentId, const AtomToolsFramework::DocumentObjectInfo& objectInfo, bool rebuilt) - { - SetGroupVisible(objectInfo.m_name, objectInfo.m_visible); - if (rebuilt) - { - RebuildGroup(objectInfo.m_name); - } - else - { - RefreshGroup(objectInfo.m_name); - } - } - - void MaterialInspector::BeforePropertyModified(AzToolsFramework::InstanceDataNode* pNode) - { - // This function is called before every single property change whether it's a button click or dragging a slider. We only want to - // begin tracking undo state for the first change in the sequence, when the user begins to drag the slider. - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); - if (!m_activeProperty && property) - { - m_activeProperty = property; - AtomToolsFramework::AtomToolsDocumentRequestBus::Event( - m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::BeginEdit); - } - } - - void MaterialInspector::SetPropertyEditingComplete(AzToolsFramework::InstanceDataNode* pNode) - { - // If tracking has started and editing has completed then we can stop tracking undue state for this sequence of changes. - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); - if (m_activeProperty && m_activeProperty == property) - { - AtomToolsFramework::AtomToolsDocumentRequestBus::Event( - m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::EndEdit); - m_activeProperty = {}; - } - } -} // namespace MaterialEditor - -#include diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.h b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.h deleted file mode 100644 index 901affd1b1..0000000000 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.h +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright (c) Contributors to the Open 3D Engine Project. - * For complete copyright and license terms please see the LICENSE at the root of this distribution. - * - * SPDX-License-Identifier: Apache-2.0 OR MIT - * - */ - -#pragma once - -#if !defined(Q_MOC_RUN) -#include -#include -#include -#include -#include -#include -#endif - -namespace MaterialEditor -{ - //! Provides controls for viewing and editing document settings. - class MaterialInspector - : public AtomToolsFramework::InspectorWidget - , public AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler - , public AzToolsFramework::IPropertyEditorNotify - { - Q_OBJECT - public: - AZ_CLASS_ALLOCATOR(MaterialInspector, AZ::SystemAllocator, 0); - - MaterialInspector(const AZ::Crc32& toolId, QWidget* parent = nullptr); - ~MaterialInspector() override; - - // AtomToolsFramework::InspectorRequestBus::Handler overrides... - void Reset() override; - - protected: - bool ShouldGroupAutoExpanded(const AZStd::string& groupName) const override; - void OnGroupExpanded(const AZStd::string& groupName) override; - void OnGroupCollapsed(const AZStd::string& groupName) override; - - private: - AZ::Crc32 GetGroupSaveStateKey(const AZStd::string& groupName) const; - bool IsInstanceNodePropertyModifed(const AzToolsFramework::InstanceDataNode* node) const; - const char* GetInstanceNodePropertyIndicator(const AzToolsFramework::InstanceDataNode* node) const; - - // AtomToolsDocumentNotificationBus::Handler implementation - void OnDocumentOpened(const AZ::Uuid& documentId) override; - void OnDocumentObjectInfoChanged( - const AZ::Uuid& documentId, const AtomToolsFramework::DocumentObjectInfo& objectInfo, bool rebuilt) override; - - // AzToolsFramework::IPropertyEditorNotify overrides... - void BeforePropertyModified(AzToolsFramework::InstanceDataNode* pNode) override; - void AfterPropertyModified([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode) override {} - void SetPropertyEditingActive([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode) override {} - void SetPropertyEditingComplete(AzToolsFramework::InstanceDataNode* pNode) override; - void SealUndoStack() override {} - void RequestPropertyContextMenu([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode, const QPoint&) override {} - void PropertySelectionChanged([[maybe_unused]] AzToolsFramework::InstanceDataNode* pNode, bool) override {} - - const AZ::Crc32 m_toolId = {}; - - // Tracking the property that is activiley being edited in the inspector - const AtomToolsFramework::DynamicProperty* m_activeProperty = {}; - - AZ::Uuid m_documentId = AZ::Uuid::CreateNull(); - AZStd::string m_documentPath; - AZStd::intrusive_ptr m_windowSettings; - }; -} // namespace MaterialEditor diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/SettingsDialog/SettingsWidget.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/SettingsDialog/SettingsWidget.cpp index 8bf4191432..3131690f6b 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/SettingsDialog/SettingsWidget.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/SettingsDialog/SettingsWidget.cpp @@ -6,19 +6,19 @@ * */ -#include #include +#include namespace MaterialEditor { SettingsWidget::SettingsWidget(QWidget* parent) : AtomToolsFramework::InspectorWidget(parent) { + SetGroupSettingsPrefix("/O3DE/Atom/MaterialEditor/SettingsWidget"); } SettingsWidget::~SettingsWidget() { - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); } void SettingsWidget::Populate() @@ -29,7 +29,6 @@ namespace MaterialEditor void SettingsWidget::Reset() { - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); AtomToolsFramework::InspectorWidget::Reset(); } } // namespace MaterialEditor diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.cpp index dd01492031..d30401c245 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.cpp @@ -32,9 +32,7 @@ namespace MaterialEditor m_viewportSettings = AZ::UserSettings::CreateFind(AZ::Crc32("MaterialViewportSettings"), AZ::UserSettings::CT_GLOBAL); - m_windowSettings = AZ::UserSettings::CreateFind( - AZ::Crc32("MaterialEditorWindowSettings"), AZ::UserSettings::CT_GLOBAL); - + SetGroupSettingsPrefix("/O3DE/Atom/MaterialEditor/ViewportSettingsInspector"); MaterialViewportNotificationBus::Handler::BusConnect(); } @@ -43,7 +41,6 @@ namespace MaterialEditor m_lightingPreset.reset(); m_modelPreset.reset(); MaterialViewportNotificationBus::Handler::BusDisconnect(); - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); } void ViewportSettingsInspector::Populate() @@ -144,7 +141,7 @@ namespace MaterialEditor }); const int itemSize = aznumeric_cast( - AtomToolsFramework::GetSettingOrDefault("/O3DE/Atom/MaterialEditor/AssetGridDialog/ModelItemSize", 180)); + AtomToolsFramework::GetSettingsValue("/O3DE/Atom/MaterialEditor/AssetGridDialog/ModelItemSize", 180)); AtomToolsFramework::AssetGridDialog dialog( "Model Preset Browser", selectableAssets, selectedAsset, QSize(itemSize, itemSize), QApplication::activeWindow()); @@ -270,7 +267,7 @@ namespace MaterialEditor }); const int itemSize = aznumeric_cast( - AtomToolsFramework::GetSettingOrDefault("/O3DE/Atom/MaterialEditor/AssetGridDialog/LightingItemSize", 180)); + AtomToolsFramework::GetSettingsValue("/O3DE/Atom/MaterialEditor/AssetGridDialog/LightingItemSize", 180)); AtomToolsFramework::AssetGridDialog dialog( "Lighting Preset Browser", selectableAssets, selectedAsset, QSize(itemSize, itemSize), QApplication::activeWindow()); @@ -338,7 +335,6 @@ namespace MaterialEditor m_viewportSettings->m_displayMapperOperationType = viewportRequests->GetDisplayMapperOperationType(); }); - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); AtomToolsFramework::InspectorWidget::Reset(); } @@ -433,23 +429,6 @@ namespace MaterialEditor { return AZ::Crc32(AZStd::string::format("ViewportSettingsInspector::PropertyGroup::%s", groupName.c_str())); } - - bool ViewportSettingsInspector::ShouldGroupAutoExpanded(const AZStd::string& groupName) const - { - auto stateItr = m_windowSettings->m_inspectorCollapsedGroups.find(GetGroupSaveStateKey(groupName)); - return stateItr == m_windowSettings->m_inspectorCollapsedGroups.end(); - } - - void ViewportSettingsInspector::OnGroupExpanded(const AZStd::string& groupName) - { - m_windowSettings->m_inspectorCollapsedGroups.erase(GetGroupSaveStateKey(groupName)); - } - - void ViewportSettingsInspector::OnGroupCollapsed(const AZStd::string& groupName) - { - m_windowSettings->m_inspectorCollapsedGroups.insert(GetGroupSaveStateKey(groupName)); - } - } // namespace MaterialEditor #include diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.h b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.h index ad4629550f..57a7377eed 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.h +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.h @@ -16,7 +16,6 @@ #include #include #include -#include #endif namespace MaterialEditor @@ -75,13 +74,9 @@ namespace MaterialEditor AZStd::string GetDefaultUniqueSaveFilePath(const AZStd::string& baseName) const; AZ::Crc32 GetGroupSaveStateKey(const AZStd::string& groupName) const; - bool ShouldGroupAutoExpanded(const AZStd::string& groupName) const override; - void OnGroupExpanded(const AZStd::string& groupName) override; - void OnGroupCollapsed(const AZStd::string& groupName) override; AZ::Render::ModelPresetPtr m_modelPreset; AZ::Render::LightingPresetPtr m_lightingPreset; AZStd::intrusive_ptr m_viewportSettings; - AZStd::intrusive_ptr m_windowSettings; }; } // namespace MaterialEditor diff --git a/Gems/Atom/Tools/MaterialEditor/Code/materialeditor_files.cmake b/Gems/Atom/Tools/MaterialEditor/Code/materialeditor_files.cmake index dc8595fe1e..ba140539fe 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/materialeditor_files.cmake +++ b/Gems/Atom/Tools/MaterialEditor/Code/materialeditor_files.cmake @@ -46,8 +46,6 @@ set(FILES Source/Window/ToolBar/ModelPresetComboBox.cpp Source/Window/ToolBar/LightingPresetComboBox.h Source/Window/ToolBar/LightingPresetComboBox.cpp - Source/Window/MaterialInspector/MaterialInspector.h - Source/Window/MaterialInspector/MaterialInspector.cpp Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.h Source/Window/ViewportSettingsInspector/ViewportSettingsInspector.cpp ) diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentInspector.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentInspector.cpp index ff31f3382f..0324feb195 100644 --- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentInspector.cpp +++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentInspector.cpp @@ -14,8 +14,11 @@ #include #include #include -#include #include +#include +#include +#include +#include #include #include #include @@ -24,9 +27,6 @@ #include #include #include -#include -#include -#include AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT #include @@ -54,7 +54,6 @@ namespace AZ MaterialPropertyInspector::~MaterialPropertyInspector() { - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); AZ::TickBus::Handler::BusDisconnect(); AZ::EntitySystemBus::Handler::BusDisconnect(); EditorMaterialSystemComponentNotificationBus::Handler::BusDisconnect(); @@ -137,7 +136,6 @@ namespace AZ m_dirtyPropertyFlags.set(); m_internalEditNotification = {}; - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); AtomToolsFramework::InspectorWidget::Reset(); } @@ -590,7 +588,7 @@ namespace AZ bool MaterialPropertyInspector::IsInstanceNodePropertyModifed(const AzToolsFramework::InstanceDataNode* node) const { - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(node); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(node); return property && !AtomToolsFramework::ArePropertyValuesEqual(property->GetValue(), property->GetConfig().m_parentValue); } @@ -719,7 +717,7 @@ namespace AZ // This function is called continuously anytime a property changes until the edit has completed // Because of that, we have to track whether or not we are continuing to edit the same property to know when editing has // started and ended - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(pNode); if (property) { if (m_activeProperty != property) @@ -731,7 +729,7 @@ namespace AZ void MaterialPropertyInspector::AfterPropertyModified(AzToolsFramework::InstanceDataNode* pNode) { - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(pNode); if (property) { if (m_activeProperty == property) @@ -748,7 +746,7 @@ namespace AZ // As above, there are symmetrical functions on the notification interface for when editing begins and ends and has been // completed but they are not being called following that pattern. when this function executes the changes to the property // are ready to be committed or reverted - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(pNode); if (property) { if (m_activeProperty == property) diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentUtil.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentUtil.cpp index 88cbbba87b..a0c0c544cd 100644 --- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentUtil.cpp +++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentUtil.cpp @@ -15,10 +15,11 @@ #include #include #include +#include #include #include -#include #include +#include #include #include #include diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialModelUvNameMapInspector.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialModelUvNameMapInspector.cpp index 53d7980fdc..ff2d5abf88 100644 --- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialModelUvNameMapInspector.cpp +++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialModelUvNameMapInspector.cpp @@ -6,10 +6,6 @@ * */ -#include -#include -#include -#include #include #include #include @@ -19,11 +15,13 @@ #include #include #include - #include -#include - +#include +#include +#include #include +#include +#include AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT #include @@ -47,15 +45,16 @@ namespace AZ const RPI::MaterialModelUvOverrideMap& matModUvOverrides, const AZStd::unordered_set& modelUvNames, MaterialModelUvOverrideMapChangedCallBack matModUvOverrideMapChangedCallBack, - QWidget* parent - ) + QWidget* parent) : AtomToolsFramework::InspectorWidget(parent) , m_matModUvOverrideMapChangedCallBack(matModUvOverrideMapChangedCallBack) , m_matModUvOverrides(matModUvOverrides) { // Load the originating product asset from which the new source has set will be generated auto materialAssetOutcome = AZ::RPI::AssetUtils::LoadAsset(assetId); - AZ_Error("AZ::Render::EditorMaterialComponentInspector", materialAssetOutcome, "Failed to load material asset: %s", assetId.ToString().c_str()); + AZ_Error( + "AZ::Render::EditorMaterialComponentInspector", materialAssetOutcome, "Failed to load material asset: %s", + assetId.ToString().c_str()); auto materialAsset = materialAssetOutcome.GetValue(); @@ -68,12 +67,13 @@ namespace AZ MaterialModelUvNameMapInspector::~MaterialModelUvNameMapInspector() { - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); } void MaterialModelUvNameMapInspector::Reset() { - AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect(); + m_activeProperty = {}; + m_group = {}; + AtomToolsFramework::InspectorWidget::Reset(); } @@ -119,7 +119,7 @@ namespace AZ // For some reason the reflected property editor notifications are not symmetrical // This function is called continuously anytime a property changes until the edit has completed // Because of that, we have to track whether or not we are continuing to edit the same property to know when editing has started and ended - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(pNode); if (property && m_activeProperty != property) { m_activeProperty = property; @@ -128,7 +128,7 @@ namespace AZ void MaterialModelUvNameMapInspector::AfterPropertyModified(AzToolsFramework::InstanceDataNode* pNode) { - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(pNode); if (property && m_activeProperty == property) { uint32_t index = 0; @@ -159,7 +159,7 @@ namespace AZ { // As above, there are symmetrical functions on the notification interface for when editing begins and ends and has been completed but they are not being called following that pattern. // when this function executes the changes to the property are ready to be committed or reverted - const AtomToolsFramework::DynamicProperty* property = AtomToolsFramework::FindDynamicPropertyForInstanceDataNode(pNode); + const auto property = AtomToolsFramework::FindAncestorInstanceDataNodeByType(pNode); if (property && m_activeProperty == property) { uint32_t index = 0; diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SharedPreview/SharedThumbnailRenderer.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SharedPreview/SharedThumbnailRenderer.cpp index 4ee75e3436..7b426adcd3 100644 --- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SharedPreview/SharedThumbnailRenderer.cpp +++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SharedPreview/SharedThumbnailRenderer.cpp @@ -53,9 +53,9 @@ namespace AZ thumbnailConfig.m_modelId = assetInfo.m_assetId; thumbnailConfig.m_materialId = SharedPreviewUtils::GetAssetIdForProductPath( - AtomToolsFramework::GetSettingOrDefault(MaterialAssetPathSetting, DefaultMaterialPath)); + AtomToolsFramework::GetSettingsValue(MaterialAssetPathSetting, DefaultMaterialPath)); thumbnailConfig.m_lightingId = SharedPreviewUtils::GetAssetIdForProductPath( - AtomToolsFramework::GetSettingOrDefault(LightingAssetPathSetting, DefaultLightingPresetPath)); + AtomToolsFramework::GetSettingsValue(LightingAssetPathSetting, DefaultLightingPresetPath)); } else if (assetInfo.m_assetType == RPI::MaterialAsset::RTTI_Type()) { @@ -65,10 +65,10 @@ namespace AZ "/O3DE/Atom/CommonFeature/SharedPreview/MaterialAssetType/LightingAssetPath"; thumbnailConfig.m_modelId = SharedPreviewUtils::GetAssetIdForProductPath( - AtomToolsFramework::GetSettingOrDefault(ModelAssetPathSetting, DefaultModelPath)); + AtomToolsFramework::GetSettingsValue(ModelAssetPathSetting, DefaultModelPath)); thumbnailConfig.m_materialId = assetInfo.m_assetId; thumbnailConfig.m_lightingId = SharedPreviewUtils::GetAssetIdForProductPath( - AtomToolsFramework::GetSettingOrDefault(LightingAssetPathSetting, DefaultLightingPresetPath)); + AtomToolsFramework::GetSettingsValue(LightingAssetPathSetting, DefaultLightingPresetPath)); } else if (assetInfo.m_assetType == RPI::AnyAsset::RTTI_Type()) { @@ -78,9 +78,9 @@ namespace AZ "/O3DE/Atom/CommonFeature/SharedPreview/LightingAssetType/MaterialAssetPath"; thumbnailConfig.m_modelId = SharedPreviewUtils::GetAssetIdForProductPath( - AtomToolsFramework::GetSettingOrDefault(ModelAssetPathSetting, DefaultModelPath)); + AtomToolsFramework::GetSettingsValue(ModelAssetPathSetting, DefaultModelPath)); thumbnailConfig.m_materialId = SharedPreviewUtils::GetAssetIdForProductPath( - AtomToolsFramework::GetSettingOrDefault(MaterialAssetPathSetting, "materials/reflectionprobe/reflectionprobevisualization.azmaterial")); + AtomToolsFramework::GetSettingsValue(MaterialAssetPathSetting, "materials/reflectionprobe/reflectionprobevisualization.azmaterial")); thumbnailConfig.m_lightingId = assetInfo.m_assetId; }