Merge pull request #594 from aws-lumberyard-dev/Atom/guthadam/materials/removing_dependencies_on_material_assignment

Updating all ASV samples to no longer use material assignment map

Gem/Code/Source/AreaLightExampleComponent.cpp

@@ -26,7 +26,6 @@
 #include <Atom/Component/DebugCamera/NoClipControllerComponent.h>
 
 #include <imgui/imgui.h>
-#include <Atom/Feature/Material/MaterialAssignment.h>
 
 #include <RHI/BasicRHIComponent.h>
 

Gem/Code/Source/AssetLoadTestComponent.cpp

@@ -173,19 +173,17 @@ namespace AtomSampleViewer
 
     void AssetLoadTestComponent::OnAllAssetsReadyActivate()
     {
-        AZ::Render::MaterialAssignmentMap materials;
         for (ModelInstanceData& instanceData : m_modelInstanceData)
         {
-            AZ::Render::MaterialAssignment& defaultAssignment = materials[AZ::Render::DefaultMaterialAssignmentId];
-            defaultAssignment = {};
-
+            AZ::Data::Instance<AZ::RPI::Material> materialInstance;
             if (instanceData.m_materialAssetId.IsValid())
             {
-                defaultAssignment.m_materialAsset.Create(instanceData.m_materialAssetId);
-                defaultAssignment.m_materialInstance = AZ::RPI::Material::FindOrCreate(defaultAssignment.m_materialAsset);
+                AZ::Data::Asset<RPI::MaterialAsset> materialAsset;
+                materialAsset.Create(instanceData.m_materialAssetId);
+                materialInstance = AZ::RPI::Material::FindOrCreate(materialAsset);
 
                 // cache the material when its loaded
-                m_cachedMaterials.insert(defaultAssignment.m_materialAsset);
+                m_cachedMaterials.insert(materialAsset);
             }
 
             if (instanceData.m_modelAssetId.IsValid())
@@ -193,7 +191,7 @@ namespace AtomSampleViewer
                 AZ::Data::Asset<AZ::RPI::ModelAsset> modelAsset;
                 modelAsset.Create(instanceData.m_modelAssetId);
 
-                instanceData.m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, materials);
+                instanceData.m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, materialInstance);
                 GetMeshFeatureProcessor()->SetTransform(instanceData.m_meshHandle, instanceData.m_transform);
             }
         }

Gem/Code/Source/BakedShaderVariantExampleComponent.cpp

@@ -12,7 +12,6 @@
 #include <SampleComponentConfig.h>
 #include <SampleComponentManager.h>
 
-#include <Atom/Feature/Material/MaterialAssignment.h>
 #include <Atom/RPI.Reflect/Asset/AssetUtils.h>
 #include <Atom/RPI.Reflect/Material/MaterialAsset.h>
 #include <Atom/RPI.Reflect/Model/ModelAsset.h>
@@ -215,7 +214,7 @@ namespace AtomSampleViewer
             AZ::Data::Asset<AZ::RPI::MaterialAsset> materialAsset;
             materialAsset.Create(selectedMaterialAssetId);
             m_material = AZ::RPI::Material::FindOrCreate(materialAsset);
-            m_meshFeatureProcessor->SetMaterialAssignmentMap(m_meshHandle, m_material);
+            m_meshFeatureProcessor->SetCustomMaterials(m_meshHandle, m_material);
         }
     }
 } // namespace AtomSampleViewer

Gem/Code/Source/CheckerboardExampleComponent.cpp

@@ -46,23 +46,19 @@ namespace AtomSampleViewer
         AZ::RPI::AssetUtils::TraceLevel traceLevel = AZ::RPI::AssetUtils::TraceLevel::Assert;
         auto meshAsset = AZ::RPI::AssetUtils::GetAssetByProductPath<AZ::RPI::ModelAsset>("objects/shaderball_simple.azmodel", traceLevel);
         auto materialAsset = AZ::RPI::AssetUtils::GetAssetByProductPath<AZ::RPI::MaterialAsset>(DefaultPbrMaterialPath, traceLevel);
