LYN2227 : Update AcquireMesh calls to use a mesh handle descriptor (#128)

* Update AtomSampleViewer calls to AcquireMesh to use the new MeshHandleDescriptor instead of a bunch of individual parameters

Gem/Code/Source/AreaLightExampleComponent.cpp

@@ -215,13 +215,13 @@ namespace AtomSampleViewer
             {
                 if (!meshHandle.IsValid())
                 {
-                    meshHandle = m_meshFeatureProcessor->AcquireMesh(modelAsset, m_materialInstances.at(i));
+                    meshHandle = m_meshFeatureProcessor->AcquireMesh(MeshHandleDescriptor{ modelAsset }, m_materialInstances.at(i));
                 }
                 else if (m_modelAsset.GetId() != modelAsset.GetId())
                 {
                     // Valid mesh handle, but wrong asset. Release and reacquire.
                     m_meshFeatureProcessor->ReleaseMesh(meshHandle);
-                    meshHandle = m_meshFeatureProcessor->AcquireMesh(modelAsset, m_materialInstances.at(i));
+                    meshHandle = m_meshFeatureProcessor->AcquireMesh(MeshHandleDescriptor{ modelAsset }, m_materialInstances.at(i));
                 }
 
                 AZ::Transform transform = AZ::Transform::CreateIdentity();

Gem/Code/Source/AreaLightExampleComponent.h

@@ -52,6 +52,7 @@ namespace AtomSampleViewer
 
         static const uint32_t MaxVariants = 10;
 
+        using MeshHandleDescriptor = AZ::Render::MeshHandleDescriptor;
         using MeshHandle = AZ::Render::MeshFeatureProcessorInterface::MeshHandle;
         using PointLightHandle = AZ::Render::PointLightFeatureProcessorInterface::LightHandle;
         using DiskLightHandle = AZ::Render::DiskLightFeatureProcessorInterface::LightHandle;

Gem/Code/Source/AssetLoadTestComponent.cpp

@@ -188,7 +188,7 @@ namespace AtomSampleViewer
                 AZ::Data::Asset<AZ::RPI::ModelAsset> modelAsset;
                 modelAsset.Create(instanceData.m_modelAssetId);
 
-                instanceData.m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, materials);
+                instanceData.m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, materials);
                 GetMeshFeatureProcessor()->SetTransform(instanceData.m_meshHandle, instanceData.m_transform);
             }
         }

Gem/Code/Source/BakedShaderVariantExampleComponent.cpp

@@ -93,7 +93,7 @@ namespace AtomSampleViewer
 
         Transform meshTransform =
             Transform::CreateFromQuaternion(Quaternion::CreateFromAxisAngle(Vector3::CreateAxisX(), -AZ::Constants::HalfPi));
-        m_meshHandle = m_meshFeatureProcessor->AcquireMesh(m_modelAsset, m_material);
+        m_meshHandle = m_meshFeatureProcessor->AcquireMesh(Render::MeshHandleDescriptor{ m_modelAsset }, m_material);
         m_meshFeatureProcessor->SetTransform(m_meshHandle, meshTransform);
 
         AZStd::vector<AZStd::string> passHierarchy;

Gem/Code/Source/BistroBenchmarkComponent.cpp

@@ -110,7 +110,7 @@ namespace AtomSampleViewer
         m_sponzaInteriorAsset = AZ::RPI::AssetUtils::GetAssetByProductPath<AZ::RPI::ModelAsset>
             ("Objects/Sponza.azmodel", traceLevel);
 
-        m_sponzaInteriorMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_sponzaInteriorAsset);
+        m_sponzaInteriorMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_sponzaInteriorAsset });
 
         // rotate the entities 180 degrees about Z (the vertical axis)
         // This makes it consistent with how it was positioned in the world when the world was Y-up.

Gem/Code/Source/CheckerboardExampleComponent.cpp

