Support for geometry shader (o3de#17266)

umesh-huawei · web-flow · commit 11dc29fce65b · 2024-01-12T12:49:40.000+01:00
* Initial Geometry shader support
* Fix enabling feature and set proper number of layers
* Remove Tesselation related code
* Change ShaderSubStageCountMax back to 2 to support DiffuseGI

Signed-off-by: Umesh Rajesh Ramchandani &lt;umesh.rajesh.ramchandani@huawei.com&gt;
diff --git a/Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp b/Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp
@@ -225,10 +225,6 @@ namespace AZ
                     return RHI::ShaderHardwareStage::Fragment;
                 case RPI::ShaderStageType::Geometry:
                     return RHI::ShaderHardwareStage::Geometry;
-                case RPI::ShaderStageType::TessellationControl:
-                    return RHI::ShaderHardwareStage::TessellationControl;
-                case RPI::ShaderStageType::TessellationEvaluation:
-                    return RHI::ShaderHardwareStage::TessellationEvaluation;
                 case RPI::ShaderStageType::Vertex:
                     return RHI::ShaderHardwareStage::Vertex;
                 case RPI::ShaderStageType::RayTracing:
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI.Edit/ShaderPlatformInterface.h b/Gems/Atom/RHI/Code/Include/Atom/RHI.Edit/ShaderPlatformInterface.h
@@ -40,8 +40,6 @@ namespace AZ::RHI
         Invalid = static_cast<uint32_t>(-1),
         Vertex = 0,
         Geometry,
-        TessellationControl,
-        TessellationEvaluation,
         Fragment,
         Compute,
         RayTracing,
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceFeatures.h b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceFeatures.h
@@ -20,9 +20,6 @@ namespace AZ::RHI
 {
     struct DeviceFeatures
     {
-        //! Whether the adapter supports tessellation shaders.
-        bool m_tessellationShader;
-
         //! Whether the adapter supports geometry shaders.
         bool m_geometryShader;
 
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/ShaderStages.h b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/ShaderStages.h
@@ -32,10 +32,9 @@ namespace AZ::RHI
         //! a vertex. On certain platforms like Metal, this stage may occur after tessellation.
         Vertex = 0,
 
-        //! This virtual stage contains platform-specific stages for hardware tessellation. The specifics
-        //! of how tessellation is achieved varies per platform. PC platforms have dedicated stages to handle this,
-        //! while others utilize compute.
-        Tessellation,
+        //! This virtual stage contains shader stages that expand an input assembly stream and manipulate
+        //! a vertex Note: Not supported on metal.
+        Geometry,
 
         //! This virtual stage contains the platform-specific stages necessary to process screen space fragments.
         //! Currently, on all supported platforms, this maps 1-to-1 with a hardware shader stage.
@@ -66,11 +65,11 @@ namespace AZ::RHI
     {
         None = 0,
         Vertex = AZ_BIT(static_cast<uint32_t>(ShaderStage::Vertex)),
-        Tessellation = AZ_BIT(static_cast<uint32_t>(ShaderStage::Tessellation)),
+        Geometry = AZ_BIT(static_cast<uint32_t>(ShaderStage::Geometry)),
         Fragment = AZ_BIT(static_cast<uint32_t>(ShaderStage::Fragment)),
         Compute = AZ_BIT(static_cast<uint32_t>(ShaderStage::Compute)),
         RayTracing = AZ_BIT(static_cast<uint32_t>(ShaderStage::RayTracing)),
-        All = Vertex | Tessellation | Fragment | Compute | RayTracing
+        All = Vertex | Geometry | Fragment | Compute | RayTracing
     };
 
     AZ_DEFINE_ENUM_BITWISE_OPERATORS(AZ::RHI::ShaderStageMask)
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI/PipelineStateDescriptor.h b/Gems/Atom/RHI/Code/Include/Atom/RHI/PipelineStateDescriptor.h
@@ -98,8 +98,8 @@ namespace AZ::RHI
         /// [Required] The vertex function to compile.
         ConstPtr<ShaderStageFunction> m_vertexFunction;
 
-        /// [Optional] The tessellation function to compile.
-        ConstPtr<ShaderStageFunction> m_tessellationFunction;
+        /// [Optional] The geometry function to compile.
+        ConstPtr<ShaderStageFunction> m_geometryFunction;
 
         /// [Required] The fragment function used to compile.
         ConstPtr<ShaderStageFunction> m_fragmentFunction;
diff --git a/Gems/Atom/RHI/Code/Source/RHI.Edit/Utils.cpp b/Gems/Atom/RHI/Code/Source/RHI.Edit/Utils.cpp
@@ -413,11 +413,7 @@ namespace AZ::RHI
         case ShaderHardwareStage::Fragment:
             return RHI::ShaderStage::Fragment;
         case ShaderHardwareStage::Geometry:
-            AZ_Assert(false, "RHI currently does not support geometry shaders");
-            return RHI::ShaderStage::Unknown;
-        case ShaderHardwareStage::TessellationControl:
-        case ShaderHardwareStage::TessellationEvaluation:
-            return RHI::ShaderStage::Tessellation;
+            return RHI::ShaderStage::Geometry;
         case ShaderHardwareStage::Vertex:
             return RHI::ShaderStage::Vertex;
         case ShaderHardwareStage::RayTracing:
diff --git a/Gems/Atom/RHI/Code/Source/RHI/PipelineStateDescriptor.cpp b/Gems/Atom/RHI/Code/Source/RHI/PipelineStateDescriptor.cpp
@@ -60,9 +60,9 @@ namespace AZ::RHI
         {
             seed = TypeHash64(m_vertexFunction->GetHash(), seed);
         }
-        if (m_tessellationFunction)
+        if (m_geometryFunction)
         {
-            seed = TypeHash64(m_tessellationFunction->GetHash(), seed);
+            seed = TypeHash64(m_geometryFunction->GetHash(), seed);
         }
         if (m_fragmentFunction)
         {
@@ -90,12 +90,9 @@ namespace AZ::RHI
 
     bool PipelineStateDescriptorForDraw::operator == (const PipelineStateDescriptorForDraw& rhs) const
     {
-        return m_fragmentFunction == rhs.m_fragmentFunction &&
-            m_pipelineLayoutDescriptor == rhs.m_pipelineLayoutDescriptor &&
-            m_renderStates == rhs.m_renderStates &&
-            m_vertexFunction == rhs.m_vertexFunction &&
-            m_tessellationFunction == rhs.m_tessellationFunction &&
-            m_inputStreamLayout == rhs.m_inputStreamLayout &&
+        return m_fragmentFunction == rhs.m_fragmentFunction && m_pipelineLayoutDescriptor == rhs.m_pipelineLayoutDescriptor &&
+            m_renderStates == rhs.m_renderStates && m_vertexFunction == rhs.m_vertexFunction &&
+            m_geometryFunction == rhs.m_geometryFunction && m_inputStreamLayout == rhs.m_inputStreamLayout && 
             m_renderAttachmentConfiguration == rhs.m_renderAttachmentConfiguration;
     }
 
diff --git a/Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/ShaderStageFunction.h b/Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/ShaderStageFunction.h
@@ -40,10 +40,6 @@ namespace AZ
         {
             /// Used when the sub-stage is 1-to-1 with the virtual stage.
             const uint32_t Default = 0;
-
-            /// Tessellation is composed of two physical stages in HLSL.
-            const uint32_t TessellationHull = 0;
-            const uint32_t TessellationDomain = 1;
         }
 
         const uint32_t ShaderSubStageCountMax = 2;
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI.Builders/ShaderPlatformInterface.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI.Builders/ShaderPlatformInterface.cpp
@@ -47,7 +47,7 @@ namespace AZ
             RHI::Ptr<ShaderStageFunction> newShaderStageFunction =  ShaderStageFunction::Create(RHI::ToRHIShaderStage(stageDescriptor.m_stageType));
 
             const DX12::ShaderByteCode& byteCode = stageDescriptor.m_byteCode;
-            const int byteCodeIndex = (stageDescriptor.m_stageType == RHI::ShaderHardwareStage::TessellationEvaluation) ? 1 : 0;
+            const int byteCodeIndex = 0;
             newShaderStageFunction->SetByteCode(byteCodeIndex, byteCode);
 
             newShaderStageFunction->Finalize();
@@ -61,8 +61,7 @@ namespace AZ
 
             hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::Vertex;
             hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::Fragment;
-            hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::TessellationControl;
-            hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::TessellationEvaluation;
+            hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::Geometry;
 
             return hasRasterProgram;
         }
@@ -229,8 +228,6 @@ namespace AZ
                 {RHI::ShaderHardwareStage::Fragment,               "ps_" + shaderModelVersion},
                 {RHI::ShaderHardwareStage::Compute,                "cs_" + shaderModelVersion},
                 {RHI::ShaderHardwareStage::Geometry,               "gs_" + shaderModelVersion},
-                {RHI::ShaderHardwareStage::TessellationControl,    "hs_" + shaderModelVersion},
-                {RHI::ShaderHardwareStage::TessellationEvaluation, "ds_" + shaderModelVersion},
                 {RHI::ShaderHardwareStage::RayTracing,             "lib_6_3"}
             };
             auto profileIt = stageToProfileName.find(shaderStageType);
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Conversions.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/Conversions.cpp
@@ -1193,8 +1193,8 @@ namespace AZ
                 return D3D12_SHADER_VISIBILITY_ALL;
             case RHI::ShaderStageMask::Vertex:
                 return D3D12_SHADER_VISIBILITY_VERTEX;
-            case RHI::ShaderStageMask::Tessellation:
-                return D3D12_SHADER_VISIBILITY_ALL;
+            case RHI::ShaderStageMask::Geometry:
+                return D3D12_SHADER_VISIBILITY_GEOMETRY;
             case RHI::ShaderStageMask::Fragment:
                 return D3D12_SHADER_VISIBILITY_PIXEL;
             case RHI::ShaderStageMask::Compute:
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp
@@ -208,7 +208,6 @@ namespace AZ
 
         void Device::InitFeatures()
         {
-            m_features.m_tessellationShader = true;
             m_features.m_geometryShader = true;
             m_features.m_computeShader = true;
             m_features.m_independentBlend = true;
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/PipelineState.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/PipelineState.cpp
@@ -61,10 +61,9 @@ namespace AZ
                 pipelineStateDesc.VS = D3D12BytecodeFromView(vertexFunction->GetByteCode());
             }
 
-            if (const ShaderStageFunction* tessellationFunction = azrtti_cast<const ShaderStageFunction*>(descriptor.m_tessellationFunction.get()))
+            if (const ShaderStageFunction* geometryFunction = azrtti_cast<const ShaderStageFunction*>(descriptor.m_geometryFunction.get()))
             {
-                pipelineStateDesc.HS = D3D12BytecodeFromView(tessellationFunction->GetByteCode(ShaderSubStage::TessellationHull));
-                pipelineStateDesc.DS = D3D12BytecodeFromView(tessellationFunction->GetByteCode(ShaderSubStage::TessellationDomain));
+                pipelineStateDesc.GS = D3D12BytecodeFromView(geometryFunction->GetByteCode());
             }
 
             if (const ShaderStageFunction* fragmentFunction = azrtti_cast<const ShaderStageFunction*>(descriptor.m_fragmentFunction.get()))
diff --git a/Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/ShaderStageFunction.h b/Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/ShaderStageFunction.h
@@ -42,10 +42,6 @@ namespace AZ
         {
             /// Used when the sub-stage is 1-to-1 with the virtual stage.
             const uint32_t Default = 0;
-
-            /// Tessellation is composed of two physical stages in Vulkan.
-            const uint32_t TesselationControl = 0;
-            const uint32_t TesselationEvaluattion = 1;
         }
 
         const uint32_t ShaderSubStageCountMax = 2;
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Builders/ShaderPlatformInterface.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Builders/ShaderPlatformInterface.cpp
@@ -42,7 +42,7 @@ namespace AZ
 
             const Vulkan::ShaderByteCode& byteCode = stageDescriptor.m_byteCode;
             const AZStd::string& entryFunctionName = stageDescriptor.m_entryFunctionName;
-            const int byteCodeIndex = (stageDescriptor.m_stageType == RHI::ShaderHardwareStage::TessellationEvaluation) ? 1 : 0;
+            const int byteCodeIndex = 0;
             newShaderStageFunction->SetByteCode(byteCodeIndex, byteCode, entryFunctionName);
 
             newShaderStageFunction->Finalize();
@@ -55,9 +55,8 @@ namespace AZ
             bool hasRasterProgram = false;
 
             hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::Vertex;
+            hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::Geometry;
             hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::Fragment;
-            hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::TessellationControl;
-            hasRasterProgram |= shaderStageType == RHI::ShaderHardwareStage::TessellationEvaluation;
 
             return hasRasterProgram;
         }
@@ -185,8 +184,6 @@ namespace AZ
                 {RHI::ShaderHardwareStage::Fragment,               "ps_" + shaderModelVersion},
                 {RHI::ShaderHardwareStage::Compute,                "cs_" + shaderModelVersion},
                 {RHI::ShaderHardwareStage::Geometry,               "gs_" + shaderModelVersion},
-                {RHI::ShaderHardwareStage::TessellationControl,    "hs_" + shaderModelVersion},
-                {RHI::ShaderHardwareStage::TessellationEvaluation, "ds_" + shaderModelVersion},
                 {RHI::ShaderHardwareStage::RayTracing,             "lib_6_3"}
             };
             auto profileIt = stageToProfileName.find(shaderStageType);