-
-        AZ::Render::MaterialAssignmentMap materials;
-        AZ::Render::MaterialAssignment& defaultMaterial = materials[AZ::Render::DefaultMaterialAssignmentId];
-        defaultMaterial.m_materialAsset = materialAsset;
-        defaultMaterial.m_materialInstance = AZ::RPI::Material::FindOrCreate(defaultMaterial.m_materialAsset);
+        auto materialInstance = AZ::RPI::Material::FindOrCreate(materialAsset);
 
         m_meshFeatureProcessor = m_scene->GetFeatureProcessor<AZ::Render::MeshFeatureProcessorInterface>();
-        m_meshHandle = m_meshFeatureProcessor->AcquireMesh(AZ::Render::MeshHandleDescriptor{ meshAsset }, materials);
+        m_meshHandle = m_meshFeatureProcessor->AcquireMesh(AZ::Render::MeshHandleDescriptor{ meshAsset }, materialInstance);
         m_meshFeatureProcessor->SetTransform(m_meshHandle, AZ::Transform::CreateIdentity());
-        
-        AZ::Debug::CameraControllerRequestBus::Event(GetCameraEntityId(), &AZ::Debug::CameraControllerRequestBus::Events::Enable,
+
+        AZ::Debug::CameraControllerRequestBus::Event(
+            GetCameraEntityId(), &AZ::Debug::CameraControllerRequestBus::Events::Enable,
             azrtti_typeid<AZ::Debug::ArcBallControllerComponent>());
 
         // Add an Image based light.
         m_defaultIbl.Init(m_scene);
 
-
         AZ::TickBus::Handler::BusConnect();
 
         // connect to the bus before creating new pipeline

Gem/Code/Source/DepthOfFieldExampleComponent.cpp

@@ -178,26 +178,21 @@ namespace AtomSampleViewer
 
     void DepthOfFieldExampleComponent::RemoveController()
     {
-        AZ::Debug::CameraControllerRequestBus::Event(
-            GetCameraEntityId(),
-            &AZ::Debug::CameraControllerRequestBus::Events::Disable);
+        AZ::Debug::CameraControllerRequestBus::Event(GetCameraEntityId(), &AZ::Debug::CameraControllerRequestBus::Events::Disable);
     }
 
     void DepthOfFieldExampleComponent::CreateMeshes()
     {
         using namespace AZ;
 
-        Render::MaterialAssignmentMap materials;
-        Render::MaterialAssignment& defaultMaterial = materials[AZ::Render::DefaultMaterialAssignmentId];
-        defaultMaterial.m_materialAsset = m_materialAsset;
-        defaultMaterial.m_materialInstance = RPI::Material::FindOrCreate(defaultMaterial.m_materialAsset);
+        auto materialInstance = RPI::Material::FindOrCreate(m_materialAsset);
 
         Vector3 translation = Vector3::CreateZero();
         Transform scaleTransform = Transform::CreateUniformScale(ModelScaleRatio);
 
         for (MeshHandle& meshHandle : m_meshHandles)
         {
-            meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ m_bunnyModelAsset }, materials);
+            meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ m_bunnyModelAsset }, materialInstance);
 
             auto transform = AZ::Transform::CreateTranslation(translation);
             transform *= scaleTransform;

Gem/Code/Source/DiffuseGIExampleComponent.cpp

@@ -227,103 +227,94 @@ namespace AtomSampleViewer
         // left wall
         if (m_leftWallVisible)
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = GetCornellBoxMaterialAsset(m_leftWallColor);
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_leftWallColor));
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(-5.0f, 0.0f, 0.0f);
             transform *= AZ::Transform::CreateRotationY(AZ::Constants::HalfPi);
             AZ::Vector3 nonUniformScale(10.05f, 10.05f, 1.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LeftWall)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_planeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LeftWall)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LeftWall)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_planeModelAsset },
+                AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_leftWallColor)));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LeftWall)], transform, nonUniformScale);
         }