@@ -58,7 +58,7 @@ namespace AtomSampleViewer
 
         AZ::RPI::ScenePtr scene = AZ::RPI::RPISystemInterface::Get()->GetDefaultScene();
         m_meshFeatureProcessor = scene->GetFeatureProcessor<AZ::Render::MeshFeatureProcessorInterface>();
-        m_meshHandle = m_meshFeatureProcessor->AcquireMesh(meshAsset, materials);
+        m_meshHandle = m_meshFeatureProcessor->AcquireMesh(AZ::Render::MeshHandleDescriptor{ meshAsset }, materials);
         m_meshFeatureProcessor->SetTransform(m_meshHandle, AZ::Transform::CreateIdentity());
         
         AZ::Debug::CameraControllerRequestBus::Event(m_cameraEntityId, &AZ::Debug::CameraControllerRequestBus::Events::Enable,

Gem/Code/Source/CullingAndLodExampleComponent.cpp

@@ -189,14 +189,14 @@ namespace AtomSampleViewer
         {
             for (uint32_t y = 0; y < numAlongYAxis; ++y)
             {
-                auto meshHandle = meshFP->AcquireMesh(objectModelAsset, material);
+                auto meshHandle = meshFP->AcquireMesh(Render::MeshHandleDescriptor{ objectModelAsset }, material);
                 Transform modelToWorld = Transform::CreateTranslation(Vector3(x * spacing, y * spacing, 2.0f));
                 meshFP->SetTransform(meshHandle, modelToWorld);
                 m_meshHandles.push_back(AZStd::move(meshHandle));
             }
         }
 
-        auto planeMeshHandle = meshFP->AcquireMesh(planeModelAsset, material);
+        auto planeMeshHandle = meshFP->AcquireMesh(Render::MeshHandleDescriptor{ planeModelAsset }, material);
         Vector3 planeNonUniformScale(numAlongXAxis * spacing, numAlongYAxis * spacing, 1.0f);
         Transform planeModelToWorld = Transform::CreateTranslation(Vector3(0.5f * numAlongXAxis * spacing, 0.5f * numAlongYAxis * spacing, 0.0f));
         meshFP->SetTransform(planeMeshHandle, planeModelToWorld, planeNonUniformScale);

Gem/Code/Source/DecalExampleComponent.cpp

@@ -81,7 +81,7 @@ namespace AtomSampleViewer
     {
         const auto meshAsset = m_assetLoadManager.GetAsset<AZ::RPI::ModelAsset>(TargetMeshName);
         const auto materialAsset = AZ::RPI::AssetUtils::GetAssetByProductPath<AZ::RPI::MaterialAsset>(TargetMaterialName, AZ::RPI::AssetUtils::TraceLevel::Assert);
-        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(meshAsset, AZ::RPI::Material::FindOrCreate(materialAsset));
+        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ meshAsset }, AZ::RPI::Material::FindOrCreate(materialAsset));
         ScaleObjectToFitDecals();
     }
 

Gem/Code/Source/DepthOfFieldExampleComponent.cpp

@@ -202,7 +202,7 @@ namespace AtomSampleViewer
 
         for (MeshHandle& meshHandle : m_meshHandles)
         {
-            meshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_bunnyModelAsset, materials);
+            meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ m_bunnyModelAsset }, materials);
 
             auto transform = AZ::Transform::CreateTranslation(translation);
             transform *= scaleTransform;

Gem/Code/Source/DiffuseGIExampleComponent.cpp

@@ -241,7 +241,7 @@ namespace AtomSampleViewer
             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(m_planeModelAsset, materialMap);
+            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);
         }
         
@@ -256,7 +256,7 @@ namespace AtomSampleViewer
             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(m_planeModelAsset, materialMap);
+            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);
         }
         
@@ -271,7 +271,7 @@ namespace AtomSampleViewer
             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(m_planeModelAsset, materialMap);
+            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);
         }
         
@@ -286,7 +286,7 @@ namespace AtomSampleViewer
             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(m_planeModelAsset, materialMap);
