Merge pull request #5159 from aws-lumberyard-dev/Atom/guthadam/materials_with_relative_paths

Update material editor and exporter to use relative paths for external references

Gems/Atom/RPI/Code/CMakeLists.txt

@@ -160,6 +160,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
                 Gem::Atom_RPI.Public
                 Gem::Atom_RHI.Public
                 Gem::Atom_RPI.Edit
+                Gem::Atom_Utils.TestUtils.Static
     )
     ly_add_googletest(
         NAME Gem::Atom_RPI.Tests

Gems/Atom/RPI/Code/Include/Atom/RPI.Edit/Material/MaterialTypeSourceData.h

@@ -209,10 +209,6 @@ namespace AZ
             //! Traversal will stop once all properties have been enumerated or the callback function returns false
             void EnumeratePropertiesInDisplayOrder(const EnumeratePropertiesCallback& callback) const;
 
-            //! 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
-            bool ConvertPropertyValueToSourceDataFormat(const PropertyDefinition& propertyDefinition, MaterialPropertyValue& propertyValue) const;
-
             Outcome<Data::Asset<MaterialTypeAsset>> CreateMaterialTypeAsset(Data::AssetId assetId, AZStd::string_view materialTypeSourceFilePath = "", bool elevateWarnings = true) const;
             
             //! Possibly renames @propertyId based on the material version update steps.

Gems/Atom/RPI/Code/Source/RPI.Edit/Material/MaterialTypeSourceData.cpp

@@ -300,48 +300,6 @@ namespace AZ
             }
         }
 