-        
+
         // right wall
         if (m_rightWallVisible)
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = GetCornellBoxMaterialAsset(m_rightWallColor);
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_rightWallColor));
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(5.0f, 0.0f, 0.0f);
             transform *= AZ::Transform::CreateRotationY(-AZ::Constants::HalfPi);
             AZ::Vector3 nonUniformScale(10.05f, 10.05f, 1.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::RightWall)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_planeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::RightWall)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::RightWall)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_planeModelAsset },
+                AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_rightWallColor)));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::RightWall)], transform, nonUniformScale);
         }
-        
+
         // back wall
         if (m_backWallVisible)
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = GetCornellBoxMaterialAsset(m_backWallColor);
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_backWallColor));
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(0.0f, 5.0f, 0.0f);
             transform *= AZ::Transform::CreateRotationX(AZ::Constants::HalfPi);
             AZ::Vector3 nonUniformScale(10.05f, 10.05f, 1.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::BackWall)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_planeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::BackWall)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::BackWall)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_planeModelAsset },
+                AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_backWallColor)));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::BackWall)], transform, nonUniformScale);
         }
-        
+
         // ceiling
         if (m_ceilingVisible)
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = GetCornellBoxMaterialAsset(m_ceilingColor);
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_ceilingColor));
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(0.0f, 0.0f, 5.0f);
             transform *= AZ::Transform::CreateRotationX(AZ::Constants::Pi);
             AZ::Vector3 nonUniformScale(10.05f, 10.05f, 1.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Ceiling)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_planeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Ceiling)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Ceiling)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_planeModelAsset },
+                AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_ceilingColor)));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Ceiling)], transform, nonUniformScale);
         }
-        
+
         // floor
         if (m_floorVisible)
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = GetCornellBoxMaterialAsset(m_floorColor);
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_floorColor));
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(0.0f, 0.0f, -5.0f);
             AZ::Vector3 nonUniformScale(10.05f, 10.05f, 1.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Floor)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_planeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Floor)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Floor)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_planeModelAsset },
+                AZ::RPI::Material::FindOrCreate(GetCornellBoxMaterialAsset(m_floorColor)));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::Floor)], transform, nonUniformScale);
         }
-        
+
         // large box
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = m_whiteMaterialAsset;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(m_whiteMaterialAsset);
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(-2.0f, 0.0f, -2.0f);
             transform *= AZ::Transform::CreateRotationZ(AZ::Constants::HalfPi * 0.2f);
             AZ::Vector3 nonUniformScale(3.0f, 3.0f, 6.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LargeBox)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_cubeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LargeBox)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LargeBox)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_cubeModelAsset }, AZ::RPI::Material::FindOrCreate(m_whiteMaterialAsset));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::LargeBox)], transform, nonUniformScale);
         }
-        
+
         // small box
         {
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = m_whiteMaterialAsset;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = AZ::RPI::Material::FindOrCreate(m_whiteMaterialAsset);
-        
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(2.0f, -1.5f, -3.5f);
             transform *= AZ::Transform::CreateRotationZ(-AZ::Constants::HalfPi * 0.2f);
             AZ::Vector3 nonUniformScale(3.0f, 3.0f, 3.0f);
-            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::SmallBox)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_cubeModelAsset }, materialMap);
-            GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::SmallBox)], transform, nonUniformScale);
+            m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::SmallBox)] = GetMeshFeatureProcessor()->AcquireMesh(
+                AZ::Render::MeshHandleDescriptor{ m_cubeModelAsset }, AZ::RPI::Material::FindOrCreate(m_whiteMaterialAsset));
+            GetMeshFeatureProcessor()->SetTransform(
+                m_meshHandles[aznumeric_cast<uint32_t>(CornellBoxMeshes::SmallBox)], transform, nonUniformScale);
         }
 
         // stop now if we were only loading the geometry