+            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);
         }
         
@@ -300,7 +300,7 @@ namespace AtomSampleViewer
             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(m_planeModelAsset, materialMap);
+            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);
         }
         
@@ -314,7 +314,7 @@ namespace AtomSampleViewer
             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(m_cubeModelAsset, materialMap);
+            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);
         }
         
@@ -328,7 +328,7 @@ namespace AtomSampleViewer
             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(m_cubeModelAsset, materialMap);
+            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);
         }
 
@@ -384,7 +384,7 @@ namespace AtomSampleViewer
         m_meshHandles.resize(aznumeric_cast<uint32_t>(SponzaMeshes::Count));
 
         AZ::Transform transform = AZ::Transform::CreateIdentity();
-        m_meshHandles[aznumeric_cast<uint32_t>(SponzaMeshes::Inside)] = GetMeshFeatureProcessor()->AcquireMesh(m_sponzaModelAsset);
+        m_meshHandles[aznumeric_cast<uint32_t>(SponzaMeshes::Inside)] = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_sponzaModelAsset });
         GetMeshFeatureProcessor()->SetTransform(m_meshHandles[aznumeric_cast<uint32_t>(SponzaMeshes::Inside)], transform);
         
         m_directionalLightPitch = AZ::DegToRad(-45.0f);

Gem/Code/Source/DynamicMaterialTestComponent.cpp

@@ -97,7 +97,11 @@ namespace AtomSampleViewer
         defaultMaterial.m_materialAsset = materialAsset;
         defaultMaterial.m_materialInstance = material;
 
-        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_modelAsset, materialMap, false, false);
+        Render::MeshHandleDescriptor meshDescriptor;
+        meshDescriptor.m_modelAsset = m_modelAsset;
+        meshDescriptor.m_isSkinnedMeshWithMotion = false;
+        meshDescriptor.m_isRayTracingEnabled = false;
+        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(meshDescriptor, materialMap);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
 
         Data::Instance<RPI::Model> model = GetMeshFeatureProcessor()->GetModel(meshHandle);

Gem/Code/Source/ExposureExampleComponent.cpp

@@ -120,7 +120,7 @@ namespace AtomSampleViewer
         const char* sponzaPath = "objects/sponza.azmodel";
         Data::Asset<RPI::ModelAsset> modelAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::ModelAsset>(sponzaPath, RPI::AssetUtils::TraceLevel::Assert);
         Data::Asset<RPI::MaterialAsset> materialAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::MaterialAsset>(DefaultPbrMaterialPath, RPI::AssetUtils::TraceLevel::Assert);
-        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, AZ::RPI::Material::FindOrCreate(materialAsset));
+        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ modelAsset }, AZ::RPI::Material::FindOrCreate(materialAsset));
 
         // rotate the entity 180 degrees about Z (the vertical axis)
         // This makes it consistent with how it was positioned in the world when the world was Y-up.

Gem/Code/Source/LightCullingExampleComponent.cpp

@@ -776,7 +776,7 @@ namespace AtomSampleViewer
 
         auto meshFeatureProcessor = GetMeshFeatureProcessor();
 
-        m_meshHandle = meshFeatureProcessor->AcquireMesh(modelAsset);
+        m_meshHandle = meshFeatureProcessor->AcquireMesh(MeshHandleDescriptor{ modelAsset });
         meshFeatureProcessor->SetTransform(m_meshHandle, Transform::CreateIdentity());
         Data::Instance<RPI::Model> model = meshFeatureProcessor->GetModel(m_meshHandle);
         // Loading in the world will probably take a while and I want to grab the AABB afterwards, so hook it up to a a ModelChangeEventHandler
