layers: Fix Tessellation with Shader Object

Author: spencer-lunarg

layers/core_checks/cc_drawdispatch.cpp

@@ -22,6 +22,8 @@
 #include "drawdispatch/drawdispatch_vuids.h"
 #include "core_validation.h"
 #include "error_message/error_strings.h"
+#include "error_message/logging.h"
+#include "generated/spirv_grammar_helper.h"
 #include "generated/vk_extension_helper.h"
 #include "state_tracker/buffer_state.h"
 #include "state_tracker/image_state.h"
@@ -1376,6 +1378,7 @@ bool CoreChecks::ValidateActionState(const LastBound &last_bound_state, const Dr
         skip |= ValidateDrawAttachmentColorBlend(last_bound_state, vuid);
         skip |= ValidateDrawAttachmentSampleLocation(last_bound_state, vuid);
         skip |= ValidateDrawDepthStencilAttachments(last_bound_state, vuid);
+        skip |= ValidateDrawTessellation(last_bound_state, vuid);
 
         if (cb_state.active_render_pass && cb_state.active_render_pass->UsesDynamicRendering()) {
             skip |= ValidateDrawDynamicRenderingFsOutputs(last_bound_state, cb_state, loc);
@@ -2136,6 +2139,86 @@ bool CoreChecks::ValidateDrawDepthStencilAttachments(const LastBound &last_bound
     return skip;
 }
 
+bool CoreChecks::ValidateDrawTessellation(const LastBound &last_bound_state, const vvl::DrawDispatchVuid &vuid) const {
+    bool skip = false;
+    // Already validation to ensure there is both a Control and Eval
+    if ((last_bound_state.GetAllActiveBoundStages() & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) == 0) {
+        return skip;
+    }
+
+    const spirv::ExecutionModeSet *tesc_execution_mode = nullptr;
+    const spirv::ExecutionModeSet *tese_execution_mode = nullptr;
+
+    if (last_bound_state.pipeline_state) {
+        for (auto &stage_state : last_bound_state.pipeline_state->stage_states) {
+            const VkShaderStageFlagBits stage = stage_state.GetStage();
+            if (stage & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) {
+                if (stage_state.entrypoint) {
+                    tesc_execution_mode = &stage_state.entrypoint->execution_mode;
+                }
+            } else if (stage & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) {
+                if (stage_state.entrypoint) {
+                    tese_execution_mode = &stage_state.entrypoint->execution_mode;
+                }
+            }
+        }
+    } else {
+        const auto tesc_shader = last_bound_state.GetShaderState(ShaderObjectStage::TESSELLATION_CONTROL);
+        if (tesc_shader && tesc_shader->entrypoint) {
+            tesc_execution_mode = &tesc_shader->entrypoint->execution_mode;
+        }
+        const auto tese_shader = last_bound_state.GetShaderState(ShaderObjectStage::TESSELLATION_EVALUATION);
+        if (tese_shader && tese_shader->entrypoint) {
+            tese_execution_mode = &tese_shader->entrypoint->execution_mode;
+        }
+    }
+
+    ASSERT_AND_RETURN_SKIP(tesc_execution_mode && tese_execution_mode);
+
+    // VUID being added in https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/7694
+    const uint32_t tesc_subdivision = tesc_execution_mode->GetTessellationSubdivision();
+    const uint32_t tese_subdivision = tese_execution_mode->GetTessellationSubdivision();
+    if (tesc_subdivision != 0 && tese_subdivision != 0 && tesc_subdivision != tese_subdivision) {
+        skip |= LogError("UNASSIGNED-vkCmdDraw-tessellation-subdivision",
+                         last_bound_state.cb_state.GetObjectList(VK_PIPELINE_BIND_POINT_GRAPHICS), vuid.loc(),
+                         "The subdivision specified in tessellation control shader (%s) does not match the subdivision in "
+                         "tessellation evaluation shader (%s).",
+                         string_SpvExecutionMode(tesc_subdivision), string_SpvExecutionMode(tese_subdivision));
+    }
+
+    const uint32_t tesc_orientation = tesc_execution_mode->GetTessellationOrientation();
+    const uint32_t tese_orientation = tese_execution_mode->GetTessellationOrientation();
+    if (tesc_orientation != 0 && tese_orientation != 0 && tesc_orientation != tese_orientation) {
+        skip |= LogError("UNASSIGNED-vkCmdDraw-tessellation-orientation",
+                         last_bound_state.cb_state.GetObjectList(VK_PIPELINE_BIND_POINT_GRAPHICS), vuid.loc(),
+                         "The orientation specified in tessellation control shader (%s) does not match the orientation in "
+                         "tessellation evaluation shader (%s).",
+                         string_SpvExecutionMode(tesc_orientation), string_SpvExecutionMode(tese_orientation));
+    }
+
+    const uint32_t tesc_spacing = tesc_execution_mode->GetTessellationSpacing();
+    const uint32_t tese_spacing = tese_execution_mode->GetTessellationSpacing();
+    if (tesc_spacing != 0 && tese_spacing != 0 && tesc_spacing != tese_spacing) {
+        skip |= LogError("UNASSIGNED-vkCmdDraw-tessellation-spacing",
+                         last_bound_state.cb_state.GetObjectList(VK_PIPELINE_BIND_POINT_GRAPHICS), vuid.loc(),
+                         "The spacing specified in tessellation control shader (%s) does not match the spacing in "
+                         "tessellation evaluation shader (%s).",
+                         string_SpvExecutionMode(tesc_spacing), string_SpvExecutionMode(tese_spacing));
+    }
+    const uint32_t tesc_patch_size = tesc_execution_mode->output_vertices;
+    const uint32_t tese_patch_size = tese_execution_mode->output_vertices;
+    if (tesc_patch_size != spirv::kInvalidValue && tese_patch_size != spirv::kInvalidValue && tesc_patch_size != tese_patch_size) {
+        skip |= LogError("UNASSIGNED-vkCmdDraw-tessellation-patch-size",
+                         last_bound_state.cb_state.GetObjectList(VK_PIPELINE_BIND_POINT_GRAPHICS), vuid.loc(),
+                         "The OutputVertices (patch size) specified in tessellation control shader (%" PRIu32
+                         ") does not match the spacing in "
+                         "tessellation evaluation shader (%" PRIu32 ").",
+                         tesc_patch_size, tese_patch_size);
+    }
+
+    return skip;
+}
+
 bool CoreChecks::ValidateDrawDynamicRenderpassExternalFormatResolve(const LastBound &last_bound_state,
                                                                     const vvl::RenderPass &rp_state,
                                                                     const vvl::DrawDispatchVuid &vuid) const {

layers/core_checks/cc_shader_interface.cpp

@@ -699,29 +699,32 @@ bool CoreChecks::ValidatePipelineTessellationStages(const spirv::Module &tesc_mo
                                                     const Location &create_info_loc) const {
     bool skip = false;
 
+    // The other tessellation modes (PointMode, Spacing, Orientation) can be in either stage.
+    // OutputVertices needs to be in TESC and Subdivision in TESE, but they can be in the other stage, but needs to match
     const uint32_t tesc_subdivision = tesc_entrypoint.execution_mode.GetTessellationSubdivision();
     const uint32_t tese_subdivision = tese_entrypoint.execution_mode.GetTessellationSubdivision();
     const uint32_t tesc_patch_size = tesc_entrypoint.execution_mode.output_vertices;
     const uint32_t tese_patch_size = tese_entrypoint.execution_mode.output_vertices;
     if (tesc_subdivision == 0 && tese_subdivision == 0) {
         const LogObjectList objlist(tesc_module_state.handle(), tese_module_state.handle());
         skip |= LogError("VUID-VkGraphicsPipelineCreateInfo-pStages-00732", objlist, create_info_loc,
-                         "Subdivision type is not specified in either of tessellation stages");
+                         "Subdivision (Triangles/Quads/IsoLines) is not specified in either of tessellation stages");
     } else if (tesc_subdivision != 0 && tese_subdivision != 0 && tesc_subdivision != tese_subdivision) {
         const LogObjectList objlist(tesc_module_state.handle(), tese_module_state.handle());
         skip |= LogError("VUID-VkGraphicsPipelineCreateInfo-pStages-00733", objlist, create_info_loc,
-                         "Subdivision type specified in tessellation control shader is %s, but subdivison type specified in "
+                         "Subdivision specified in tessellation control shader is %s, but subdivison type specified in "
                          "tessellation evaluation shader is %s",
                          string_SpvExecutionMode(tesc_subdivision), string_SpvExecutionMode(tese_subdivision));
     }
-    if (tesc_patch_size == vvl::kU32Max && tese_patch_size == vvl::kU32Max) {
+    if (tesc_patch_size == spirv::kInvalidValue && tese_patch_size == spirv::kInvalidValue) {
         const LogObjectList objlist(tesc_module_state.handle(), tese_module_state.handle());
         skip |= LogError("VUID-VkGraphicsPipelineCreateInfo-pStages-00734", objlist, create_info_loc,
-                         "Output patch size is not specified in either of tessellation stages");
-    } else if (tesc_patch_size != vvl::kU32Max && tese_patch_size != vvl::kU32Max && tesc_patch_size != tese_patch_size) {
+                         "OutputVertices (patch size) is not specified in either of tessellation stages");
+    } else if (tesc_patch_size != spirv::kInvalidValue && tese_patch_size != spirv::kInvalidValue &&
+               tesc_patch_size != tese_patch_size) {
         const LogObjectList objlist(tesc_module_state.handle(), tese_module_state.handle());
         skip |= LogError("VUID-VkGraphicsPipelineCreateInfo-pStages-00735", objlist, create_info_loc,
-                         "Output patch size specified in tessellation control shader is %" PRIu32
+                         "OutputVertices (patch size) specified in tessellation control shader is %" PRIu32
                          ", but subdivison type specified in tessellation evaluation shader is %" PRIu32,
                          tesc_patch_size, tese_patch_size);
     }