@@ -338,22 +329,28 @@ namespace AtomSampleViewer
 
         // point light
         {
-            AZ::Render::PointLightFeatureProcessorInterface* pointLightFeatureProcessor = m_scene->GetFeatureProcessor<AZ::Render::PointLightFeatureProcessorInterface>();
+            AZ::Render::PointLightFeatureProcessorInterface* pointLightFeatureProcessor =
+                m_scene->GetFeatureProcessor<AZ::Render::PointLightFeatureProcessorInterface>();
             m_pointLightHandle = pointLightFeatureProcessor->AcquireLight();
             pointLightFeatureProcessor->SetPosition(m_pointLightHandle, m_pointLightPos);
-            pointLightFeatureProcessor->SetRgbIntensity(m_pointLightHandle, AZ::Render::PhotometricColor<AZ::Render::PhotometricUnit::Candela>(m_pointLightIntensity * m_pointLightColor));
+            pointLightFeatureProcessor->SetRgbIntensity(
+                m_pointLightHandle,
+                AZ::Render::PhotometricColor<AZ::Render::PhotometricUnit::Candela>(m_pointLightIntensity * m_pointLightColor));
             pointLightFeatureProcessor->SetBulbRadius(m_pointLightHandle, 1.0f);
-            pointLightFeatureProcessor->SetAttenuationRadius(m_pointLightHandle, ComputePointLightAttenuationRadius(m_pointLightColor, m_pointLightIntensity));
+            pointLightFeatureProcessor->SetAttenuationRadius(
+                m_pointLightHandle, ComputePointLightAttenuationRadius(m_pointLightColor, m_pointLightIntensity));
         }
 
         // diffuse probe grid
         {
-            AZ::Render::DiffuseProbeGridFeatureProcessorInterface* diffuseProbeGridFeatureProcessor = m_scene->GetFeatureProcessor<AZ::Render::DiffuseProbeGridFeatureProcessorInterface>();
+            AZ::Render::DiffuseProbeGridFeatureProcessorInterface* diffuseProbeGridFeatureProcessor =
+                m_scene->GetFeatureProcessor<AZ::Render::DiffuseProbeGridFeatureProcessorInterface>();
             AZ::Transform transform = AZ::Transform::CreateIdentity();
 
             m_origin.Set(-0.8f, 0.5f, -0.055f);
             transform.SetTranslation(m_origin);
-            m_diffuseProbeGrid = diffuseProbeGridFeatureProcessor->AddProbeGrid(transform, AZ::Vector3(12.0f, 12.0f, 12.0f), AZ::Vector3(1.5f, 1.5f, 2.0f));
+            m_diffuseProbeGrid =
+                diffuseProbeGridFeatureProcessor->AddProbeGrid(transform, AZ::Vector3(12.0f, 12.0f, 12.0f), AZ::Vector3(1.5f, 1.5f, 2.0f));
             diffuseProbeGridFeatureProcessor->SetAmbientMultiplier(m_diffuseProbeGrid, m_ambientMultiplier);
 
             m_viewBias = 0.5f;
@@ -362,7 +359,8 @@ namespace AtomSampleViewer
             m_normalBias = 0.1f;
             diffuseProbeGridFeatureProcessor->SetNormalBias(m_diffuseProbeGrid, m_normalBias);
 
-            AZ::Render::DiffuseGlobalIlluminationFeatureProcessorInterface* diffuseGlobalIlluminationFeatureProcessor = m_scene->GetFeatureProcessor<AZ::Render::DiffuseGlobalIlluminationFeatureProcessorInterface>();
+            AZ::Render::DiffuseGlobalIlluminationFeatureProcessorInterface* diffuseGlobalIlluminationFeatureProcessor =
+                m_scene->GetFeatureProcessor<AZ::Render::DiffuseGlobalIlluminationFeatureProcessorInterface>();
             diffuseGlobalIlluminationFeatureProcessor->SetQualityLevel(AZ::Render::DiffuseGlobalIlluminationQualityLevel::Medium);
         }
 

Gem/Code/Source/DynamicMaterialTestComponent.cpp