@@ -802,7 +802,7 @@ namespace AtomSampleViewer
         Render::MaterialAssignmentMap materialAssignmentMap = CreateMaterialAssignmentMap(TransparentMaterialName);
         for (const AZ::Vector3& position : TransparentModelPositions)
         {
-            AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(transparentModelAsset, materialAssignmentMap);
+            AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(MeshHandleDescriptor{ transparentModelAsset }, materialAssignmentMap);
             GetMeshFeatureProcessor()->SetTransform(meshHandle, Transform::CreateTranslation(position));
             m_transparentMeshHandles.push_back(std::move(meshHandle));
         }

Gem/Code/Source/MSAA_RPI_ExampleComponent.cpp

@@ -186,7 +186,7 @@ namespace AtomSampleViewer
 
     void MSAA_RPI_ExampleComponent::ActivateModel()
     {
-        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(GetModelAsset(), AZ::RPI::Material::FindOrCreate(GetMaterialAsset()));
+        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ GetModelAsset() }, AZ::RPI::Material::FindOrCreate(GetMaterialAsset()));
         GetMeshFeatureProcessor()->SetTransform(m_meshHandle, AZ::Transform::CreateIdentity());
 
         AZ::Data::Instance<AZ::RPI::Model> model = GetMeshFeatureProcessor()->GetModel(m_meshHandle);

Gem/Code/Source/MaterialHotReloadTestComponent.cpp

@@ -319,7 +319,7 @@ namespace AtomSampleViewer
             m_material = Material::Create(m_materialAsset);
 
             Transform meshTransform = Transform::CreateFromQuaternion(Quaternion::CreateFromAxisAngle(Vector3::CreateAxisX(), -AZ::Constants::HalfPi));
-            m_meshHandle = m_meshFeatureProcessor->AcquireMesh(m_modelAsset, m_material);
+            m_meshHandle = m_meshFeatureProcessor->AcquireMesh(MeshHandleDescriptor{ m_modelAsset }, m_material);
             m_meshFeatureProcessor->SetTransform(m_meshHandle, meshTransform);
 
             Data::Instance<RPI::Model> model = GetMeshFeatureProcessor()->GetModel(m_meshHandle);
@@ -468,7 +468,7 @@ namespace AtomSampleViewer
             if (updateIndicatorMesh)
             {
                 m_meshFeatureProcessor->ReleaseMesh(m_shaderVariantIndicatorMeshHandle);
-                m_shaderVariantIndicatorMeshHandle = m_meshFeatureProcessor->AcquireMesh(m_modelAsset, m_shaderVariantIndicatorMaterial_current);
+                m_shaderVariantIndicatorMeshHandle = m_meshFeatureProcessor->AcquireMesh(Render::MeshHandleDescriptor{ m_modelAsset }, m_shaderVariantIndicatorMaterial_current);
                 m_meshFeatureProcessor->SetTransform(m_shaderVariantIndicatorMeshHandle, m_shaderVariantIndicatorMeshTransform,
                     m_shaderVariantIndicatorMeshNonUniformScale);
             }

Gem/Code/Source/MeshExampleComponent.cpp

@@ -362,7 +362,7 @@ namespace AtomSampleViewer
 
             m_modelAsset.Create(m_modelBrowser.GetSelectedAssetId());
             GetMeshFeatureProcessor()->ReleaseMesh(m_meshHandle);
-            m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_modelAsset, m_materialOverrideInstance);
+            m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(MeshHandleDescriptor{ m_modelAsset }, m_materialOverrideInstance);
             GetMeshFeatureProcessor()->SetTransform(m_meshHandle, AZ::Transform::CreateIdentity());
             GetMeshFeatureProcessor()->ConnectModelChangeEventHandler(m_meshHandle, m_changedHandler);
             GetMeshFeatureProcessor()->SetLodOverride(m_meshHandle, m_lodOverride);
@@ -375,7 +375,7 @@ namespace AtomSampleViewer
     
     void MeshExampleComponent::CreateGroundPlane()
     {
-        m_groundPlandMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_groundPlaneModelAsset, m_groundPlaneMaterial);
+        m_groundPlandMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(MeshHandleDescriptor{ m_groundPlaneModelAsset }, m_groundPlaneMaterial);
     }
 
     void MeshExampleComponent::UpdateGroundPlane()