-        bool MaterialTypeSourceData::ConvertPropertyValueToSourceDataFormat(const PropertyDefinition& propertyDefinition, MaterialPropertyValue& propertyValue) const
-        {
-            if (propertyDefinition.m_dataType == AZ::RPI::MaterialPropertyDataType::Enum && propertyValue.Is<uint32_t>())
-            {
-                const uint32_t index = propertyValue.GetValue<uint32_t>();
-                if (index >= propertyDefinition.m_enumValues.size())
-                {
-                    AZ_Error("Material source data", false, "Invalid value for material enum property: '%s'.", propertyDefinition.m_name.c_str());
-                    return false;
-                }
-
-                propertyValue = propertyDefinition.m_enumValues[index];
-                return true;
-            }
-
-            // Image asset references must be converted from asset IDs to a relative source file path
-            if (propertyDefinition.m_dataType == AZ::RPI::MaterialPropertyDataType::Image && propertyValue.Is<Data::Asset<ImageAsset>>())
-            {
-                const Data::Asset<ImageAsset>& imageAsset = propertyValue.GetValue<Data::Asset<ImageAsset>>();
-
-                Data::AssetInfo imageAssetInfo;
-                if (imageAsset.GetId().IsValid())
-                {
-                    bool result = false;
-                    AZStd::string rootFilePath;
-                    const AZStd::string platformName = ""; // Empty for default
-                    AzToolsFramework::AssetSystemRequestBus::BroadcastResult(result, &AzToolsFramework::AssetSystem::AssetSystemRequest::GetAssetInfoById,
-                        imageAsset.GetId(), imageAsset.GetType(), platformName, imageAssetInfo, rootFilePath);
-                    if (!result)
-                    {
-                        AZ_Error("Material source data", false, "Image asset could not be found for property: '%s'.", propertyDefinition.m_name.c_str());
-                        return false;
-                    }
-                }
-
-                propertyValue = imageAssetInfo.m_relativePath;
-                return true;
-            }
-
-            return true;
-        }
-
         Outcome<Data::Asset<MaterialTypeAsset>> MaterialTypeSourceData::CreateMaterialTypeAsset(Data::AssetId assetId, AZStd::string_view materialTypeSourceFilePath, bool elevateWarnings) const
         {
             MaterialTypeAssetCreator materialTypeAssetCreator;

Gems/Atom/RPI/Code/Tests/Common/RPITestFixture.h

@@ -21,7 +21,7 @@
 #include <Common/AssetManagerTestFixture.h>
 #include <Common/RHI/Stubs.h>
 #include <Common/RHI/Factory.h>
-#include <Common/AssetSystemStub.h>
+#include <Atom/Utils/TestUtils/AssetSystemStub.h>
 
 namespace UnitTest
 {

Gems/Atom/RPI/Code/atom_rpi_tests_files.cmake

@@ -10,8 +10,6 @@ set(FILES
     Tests/Buffer/BufferTests.cpp
     Tests/Common/AssetManagerTestFixture.cpp
     Tests/Common/AssetManagerTestFixture.h
-    Tests/Common/AssetSystemStub.cpp
-    Tests/Common/AssetSystemStub.h
     Tests/Common/ErrorMessageFinder.cpp
     Tests/Common/ErrorMessageFinder.h
     Tests/Common/ErrorMessageFinderTests.cpp

Gems/Atom/Tools/AtomToolsFramework/Code/CMakeLists.txt

@@ -61,3 +61,31 @@ ly_add_target(
         PRIVATE
             Gem::AtomToolsFramework.Static
 )
+
+################################################################################
+# Tests
+################################################################################
+if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
+
+    ly_add_target(
+        NAME AtomToolsFramework.Tests ${PAL_TRAIT_TEST_TARGET_TYPE}
+        NAMESPACE Gem
+        FILES_CMAKE
+            atomtoolsframework_tests_files.cmake
+        INCLUDE_DIRECTORIES
+            PRIVATE
+                .
+                Tests
+        BUILD_DEPENDENCIES
+            PRIVATE
+                AZ::AzTest
+                AZ::AzTestShared
+                Gem::AtomToolsFramework.Static
+                Gem::Atom_Utils.TestUtils.Static
+    )
+
+    ly_add_googletest(
+        NAME Gem::AtomToolsFramework.Tests
+    )
+
+endif()

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Util/MaterialPropertyUtil.h

@@ -7,11 +7,12 @@
  */
 #pragma once
 
-#include <AzCore/std/any.h>
-#include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
 #include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
 #include <Atom/RPI.Reflect/Material/MaterialPropertyDescriptor.h>
 #include <Atom/RPI.Reflect/Material/MaterialPropertyValue.h>
+#include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
+#include <AzCore/IO/Path/Path.h>
+#include <AzCore/std/any.h>
 
 namespace AzToolsFramework
 {
@@ -35,12 +36,31 @@ namespace AtomToolsFramework
     //! Convert and assign material property meta data fields to editor dynamic property configuration 
     void ConvertToPropertyConfig(AtomToolsFramework::DynamicPropertyConfig& propertyConfig, const AZ::RPI::MaterialPropertyDynamicMetadata& propertyMetaData);
 
-    //! Convert and assign editor dynamic property configuration fields to material property meta data 
+    //! 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
+    //! @param propertyDefinition describes type information and other details about propertyValue
+    //! @param propertyValue the value being converted before saving
+    bool ConvertToExportFormat(
+        const AZStd::string& exportPath,
+        const AZ::RPI::MaterialTypeSourceData::PropertyDefinition& propertyDefinition,
+        AZ::RPI::MaterialPropertyValue& propertyValue);
+
+    //! Generate a file path from the exported file to the external reference.
+    //! This function returns a relative path from the export file to the reference file.
+    //! If the relative path is too different or distant from the export path then we return the asset folder relative 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 maxPathDepth the maximum relative depth or number of parent or child folders between the export path and the reference path
+    AZStd::string GetExteralReferencePath(
+        const AZStd::string& exportPath, const AZStd::string& referencePath, const uint32_t maxPathDepth = 2);
+
     //! Traverse up the instance data node hierarchy to find the containing dynamic property object 
     const AtomToolsFramework::DynamicProperty* FindDynamicPropertyForInstanceDataNode(const AzToolsFramework::InstanceDataNode* pNode);
 } // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Util/MaterialPropertyUtil.cpp

@@ -6,9 +6,10 @@
  *
  */
 
-#include <AtomToolsFramework/Util/MaterialPropertyUtil.h>
 #include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
+#include <AtomToolsFramework/Util/MaterialPropertyUtil.h>
 
+#include <Atom/RPI.Edit/Common/AssetUtils.h>
 #include <Atom/RPI.Reflect/Image/ImageAsset.h>
 #include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
 #include <Atom/RPI.Reflect/Material/MaterialAsset.h>
@@ -18,6 +19,7 @@
 #include <AzCore/Math/Vector2.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/Math/Vector4.h>
+#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/UI/PropertyEditor/InstanceDataHierarchy.h>
 
 namespace AtomToolsFramework
@@ -163,6 +165,88 @@ namespace AtomToolsFramework
         return false;
     }
 
+    bool ConvertToExportFormat(
+        const AZStd::string& exportPath,
+        const AZ::RPI::MaterialTypeSourceData::PropertyDefinition& propertyDefinition,
+        AZ::RPI::MaterialPropertyValue& propertyValue)
+    {
+        if (propertyDefinition.m_dataType == AZ::RPI::MaterialPropertyDataType::Enum && propertyValue.Is<uint32_t>())
+        {
+            const uint32_t index = propertyValue.GetValue<uint32_t>();
+            if (index >= propertyDefinition.m_enumValues.size())
+            {
+                AZ_Error("AtomToolsFramework", false, "Invalid value for material enum property: '%s'.", propertyDefinition.m_name.c_str());
+                return false;
+            }
+
+            propertyValue = propertyDefinition.m_enumValues[index];
+            return true;
+        }
+
+        // Image asset references must be converted from asset IDs to a relative source file path
+        if (propertyDefinition.m_dataType == AZ::RPI::MaterialPropertyDataType::Image)
+        {
+            if (propertyValue.Is<AZ::Data::Asset<AZ::RPI::ImageAsset>>())
+            {
+                const auto& imageAsset = propertyValue.GetValue<AZ::Data::Asset<AZ::RPI::ImageAsset>>();
+                const auto& imagePath = AZ::RPI::AssetUtils::GetSourcePathByAssetId(imageAsset.GetId());
+                propertyValue = GetExteralReferencePath(exportPath, imagePath);
+                return true;
+            }
+
+            if (propertyValue.Is<AZ::Data::Instance<AZ::RPI::Image>>())
+            {
+                const auto& image = propertyValue.GetValue<AZ::Data::Instance<AZ::RPI::Image>>();
+                const auto& imagePath = image ? AZ::RPI::AssetUtils::GetSourcePathByAssetId(image->GetAssetId()) : "";
+                propertyValue = GetExteralReferencePath(exportPath, imagePath);
+                return true;
+            }
+        }
+
+        return true;
+    }
+
+    AZStd::string GetExteralReferencePath(const AZStd::string& exportPath, const AZStd::string& referencePath, const uint32_t maxPathDepth)
+    {
+        if (referencePath.empty())
+        {
+            return {};
+        }
+
+        AZ::IO::BasicPath<AZStd::string> exportFolder(exportPath);
+        exportFolder.RemoveFilename();
+
+        const AZStd::string relativePath = AZ::IO::PathView(referencePath).LexicallyRelative(exportFolder).StringAsPosix();
+
+        // Count the difference in depth between the export file path and the referenced file path.
+        uint32_t parentFolderCount = 0;
+        AZStd::string::size_type pos = 0;
+        const AZStd::string parentFolderToken = "..";
+        while ((pos = relativePath.find(parentFolderToken, pos)) != AZStd::string::npos)
+        {
+            parentFolderCount++;
+            pos += parentFolderToken.length();
+        }
+
+        // If the difference in depth is too great then revert to using the asset folder relative path.
+        // We could change this to only use relative paths for references in subfolders.
+        if (parentFolderCount > maxPathDepth)
+        {
+            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;
+            }
+        }
+
+        return relativePath;
+    }
+
     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
@@ -172,7 +256,8 @@ namespace AtomToolsFramework
             const AZ::SerializeContext::ClassData* classData = currentNode->GetClassMetadata();
             if (context && classData)
             {
-                if (context->CanDowncast(classData->m_typeId, azrtti_typeid<AtomToolsFramework::DynamicProperty>(), classData->m_azRtti, nullptr))
+                if (context->CanDowncast(
+                        classData->m_typeId, azrtti_typeid<AtomToolsFramework::DynamicProperty>(), classData->m_azRtti, nullptr))
                 {
                     return static_cast<const AtomToolsFramework::DynamicProperty*>(currentNode->FirstInstance());
                 }

Gems/Atom/Tools/AtomToolsFramework/Code/Tests/AtomToolsFrameworkTest.cpp

@@ -7,25 +7,71 @@
  */
 
 #include <AzTest/AzTest.h>
+#include <Atom/Utils/TestUtils/AssetSystemStub.h>
+#include <AtomToolsFramework/Util/MaterialPropertyUtil.h>
 
-class AtomToolsFrameworkTest
-    : public ::testing::Test
+namespace UnitTest
 {
-protected:
-    void SetUp() override
+    class AtomToolsFrameworkTest : public ::testing::Test
     {
+    protected:
+        void SetUp() override
+        {
+            if (!AZ::AllocatorInstance<AZ::SystemAllocator>::IsReady())
+            {
+                AZ::AllocatorInstance<AZ::SystemAllocator>::Create(AZ::SystemAllocator::Descriptor());
+            }
 
+            m_assetSystemStub.Activate();
+
+            RegisterSourceAsset("objects/upgrades/materials/supercondor.material");
+            RegisterSourceAsset("materials/condor.material");
+            RegisterSourceAsset("materials/talisman.material");
+            RegisterSourceAsset("materials/city.material");
+            RegisterSourceAsset("materials/totem.material");
+            RegisterSourceAsset("textures/orange.png");
+            RegisterSourceAsset("textures/red.png");
+            RegisterSourceAsset("textures/gold.png");
+            RegisterSourceAsset("textures/fuzz.png");
+        }
+
+        void TearDown() override
+        {
+            m_assetSystemStub.Deactivate();
+
+            if (AZ::AllocatorInstance<AZ::SystemAllocator>::IsReady())
+            {
+                AZ::AllocatorInstance<AZ::SystemAllocator>::Destroy();
+            }
+        }
+
+        void RegisterSourceAsset(const AZStd::string& path)
+        {
+            const AZ::IO::BasicPath assetRootPath = AZ::IO::PathView(m_assetRoot).LexicallyNormal();
+            const AZ::IO::BasicPath normalizedPath = AZ::IO::BasicPath(assetRootPath).Append(path).LexicallyNormal();
+
+            AZ::Data::AssetInfo assetInfo = {};
+            assetInfo.m_assetId = AZ::Uuid::CreateRandom();
+            assetInfo.m_relativePath = normalizedPath.LexicallyRelative(assetRootPath).StringAsPosix();
+            m_assetSystemStub.RegisterSourceInfo(normalizedPath.StringAsPosix().c_str(), assetInfo, assetRootPath.StringAsPosix().c_str());
+        }
+
+        static constexpr const char* m_assetRoot = "d:/project/assets/";
+        AssetSystemStub m_assetSystemStub;
+    };
+
+    TEST_F(AtomToolsFrameworkTest, GetExteralReferencePath_Succeeds)
+    {
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("", "", 2), "");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/materials/condor.material", "", 2), "");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/materials/talisman.material", "", 2), "");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/materials/talisman.material", "d:/project/assets/textures/gold.png", 2), "../textures/gold.png");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/materials/talisman.material", "d:/project/assets/textures/gold.png", 0), "textures/gold.png");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/objects/upgrades/materials/supercondor.material", "d:/project/assets/materials/condor.material", 3), "../../../materials/condor.material");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/objects/upgrades/materials/supercondor.material", "d:/project/assets/materials/condor.material", 2), "materials/condor.material");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/objects/upgrades/materials/supercondor.material", "d:/project/assets/materials/condor.material", 1), "materials/condor.material");
+        ASSERT_EQ(AtomToolsFramework::GetExteralReferencePath("d:/project/assets/objects/upgrades/materials/supercondor.material", "d:/project/assets/materials/condor.material", 0), "materials/condor.material");
     }
 