@@ -95,15 +95,10 @@ namespace AtomSampleViewer
         AZ::Data::Asset<AZ::RPI::MaterialAsset>& materialAsset = m_materialConfigs[m_currentMaterialConfig].m_materialAsset;
         AZ::Data::Instance<AZ::RPI::Material> material = Material::Create(materialAsset);
          
-        Render::MaterialAssignmentMap materialMap;
-        Render::MaterialAssignment& defaultMaterial = materialMap[Render::DefaultMaterialAssignmentId];
-        defaultMaterial.m_materialAsset = materialAsset;
-        defaultMaterial.m_materialInstance = material;
-
         Render::MeshHandleDescriptor meshDescriptor;
         meshDescriptor.m_modelAsset = m_modelAsset;
         meshDescriptor.m_isRayTracingEnabled = false;
-        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(meshDescriptor, materialMap);
+        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(meshDescriptor, material);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
 
         Data::Instance<RPI::Model> model = GetMeshFeatureProcessor()->GetModel(meshHandle);

Gem/Code/Source/LightCullingExampleComponent.cpp

@@ -82,14 +82,6 @@ namespace AtomSampleViewer
         color.SetA(AuxGeomDebugAlpha);
         return color;
     }
-    static AZ::Render::MaterialAssignmentMap CreateMaterialAssignmentMap(const char* materialPath)
-    {
-        Render::MaterialAssignmentMap materials;
-        Render::MaterialAssignment& defaultMaterialAssignment = materials[AZ::Render::DefaultMaterialAssignmentId];
-        defaultMaterialAssignment.m_materialAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::MaterialAsset>(materialPath, RPI::AssetUtils::TraceLevel::Assert);
-        defaultMaterialAssignment.m_materialInstance = RPI::Material::FindOrCreate(defaultMaterialAssignment.m_materialAsset);
-        return materials;
-    }
 
     LightCullingExampleComponent::LightCullingExampleComponent()
     {
@@ -790,10 +782,12 @@ namespace AtomSampleViewer
         Data::Asset<RPI::ModelAsset> transparentModelAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::ModelAsset>(TransparentModelName, RPI::AssetUtils::TraceLevel::Assert);
 
         // Override the shader ball material with a transparent material
-        Render::MaterialAssignmentMap materialAssignmentMap = CreateMaterialAssignmentMap(TransparentMaterialName);
+        auto materialAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::MaterialAsset>(TransparentMaterialName, RPI::AssetUtils::TraceLevel::Assert);
+        auto materialInstance = RPI::Material::FindOrCreate(materialAsset);
+
         for (const AZ::Vector3& position : TransparentModelPositions)
         {
-            AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(MeshHandleDescriptor{ transparentModelAsset }, materialAssignmentMap);
+            AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(MeshHandleDescriptor{ transparentModelAsset }, materialInstance);
             GetMeshFeatureProcessor()->SetTransform(meshHandle, Transform::CreateTranslation(position));
             m_transparentMeshHandles.push_back(std::move(meshHandle));
         }

Gem/Code/Source/MeshExampleComponent.cpp

@@ -267,7 +267,7 @@ namespace AtomSampleViewer
         m_modelAsset = {};
         m_groundPlaneModelAsset = {};
 
-        m_materialOverrideInstance = nullptr;
+        m_customMaterialInstance = nullptr;
 
         ShutdownLightingPresets();
     }
@@ -415,7 +415,7 @@ namespace AtomSampleViewer
             ImGui::Separator();
             ImGui::Spacing();
 
-            if (m_materialOverrideInstance && ImGui::Button("Material Details..."))
+            if (m_customMaterialInstance && ImGui::Button("Material Details..."))
             {
                 m_imguiMaterialDetails.OpenDialog();
             }