Gem/Code/Source/MultiRenderPipelineExampleComponent.cpp

@@ -122,10 +122,10 @@ namespace AtomSampleViewer
             RPI::AssetUtils::TraceLevel::Assert);
         auto floorAsset = RPI::AssetUtils::LoadAssetByProductPath<RPI::ModelAsset>(CubeModelFilePath,
             RPI::AssetUtils::TraceLevel::Assert);
-        m_floorMeshHandle = meshFeatureProcessor->AcquireMesh(floorAsset, material);
+        m_floorMeshHandle = meshFeatureProcessor->AcquireMesh(Render::MeshHandleDescriptor{ floorAsset }, material);
         for (uint32_t bunnyIndex = 0; bunnyIndex < BunnyCount; bunnyIndex++)
         {
-            m_bunnyMeshHandles[bunnyIndex] = meshFeatureProcessor->AcquireMesh(bunnyAsset, material);
+            m_bunnyMeshHandles[bunnyIndex] = meshFeatureProcessor->AcquireMesh(Render::MeshHandleDescriptor{ bunnyAsset }, material);
         }
 
         const Vector3 floorNonUniformScale{ 12.f, 12.f, 0.1f };

Gem/Code/Source/MultiSceneExampleComponent.cpp

@@ -165,11 +165,12 @@ namespace AtomSampleViewer
         const auto LoadMesh = [this](const char* modelPath) -> Render::MeshFeatureProcessorInterface::MeshHandle
         {
             AZ_Assert(m_meshFeatureProcessor, "Cannot find mesh feature processor on scene");
+
             auto meshAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::ModelAsset>(modelPath, RPI::AssetUtils::TraceLevel::Assert);            
             auto materialAsset = RPI::AssetUtils::LoadAssetByProductPath<RPI::MaterialAsset>(DefaultPbrMaterialPath,
                 RPI::AssetUtils::TraceLevel::Assert);
             auto material = AZ::RPI::Material::FindOrCreate(materialAsset);
-            Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = m_meshFeatureProcessor->AcquireMesh(meshAsset, material);
+            Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = m_meshFeatureProcessor->AcquireMesh(Render::MeshHandleDescriptor{ meshAsset }, material);
 
             return meshHandle;
         };
@@ -471,7 +472,8 @@ namespace AtomSampleViewer
             auto material = AZ::RPI::Material::FindOrCreate(materialAsset);
             auto bunnyAsset = RPI::AssetUtils::LoadAssetByProductPath<RPI::ModelAsset>(BunnyModelFilePath,
                 RPI::AssetUtils::TraceLevel::Assert);
-            m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(bunnyAsset, material);
+            m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ bunnyAsset }, material);
+
             GetMeshFeatureProcessor()->SetTransform(m_meshHandle, Transform::CreateRotationZ(Constants::Pi));
         }
 

Gem/Code/Source/ParallaxMappingExampleComponent.cpp

@@ -162,7 +162,7 @@ namespace AtomSampleViewer
         AZ::Data::Instance<AZ::RPI::Material> material,
         AZ::Transform transform)
     {
-        AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, material);
+        AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, material);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
         return meshHandle;
     }

Gem/Code/Source/SSRExampleComponent.cpp

@@ -100,7 +100,7 @@ namespace AtomSampleViewer
             transform *= AZ::Transform::CreateRotationZ(AZ::Constants::Pi);
             transform.SetTranslation(0.0f, 0.0f, -0.05f);
 
-            m_statueMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, AZ::RPI::Material::FindOrCreate(materialAsset));
+            m_statueMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, AZ::RPI::Material::FindOrCreate(materialAsset));
             GetMeshFeatureProcessor()->SetTransform(m_statueMeshHandle, transform);
         }
 
