Removed deprecated Blast legacy materials. (#95)

Signed-off-by: moraaar <[email protected]>

## What does this PR do?

Removes legacy Blast materials, which was deprecated in O3DE 2022.10.0 release.
**There is no Blast documentation to update for now because it was taken out from the user guide.**

Closes https://github.com/o3de/o3de/issues/9839 (deprecation GHI)

In addition quick changes:
- Added the new Unified target to Blast gem
- Added 1 empty unit test to Blast Editor target (before it was failing to execute with an unexpected error that the target is not a valid win32 target, it's preferable to be working as usual but with no tests)

## How was this PR tested?

Enabled Blast gem in AutomatedTesting project.
Built and run the editor.
Opened, edited and saved a blast material, checked it was saved correctly and that it applied correctly to a blast component.

Gems/Blast/Code/CMakeLists.txt

@@ -59,7 +59,7 @@ ly_add_target(
 # clients and servers use the above Gem module.
 ly_create_alias(NAME Blast.Servers NAMESPACE Gem TARGETS Gem::Blast)
 ly_create_alias(NAME Blast.Clients NAMESPACE Gem TARGETS Gem::Blast)
-
+ly_create_alias(NAME Blast.Unified NAMESPACE Gem TARGETS Gem::Blast)
 
 if(PAL_TRAIT_BUILD_HOST_TOOLS)
 
@@ -165,9 +165,9 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
                     AZ::AzToolsFrameworkTestCommon
                     Gem::Blast.Editor.Static
         )
-        # Commented out as currently there are no Blast Editor tests
-        # ly_add_googletest(
-            # NAME Gem::Blast.Editor.Tests
-        # )
+        ly_add_googletest(
+            NAME Gem::Blast.Editor.Tests
+            TEST_SUITE sandbox
+        )
     endif()
 endif()

Gems/Blast/Code/Source/Editor/EditorBlastFamilyComponent.cpp

@@ -22,12 +22,10 @@ namespace Blast
         if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
         {
             serialize->Class<EditorBlastFamilyComponent, EditorComponentBase>()
-                ->Version(4)
+                ->Version(5)
                 ->Field("BlastAsset", &EditorBlastFamilyComponent::m_blastAsset)
                 ->Field("BlastMaterialAsset", &EditorBlastFamilyComponent::m_blastMaterialAsset)
-                ->Field("BlastMaterial", &EditorBlastFamilyComponent::m_legacyBlastMaterialId)
                 ->Field("PhysicsMaterialAsset", &EditorBlastFamilyComponent::m_physicsMaterialAsset)
-                ->Field("PhysicsMaterial", &EditorBlastFamilyComponent::m_legacyPhysicsMaterialId)
                 ->Field("ActorConfiguration", &EditorBlastFamilyComponent::m_actorConfiguration);
 
             if (AZ::EditContext* ec = serialize->GetEditContext())

Gems/Blast/Code/Source/Editor/EditorBlastFamilyComponent.h

@@ -10,7 +10,6 @@
 #include <Asset/BlastAsset.h>
 #include <AzCore/Component/Component.h>
 #include <AzFramework/Physics/Material/PhysicsMaterialAsset.h>
-#include <AzFramework/Physics/Material/Legacy/LegacyPhysicsMaterialSelection.h>
 #include <Blast/BlastActorConfiguration.h>
 #include <Blast/BlastDebug.h>
 #include <Material/BlastMaterialAsset.h>
@@ -55,9 +54,7 @@ namespace Blast
         // Configurations
         AZ::Data::Asset<BlastAsset> m_blastAsset;
         AZ::Data::Asset<MaterialAsset> m_blastMaterialAsset;
-        BlastMaterialId m_legacyBlastMaterialId; // Kept to convert old blast material assets.
         AZ::Data::Asset<Physics::MaterialAsset> m_physicsMaterialAsset;
-        PhysicsLegacy::MaterialId m_legacyPhysicsMaterialId; // Kept to convert old physics material assets.
 
         BlastActorConfiguration m_actorConfiguration;
     };

Gems/Blast/Code/Source/Editor/EditorSystemComponent.cpp

@@ -10,7 +10,6 @@
 #include <AzCore/Serialization/SerializeContext.h>
 #include <Editor/EditorSystemComponent.h>
 #include <Editor/EditorWindow.h>
-#include <Editor/Material/LegacyBlastMaterialAssetConversion.h>
 
 namespace Blast
 {
@@ -18,8 +17,6 @@ namespace Blast
     {
         BlastChunksAsset::Reflect(context);
 
-        ReflectLegacyMaterialClasses(context);
-
         if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
         {
             serializeContext->Class<EditorSystemComponent, AZ::Component>()->Version(1);

Gems/Blast/Code/Source/Editor/Material/LegacyBlastMaterialAssetConversion.cpp

@@ -1,334 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/Console/IConsole.h>
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/Asset/AssetManager.h>
-#include <AzCore/IO/IOUtils.h>
-#include <AzCore/std/smart_ptr/make_shared.h>
-
-#include <AzFramework/Asset/GenericAssetHandler.h>
-
-#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
-#include <AzToolsFramework/SourceControl/SourceControlAPI.h>
-#include <AzToolsFramework/Physics/Material/Legacy/LegacyPhysicsMaterialConversionUtils.h>
-
-#include <Material/BlastMaterialConfiguration.h>
-#include <Material/BlastMaterialAsset.h>
-
-namespace Blast
-{
-    void ConvertMaterialLibrariesIntoIndividualMaterials([[maybe_unused]] const AZ::ConsoleCommandContainer& commandArgs);
-
-    AZ_CONSOLEFREEFUNC("ed_blastConvertMaterialLibrariesIntoIndividualMaterials", ConvertMaterialLibrariesIntoIndividualMaterials, AZ::ConsoleFunctorFlags::Null,
-        "Finds legacy blast material library assets in the project and generates new individual blast material assets. Original library assets will be deleted.");
-
-    // O3DE_DEPRECATION_NOTICE(GHI-9839)
-    // Default values used for initializing materials.
-    // Use BlastMaterialConfiguration to define properties for materials at the time of creation.
-    class BlastMaterialConfiguration
-    {
-    public:
-        AZ_TYPE_INFO(BlastMaterialConfiguration, "{BEC875B1-26E4-4A4A-805E-0E880372720D}");
-
-        static void Reflect(AZ::ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-            {
-                serializeContext->Class<BlastMaterialConfiguration>()
-                    ->Version(1)
-                    ->Field("MaterialName", &BlastMaterialConfiguration::m_materialName)
-                    ->Field("Health", &BlastMaterialConfiguration::m_health)
-                    ->Field("ForceDivider", &BlastMaterialConfiguration::m_forceDivider)
-                    ->Field("MinDamageThreshold", &BlastMaterialConfiguration::m_minDamageThreshold)
-                    ->Field("MaxDamageThreshold", &BlastMaterialConfiguration::m_maxDamageThreshold)
-                    ->Field("StressLinearFactor", &BlastMaterialConfiguration::m_stressLinearFactor)
-                    ->Field("StressAngularFactor", &BlastMaterialConfiguration::m_stressAngularFactor);
-            }
-        }
-
-        float m_health = 1.0f;
-        float m_forceDivider = 1.0f;
-        float m_minDamageThreshold = 0.0f;
-        float m_maxDamageThreshold = 1.0f;
-        float m_stressLinearFactor = 1.0f;
-        float m_stressAngularFactor = 1.0f;
-
-        AZStd::string m_materialName{ "Default" };
-    };
-
-    // O3DE_DEPRECATION_NOTICE(GHI-9839)
-    // A single BlastMaterial entry in the material library
-    // BlastMaterialLibraryAsset holds a collection of BlastMaterialFromAssetConfiguration instances.
-    class BlastMaterialFromAssetConfiguration
-    {
-    public:
-        AZ_TYPE_INFO(BlastMaterialFromAssetConfiguration, "{E380E174-BCA3-4BBB-AA39-8FAD39005B12}");
-
-        static void Reflect(AZ::ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-            {
-                serializeContext->Class<BlastMaterialFromAssetConfiguration>()
-                    ->Version(1)
-                    ->Field("Configuration", &BlastMaterialFromAssetConfiguration::m_configuration)
-                    ->Field("UID", &BlastMaterialFromAssetConfiguration::m_id);
-            }
-        }
-
-        BlastMaterialConfiguration m_configuration;
-        BlastMaterialId m_id;
-
-        void CopyDataToMaterialAsset(MaterialAsset& materialAsset) const
-        {
-            materialAsset.m_materialConfiguration.m_health = m_configuration.m_health;
-            materialAsset.m_materialConfiguration.m_forceDivider = m_configuration.m_forceDivider;
-            materialAsset.m_materialConfiguration.m_minDamageThreshold = m_configuration.m_minDamageThreshold;
-            materialAsset.m_materialConfiguration.m_maxDamageThreshold = m_configuration.m_maxDamageThreshold;
-            materialAsset.m_materialConfiguration.m_stressLinearFactor = m_configuration.m_stressLinearFactor;
-            materialAsset.m_materialConfiguration.m_stressAngularFactor = m_configuration.m_stressAngularFactor;
-            materialAsset.m_legacyBlastMaterialId = m_id;
-        }
-    };
-
-    // O3DE_DEPRECATION_NOTICE(GHI-9839)
-    // An asset that holds a list of materials.
-    class BlastMaterialLibraryAsset : public AZ::Data::AssetData
-    {
-    public:
-        AZ_CLASS_ALLOCATOR(BlastMaterialLibraryAsset, AZ::SystemAllocator, 0);
-        AZ_RTTI(BlastMaterialLibraryAsset, "{55F38C86-0767-4E7F-830A-A4BF624BE4DA}", AZ::Data::AssetData);
-
-        BlastMaterialLibraryAsset() = default;
-        virtual ~BlastMaterialLibraryAsset() = default;
-
-        static void Reflect(AZ::ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-            {
-                serializeContext->Class<BlastMaterialLibraryAsset>()
-                    ->Version(1)
-                    ->Field("Properties", &BlastMaterialLibraryAsset::m_materialLibrary);
-            }
-        }
-
-        AZStd::vector<BlastMaterialFromAssetConfiguration> m_materialLibrary;
-    };
-
-    void ReflectLegacyMaterialClasses(AZ::ReflectContext* context)
-    {
-        BlastMaterialConfiguration::Reflect(context);
-        BlastMaterialFromAssetConfiguration::Reflect(context);
-        BlastMaterialLibraryAsset::Reflect(context);
-    }
-
-    struct BlastMaterialLibrary
-    {
-        AZStd::vector<BlastMaterialFromAssetConfiguration> m_materialAssetConfigurations;
-        AZStd::string m_sourceFile; // Path to material library source file
-    };
-
-    // Collects all legacy material libraries to convert to new material assets
-    AZStd::vector<BlastMaterialLibrary> CollectMaterialLibraries(AZ::Data::AssetHandler* materialAssetHandler)
-    {
-        AZStd::vector<BlastMaterialLibrary> materialLibraries;
-
-        // Unregister the MaterialAsset handler new for .blastmaterial files
-        AZ::Data::AssetManager::Instance().UnregisterHandler(materialAssetHandler);
-
-        // Create and register the asset handler for legacy BlastMaterialLibraryAsset to handle old .blastmaterial files
-        auto materialLibraryAssetHandler = AZStd::make_unique<AzFramework::GenericAssetHandler<BlastMaterialLibraryAsset>>(
-            "Blast Material", "Blast Material", "blastmaterial");
-        AZ::Data::AssetManager::Instance().RegisterHandler(materialLibraryAssetHandler.get(), BlastMaterialLibraryAsset::RTTI_Type());
-
-        AZ::Data::AssetCatalogRequests::AssetEnumerationCB assetEnumerationCB =
-            [&materialLibraryAssetHandler, &materialLibraries](const AZ::Data::AssetId assetId, const AZ::Data::AssetInfo& assetInfo)
-        {
-            // In the catalog all .blastmaterial files have rtti type of new MaterialAsset class.
-            if (assetInfo.m_assetType != MaterialAsset::RTTI_Type())
-            {
-                return;
-            }
-
-            AZStd::optional<AZStd::string> assetFullPath = Physics::Utils::GetFullSourceAssetPathById(assetId);
-            if (!assetFullPath.has_value())
-            {
-                return;
-            }
-
-            auto assetDataStream = AZStd::make_shared<AZ::Data::AssetDataStream>();
-            // Read in the data from a file to a buffer, then hand ownership of the buffer over to the assetDataStream
-            {
-                AZ::IO::FileIOStream stream(assetFullPath->c_str(), AZ::IO::OpenMode::ModeRead);
-                if (!AZ::IO::RetryOpenStream(stream))
-                {
-                    AZ_Warning("BlastMaterialConversion", false, "Source file '%s' could not be opened.", assetFullPath->c_str());
-                    return;
-                }
-                AZStd::vector<AZ::u8> fileBuffer(stream.GetLength());
-                size_t bytesRead = stream.Read(fileBuffer.size(), fileBuffer.data());
-                if (bytesRead != stream.GetLength())
-                {
-                    AZ_Warning("BlastMaterialConversion", false, "Source file '%s' could not be read.", assetFullPath->c_str());
-                    return;
-                }
-
-                // Only consider old .blastmaterial assets by checking if the legacy material library asset type id is part of the content.
-                AZStd::string_view fileBufferString(reinterpret_cast<const char*>(fileBuffer.data()), bytesRead);
-                if (!fileBufferString.contains(BlastMaterialLibraryAsset::RTTI_Type().ToString<AZStd::string>().c_str()))
-                {
-                    return;
-                }
-
-                assetDataStream->Open(AZStd::move(fileBuffer));
-            }
-
-            AZ::Data::Asset<BlastMaterialLibraryAsset> materialLibraryAsset;
-            materialLibraryAsset.Create(AZ::Data::AssetId(AZ::Uuid::CreateRandom()));
-
-            if (materialLibraryAssetHandler->LoadAssetDataFromStream(materialLibraryAsset, assetDataStream, nullptr) != AZ::Data::AssetHandler::LoadResult::LoadComplete)
-            {
-                AZ_Warning("BlastMaterialConversion", false, "Failed to load BlastMaterialLibraryAsset asset: '%s'", assetFullPath->c_str());
-                return;
-            }
-
-            BlastMaterialLibrary blastMaterialLibrary;
-            blastMaterialLibrary.m_materialAssetConfigurations = materialLibraryAsset->m_materialLibrary;
-            blastMaterialLibrary.m_sourceFile = AZStd::move(*assetFullPath);
-
-            materialLibraries.push_back(AZStd::move(blastMaterialLibrary));
-        };
-
-        AZ::Data::AssetCatalogRequestBus::Broadcast(&AZ::Data::AssetCatalogRequestBus::Events::EnumerateAssets,
-            nullptr,
-            assetEnumerationCB,
-            nullptr);
-
-        // Unregister and destroy the asset handler for legacy BlastMaterialLibraryAsset
-        AZ::Data::AssetManager::Instance().UnregisterHandler(materialLibraryAssetHandler.get());
-        materialLibraryAssetHandler.reset();
-
-        // Register back the new MaterialAsset handler for .blastmaterial files
-        AZ::Data::AssetManager::Instance().RegisterHandler(materialAssetHandler, MaterialAsset::RTTI_Type());
-
-        return materialLibraries;
-    }
-
-    void ConvertMaterialLibrary(const BlastMaterialLibrary& materialLibrary, AZ::Data::AssetHandler* materialAssetHandler)
-    {
-        AZ_TracePrintf("BlastMaterialConversion", "Converting blast material library '%s' (%zu materials).\n",
-            materialLibrary.m_sourceFile.c_str(),
-            materialLibrary.m_materialAssetConfigurations.size());
-
-        for (const auto& materialAssetConfiguration : materialLibrary.m_materialAssetConfigurations)
-        {
-            AZStd::string targetSourceFile = materialLibrary.m_sourceFile;
-            AZ::StringFunc::Path::ReplaceFullName(targetSourceFile, materialAssetConfiguration.m_configuration.m_materialName.c_str(), ".blastmaterial");
-
-            AZ_TracePrintf("BlastMaterialConversion", "Material '%s' found. Generating '%s'.\n",
-                materialAssetConfiguration.m_configuration.m_materialName.c_str(),
-                targetSourceFile.c_str());
-
-            // If there is a source file with the same name already then generate a unique target source name
-            int suffixNumber = 1;
-            while (AZ::IO::FileIOBase::GetInstance()->Exists(targetSourceFile.c_str()))
-            {
-                const AZStd::string materialNameWithSuffix = AZStd::string::format("%s_%d", materialAssetConfiguration.m_configuration.m_materialName.c_str(), suffixNumber++);
-                AZ_Warning("BlastMaterialConversion", false, "Source file '%s' already exists, using %s filename.", targetSourceFile.c_str(), materialNameWithSuffix.c_str());
-                AZ::StringFunc::Path::ReplaceFullName(targetSourceFile, materialNameWithSuffix.c_str(), ".blastmaterial");
-            }
-
-            AZ::Data::Asset<MaterialAsset> newMaterialAsset;
-            newMaterialAsset.Create(AZ::Data::AssetId(AZ::Uuid::CreateRandom()));
-            materialAssetConfiguration.CopyDataToMaterialAsset(*newMaterialAsset);
-
-            AZStd::vector<AZ::u8> byteBuffer;
-            AZ::IO::ByteContainerStream<decltype(byteBuffer)> byteStream(&byteBuffer);
-
-            if (!materialAssetHandler->SaveAssetData(newMaterialAsset, &byteStream))
-            {
-                AZ_Warning("BlastMaterialConversion", false, "Failed to save runtime Blast Material to object stream");
-                continue; // next material
-            }
-
-            AZ::IO::FileIOStream outFileStream(targetSourceFile.c_str(), AZ::IO::OpenMode::ModeWrite);
-            if (!outFileStream.IsOpen())
-            {
-                AZ_Warning("BlastMaterialConversion", false, "Failed to open output file '%s'", targetSourceFile.c_str());
-                continue; // next material
-            }
-
-            size_t bytesWritten = outFileStream.Write(byteBuffer.size(), byteBuffer.data());
-            if (bytesWritten != byteBuffer.size())
-            {
-                AZ_Warning("BlastMaterialConversion", false, "Unable to save Blast Material Asset file '%s'", targetSourceFile.c_str());
-                continue; // next material
-            }
-
-            // Add new file to source control (which is done by calling RequestEdit)
-            AzToolsFramework::SourceControlCommandBus::Broadcast(
-                &AzToolsFramework::SourceControlCommandBus::Events::RequestEdit,
-                targetSourceFile.c_str(), true,
-                [targetSourceFile]([[maybe_unused]] bool success, [[maybe_unused]] const AzToolsFramework::SourceControlFileInfo& info)
-                {
-                    AZ_UNUSED(targetSourceFile);
-                    AZ_Warning("BlastMaterialConversion", success, "Unable to mark for add '%s' in source control.", targetSourceFile.c_str());
-                }
-            );
-        }
-
-        // Delete old material library assets from source
-        AZ_TracePrintf("BlastMaterialConversion", "Deleting blast material library '%s'.\n", materialLibrary.m_sourceFile.c_str());
-        if (AZ::IO::FileIOBase::GetInstance()->Exists(materialLibrary.m_sourceFile.c_str()))
-        {
-            // Mark for deletion in source control (it will also delete the file)
-            AzToolsFramework::SourceControlCommandBus::Broadcast(
-                &AzToolsFramework::SourceControlCommandBus::Events::RequestDelete,
-                materialLibrary.m_sourceFile.c_str(),
-                [sourceFile = materialLibrary.m_sourceFile](bool success, [[maybe_unused]] const AzToolsFramework::SourceControlFileInfo& info)
-            {
-                AZ_Warning("BlastMaterialConversion", success, "Unable to mark for deletion '%s' in source control.", sourceFile.c_str());
-
-                // If source control didn't delete it, then delete the file ourselves.
-                if (!success)
-                {
-                    AZ::IO::FileIOBase::GetInstance()->Remove(sourceFile.c_str());
-                }
-            }
-            );
-        }
-
-        AZ_TracePrintf("BlastMaterialConversion", "\n");
-    }
-
-    void ConvertMaterialLibrariesIntoIndividualMaterials([[maybe_unused]] const AZ::ConsoleCommandContainer& commandArgs)
-    {
-        auto* materialAssetHandler = AZ::Data::AssetManager::Instance().GetHandler(MaterialAsset::RTTI_Type());
-        if (!materialAssetHandler)
-        {
-            AZ_Error("BlastMaterialConversion", false, "Unable to find blast MaterialAsset handler.");
-            return;
-        }
-
-        AZ_TracePrintf("BlastMaterialConversion", "Searching for blast material library assets to convert...\n");
-        AZStd::vector<BlastMaterialLibrary> materialLibrariesToConvert = CollectMaterialLibraries(materialAssetHandler);
-        if (materialLibrariesToConvert.empty())
-        {
-            AZ_TracePrintf("BlastMaterialConversion", "No blast material library assets found to convert.\n");
-            return;
-        }
-        AZ_TracePrintf("BlastMaterialConversion", "Found %zu blast material libraries.\n", materialLibrariesToConvert.size());
-        AZ_TracePrintf("BlastMaterialConversion", "\n");
-
-        for (const auto& materialLibrary : materialLibrariesToConvert)
-        {
-            ConvertMaterialLibrary(materialLibrary, materialAssetHandler);
-        }
-    }
-} // namespace Blast

Gems/Blast/Code/Source/Editor/Material/LegacyBlastMaterialAssetConversion.h

@@ -1,20 +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
-
-namespace AZ
-{
-    class ReflectContext;
-}
-
-namespace Blast
-{
-    // Reflection of legacy blast material classes.
-    // Used when converting old material asset to new one.
-    void ReflectLegacyMaterialClasses(AZ::ReflectContext* context);
-} // namespace Blast

Gems/Blast/Code/Source/Editor/Material/LegacyBlastMaterialPrefabConversion.cpp

@@ -1,236 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/Console/IConsole.h>
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/Asset/AssetManager.h>
-
-#include <AzFramework/API/ApplicationAPI.h>
-
-#include <AzToolsFramework/SourceControl/SourceControlAPI.h>
-#include <AzToolsFramework/Physics/Material/Legacy/LegacyPhysicsMaterialConversionUtils.h>
-#include <AzToolsFramework/Physics/Material/Legacy/LegacyPhysicsPrefabConversionUtils.h>
-
-#include <Material/BlastMaterialAsset.h>
-#include <Editor/EditorBlastFamilyComponent.h>
-
-namespace Blast
-{
-    void FixPrefabsWithBlastComponentLegacyMaterials([[maybe_unused]] const AZ::ConsoleCommandContainer& commandArgs);
-
-    AZ_CONSOLEFREEFUNC("ed_blastFixPrefabsWithBlastComponentLegacyMaterials", FixPrefabsWithBlastComponentLegacyMaterials, AZ::ConsoleFunctorFlags::Null,
-        "Finds prefabs that contain blast components using legacy blast material ids and fixes them by using new blast material assets.");
-
-    Physics::Utils::LegacyMaterialIdToNewAssetIdMap CollectConvertedMaterialIds()
-    {
-        Physics::Utils::LegacyMaterialIdToNewAssetIdMap legacyMaterialIdToNewAssetIdMap;
-
-        AZ::Data::AssetCatalogRequests::AssetEnumerationCB assetEnumerationCB =
-            [&legacyMaterialIdToNewAssetIdMap](const AZ::Data::AssetId assetId, const AZ::Data::AssetInfo& assetInfo)
-        {
-            if (assetInfo.m_assetType != MaterialAsset::RTTI_Type())
-            {
-                return;
-            }
-
-            AZ::Data::Asset<MaterialAsset> materialAsset(assetId, assetInfo.m_assetType);
-            materialAsset.QueueLoad();
-            materialAsset.BlockUntilLoadComplete();
-
-            if (materialAsset.IsReady())
-            {
-                if (const AZ::Uuid& legacyBlastMaterialId = materialAsset->GetLegacyBlastMaterialId().m_id;
-                    !legacyBlastMaterialId.IsNull())
-                {
-                    legacyMaterialIdToNewAssetIdMap.emplace(legacyBlastMaterialId, assetId);
-                }
-            }
-            else
-            {
-                AZ_Warning("BlastMaterialConversion", false, "Unable to load blast material asset '%s'.", assetInfo.m_relativePath.c_str());
-            }
-        };
-
-        AZ::Data::AssetCatalogRequestBus::Broadcast(&AZ::Data::AssetCatalogRequestBus::Events::EnumerateAssets,
-            nullptr,
-            assetEnumerationCB,
-            nullptr);
-
-        return legacyMaterialIdToNewAssetIdMap;
-    }
-
-    AZ::Data::Asset<MaterialAsset> ConvertLegacyMaterialIdToMaterialAsset(
-        const BlastMaterialId& legacyMaterialId,
-        const Physics::Utils::LegacyMaterialIdToNewAssetIdMap& legacyMaterialIdToNewAssetIdMap)
-    {
-        if (legacyMaterialId.m_id.IsNull())
-        {
-            return {};
-        }
-
-        auto it = legacyMaterialIdToNewAssetIdMap.find(legacyMaterialId.m_id);
-        if (it == legacyMaterialIdToNewAssetIdMap.end())
-        {
-            AZ_Warning(
-                "BlastMaterialConversion", false, "Unable to find a blast material asset to replace legacy material id '%s' with.",
-                legacyMaterialId.m_id.ToString<AZStd::string>().c_str());
-            return {};
-        }
-
-        const AZ::Data::AssetId newMaterialAssetId = it->second;
-
-        AZ::Data::AssetInfo assetInfo;
-        AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequests::GetAssetInfoById, newMaterialAssetId);
-        AZ::Data::Asset<MaterialAsset> newMaterialAsset(newMaterialAssetId, assetInfo.m_assetType, assetInfo.m_relativePath);
-
-        return newMaterialAsset;
-    }
-
-    bool FixBlastMaterialId(
-        Physics::Utils::PrefabInfo& prefabInfo,
-        AzToolsFramework::Prefab::PrefabDomValue& component,
-        const Physics::Utils::LegacyMaterialIdToNewAssetIdMap& legacyMaterialIdToNewAssetIdMap,
-        const AZStd::vector<AZStd::string>& oldMemberChain,
-        const AZStd::vector<AZStd::string>& newMemberChain)
-    {
-        BlastMaterialId legacyMaterialId;
-        if (Physics::Utils::LoadObjectFromPrefabComponent<BlastMaterialId>(oldMemberChain, component, legacyMaterialId))
-        {
-            AZ::Data::Asset<MaterialAsset> materialAsset =
-                ConvertLegacyMaterialIdToMaterialAsset(legacyMaterialId, legacyMaterialIdToNewAssetIdMap);
-
-            if (!materialAsset.GetId().IsValid())
-            {
-                return false;
-            }
-
-            if (!Physics::Utils::StoreObjectToPrefabComponent<AZ::Data::Asset<MaterialAsset>>(
-                newMemberChain, prefabInfo.m_template->GetPrefabDom(), component, materialAsset))
-            {
-                AZ_Warning(
-                    "BlastMaterialConversion", false, "Unable to set blast material asset to prefab '%s'.",
-                    prefabInfo.m_prefabFullPath.c_str());
-                return false;
-            }
-
-            // Remove legacy material id field
-            Physics::Utils::RemoveMemberChainInPrefabComponent(oldMemberChain, component);
-
-            AZ_TracePrintf(
-                "BlastMaterialConversion", "Legacy material id '%s' will be replaced by blast material asset '%s'.\n",
-                legacyMaterialId.m_id.ToString<AZStd::string>().c_str(), materialAsset.GetHint().c_str());
-
-            return true;
-        }
-        return false;
-    };
-
-    void FixPrefabBlastMaterials(
-        Physics::Utils::PrefabInfo& prefabInfo,
-        const Physics::Utils::LegacyMaterialIdToNewAssetIdMap& legacyMaterialIdToNewAssetIdMap)
-    {
-        bool prefabModified = false;
-        for (auto* entity : Physics::Utils::GetPrefabEntities(prefabInfo.m_template->GetPrefabDom()))
-        {
-            for (auto* component : Physics::Utils::GetEntityComponents(*entity))
-            {
-                const AZ::TypeId componentTypeId = Physics::Utils::GetComponentTypeId(*component);
-
-                if (componentTypeId == azrtti_typeid<EditorBlastFamilyComponent>())
-                {
-                    if (FixBlastMaterialId(prefabInfo, *component, legacyMaterialIdToNewAssetIdMap,
-                        { "BlastMaterial" }, { "BlastMaterialAsset" }))
-                    {
-                        prefabModified = true;
-                    }
-                }
-            }
-        }
-
-        if (prefabModified)
-        {
-            AZ_TracePrintf("BlastMaterialConversion", "Saving modified prefab '%s'.\n", prefabInfo.m_prefabFullPath.c_str());
-
-            auto* prefabSystemComponent = AZ::Interface<AzToolsFramework::Prefab::PrefabSystemComponentInterface>::Get();
-
-            prefabInfo.m_template->MarkAsDirty(true);
-            prefabSystemComponent->PropagateTemplateChanges(prefabInfo.m_templateId);
-
-            // Request source control to edit prefab file
-            AzToolsFramework::SourceControlCommandBus::Broadcast(
-                &AzToolsFramework::SourceControlCommandBus::Events::RequestEdit,
-                prefabInfo.m_prefabFullPath.c_str(), true,
-                [prefabInfo]([[maybe_unused]] bool success, const AzToolsFramework::SourceControlFileInfo& info)
-                {
-                    // This is called from the main thread on the next frame from TickBus,
-                    // that is why 'prefabInfo' is captured as a copy.
-                    if (!info.IsReadOnly())
-                    {
-                        auto* prefabLoader = AZ::Interface<AzToolsFramework::Prefab::PrefabLoaderInterface>::Get();
-                        if (!prefabLoader->SaveTemplate(prefabInfo.m_templateId))
-                        {
-                            AZ_Warning("BlastMaterialConversion", false, "Unable to save prefab '%s'",
-                                prefabInfo.m_prefabFullPath.c_str());
-                        }
-                    }
-                    else
-                    {
-                        AZ_Warning("BlastMaterialConversion", false, "Unable to check out asset '%s' in source control.",
-                            prefabInfo.m_prefabFullPath.c_str());
-                    }
-                }
-            );
-
-            AZ_TracePrintf("BlastMaterialConversion", "\n");
-        }
-    }
-
-    void FixPrefabsWithBlastComponentLegacyMaterials([[maybe_unused]] const AZ::ConsoleCommandContainer& commandArgs)
-    {
-        bool prefabSystemEnabled = false;
-        AzFramework::ApplicationRequests::Bus::BroadcastResult(
-            prefabSystemEnabled, &AzFramework::ApplicationRequests::IsPrefabSystemEnabled);
-        if (!prefabSystemEnabled)
-        {
-            AZ_TracePrintf("BlastMaterialConversion", "Prefabs system is not enabled. Prefabs won't be converted.\n");
-            AZ_TracePrintf("BlastMaterialConversion", "\n");
-            return;
-        }
-
-        AZ_TracePrintf("BlastMaterialConversion", "Searching for converted blast material assets...\n");
-        Physics::Utils::LegacyMaterialIdToNewAssetIdMap legacyMaterialIdToNewAssetIdMap = CollectConvertedMaterialIds();
-        if (legacyMaterialIdToNewAssetIdMap.empty())
-        {
-            AZ_TracePrintf("BlastMaterialConversion", "No converted blast material assets found.\n");
-            AZ_TracePrintf("BlastMaterialConversion", "Command stopped as there are no blast materials with legacy information to be able to fix assets.\n");
-            return;
-        }
-        AZ_TracePrintf("BlastMaterialConversion", "Found %zu converted blast materials.\n", legacyMaterialIdToNewAssetIdMap.size());
-        AZ_TracePrintf("BlastMaterialConversion", "\n");
-
-        AZ_TracePrintf("BlastMaterialConversion", "Searching for prefabs to convert...\n");
-        AZ_TracePrintf("BlastMaterialConversion", "\n");
-        AZStd::vector<Physics::Utils::PrefabInfo> prefabs = Physics::Utils::CollectPrefabs();
-        if (prefabs.empty())
-        {
-            AZ_TracePrintf("BlastMaterialConversion", "No prefabs found.\n");
-            AZ_TracePrintf("BlastMaterialConversion", "\n");
-            return;
-        }
-        AZ_TracePrintf("BlastMaterialConversion", "Found %zu prefabs to check.\n", prefabs.size());
-        AZ_TracePrintf("BlastMaterialConversion", "\n");
-
-        for (auto& prefab : prefabs)
-        {
-            FixPrefabBlastMaterials(prefab, legacyMaterialIdToNewAssetIdMap);
-        }
-
-        AZ_TracePrintf("BlastMaterialConversion", "Prefab conversion finished.\n");
-        AZ_TracePrintf("BlastMaterialConversion", "\n");
-    }
-} // namespace Blast

Gems/Blast/Code/Source/Material/BlastMaterialAsset.cpp

@@ -13,27 +13,14 @@
 
 namespace Blast
 {
-    void BlastMaterialId::Reflect(AZ::ReflectContext* context)
-    {
-        if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-        {
-            serializeContext->Class<Blast::BlastMaterialId>()
-                ->Version(1)
-                ->Field("BlastMaterialId", &Blast::BlastMaterialId::m_id);
-        }
-    }
-
     void MaterialAsset::Reflect(AZ::ReflectContext* context)
     {
-        BlastMaterialId::Reflect(context);
-
         if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
         {
             serializeContext->Class<Blast::MaterialAsset, AZ::Data::AssetData>()
-                ->Version(1)
+                ->Version(2)
                 ->Attribute(AZ::Edit::Attributes::EnableForAssetEditor, true)
                 ->Field("MaterialConfiguration", &MaterialAsset::m_materialConfiguration)
-                ->Field("LegacyBlastMaterialId", &MaterialAsset::m_legacyBlastMaterialId)
                 ;
 
             if (auto* editContext = serializeContext->GetEditContext())
@@ -53,9 +40,4 @@ namespace Blast
     {
         return m_materialConfiguration;
     }
-
-    BlastMaterialId MaterialAsset::GetLegacyBlastMaterialId() const
-    {
-        return m_legacyBlastMaterialId;
-    }
 } // namespace Blast

Gems/Blast/Code/Source/Material/BlastMaterialAsset.h

@@ -15,20 +15,6 @@
 
 namespace Blast
 {
-    // O3DE_DEPRECATION_NOTICE(GHI-9839)
-    // Legacy blast material Id class used to identify the material in the collection of materials.
-    // Used when converting old material asset to new one.
-    class BlastMaterialId
-    {
-    public:
-        AZ_CLASS_ALLOCATOR(BlastMaterialId, AZ::SystemAllocator, 0);
-        AZ_TYPE_INFO(BlastMaterialId, "{BDB30505-C93E-4A83-BDD7-41027802DE0A}");
-
-        static void Reflect(AZ::ReflectContext* context);
-
-        AZ::Uuid m_id = AZ::Uuid::CreateNull();
-    };
-
     //! MaterialAsset defines a single material, which includes the configuration to create a Material instance to use at runtime.
     class MaterialAsset
         : public AZ::Data::AssetData
@@ -44,14 +30,7 @@ namespace Blast
 
         const MaterialConfiguration& GetMaterialConfiguration() const;
 
-        BlastMaterialId GetLegacyBlastMaterialId() const;
-
     protected:
         MaterialConfiguration m_materialConfiguration;
-
-        // Legacy Blast material Id is only used when converting from old blast material asset,
-        // which holds a library of materials, to the new blast material asset.
-        BlastMaterialId m_legacyBlastMaterialId;
-        friend class BlastMaterialFromAssetConfiguration;
     };
 } // namespace Blast

Gems/Blast/Code/Tests/Editor/EditorTestMain.cpp

@@ -8,4 +8,9 @@
 
 #include <AzTest/AzTest.h>
 
+TEST(BlastEditor, Test)
+{
+    EXPECT_TRUE(true);
+}
+
 AZ_UNIT_TEST_HOOK(DEFAULT_UNIT_TEST_ENV);

Gems/Blast/Code/blast_editor_files.cmake

@@ -15,9 +15,6 @@ set(FILES
     Source/Editor/EditorBlastChunksAssetHandler.cpp
     Source/Editor/EditorSystemComponent.h
     Source/Editor/EditorSystemComponent.cpp
-    Source/Editor/Material/LegacyBlastMaterialAssetConversion.h
-    Source/Editor/Material/LegacyBlastMaterialAssetConversion.cpp
-    Source/Editor/Material/LegacyBlastMaterialPrefabConversion.cpp
     Editor/ConfigurationWidget.h
     Editor/ConfigurationWidget.cpp
     Editor/EditorWindow.h