@@ -458,11 +458,11 @@ namespace AtomSampleViewer
         {
             AZ::Data::Asset<AZ::RPI::MaterialAsset> materialAsset;
             materialAsset.Create(selectedMaterialAssetId);
-            m_materialOverrideInstance = AZ::RPI::Material::FindOrCreate(materialAsset);
+            m_customMaterialInstance = AZ::RPI::Material::FindOrCreate(materialAsset);
         }
         else
         {
-            m_materialOverrideInstance = nullptr;
+            m_customMaterialInstance = nullptr;
         }
 
 
@@ -472,14 +472,14 @@ namespace AtomSampleViewer
 
             m_modelAsset.Create(m_modelBrowser.GetSelectedAssetId());
             GetMeshFeatureProcessor()->ReleaseMesh(m_meshHandle);
-            m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_modelAsset }, m_materialOverrideInstance);
+            m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_modelAsset }, m_customMaterialInstance);
             GetMeshFeatureProcessor()->SetTransform(m_meshHandle, AZ::Transform::CreateIdentity());
             GetMeshFeatureProcessor()->ConnectModelChangeEventHandler(m_meshHandle, m_changedHandler);
             GetMeshFeatureProcessor()->SetMeshLodConfiguration(m_meshHandle, m_lodConfig);
         }
         else
         {
-            GetMeshFeatureProcessor()->SetMaterialAssignmentMap(m_meshHandle, m_materialOverrideInstance);
+            GetMeshFeatureProcessor()->SetCustomMaterials(m_meshHandle, m_customMaterialInstance);
         }
     }
     

Gem/Code/Source/MeshExampleComponent.h

@@ -126,7 +126,7 @@ namespace AtomSampleViewer
         bool m_useMultiViewXRPipeline = false;
         bool m_switchPipeline = false;
 
-        AZ::Data::Instance<AZ::RPI::Material> m_materialOverrideInstance; //< Holds a copy of the material instance being used when m_enableMaterialOverride is true.
+        AZ::Data::Instance<AZ::RPI::Material> m_customMaterialInstance; //< Holds a copy of the material instance being used when m_enableMaterialOverride is true.
         AZ::Render::MeshFeatureProcessorInterface::MeshHandle m_meshHandle;
         AZ::Data::Asset<AZ::RPI::ModelAsset> m_modelAsset;
 

Gem/Code/Source/Performance/HighInstanceExampleComponent.cpp

@@ -224,19 +224,17 @@ namespace AtomSampleViewer
 
     void HighInstanceTestComponent::OnAllAssetsReadyActivate()
     {
-        AZ::Render::MaterialAssignmentMap materials;
         for (ModelInstanceData& instanceData : m_modelInstanceData)
         {
-            AZ::Render::MaterialAssignment& defaultAssignment = materials[AZ::Render::DefaultMaterialAssignmentId];
-            defaultAssignment = {};
-
+            AZ::Data::Instance<AZ::RPI::Material> materialInstance;
             if (instanceData.m_materialAssetId.IsValid())
             {
-                defaultAssignment.m_materialAsset.Create(instanceData.m_materialAssetId);
-                defaultAssignment.m_materialInstance = AZ::RPI::Material::FindOrCreate(defaultAssignment.m_materialAsset);
+                AZ::Data::Asset<RPI::MaterialAsset> materialAsset;
+                materialAsset.Create(instanceData.m_materialAssetId);
+                materialInstance = AZ::RPI::Material::FindOrCreate(materialAsset);
 
                 // cache the material when its loaded
-                m_cachedMaterials.insert(defaultAssignment.m_materialAsset);
+                m_cachedMaterials.insert(materialAsset);
             }
 
             if (instanceData.m_modelAssetId.IsValid())
@@ -244,7 +242,7 @@ namespace AtomSampleViewer
                 AZ::Data::Asset<AZ::RPI::ModelAsset> modelAsset;
                 modelAsset.Create(instanceData.m_modelAssetId);
 
-                instanceData.m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, materials);
+                instanceData.m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, materialInstance);
                 GetMeshFeatureProcessor()->SetTransform(instanceData.m_meshHandle, instanceData.m_transform);
             }
         }

Gem/Code/Source/SceneReloadSoakTestComponent.cpp