@@ -111,7 +111,7 @@ namespace AtomSampleViewer
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             transform.SetTranslation(-4.5f, 0.0f, 0.49f);
 
-            m_boxMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, AZ::RPI::Material::FindOrCreate(materialAsset));
+            m_boxMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, AZ::RPI::Material::FindOrCreate(materialAsset));
             GetMeshFeatureProcessor()->SetTransform(m_boxMeshHandle, transform);
         }
 
@@ -123,7 +123,7 @@ namespace AtomSampleViewer
             transform *= AZ::Transform::CreateRotationZ(AZ::Constants::Pi);
             transform.SetTranslation(4.5f, 0.0f, 0.89f);
 
-            m_shaderBallMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, AZ::RPI::Material::FindOrCreate(materialAsset));
+            m_shaderBallMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ modelAsset }, AZ::RPI::Material::FindOrCreate(materialAsset));
             GetMeshFeatureProcessor()->SetTransform(m_shaderBallMeshHandle, transform);
         }
     }
@@ -159,7 +159,7 @@ namespace AtomSampleViewer
 
         // load mesh
         AZ::Data::Asset<AZ::RPI::ModelAsset> planeModel = AZ::RPI::AssetUtils::GetAssetByProductPath<AZ::RPI::ModelAsset>("objects/plane.azmodel", AZ::RPI::AssetUtils::TraceLevel::Error);
-        m_groundMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(planeModel, AZ::RPI::Material::FindOrCreate(m_groundMaterialAsset));
+        m_groundMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ planeModel }, AZ::RPI::Material::FindOrCreate(m_groundMaterialAsset));
 
         AZ::Transform transform = AZ::Transform::CreateIdentity();
         const AZ::Vector3 nonUniformScale(15.0f, 15.0f, 1.0f);

Gem/Code/Source/SceneReloadSoakTestComponent.cpp

@@ -111,7 +111,7 @@ namespace AtomSampleViewer
         Data::Asset<ModelAsset> modelAsset;
         modelAsset.Create(m_modelAssetId);
 
-        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, materials);
+        auto meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ modelAsset }, materials);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
         m_meshHandles.push_back(AZStd::move(meshHandle));
     }

Gem/Code/Source/ShadingExampleComponent.cpp

@@ -58,7 +58,7 @@ 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);
-        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(meshAsset, AZ::RPI::Material::FindOrCreate(materialAsset));
+        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ meshAsset }, AZ::RPI::Material::FindOrCreate(materialAsset));
         GetMeshFeatureProcessor()->SetTransform(m_meshHandle, AZ::Transform::CreateIdentity());
 
         UseArcBallCameraController();

Gem/Code/Source/ShadowExampleComponent.cpp

@@ -350,8 +350,8 @@ namespace AtomSampleViewer
         using namespace AZ;
 
         m_materialInstance = RPI::Material::FindOrCreate(m_materialAsset);