@@ -224,15 +221,13 @@ namespace AZ
             {
             case RHI::ShaderHardwareStage::Vertex:
             case RHI::ShaderHardwareStage::Geometry:
-            case RHI::ShaderHardwareStage::TessellationEvaluation:
                 RHI::ShaderBuildArguments::AppendArguments(dxcArguments, { "-fvk-invert-y" });
                 break;
             case RHI::ShaderHardwareStage::Fragment:
                 // Enable the use of subpass input. DXC doesn't compile if a SubpassInput is present
                 // when compiling a shader stage that is not the fragment shader (even if it's not being used).
                 RHI::ShaderBuildArguments::AppendArguments(dxcArguments, { "-DAZ_USE_SUBPASSINPUT", "-fvk-use-dx-position-w"});
                 break;
-            case RHI::ShaderHardwareStage::TessellationControl:
             case RHI::ShaderHardwareStage::Compute:
             case RHI::ShaderHardwareStage::RayTracing:
                 break;
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Reflect/Conversion.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Reflect/Conversion.cpp
@@ -559,7 +559,7 @@ namespace AZ
             return flags;
         }
 
-        VkShaderStageFlagBits ConvertShaderStage(RHI::ShaderStage stage, uint32_t subStageIndex /* = 0 */)
+        VkShaderStageFlagBits ConvertShaderStage(RHI::ShaderStage stage, [[maybe_unused]] uint32_t subStageIndex /* = 0 */)
         {
             switch (stage)
             {
@@ -569,8 +569,8 @@ namespace AZ
                 return VK_SHADER_STAGE_FRAGMENT_BIT;
             case RHI::ShaderStage::Compute:
                 return VK_SHADER_STAGE_COMPUTE_BIT;
-            case RHI::ShaderStage::Tessellation:
-                return subStageIndex == 0 ? VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT : VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+            case RHI::ShaderStage::Geometry:
+                return VK_SHADER_STAGE_GEOMETRY_BIT;
             default:
                 AZ_Assert(false, "Invalid shader stage %d", stage);
                 return VkShaderStageFlagBits(0);
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.cpp
@@ -271,6 +271,9 @@ namespace AZ
                 vulkan12Features.descriptorBindingStorageBufferUpdateAfterBind = physicalDevice.GetPhysicalDeviceVulkan12Features().descriptorBindingStorageBufferUpdateAfterBind;
                 vulkan12Features.descriptorBindingPartiallyBound = physicalDevice.GetPhysicalDeviceVulkan12Features().descriptorBindingPartiallyBound;
                 vulkan12Features.descriptorBindingUpdateUnusedWhilePending = physicalDevice.GetPhysicalDeviceVulkan12Features().descriptorBindingUpdateUnusedWhilePending;
+                vulkan12Features.shaderOutputViewportIndex = physicalDevice.GetPhysicalDeviceVulkan12Features().shaderOutputViewportIndex;
+                vulkan12Features.shaderOutputLayer = physicalDevice.GetPhysicalDeviceVulkan12Features().shaderOutputLayer;
+                shaderImageAtomicInt64.pNext = &vulkan12Features;
 
                 accelerationStructureFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
                 accelerationStructureFeatures.accelerationStructure = physicalDevice.GetPhysicalDeviceAccelerationStructureFeatures().accelerationStructure;
@@ -1061,7 +1064,6 @@ namespace AZ
 
         void Device::InitFeaturesAndLimits(const PhysicalDevice& physicalDevice)
         {
-            m_features.m_tessellationShader = (m_enabledDeviceFeatures.tessellationShader == VK_TRUE);
             m_features.m_geometryShader = (m_enabledDeviceFeatures.geometryShader == VK_TRUE);
             m_features.m_computeShader = true;
             m_features.m_independentBlend = (m_enabledDeviceFeatures.independentBlend == VK_TRUE);
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Framebuffer.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Framebuffer.cpp
@@ -148,9 +148,18 @@ namespace AZ
             AZ_Assert(!m_attachments.empty(), "Attachment image view is empty.");
 
             AZStd::vector<VkImageView> imageViews(m_attachments.size(), VK_NULL_HANDLE);
+            uint32_t maxLayers = 1;
             for (size_t index = 0; index < imageViews.size(); ++index)
             {
                 imageViews[index] = m_attachments[index]->GetNativeImageView();
+                if (m_attachments[index]->GetDescriptor().m_isArray)
+                {
+                    maxLayers = AZStd::max(
+                        maxLayers,
+                        static_cast<uint32_t>(
+                            m_attachments[index]->GetImageSubresourceRange().m_arraySliceMax -
+                            m_attachments[index]->GetImageSubresourceRange().m_arraySliceMin + 1));
+                }
             }
 
             VkFramebufferCreateInfo createInfo{};
@@ -161,8 +170,8 @@ namespace AZ
             createInfo.pAttachments = imageViews.data();
             createInfo.width = m_size.m_width;
             createInfo.height = m_size.m_height;
-            createInfo.layers = 1;
-            
+            createInfo.layers = maxLayers;
+
             auto& device = static_cast<Device&>(GetDevice());
             const VkResult result = device.GetContext().CreateFramebuffer(
                 device.GetNativeDevice(), &createInfo, VkSystemAllocator::Get(), &m_nativeFramebuffer);
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/GraphicsPipeline.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/GraphicsPipeline.cpp
@@ -123,16 +123,14 @@ namespace AZ
             m_pipelineShaderStageCreateInfos.emplace_back();
             FillPipelineShaderStageCreateInfo(*func, RHI::ShaderStage::Vertex, ShaderSubStage::Default, *m_pipelineShaderStageCreateInfos.rbegin());
 
-            if (GetDevice().GetFeatures().m_tessellationShader)
+            if (GetDevice().GetFeatures().m_geometryShader)
             {
-                func = static_cast<ShaderStageFunction const*>(descriptor.m_tessellationFunction.get());
+                func = static_cast<ShaderStageFunction const*>(descriptor.m_geometryFunction.get());
                 if (func)
                 {
-                    for (uint32_t subStageIndex = 0; subStageIndex < ShaderSubStageCountMax; ++subStageIndex)
-                    {
-                        m_pipelineShaderStageCreateInfos.emplace_back();
-                        FillPipelineShaderStageCreateInfo(*func, RHI::ShaderStage::Tessellation, subStageIndex, *m_pipelineShaderStageCreateInfos.rbegin());
-                    }
+                    m_pipelineShaderStageCreateInfos.emplace_back();
+                    FillPipelineShaderStageCreateInfo(
+                        *func, RHI::ShaderStage::Geometry, ShaderSubStage::Default, *m_pipelineShaderStageCreateInfos.rbegin());
                 }
             }
 
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Pipeline.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Pipeline.cpp
@@ -106,18 +106,8 @@ namespace AZ
             case RHI::ShaderStage::Vertex:
                 stageBits = VK_SHADER_STAGE_VERTEX_BIT;
                 break;
-            case RHI::ShaderStage::Tessellation:
-                switch (subStageIndex)
-                {
-                case ShaderSubStage::TesselationControl:
-                    stageBits = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
-                    break;
-                case ShaderSubStage::TesselationEvaluattion:
-                    stageBits = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
-                    break;
-                default:
-                    AZ_Assert(false, "Shader Sub Stage is wrong.");
-                }
+            case RHI::ShaderStage::Geometry:
+                stageBits = VK_SHADER_STAGE_GEOMETRY_BIT;
                 break;
             case RHI::ShaderStage::Fragment:
                 stageBits = VK_SHADER_STAGE_FRAGMENT_BIT;
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Edit/Shader/ShaderVariantAssetCreator.cpp b/Gems/Atom/RPI/Code/Source/RPI.Edit/Shader/ShaderVariantAssetCreator.cpp
@@ -44,7 +44,7 @@ namespace AZ
             bool foundDispatchFunctions = false;
 
             if (m_asset->GetShaderStageFunction(RHI::ShaderStage::Vertex) ||
-                m_asset->GetShaderStageFunction(RHI::ShaderStage::Tessellation) ||
+                m_asset->GetShaderStageFunction(RHI::ShaderStage::Geometry) ||
                 m_asset->GetShaderStageFunction(RHI::ShaderStage::Fragment))
             {
                 foundDrawFunctions = true;
@@ -69,15 +69,13 @@ namespace AZ
                 return false;
             }
 
-            if (m_asset->GetShaderStageFunction(RHI::ShaderStage::Tessellation) &&
+            if (m_asset->GetShaderStageFunction(RHI::ShaderStage::Geometry) &&
                 !m_asset->GetShaderStageFunction(RHI::ShaderStage::Vertex))
             {
-                ReportError("Shader Variant with StableId '%u' has a tessellation function but no vertex function.", m_asset->m_stableId);
+                ReportError("Shader Variant with StableId '%u' has a geometry function but no vertex function.", m_asset->m_stableId);
                 return false;
             }
 
-
-
             m_asset->SetReady();
             return EndCommon(result);
         }
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/ShaderVariant.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/ShaderVariant.cpp
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAssetCreator.cpp b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAssetCreator.cpp
diff --git a/Gems/Atom/RPI/Code/Tests/Shader/ShaderTests.cpp b/Gems/Atom/RPI/Code/Tests/Shader/ShaderTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,6 @@ namespace AZ::RHI`
`20`	`20`	`{`
`21`	`21`	`struct DeviceFeatures`
`22`	`22`	`{`
`23`		`- //! Whether the adapter supports tessellation shaders.`
`24`		`- bool m_tessellationShader;`
`25`		`-`
`26`	`23`	`//! Whether the adapter supports geometry shaders.`
`27`	`24`	`bool m_geometryShader;`
`28`	`25`
Original file line number	Diff line number	Diff line change
`@@ -60,9 +60,9 @@ namespace AZ::RHI`
`60`	`60`	`{`
`61`	`61`	`seed = TypeHash64(m_vertexFunction->GetHash(), seed);`
`62`	`62`	`}`
`63`		`- if (m_tessellationFunction)`
	`63`	`+ if (m_geometryFunction)`
`64`	`64`	`{`
`65`		`- seed = TypeHash64(m_tessellationFunction->GetHash(), seed);`
	`65`	`+ seed = TypeHash64(m_geometryFunction->GetHash(), seed);`
`66`	`66`	`}`
`67`	`67`	`if (m_fragmentFunction)`
`68`	`68`	`{`
`@@ -90,12 +90,9 @@ namespace AZ::RHI`
`90`	`90`
`91`	`91`	`bool PipelineStateDescriptorForDraw::operator == (const PipelineStateDescriptorForDraw& rhs) const`
`92`	`92`	`{`
`93`		`- return m_fragmentFunction == rhs.m_fragmentFunction &&`
`94`		`- m_pipelineLayoutDescriptor == rhs.m_pipelineLayoutDescriptor &&`
`95`		`- m_renderStates == rhs.m_renderStates &&`
`96`		`- m_vertexFunction == rhs.m_vertexFunction &&`
`97`		`- m_tessellationFunction == rhs.m_tessellationFunction &&`
`98`		`- m_inputStreamLayout == rhs.m_inputStreamLayout &&`
	`93`	`+ return m_fragmentFunction == rhs.m_fragmentFunction && m_pipelineLayoutDescriptor == rhs.m_pipelineLayoutDescriptor &&`
	`94`	`+ m_renderStates == rhs.m_renderStates && m_vertexFunction == rhs.m_vertexFunction &&`
	`95`	`+ m_geometryFunction == rhs.m_geometryFunction && m_inputStreamLayout == rhs.m_inputStreamLayout &&`
`99`	`96`	`m_renderAttachmentConfiguration == rhs.m_renderAttachmentConfiguration;`
`100`	`97`	`}`
`101`	`98`
Original file line number	Diff line number	Diff line change
`@@ -40,10 +40,6 @@ namespace AZ`
`40`	`40`	`{`
`41`	`41`	`/// Used when the sub-stage is 1-to-1 with the virtual stage.`
`42`	`42`	`const uint32_t Default = 0;`
`43`		`-`
`44`		`- /// Tessellation is composed of two physical stages in HLSL.`
`45`		`- const uint32_t TessellationHull = 0;`
`46`		`- const uint32_t TessellationDomain = 1;`
`47`	`43`	`}`
`48`	`44`
`49`	`45`	`const uint32_t ShaderSubStageCountMax = 2;`