@@ -92,22 +92,18 @@ namespace AtomSampleViewer
 
     void SceneReloadSoakTestComponent::CreateLatticeInstance(const Transform& transform)
     {
-        Render::MaterialAssignmentMap materials;
-        Render::MaterialAssignment& defaultMaterial = materials[Render::DefaultMaterialAssignmentId];
-        defaultMaterial.m_materialAsset = Data::AssetManager::Instance().GetAsset<MaterialAsset>(m_materialAssetId, AZ::Data::AssetLoadBehavior::PreLoad);
-        defaultMaterial.m_materialAsset.BlockUntilLoadComplete();
+        Data::Asset<MaterialAsset> materialAsset;
+        materialAsset.Create(m_materialAssetId);
 
         // We have a mixture of both unique and shared instance to give more variety and therefore more opportunity for things to break.
         bool materialIsUnique = (m_materialIsUnique.size() % 2) == 0;
-        defaultMaterial.m_materialInstance = materialIsUnique ?
-            Material::Create(defaultMaterial.m_materialAsset) :
-            Material::FindOrCreate(defaultMaterial.m_materialAsset);
+        auto materialInstance = materialIsUnique ? Material::Create(materialAsset) : Material::FindOrCreate(materialAsset);
         m_materialIsUnique.push_back(materialIsUnique);
 
         Data::Asset<ModelAsset> modelAsset;
         modelAsset.Create(m_modelAssetId);
 
-        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ modelAsset }, materials);
+        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ modelAsset }, materialInstance);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
         m_meshHandles.push_back(AZStd::move(meshHandle));
     }
@@ -132,19 +128,8 @@ namespace AtomSampleViewer
             bool updatedSharedMaterialInstance = false;
             size_t entityIndex = 0;
 
-            MaterialPropertyIndex colorPropertyIndex;
-
             for (auto& meshHandle : m_meshHandles)
             {
-                const Render::MaterialAssignmentMap& materials = GetMeshFeatureProcessor()->GetMaterialAssignmentMap(meshHandle);
-                const auto defaultMaterialItr = materials.find(Render::DefaultMaterialAssignmentId);
-                const auto& defaultMaterial = defaultMaterialItr != materials.end() ? defaultMaterialItr->second : Render::MaterialAssignment();
-                Data::Instance<Material> material = defaultMaterial.m_materialInstance;
-                if (material == nullptr)
-                {
-                    continue;
-                }
-
                 static const float speed = 4.0f;
                 const float t = static_cast<float>(sin(m_totalTime * speed) * 0.5f + 0.5f);
 
@@ -168,26 +153,27 @@ namespace AtomSampleViewer
 
                 if (m_materialIsUnique[entityIndex] || !updatedSharedMaterialInstance)
                 {
-                    if (colorPropertyIndex.IsNull())
+                    for (auto& customMaterialPair : GetMeshFeatureProcessor()->GetCustomMaterials(meshHandle))
                     {
-                        colorPropertyIndex = material->FindPropertyIndex(Name("baseColor.color"));
-                    }
-
-                    if (colorPropertyIndex.IsValid())
-                    {
-                        material->SetPropertyValue(colorPropertyIndex, color);
-
-                        if (!m_materialIsUnique[entityIndex])
+                        if (Data::Instance<Material> material = customMaterialPair.second.m_material)
                         {
-                            updatedSharedMaterialInstance = true;
+                            MaterialPropertyIndex colorPropertyIndex = material->FindPropertyIndex(Name("baseColor.color"));
+                            if (colorPropertyIndex.IsValid())
+                            {
+                                material->SetPropertyValue(colorPropertyIndex, color);
+                                material->Compile();
+
+                                if (!m_materialIsUnique[entityIndex])
+                                {
+                                    updatedSharedMaterialInstance = true;
+                                }
+                            }
+                            else
+                            {
+                                AZ_Error("", false, "Could not find the color property index");
+                            }
                         }
                     }
-                    else
-                    {
-                        AZ_Error("", false, "Could not find the color property index");
-                    }
-
-                    material->Compile();
                 }
 
                 entityIndex++;

Gem/Code/Source/SkinnedMeshContainer.cpp

@@ -170,10 +170,6 @@ namespace AtomSampleViewer
             auto materialAsset = AZ::RPI::AssetUtils::LoadAssetByProductPath<AZ::RPI::MaterialAsset>(SkinnedMeshMaterial);
             auto materialOverrideInstance = AZ::RPI::Material::FindOrCreate(materialAsset);
 
-            AZ::Render::MaterialAssignmentMap materialMap;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = materialAsset;
-            materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = materialOverrideInstance;
-
             if (renderData.m_skinnedMeshInstance->m_model)
             {
                 AZ::Render::MeshHandleDescriptor meshDescriptor;
@@ -181,7 +177,7 @@ namespace AtomSampleViewer
                 meshDescriptor.m_isRayTracingEnabled = false;
                 renderData.m_meshHandle =
                     AZStd::make_shared<AZ::Render::MeshFeatureProcessorInterface::MeshHandle>(m_meshFeatureProcessor->AcquireMesh(
-                        meshDescriptor, materialMap));
+                        meshDescriptor, materialOverrideInstance));
                 m_meshFeatureProcessor->SetTransform(*renderData.m_meshHandle, renderData.m_rootTransform);
             }
             // If render proxies already exist, they will be auto-freed