-    void TearDown() override
-    {
-
-    }
-};
-
-TEST_F(AtomToolsFrameworkTest, SanityTest)
-{
-    ASSERT_TRUE(true);
-}
-
-AZ_UNIT_TEST_HOOK(DEFAULT_UNIT_TEST_ENV);
+    AZ_UNIT_TEST_HOOK(DEFAULT_UNIT_TEST_ENV);
+} // namespace UnitTest

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

@@ -0,0 +1,11 @@
+#
+# 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
+#
+#
+
+set(FILES
+    Tests/AtomToolsFrameworkTest.cpp
+)

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.cpp

@@ -230,18 +230,13 @@ namespace MaterialEditor
 
         // create source data from properties
         MaterialSourceData sourceData;
-        sourceData.m_materialType = m_materialSourceData.m_materialType;
-        sourceData.m_parentMaterial = m_materialSourceData.m_parentMaterial;
-        
-        AZ_Assert(m_materialAsset && m_materialAsset->GetMaterialTypeAsset(), "When IsOpen() is true, these assets should not be null.");
         sourceData.m_materialTypeVersion = m_materialAsset->GetMaterialTypeAsset()->GetVersion();
-
-        // Force save data to store forward slashes
-        AzFramework::StringFunc::Replace(sourceData.m_materialType, "\\", "/");
-        AzFramework::StringFunc::Replace(sourceData.m_parentMaterial, "\\", "/");
+        sourceData.m_materialType = AtomToolsFramework::GetExteralReferencePath(m_absolutePath, m_materialSourceData.m_materialType);
+        sourceData.m_parentMaterial = AtomToolsFramework::GetExteralReferencePath(m_absolutePath, m_materialSourceData.m_parentMaterial);
 
         // populate sourceData with modified or overwritten properties