-        m_floorMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_floorModelAsset, m_materialInstance);
-        m_bunnyMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_bunnyModelAsset, m_materialInstance);
+        m_floorMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ m_floorModelAsset }, m_materialInstance);
+        m_bunnyMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ m_bunnyModelAsset }, m_materialInstance);
 
         auto updateFloorTransform = [&](Data::Instance<RPI::Model> model)
         {

Gem/Code/Source/ShadowedSponzaExampleComponent.cpp

@@ -219,7 +219,7 @@ namespace AtomSampleViewer
         Data::Asset<RPI::ModelAsset> modelAsset =
             RPI::AssetUtils::GetAssetByProductPath<RPI::ModelAsset>(modelPath, RPI::AssetUtils::TraceLevel::Assert);
         Data::Asset<RPI::MaterialAsset> materialAsset = RPI::AssetUtils::GetAssetByProductPath<RPI::MaterialAsset>(DefaultPbrMaterialPath, RPI::AssetUtils::TraceLevel::Assert);
-        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(modelAsset, RPI::Material::FindOrCreate(materialAsset));
+        m_meshHandle = GetMeshFeatureProcessor()->AcquireMesh(Render::MeshHandleDescriptor{ modelAsset }, RPI::Material::FindOrCreate(materialAsset));
 
         // rotate the entity 180 degrees about Z (the vertical axis)
         // This makes it consistent with how it was positioned in the world when the world was Y-up.

Gem/Code/Source/SkinnedMeshContainer.cpp

@@ -175,12 +175,15 @@ namespace AtomSampleViewer
             AZ::Render::MaterialAssignmentMap materialMap;
             materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialAsset = materialAsset;
             materialMap[AZ::Render::DefaultMaterialAssignmentId].m_materialInstance = materialOverrideInstance;
-            bool isSkinnedMeshWithMotion = true;
+
             if (renderData.m_skinnedMeshInstance->m_model)
             {
+                AZ::Render::MeshHandleDescriptor meshDescriptor;
+                meshDescriptor.m_modelAsset = renderData.m_skinnedMeshInstance->m_model->GetModelAsset();
+                meshDescriptor.m_isSkinnedMeshWithMotion = true;
                 renderData.m_meshHandle =
                     AZStd::make_shared<AZ::Render::MeshFeatureProcessorInterface::MeshHandle>(m_meshFeatureProcessor->AcquireMesh(
-                        renderData.m_skinnedMeshInstance->m_model->GetModelAsset(), materialMap, isSkinnedMeshWithMotion));
+                        meshDescriptor, materialMap));
                 m_meshFeatureProcessor->SetTransform(*renderData.m_meshHandle, renderData.m_rootTransform);
             }
             // If render proxies already exist, they will be auto-freed

Gem/Code/Source/SkinnedMeshExampleComponent.cpp

@@ -63,7 +63,7 @@ namespace AtomSampleViewer
     void SkinnedMeshExampleComponent::CreatePlaneObject()
     {
         auto meshAsset = AZ::RPI::AssetUtils::GetAssetByProductPath<AZ::RPI::ModelAsset>("objects/plane.azmodel");
-        m_planeMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(meshAsset);
+        m_planeMeshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ meshAsset });
         GetMeshFeatureProcessor()->SetTransform(m_planeMeshHandle, AZ::Transform::CreateIdentity());
     }
 

Gem/Code/Source/SsaoExampleComponent.cpp

@@ -98,7 +98,7 @@ namespace AtomSampleViewer
 
         // Create Mesh and Model
         MeshFeatureProcessorInterface* meshFeatureProcessor = GetMeshFeatureProcessor();
-        m_meshHandle = meshFeatureProcessor->AcquireMesh(modelAsset, RPI::Material::FindOrCreate(materialAsset));
+        m_meshHandle = meshFeatureProcessor->AcquireMesh(MeshHandleDescriptor{ modelAsset }, RPI::Material::FindOrCreate(materialAsset));
         meshFeatureProcessor->SetTransform(m_meshHandle, Transform::CreateIdentity());
         Data::Instance<RPI::Model> model = meshFeatureProcessor->GetModel(m_meshHandle);
 

Gem/Code/Source/TransparencyExampleComponent.cpp

@@ -136,7 +136,7 @@ namespace AtomSampleViewer
         defaultMaterial.m_materialAsset = m_materialAsset;
         defaultMaterial.m_materialInstance = AZ::RPI::Material::Create(m_materialAsset);
 
-        AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(m_modelAsset, materialMap);
+        AZ::Render::MeshFeatureProcessorInterface::MeshHandle meshHandle = GetMeshFeatureProcessor()->AcquireMesh(AZ::Render::MeshHandleDescriptor{ m_modelAsset }, materialMap);
         GetMeshFeatureProcessor()->SetTransform(meshHandle, transform);
 
         AZ::Data::Instance<AZ::RPI::Model> model = GetMeshFeatureProcessor()->GetModel(meshHandle);