Gem/Code/Source/TransparencyExampleComponent.cpp

@@ -106,21 +106,23 @@ namespace AtomSampleViewer
 
                 for (int i = 0; i < NumOfMeshes; ++i)
                 {
-                    const AZ::Render::MaterialAssignmentMap& materials = GetMeshFeatureProcessor()->GetMaterialAssignmentMap(m_meshHandles[i]);
-                    const AZ::Render::MaterialAssignment defaultMaterial = AZ::Render::GetMaterialAssignmentFromMap(materials, AZ::Render::DefaultMaterialAssignmentId);
-                    AZ::Data::Instance<AZ::RPI::Material> material = defaultMaterial.m_materialInstance;
-
-                    material->SetPropertyValue(colorProperty, colors[i]);
-
-                    if (material->NeedsCompile())
-                    {
-                        bool thisMaterialsCompiled = material->Compile();
-                        numMaterialsCompiled += uint32_t(thisMaterialsCompiled);
-                    }
-                    else
+                    for (auto& customMaterial : GetMeshFeatureProcessor()->GetCustomMaterials(m_meshHandles[i]))
                     {
-                        // Material already compiled
-                        ++numMaterialsCompiled;
+                        if (AZ::Data::Instance<AZ::RPI::Material> material = customMaterial.second.m_material)
+                        {
+                            material->SetPropertyValue(colorProperty, colors[i]);
+
+                            if (material->NeedsCompile())
+                            {
+                                bool thisMaterialsCompiled = material->Compile();
+                                numMaterialsCompiled += uint32_t(thisMaterialsCompiled);
+                            }
+                            else
+                            {
+                                // Material already compiled
+                                ++numMaterialsCompiled;
+                            }
+                        }
                     }
                 }
 
@@ -136,12 +138,9 @@ namespace AtomSampleViewer
 
     void TransparencyExampleComponent::LoadMesh(AZ::Transform transform)
     {
-        AZ::Render::MaterialAssignmentMap materialMap;
-        AZ::Render::MaterialAssignment& defaultMaterial = materialMap[AZ::Render::DefaultMaterialAssignmentId];
-        defaultMaterial.m_materialAsset = m_materialAsset;
-        defaultMaterial.m_materialInstance = AZ::RPI::Material::Create(m_materialAsset);
+        auto materialInstance = AZ::RPI::Material::Create(m_materialAsset);
 
-        AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_modelAsset }, materialMap);
+        AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_modelAsset }, materialInstance);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
 
         AZ::Data::Instance<AZ::RPI::Model> model = GetMeshFeatureProcessor()->GetModel(meshHandle);