-        const bool savedProperties = SavePropertiesToSourceData(sourceData, [](const AtomToolsFramework::DynamicProperty& property) {
+        const bool savedProperties = SavePropertiesToSourceData(m_absolutePath, sourceData, [](const AtomToolsFramework::DynamicProperty& property)
+        {
             return !AtomToolsFramework::ArePropertyValuesEqual(property.GetValue(), property.GetConfig().m_parentValue);
         });
 
@@ -304,18 +299,13 @@ namespace MaterialEditor
 
         // create source data from properties
         MaterialSourceData sourceData;
-        sourceData.m_materialType = m_materialSourceData.m_materialType;
-        sourceData.m_parentMaterial = m_materialSourceData.m_parentMaterial;
-        
-        AZ_Assert(m_materialAsset && m_materialAsset->GetMaterialTypeAsset(), "When IsOpen() is true, these assets should not be null.");
         sourceData.m_materialTypeVersion = m_materialAsset->GetMaterialTypeAsset()->GetVersion();
-
-        // Force save data to store forward slashes
-        AzFramework::StringFunc::Replace(sourceData.m_materialType, "\\", "/");
-        AzFramework::StringFunc::Replace(sourceData.m_parentMaterial, "\\", "/");
+        sourceData.m_materialType = AtomToolsFramework::GetExteralReferencePath(normalizedSavePath, m_materialSourceData.m_materialType);
+        sourceData.m_parentMaterial = AtomToolsFramework::GetExteralReferencePath(normalizedSavePath, m_materialSourceData.m_parentMaterial);
 
         // populate sourceData with modified or overwritten properties
-        const bool savedProperties = SavePropertiesToSourceData(sourceData, [](const AtomToolsFramework::DynamicProperty& property) {
+        const bool savedProperties = SavePropertiesToSourceData(normalizedSavePath, sourceData, [](const AtomToolsFramework::DynamicProperty& property)
+        {
             return !AtomToolsFramework::ArePropertyValuesEqual(property.GetValue(), property.GetConfig().m_parentValue);
         });
 
@@ -377,23 +367,18 @@ namespace MaterialEditor
 
         // create source data from properties
         MaterialSourceData sourceData;
-        sourceData.m_materialType = m_materialSourceData.m_materialType;
-        
-        AZ_Assert(m_materialAsset && m_materialAsset->GetMaterialTypeAsset(), "When IsOpen() is true, these assets should not be null.");
         sourceData.m_materialTypeVersion = m_materialAsset->GetMaterialTypeAsset()->GetVersion();
+        sourceData.m_materialType = AtomToolsFramework::GetExteralReferencePath(normalizedSavePath, m_materialSourceData.m_materialType);
 
         // Only assign a parent path if the source was a .material
         if (AzFramework::StringFunc::Path::IsExtension(m_relativePath.c_str(), MaterialSourceData::Extension))
         {
-            sourceData.m_parentMaterial = m_relativePath;
+            sourceData.m_parentMaterial = AtomToolsFramework::GetExteralReferencePath(normalizedSavePath, m_absolutePath);
         }
 
-        // Force save data to store forward slashes
-        AzFramework::StringFunc::Replace(sourceData.m_materialType, "\\", "/");
-        AzFramework::StringFunc::Replace(sourceData.m_parentMaterial, "\\", "/");
-
         // populate sourceData with modified properties
-        const bool savedProperties = SavePropertiesToSourceData(sourceData, [](const AtomToolsFramework::DynamicProperty& property) {
+        const bool savedProperties = SavePropertiesToSourceData(normalizedSavePath, sourceData, [](const AtomToolsFramework::DynamicProperty& property)
+        {
             return !AtomToolsFramework::ArePropertyValuesEqual(property.GetValue(), property.GetConfig().m_originalValue);
         });
 
@@ -590,7 +575,8 @@ namespace MaterialEditor
         }
     }
 
-    bool MaterialDocument::SavePropertiesToSourceData(AZ::RPI::MaterialSourceData& sourceData, PropertyFilterFunction propertyFilter) const
+    bool MaterialDocument::SavePropertiesToSourceData(
+        const AZStd::string& exportPath, AZ::RPI::MaterialSourceData& sourceData, PropertyFilterFunction propertyFilter) const
     {
         using namespace AZ;
         using namespace RPI;
@@ -598,7 +584,7 @@ namespace MaterialEditor
         bool result = true;
 
         // populate sourceData with properties that meet the filter
-        m_materialTypeSourceData.EnumerateProperties([this, &sourceData, &propertyFilter, &result](const AZStd::string& groupName, const AZStd::string& propertyName, const auto& propertyDefinition) {
+        m_materialTypeSourceData.EnumerateProperties([&](const AZStd::string& groupName, const AZStd::string& propertyName, const auto& propertyDefinition) {
 
             const MaterialPropertyId propertyId(groupName, propertyName);
 
@@ -608,7 +594,7 @@ namespace MaterialEditor
                 MaterialPropertyValue propertyValue = AtomToolsFramework::ConvertToRuntimeType(it->second.GetValue());
                 if (propertyValue.IsValid())
                 {
-                    if (!m_materialTypeSourceData.ConvertPropertyValueToSourceDataFormat(propertyDefinition, propertyValue))
+                    if (!AtomToolsFramework::ConvertToExportFormat(exportPath, propertyDefinition, propertyValue))
                     {
                         AZ_Error("MaterialDocument", false, "Material document property could not be converted: '%s' in '%s'.", propertyId.GetFullName().GetCStr(), m_absolutePath.c_str());
                         result = false;
@@ -663,8 +649,6 @@ namespace MaterialEditor
             return false;
         }
 
-        AZStd::string materialTypeSourceFilePath;
-
         // The material document and inspector are constructed from source data
         if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), MaterialSourceData::Extension))
         {
@@ -675,13 +659,24 @@ namespace MaterialEditor
                 return false;
             }
 
-            // We must also always load the material type data for a complete, ordered set of the
-            // groups and properties that will be needed for comparison and building the inspector
-            materialTypeSourceFilePath = AssetUtils::ResolvePathReference(m_absolutePath, m_materialSourceData.m_materialType);
-            auto materialTypeOutcome = MaterialUtils::LoadMaterialTypeSourceData(materialTypeSourceFilePath);
+            // We always need the absolute path for the material type and parent material to load source data and resolving
+            // relative paths when saving. This will convert and store them as absolute paths for use within the document.
+            if (!m_materialSourceData.m_parentMaterial.empty())
+            {
+                m_materialSourceData.m_parentMaterial =
+                    AssetUtils::ResolvePathReference(m_absolutePath, m_materialSourceData.m_parentMaterial);
+            }
+
+            if (!m_materialSourceData.m_materialType.empty())
+            {
+                m_materialSourceData.m_materialType = AssetUtils::ResolvePathReference(m_absolutePath, m_materialSourceData.m_materialType);
+            }
+
+            // Load the material type source data which provides the layout and default values of all of the properties
+            auto materialTypeOutcome = MaterialUtils::LoadMaterialTypeSourceData(m_materialSourceData.m_materialType);
             if (!materialTypeOutcome.IsSuccess())
             {
-                AZ_Error("MaterialDocument", false, "Material type source data could not be loaded: '%s'.", materialTypeSourceFilePath.c_str());
+                AZ_Error("MaterialDocument", false, "Material type source data could not be loaded: '%s'.", m_materialSourceData.m_materialType.c_str());
                 return false;
             }
             m_materialTypeSourceData = materialTypeOutcome.GetValue();
@@ -694,10 +689,10 @@ namespace MaterialEditor
         }
         else if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), MaterialTypeSourceData::Extension))
         {
-            materialTypeSourceFilePath = m_absolutePath;
-
-            // Load the material type source data, which will be used for enumerating properties and building material source data
-            auto materialTypeOutcome = MaterialUtils::LoadMaterialTypeSourceData(materialTypeSourceFilePath);
+            // A material document can be created or loaded from material or material type source data. If we are attempting to load
+            // material type source data then the material source data object can be created just by referencing the document path as the
+            // material type path.
+            auto materialTypeOutcome = MaterialUtils::LoadMaterialTypeSourceData(m_absolutePath);
             if (!materialTypeOutcome.IsSuccess())
             {
                 AZ_Error("MaterialDocument", false, "Material type source data could not be loaded: '%s'.", m_absolutePath.c_str());
@@ -705,9 +700,8 @@ namespace MaterialEditor
             }
             m_materialTypeSourceData = materialTypeOutcome.GetValue();
 
-            // The document represents a material, not a material type.
-            // If the input data is a material type file we have to generate the material source data by referencing it.
-            m_materialSourceData.m_materialType = m_relativePath;
+            // We are storing absolute paths in the loaded version of the source data so that the files can be resolved at all times.
+            m_materialSourceData.m_materialType = m_absolutePath;
             m_materialSourceData.m_parentMaterial.clear();
         }
         else
@@ -870,7 +864,8 @@ namespace MaterialEditor
             m_properties[propertyConfig.m_id] = AtomToolsFramework::DynamicProperty(propertyConfig);
         }
 
-        const MaterialFunctorSourceData::EditorContext editorContext = MaterialFunctorSourceData::EditorContext(materialTypeSourceFilePath, m_materialAsset->GetMaterialPropertiesLayout());
+        const MaterialFunctorSourceData::EditorContext editorContext =
+            MaterialFunctorSourceData::EditorContext(m_materialSourceData.m_materialType, m_materialAsset->GetMaterialPropertiesLayout());
         for (Ptr<MaterialFunctorSourceDataHolder> functorData : m_materialTypeSourceData.m_materialFunctorSourceData)
         {
             MaterialFunctorSourceData::FunctorResult result2 = functorData->CreateFunctor(editorContext);

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.h

@@ -110,7 +110,8 @@ namespace MaterialEditor
         void OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
         //////////////////////////////////////////////////////////////////////////
 
-        bool SavePropertiesToSourceData(AZ::RPI::MaterialSourceData& sourceData, PropertyFilterFunction propertyFilter) const;
+        bool SavePropertiesToSourceData(
+            const AZStd::string& exportPath, AZ::RPI::MaterialSourceData& sourceData, PropertyFilterFunction propertyFilter) const;
 
         bool OpenInternal(AZStd::string_view loadPath);
 

Gems/Atom/Utils/Code/CMakeLists.txt

@@ -27,6 +27,27 @@ ly_add_target(
             3rdParty::libpng
 )
 
+if(PAL_TRAIT_BUILD_HOST_TOOLS)
+
+    ly_add_target(
+        NAME Atom_Utils.TestUtils.Static STATIC
+        NAMESPACE Gem
+        FILES_CMAKE
+            atom_utils_editor_files.cmake
+        INCLUDE_DIRECTORIES
+            PRIVATE
+                Source
+            PUBLIC
+                Include
+        BUILD_DEPENDENCIES
+            PRIVATE
+                AZ::AtomCore
+                AZ::AzCore
+                AZ::AzFramework
+                AZ::AzToolsFramework
+    )
+endif()
+
 ################################################################################
 # Tests
 ################################################################################

Gems/Atom/Utils/Code/Source/TestUtils/AssetSystemStub.cpp

@@ -6,7 +6,7 @@
  *
  */
 
-#include <Common/AssetSystemStub.h>
+#include <Atom/Utils/TestUtils/AssetSystemStub.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 
 namespace UnitTest

Gems/Atom/Utils/Code/atom_utils_editor_files.cmake

@@ -0,0 +1,12 @@
+#
+# 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
+#
+#
+
+set(FILES
+    Include/Atom/Utils/TestUtils/AssetSystemStub.h
+    Source/TestUtils/AssetSystemStub.cpp
+)

Gems/AtomLyIntegration/CommonFeatures/Code/Source/Material/EditorMaterialComponentUtil.cpp

@@ -17,6 +17,7 @@
 #include <Atom/RPI.Reflect/Material/MaterialAsset.h>
 #include <Atom/RPI.Reflect/Material/MaterialPropertiesLayout.h>
 #include <Atom/RPI.Reflect/Material/MaterialTypeAsset.h>
+#include <AtomToolsFramework/Util/MaterialPropertyUtil.h>
 #include <AzFramework/API/ApplicationAPI.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
@@ -97,51 +98,28 @@ namespace AZ
 
             bool SaveSourceMaterialFromEditData(const AZStd::string& path, const MaterialEditData& editData)
             {
-                // Construct the material source data object that will be exported
-                AZ::RPI::MaterialSourceData exportData;
-
-                // Converting absolute material paths to relative paths
-                bool result = false;
-                AZ::Data::AssetInfo info;
-                AZStd::string watchFolder;
-                AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
-                    result, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath,
-                    editData.m_materialTypeSourcePath.c_str(), info, watchFolder);
-                if (!result)
+                if (path.empty() || !editData.m_materialAsset.IsReady() || !editData.m_materialTypeAsset.IsReady() ||
+                    editData.m_materialTypeSourcePath.empty())
                 {
-                    AZ_Error(
-                        "AZ::Render::EditorMaterialComponentUtil", false,
-                        "Failed to get material type source file info while attempting to export: %s", path.c_str());
+                    AZ_Error("AZ::Render::EditorMaterialComponentUtil", false, "Can not export: %s", path.c_str());
                     return false;
                 }
 
-                exportData.m_materialType = info.m_relativePath;
-
-                if (!editData.m_materialParentSourcePath.empty())
-                {
-                    result = false;
-                    AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
-                        result, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath,
-                        editData.m_materialParentSourcePath.c_str(), info, watchFolder);
-                    if (!result)
-                    {
-                        AZ_Error(
-                            "AZ::Render::EditorMaterialComponentUtil", false,
-                            "Failed to get parent material source file info while attempting to export: %s", path.c_str());
-                        return false;
-                    }
-
-                    exportData.m_parentMaterial = info.m_relativePath;
-                }
+                // Construct the material source data object that will be exported
+                AZ::RPI::MaterialSourceData exportData;
+                exportData.m_materialTypeVersion = editData.m_materialTypeAsset->GetVersion();
+                exportData.m_materialType = AtomToolsFramework::GetExteralReferencePath(path, editData.m_materialTypeSourcePath);
+                exportData.m_parentMaterial = AtomToolsFramework::GetExteralReferencePath(path, editData.m_materialParentSourcePath);
 
                 // Copy all of the properties from the material asset to the source data that will be exported
-                result = true;
-                editData.m_materialTypeSourceData.EnumerateProperties([&](const AZStd::string& groupName, const AZStd::string& propertyName, const auto& propertyDefinition) {
+                bool result = true;
+                editData.m_materialTypeSourceData.EnumerateProperties([&](const AZStd::string& groupName, const AZStd::string& propertyName, const auto& propertyDefinition){
                     const AZ::RPI::MaterialPropertyId propertyId(groupName, propertyName);
                     const AZ::RPI::MaterialPropertyIndex propertyIndex =
                         editData.m_materialAsset->GetMaterialPropertiesLayout()->FindPropertyIndex(propertyId.GetFullName());
 
-                    AZ::RPI::MaterialPropertyValue propertyValue = editData.m_materialAsset->GetPropertyValues()[propertyIndex.GetIndex()];
+                    AZ::RPI::MaterialPropertyValue propertyValue =
+                        editData.m_materialAsset->GetPropertyValues()[propertyIndex.GetIndex()];
 
                     AZ::RPI::MaterialPropertyValue propertyValueDefault = propertyDefinition.m_value;
                     if (editData.m_materialParentAsset.IsReady())
@@ -151,12 +129,12 @@ namespace AZ
 
                     // Check for and apply any property overrides before saving property values
                     auto propertyOverrideItr = editData.m_materialPropertyOverrideMap.find(propertyId.GetFullName());
-                    if(propertyOverrideItr != editData.m_materialPropertyOverrideMap.end())
+                    if (propertyOverrideItr != editData.m_materialPropertyOverrideMap.end())
                     {
                         propertyValue = AZ::RPI::MaterialPropertyValue::FromAny(propertyOverrideItr->second);
                     }
 
-                    if (!editData.m_materialTypeSourceData.ConvertPropertyValueToSourceDataFormat(propertyDefinition, propertyValue))
+                    if (!AtomToolsFramework::ConvertToExportFormat(path, propertyDefinition, propertyValue))
                     {
                         AZ_Error("AZ::Render::EditorMaterialComponentUtil", false, "Failed to export: %s", path.c_str());
                         result = false;