layers: Generate CB dynamic status flags
diff --git a/layers/cmd_buffer_state.cpp b/layers/cmd_buffer_state.cpp
index 8cd9230..ce87416 100644
--- a/layers/cmd_buffer_state.cpp
+++ b/layers/cmd_buffer_state.cpp
@@ -76,287 +76,6 @@
return kGeneratedCommandNameList[type];
}
-VkDynamicState ConvertToDynamicState(CBStatus flag) {
- switch (flag) {
- case CBSTATUS_LINE_WIDTH_SET:
- return VK_DYNAMIC_STATE_LINE_WIDTH;
- case CBSTATUS_DEPTH_BIAS_SET:
- return VK_DYNAMIC_STATE_DEPTH_BIAS;
- case CBSTATUS_BLEND_CONSTANTS_SET:
- return VK_DYNAMIC_STATE_BLEND_CONSTANTS;
- case CBSTATUS_DEPTH_BOUNDS_SET:
- return VK_DYNAMIC_STATE_DEPTH_BOUNDS;
- case CBSTATUS_STENCIL_READ_MASK_SET:
- return VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK;
- case CBSTATUS_STENCIL_WRITE_MASK_SET:
- return VK_DYNAMIC_STATE_STENCIL_WRITE_MASK;
- case CBSTATUS_STENCIL_REFERENCE_SET:
- return VK_DYNAMIC_STATE_STENCIL_REFERENCE;
- case CBSTATUS_VIEWPORT_SET:
- return VK_DYNAMIC_STATE_VIEWPORT;
- case CBSTATUS_SCISSOR_SET:
- return VK_DYNAMIC_STATE_SCISSOR;
- case CBSTATUS_EXCLUSIVE_SCISSOR_SET:
- return VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV;
- case CBSTATUS_SHADING_RATE_PALETTE_SET:
- return VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV;
- case CBSTATUS_LINE_STIPPLE_SET:
- return VK_DYNAMIC_STATE_LINE_STIPPLE_EXT;
- case CBSTATUS_VIEWPORT_W_SCALING_SET:
- return VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV;
- case CBSTATUS_CULL_MODE_SET:
- return VK_DYNAMIC_STATE_CULL_MODE_EXT;
- case CBSTATUS_FRONT_FACE_SET:
- return VK_DYNAMIC_STATE_FRONT_FACE_EXT;
- case CBSTATUS_PRIMITIVE_TOPOLOGY_SET:
- return VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT;
- case CBSTATUS_VIEWPORT_WITH_COUNT_SET:
- return VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT;
- case CBSTATUS_SCISSOR_WITH_COUNT_SET:
- return VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT;
- case CBSTATUS_VERTEX_INPUT_BINDING_STRIDE_SET:
- return VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT;
- case CBSTATUS_DEPTH_TEST_ENABLE_SET:
- return VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT;
- case CBSTATUS_DEPTH_WRITE_ENABLE_SET:
- return VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT;
- case CBSTATUS_DEPTH_COMPARE_OP_SET:
- return VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT;
- case CBSTATUS_DEPTH_BOUNDS_TEST_ENABLE_SET:
- return VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT;
- case CBSTATUS_STENCIL_TEST_ENABLE_SET:
- return VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT;
- case CBSTATUS_STENCIL_OP_SET:
- return VK_DYNAMIC_STATE_STENCIL_OP_EXT;
- case CBSTATUS_DISCARD_RECTANGLE_SET:
- return VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT;
- case CBSTATUS_SAMPLE_LOCATIONS_SET:
- return VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT;
- case CBSTATUS_COARSE_SAMPLE_ORDER_SET:
- return VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV;
- case CBSTATUS_PATCH_CONTROL_POINTS_SET:
- return VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT;
- case CBSTATUS_RASTERIZER_DISCARD_ENABLE_SET:
- return VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT;
- case CBSTATUS_DEPTH_BIAS_ENABLE_SET:
- return VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT;
- case CBSTATUS_LOGIC_OP_SET:
- return VK_DYNAMIC_STATE_LOGIC_OP_EXT;
- case CBSTATUS_PRIMITIVE_RESTART_ENABLE_SET:
- return VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT;
- case CBSTATUS_VERTEX_INPUT_SET:
- return VK_DYNAMIC_STATE_VERTEX_INPUT_EXT;
- case CBSTATUS_COLOR_WRITE_ENABLE_SET:
- return VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT;
- case CBSTATUS_TESSELLATION_DOMAIN_ORIGIN_SET:
- return VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT;
- case CBSTATUS_DEPTH_CLAMP_ENABLE_SET:
- return VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT;
- case CBSTATUS_POLYGON_MODE_SET:
- return VK_DYNAMIC_STATE_POLYGON_MODE_EXT;
- case CBSTATUS_RASTERIZATION_SAMPLES_SET:
- return VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT;
- case CBSTATUS_SAMPLE_MASK_SET:
- return VK_DYNAMIC_STATE_SAMPLE_MASK_EXT;
- case CBSTATUS_ALPHA_TO_COVERAGE_ENABLE_SET:
- return VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT;
- case CBSTATUS_ALPHA_TO_ONE_ENABLE_SET:
- return VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT;
- case CBSTATUS_LOGIC_OP_ENABLE_SET:
- return VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT;
- case CBSTATUS_COLOR_BLEND_ENABLE_SET:
- return VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT;
- case CBSTATUS_COLOR_BLEND_EQUATION_SET:
- return VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT;
- case CBSTATUS_COLOR_WRITE_MASK_SET:
- return VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT;
- case CBSTATUS_RASTERIZATION_STREAM_SET:
- return VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT;
- case CBSTATUS_CONSERVATIVE_RASTERIZATION_MODE_SET:
- return VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT;
- case CBSTATUS_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_SET:
- return VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT;
- case CBSTATUS_DEPTH_CLIP_ENABLE_SET:
- return VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT;
- case CBSTATUS_SAMPLE_LOCATIONS_ENABLE_SET:
- return VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT;
- case CBSTATUS_COLOR_BLEND_ADVANCED_SET:
- return VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT;
- case CBSTATUS_PROVOKING_VERTEX_MODE_SET:
- return VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT;
- case CBSTATUS_LINE_RASTERIZATION_MODE_SET:
- return VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT;
- case CBSTATUS_LINE_STIPPLE_ENABLE_SET:
- return VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT;
- case CBSTATUS_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_SET:
- return VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT;
- case CBSTATUS_VIEWPORT_W_SCALING_ENABLE_SET:
- return VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV;
- case CBSTATUS_VIEWPORT_SWIZZLE_SET:
- return VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV;
- case CBSTATUS_COVERAGE_TO_COLOR_ENABLE_SET:
- return VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV;
- case CBSTATUS_COVERAGE_TO_COLOR_LOCATION_SET:
- return VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV;
- case CBSTATUS_COVERAGE_MODULATION_MODE_SET:
- return VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV;
- case CBSTATUS_COVERAGE_MODULATION_TABLE_ENABLE_SET:
- return VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV;
- case CBSTATUS_COVERAGE_MODULATION_TABLE_SET:
- return VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV;
- case CBSTATUS_SHADING_RATE_IMAGE_ENABLE_SET:
- return VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV;
- case CBSTATUS_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_SET:
- return VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV;
- case CBSTATUS_COVERAGE_REDUCTION_MODE_SET:
- return VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV;
- default:
- // CBSTATUS_INDEX_BUFFER_BOUND is not in VkDynamicState
- return VK_DYNAMIC_STATE_MAX_ENUM;
- }
- return VK_DYNAMIC_STATE_MAX_ENUM;
-}
-
-CBStatus ConvertToCBStatus(VkDynamicState state) {
- switch (state) {
- case VK_DYNAMIC_STATE_VIEWPORT:
- return CBSTATUS_VIEWPORT_SET;
- case VK_DYNAMIC_STATE_SCISSOR:
- return CBSTATUS_SCISSOR_SET;
- case VK_DYNAMIC_STATE_LINE_WIDTH:
- return CBSTATUS_LINE_WIDTH_SET;
- case VK_DYNAMIC_STATE_DEPTH_BIAS:
- return CBSTATUS_DEPTH_BIAS_SET;
- case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
- return CBSTATUS_BLEND_CONSTANTS_SET;
- case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
- return CBSTATUS_DEPTH_BOUNDS_SET;
- case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
- return CBSTATUS_STENCIL_READ_MASK_SET;
- case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
- return CBSTATUS_STENCIL_WRITE_MASK_SET;
- case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
- return CBSTATUS_STENCIL_REFERENCE_SET;
- case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
- return CBSTATUS_VIEWPORT_W_SCALING_SET;
- case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
- return CBSTATUS_DISCARD_RECTANGLE_SET;
- case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
- return CBSTATUS_SAMPLE_LOCATIONS_SET;
- case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
- return CBSTATUS_SHADING_RATE_PALETTE_SET;
- case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV:
- return CBSTATUS_COARSE_SAMPLE_ORDER_SET;
- case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
- return CBSTATUS_EXCLUSIVE_SCISSOR_SET;
- case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
- return CBSTATUS_LINE_STIPPLE_SET;
- case VK_DYNAMIC_STATE_CULL_MODE_EXT:
- return CBSTATUS_CULL_MODE_SET;
- case VK_DYNAMIC_STATE_FRONT_FACE_EXT:
- return CBSTATUS_FRONT_FACE_SET;
- case VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT:
- return CBSTATUS_PRIMITIVE_TOPOLOGY_SET;
- case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT:
- return CBSTATUS_VIEWPORT_WITH_COUNT_SET;
- case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT:
- return CBSTATUS_SCISSOR_WITH_COUNT_SET;
- case VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT:
- return CBSTATUS_VERTEX_INPUT_BINDING_STRIDE_SET;
- case VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT:
- return CBSTATUS_DEPTH_TEST_ENABLE_SET;
- case VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT:
- return CBSTATUS_DEPTH_WRITE_ENABLE_SET;
- case VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT:
- return CBSTATUS_DEPTH_COMPARE_OP_SET;
- case VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT:
- return CBSTATUS_DEPTH_BOUNDS_TEST_ENABLE_SET;
- case VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT:
- return CBSTATUS_STENCIL_TEST_ENABLE_SET;
- case VK_DYNAMIC_STATE_STENCIL_OP_EXT:
- return CBSTATUS_STENCIL_OP_SET;
- case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
- return CBSTATUS_PATCH_CONTROL_POINTS_SET;
- case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT:
- return CBSTATUS_RASTERIZER_DISCARD_ENABLE_SET;
- case VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT:
- return CBSTATUS_DEPTH_BIAS_ENABLE_SET;
- case VK_DYNAMIC_STATE_LOGIC_OP_EXT:
- return CBSTATUS_LOGIC_OP_SET;
- case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT:
- return CBSTATUS_PRIMITIVE_RESTART_ENABLE_SET;
- case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
- return CBSTATUS_VERTEX_INPUT_SET;
- case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
- return CBSTATUS_COLOR_WRITE_ENABLE_SET;
- case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
- return CBSTATUS_TESSELLATION_DOMAIN_ORIGIN_SET;
- case VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT:
- return CBSTATUS_DEPTH_CLAMP_ENABLE_SET;
- case VK_DYNAMIC_STATE_POLYGON_MODE_EXT:
- return CBSTATUS_POLYGON_MODE_SET;
- case VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT:
- return CBSTATUS_RASTERIZATION_SAMPLES_SET;
- case VK_DYNAMIC_STATE_SAMPLE_MASK_EXT:
- return CBSTATUS_SAMPLE_MASK_SET;
- case VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT:
- return CBSTATUS_ALPHA_TO_COVERAGE_ENABLE_SET;
- case VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT:
- return CBSTATUS_ALPHA_TO_ONE_ENABLE_SET;
- case VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT:
- return CBSTATUS_LOGIC_OP_ENABLE_SET;
- case VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT:
- return CBSTATUS_COLOR_BLEND_ENABLE_SET;
- case VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT:
- return CBSTATUS_COLOR_BLEND_EQUATION_SET;
- case VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT:
- return CBSTATUS_COLOR_WRITE_MASK_SET;
- case VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT:
- return CBSTATUS_RASTERIZATION_STREAM_SET;
- case VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT:
- return CBSTATUS_CONSERVATIVE_RASTERIZATION_MODE_SET;
- case VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT:
- return CBSTATUS_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_SET;
- case VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT:
- return CBSTATUS_DEPTH_CLIP_ENABLE_SET;
- case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT:
- return CBSTATUS_SAMPLE_LOCATIONS_ENABLE_SET;
- case VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT:
- return CBSTATUS_COLOR_BLEND_ADVANCED_SET;
- case VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT:
- return CBSTATUS_PROVOKING_VERTEX_MODE_SET;
- case VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT:
- return CBSTATUS_LINE_RASTERIZATION_MODE_SET;
- case VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT:
- return CBSTATUS_LINE_STIPPLE_ENABLE_SET;
- case VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT:
- return CBSTATUS_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_SET;
- case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV:
- return CBSTATUS_VIEWPORT_W_SCALING_ENABLE_SET;
- case VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV:
- return CBSTATUS_VIEWPORT_SWIZZLE_SET;
- case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV:
- return CBSTATUS_COVERAGE_TO_COLOR_ENABLE_SET;
- case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV:
- return CBSTATUS_COVERAGE_TO_COLOR_LOCATION_SET;
- case VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV:
- return CBSTATUS_COVERAGE_MODULATION_MODE_SET;
- case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV:
- return CBSTATUS_COVERAGE_MODULATION_TABLE_ENABLE_SET;
- case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV:
- return CBSTATUS_COVERAGE_MODULATION_TABLE_SET;
- case VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV:
- return CBSTATUS_SHADING_RATE_IMAGE_ENABLE_SET;
- case VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV:
- return CBSTATUS_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_SET;
- case VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV:
- return CBSTATUS_COVERAGE_REDUCTION_MODE_SET;
- default:
- return CBSTATUS_NUM;
- }
- return CBSTATUS_NUM;
-}
-
CMD_BUFFER_STATE::CMD_BUFFER_STATE(ValidationStateTracker *dev, VkCommandBuffer cb, const VkCommandBufferAllocateInfo *pCreateInfo,
const COMMAND_POOL_STATE *pool)
: REFCOUNTED_NODE(cb, kVulkanObjectTypeCommandBuffer),
@@ -1128,8 +847,8 @@
uint32_t &used = usedViewportScissorCount;
used = std::max(used, pipelineStaticViewportCount);
used = std::max(used, pipelineStaticScissorCount);
- usedDynamicViewportCount |= dynamic_status[CBSTATUS_VIEWPORT_WITH_COUNT_SET];
- usedDynamicScissorCount |= dynamic_status[CBSTATUS_SCISSOR_WITH_COUNT_SET];
+ usedDynamicViewportCount |= dynamic_status[CB_DYNAMIC_VIEWPORT_WITH_COUNT_SET];
+ usedDynamicScissorCount |= dynamic_status[CB_DYNAMIC_SCISSOR_WITH_COUNT_SET];
}
// Generic function to handle state update for all CmdDispatch* type functions
@@ -1384,21 +1103,19 @@
void CMD_BUFFER_STATE::RecordCmd(CMD_TYPE cmd_type) { commandCount++; }
-void CMD_BUFFER_STATE::RecordStateCmd(CMD_TYPE cmd_type, CBStatus state)
-{
- CBStatusFlags state_bits;
+void CMD_BUFFER_STATE::RecordStateCmd(CMD_TYPE cmd_type, CB_DYNAMIC_STATUS state) {
+ CBDynamicFlags state_bits;
state_bits.set(state);
RecordStateCmd(cmd_type, state_bits);
}
-void CMD_BUFFER_STATE::RecordStateCmd(CMD_TYPE cmd_type, CBStatusFlags const & state_bits)
-{
+void CMD_BUFFER_STATE::RecordStateCmd(CMD_TYPE cmd_type, CBDynamicFlags const &state_bits) {
RecordCmd(cmd_type);
status |= state_bits;
static_status &= ~state_bits;
}
-void CMD_BUFFER_STATE::RecordColorWriteEnableStateCmd(CMD_TYPE cmd_type, CBStatus state, uint32_t attachment_count) {
+void CMD_BUFFER_STATE::RecordColorWriteEnableStateCmd(CMD_TYPE cmd_type, CB_DYNAMIC_STATUS state, uint32_t attachment_count) {
RecordStateCmd(cmd_type, state);
dynamicColorWriteEnableAttachmentCount = std::max(dynamicColorWriteEnableAttachmentCount, attachment_count);
}
diff --git a/layers/cmd_buffer_state.h b/layers/cmd_buffer_state.h
index 8d5d6ff..85e3ac2 100644
--- a/layers/cmd_buffer_state.h
+++ b/layers/cmd_buffer_state.h
@@ -36,8 +36,6 @@
#include "descriptor_sets.h"
#include "qfo_transfer.h"
-#include <bitset>
-
struct SUBPASS_INFO;
class FRAMEBUFFER_STATE;
class RENDER_PASS_STATE;
@@ -120,86 +118,6 @@
CB_INVALID_INCOMPLETE, // fouled before recording was completed
};
-// CB Status -- used to track status of various bindings on cmd buffer objects
-
-enum CBStatus {
- CBSTATUS_INDEX_BUFFER_BOUND = 0, // Index buffer has been set
- CBSTATUS_FIRST_DYNAMIC, // Start of the dynamic state section
- CBSTATUS_LINE_WIDTH_SET = CBSTATUS_FIRST_DYNAMIC, // Line width has been set
- CBSTATUS_DEPTH_BIAS_SET, // Depth bias has been set
- CBSTATUS_BLEND_CONSTANTS_SET, // Blend constants state has been set
- CBSTATUS_DEPTH_BOUNDS_SET, // Depth bounds state object has been set
- CBSTATUS_STENCIL_READ_MASK_SET, // Stencil read mask has been set
- CBSTATUS_STENCIL_WRITE_MASK_SET, // Stencil write mask has been set
- CBSTATUS_STENCIL_REFERENCE_SET, // Stencil reference has been set
- CBSTATUS_VIEWPORT_SET,
- CBSTATUS_SCISSOR_SET,
- CBSTATUS_EXCLUSIVE_SCISSOR_SET,
- CBSTATUS_SHADING_RATE_PALETTE_SET,
- CBSTATUS_LINE_STIPPLE_SET,
- CBSTATUS_VIEWPORT_W_SCALING_SET,
- CBSTATUS_CULL_MODE_SET,
- CBSTATUS_FRONT_FACE_SET,
- CBSTATUS_PRIMITIVE_TOPOLOGY_SET,
- CBSTATUS_VIEWPORT_WITH_COUNT_SET,
- CBSTATUS_SCISSOR_WITH_COUNT_SET,
- CBSTATUS_VERTEX_INPUT_BINDING_STRIDE_SET,
- CBSTATUS_DEPTH_TEST_ENABLE_SET,
- CBSTATUS_DEPTH_WRITE_ENABLE_SET,
- CBSTATUS_DEPTH_COMPARE_OP_SET,
- CBSTATUS_DEPTH_BOUNDS_TEST_ENABLE_SET,
- CBSTATUS_STENCIL_TEST_ENABLE_SET,
- CBSTATUS_STENCIL_OP_SET,
- CBSTATUS_DISCARD_RECTANGLE_SET,
- CBSTATUS_SAMPLE_LOCATIONS_SET,
- CBSTATUS_COARSE_SAMPLE_ORDER_SET,
- CBSTATUS_PATCH_CONTROL_POINTS_SET,
- CBSTATUS_RASTERIZER_DISCARD_ENABLE_SET,
- CBSTATUS_DEPTH_BIAS_ENABLE_SET,
- CBSTATUS_LOGIC_OP_SET,
- CBSTATUS_PRIMITIVE_RESTART_ENABLE_SET,
- CBSTATUS_VERTEX_INPUT_SET,
- CBSTATUS_COLOR_WRITE_ENABLE_SET,
- CBSTATUS_TESSELLATION_DOMAIN_ORIGIN_SET,
- CBSTATUS_DEPTH_CLAMP_ENABLE_SET,
- CBSTATUS_POLYGON_MODE_SET,
- CBSTATUS_RASTERIZATION_SAMPLES_SET,
- CBSTATUS_SAMPLE_MASK_SET,
- CBSTATUS_ALPHA_TO_COVERAGE_ENABLE_SET,
- CBSTATUS_ALPHA_TO_ONE_ENABLE_SET,
- CBSTATUS_LOGIC_OP_ENABLE_SET,
- CBSTATUS_COLOR_BLEND_ENABLE_SET,
- CBSTATUS_COLOR_BLEND_EQUATION_SET,
- CBSTATUS_COLOR_WRITE_MASK_SET,
- CBSTATUS_RASTERIZATION_STREAM_SET,
- CBSTATUS_CONSERVATIVE_RASTERIZATION_MODE_SET,
- CBSTATUS_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_SET,
- CBSTATUS_DEPTH_CLIP_ENABLE_SET,
- CBSTATUS_SAMPLE_LOCATIONS_ENABLE_SET,
- CBSTATUS_COLOR_BLEND_ADVANCED_SET,
- CBSTATUS_PROVOKING_VERTEX_MODE_SET,
- CBSTATUS_LINE_RASTERIZATION_MODE_SET,
- CBSTATUS_LINE_STIPPLE_ENABLE_SET,
- CBSTATUS_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_SET,
- CBSTATUS_VIEWPORT_W_SCALING_ENABLE_SET,
- CBSTATUS_VIEWPORT_SWIZZLE_SET,
- CBSTATUS_COVERAGE_TO_COLOR_ENABLE_SET,
- CBSTATUS_COVERAGE_TO_COLOR_LOCATION_SET,
- CBSTATUS_COVERAGE_MODULATION_MODE_SET,
- CBSTATUS_COVERAGE_MODULATION_TABLE_ENABLE_SET,
- CBSTATUS_COVERAGE_MODULATION_TABLE_SET,
- CBSTATUS_SHADING_RATE_IMAGE_ENABLE_SET,
- CBSTATUS_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_SET,
- CBSTATUS_COVERAGE_REDUCTION_MODE_SET,
- CBSTATUS_NUM,
-};
-
-typedef std::bitset<CBSTATUS_NUM> CBStatusFlags;
-
-VkDynamicState ConvertToDynamicState(CBStatus flag);
-CBStatus ConvertToCBStatus(VkDynamicState state);
-std::string DynamicStateString(CBStatusFlags const &input_value);
-
struct BufferBinding {
std::shared_ptr<BUFFER_STATE> buffer_state;
VkDeviceSize size;
@@ -258,10 +176,10 @@
bool pipeline_bound = false; // True if CmdBindPipeline has been called on this command buffer, false otherwise
typedef uint64_t ImageLayoutUpdateCount;
ImageLayoutUpdateCount image_layout_change_count; // The sequence number for changes to image layout (for cached validation)
- CBStatusFlags status; // Track status of various bindings on cmd buffer
- CBStatusFlags static_status; // All state bits provided by current graphics pipeline
+ CBDynamicFlags status; // Track status of various bindings on cmd buffer
+ CBDynamicFlags static_status; // All state bits provided by current graphics pipeline
// rather than dynamic state
- CBStatusFlags dynamic_status; // dynamic state set up in pipeline
+ CBDynamicFlags dynamic_status; // dynamic state set up in pipeline
std::string begin_rendering_func_name;
// Currently storing "lastBound" objects on per-CB basis
// long-term may want to create caches of "lastBound" states and could have
@@ -510,9 +428,9 @@
void UpdatePipelineState(CMD_TYPE cmd_type, const VkPipelineBindPoint bind_point);
virtual void RecordCmd(CMD_TYPE cmd_type);
- void RecordStateCmd(CMD_TYPE cmd_type, CBStatus state);
- void RecordStateCmd(CMD_TYPE cmd_type, CBStatusFlags const & state_bits);
- void RecordColorWriteEnableStateCmd(CMD_TYPE cmd_type, CBStatus state, uint32_t attachment_count);
+ void RecordStateCmd(CMD_TYPE cmd_type, CB_DYNAMIC_STATUS state);
+ void RecordStateCmd(CMD_TYPE cmd_type, CBDynamicFlags const &state_bits);
+ void RecordColorWriteEnableStateCmd(CMD_TYPE cmd_type, CB_DYNAMIC_STATUS state, uint32_t attachment_count);
void RecordTransferCmd(CMD_TYPE cmd_type, std::shared_ptr<BINDABLE> &&buf1, std::shared_ptr<BINDABLE> &&buf2 = nullptr);
void RecordSetEvent(CMD_TYPE cmd_type, VkEvent event, VkPipelineStageFlags2KHR stageMask);
void RecordResetEvent(CMD_TYPE cmd_type, VkEvent event, VkPipelineStageFlags2KHR stageMask);
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index 7e703af..49302ab 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -368,7 +368,8 @@
}
// Check object status for selected flag state
-bool CoreChecks::ValidateStatus(const CMD_BUFFER_STATE *pNode, CBStatus status, const char *fail_msg, const char *msg_code) const {
+bool CoreChecks::ValidateStatus(const CMD_BUFFER_STATE *pNode, CB_DYNAMIC_STATUS status, const char *fail_msg,
+ const char *msg_code) const {
if (!(pNode->status[status])) {
return LogError(pNode->commandBuffer(), msg_code, "%s: %s.", report_data->FormatHandle(pNode->commandBuffer()).c_str(),
fail_msg);
@@ -390,37 +391,37 @@
if (pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ||
pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) {
result |=
- ValidateStatus(pCB, CBSTATUS_LINE_WIDTH_SET, "Dynamic line width state not set for this command buffer", msg_code);
+ ValidateStatus(pCB, CB_DYNAMIC_LINE_WIDTH_SET, "Dynamic line width state not set for this command buffer", msg_code);
}
const auto rp_state = pPipe->RasterizationState();
if (rp_state && (rp_state->depthBiasEnable == VK_TRUE)) {
result |=
- ValidateStatus(pCB, CBSTATUS_DEPTH_BIAS_SET, "Dynamic depth bias state not set for this command buffer", msg_code);
+ ValidateStatus(pCB, CB_DYNAMIC_DEPTH_BIAS_SET, "Dynamic depth bias state not set for this command buffer", msg_code);
}
if (pPipe->BlendConstantsEnabled()) {
- result |= ValidateStatus(pCB, CBSTATUS_BLEND_CONSTANTS_SET, "Dynamic blend constants state not set for this command buffer",
- msg_code);
+ result |= ValidateStatus(pCB, CB_DYNAMIC_BLEND_CONSTANTS_SET,
+ "Dynamic blend constants state not set for this command buffer", msg_code);
}
const auto ds_state = pPipe->DepthStencilState();
if (ds_state && (ds_state->depthBoundsTestEnable == VK_TRUE)) {
- result |=
- ValidateStatus(pCB, CBSTATUS_DEPTH_BOUNDS_SET, "Dynamic depth bounds state not set for this command buffer", msg_code);
+ result |= ValidateStatus(pCB, CB_DYNAMIC_DEPTH_BOUNDS_SET, "Dynamic depth bounds state not set for this command buffer",
+ msg_code);
}
if (ds_state && (ds_state->stencilTestEnable == VK_TRUE)) {
- result |= ValidateStatus(pCB, CBSTATUS_STENCIL_READ_MASK_SET,
+ result |= ValidateStatus(pCB, CB_DYNAMIC_STENCIL_COMPARE_MASK_SET,
"Dynamic stencil read mask state not set for this command buffer", msg_code);
- result |= ValidateStatus(pCB, CBSTATUS_STENCIL_WRITE_MASK_SET,
+ result |= ValidateStatus(pCB, CB_DYNAMIC_STENCIL_WRITE_MASK_SET,
"Dynamic stencil write mask state not set for this command buffer", msg_code);
- result |= ValidateStatus(pCB, CBSTATUS_STENCIL_REFERENCE_SET,
+ result |= ValidateStatus(pCB, CB_DYNAMIC_STENCIL_REFERENCE_SET,
"Dynamic stencil reference state not set for this command buffer", msg_code);
}
if (pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ||
pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) {
const auto *line_state = LvlFindInChain<VkPipelineRasterizationLineStateCreateInfoEXT>(rp_state);
if (line_state && line_state->stippledLineEnable) {
- result |= ValidateStatus(pCB, CBSTATUS_LINE_STIPPLE_SET, "Dynamic line stipple state not set for this command buffer",
- msg_code);
+ result |= ValidateStatus(pCB, CB_DYNAMIC_LINE_STIPPLE_EXT_SET,
+ "Dynamic line stipple state not set for this command buffer", msg_code);
}
}
@@ -779,19 +780,6 @@
}
}
-std::string DynamicStateString(CBStatusFlags const &input_value) {
- std::string ret;
- for (int index = 0; index < CBSTATUS_NUM; ++index) {
- CBStatus status = static_cast<CBStatus>(index);
- if (input_value[status]) {
- if (!ret.empty()) ret.append("|");
- ret.append(string_VkDynamicState(ConvertToDynamicState(status)));
- }
- }
- if (ret.empty()) ret.append(string_VkDynamicState(ConvertToDynamicState(CBSTATUS_NUM)));
- return ret;
-}
-
bool CoreChecks::GetPhysicalDeviceImageFormatProperties(IMAGE_STATE &image_state, const char *vuid_string) const {
bool skip = false;
const auto image_create_info = image_state.createInfo;
@@ -1114,7 +1102,7 @@
}
// Verify if using dynamic state setting commands that it doesn't set up in pipeline
- CBStatusFlags invalid_status(~CBStatusFlags(1U << CBSTATUS_INDEX_BUFFER_BOUND));
+ CBDynamicFlags invalid_status(~CBDynamicFlags(0));
invalid_status &= ~pCB->dynamic_status;
invalid_status &= ~pCB->static_status;
@@ -1400,22 +1388,23 @@
}
}
- skip |= ValidateStatus(pCB, CBSTATUS_PATCH_CONTROL_POINTS_SET, "Dynamic patch control points not set for this command buffer",
- vuid.patch_control_points);
- skip |= ValidateStatus(pCB, CBSTATUS_RASTERIZER_DISCARD_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_PATCH_CONTROL_POINTS_EXT_SET,
+ "Dynamic patch control points not set for this command buffer", vuid.patch_control_points);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_RASTERIZER_DISCARD_ENABLE_SET,
"Dynamic rasterizer discard enable not set for this command buffer", vuid.rasterizer_discard_enable);
- skip |= ValidateStatus(pCB, CBSTATUS_DEPTH_BIAS_ENABLE_SET, "Dynamic depth bias enable not set for this command buffer",
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_DEPTH_BIAS_ENABLE_SET, "Dynamic depth bias enable not set for this command buffer",
vuid.depth_bias_enable);
- skip |= ValidateStatus(pCB, CBSTATUS_LOGIC_OP_SET, "Dynamic state logicOp not set for this command buffer", vuid.logic_op);
- skip |= ValidateStatus(pCB, CBSTATUS_PRIMITIVE_RESTART_ENABLE_SET,
- "Dynamic primitive restart enable not set for this command buffer", vuid.primitive_restart_enable);
- skip |= ValidateStatus(pCB, CBSTATUS_VERTEX_INPUT_BINDING_STRIDE_SET,
- "Dynamic vertex input binding stride not set for this command buffer", vuid.vertex_input_binding_stride);
skip |=
- ValidateStatus(pCB, CBSTATUS_VERTEX_INPUT_SET, "Dynamic vertex input not set for this command buffer", vuid.vertex_input);
- skip |= ValidateStatus(pCB, CBSTATUS_COLOR_WRITE_ENABLE_SET, "Dynamic color write enable not set for this command buffer",
+ ValidateStatus(pCB, CB_DYNAMIC_LOGIC_OP_EXT_SET, "Dynamic state logicOp not set for this command buffer", vuid.logic_op);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_PRIMITIVE_RESTART_ENABLE_SET,
+ "Dynamic primitive restart enable not set for this command buffer", vuid.primitive_restart_enable);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_VERTEX_INPUT_BINDING_STRIDE_SET,
+ "Dynamic vertex input binding stride not set for this command buffer", vuid.vertex_input_binding_stride);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_VERTEX_INPUT_EXT_SET, "Dynamic vertex input not set for this command buffer",
+ vuid.vertex_input);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COLOR_WRITE_ENABLE_EXT_SET, "Dynamic color write enable not set for this command buffer",
vuid.color_write_enable);
- if (IsDynamic(pPipeline, VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT) && pCB->status[CBSTATUS_COLOR_WRITE_ENABLE_SET]) {
+ if (IsDynamic(pPipeline, VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT) && pCB->status[CB_DYNAMIC_COLOR_WRITE_ENABLE_EXT_SET]) {
const auto color_blend_state = pCB->GetCurrentPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS)->ColorBlendState();
if (color_blend_state) {
uint32_t blend_attachment_count = color_blend_state->attachmentCount;
@@ -1429,12 +1418,12 @@
}
}
}
- skip |= ValidateStatus(pCB, CBSTATUS_SAMPLE_LOCATIONS_SET, "Dynamic sample locations not set for this command buffer",
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_SAMPLE_LOCATIONS_EXT_SET, "Dynamic sample locations not set for this command buffer",
vuid.dynamic_sample_locations);
// VUID {refpage}-primitiveTopology-03420
- skip |= ValidateStatus(pCB, CBSTATUS_PRIMITIVE_TOPOLOGY_SET, "Dynamic primitive topology state not set for this command buffer",
- vuid.primitive_topology);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_PRIMITIVE_TOPOLOGY_SET,
+ "Dynamic primitive topology state not set for this command buffer", vuid.primitive_topology);
if (IsDynamic(pPipeline, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT) &&
!phys_dev_ext_props.extended_dynamic_state3_props.dynamicPrimitiveTopologyUnrestricted) {
bool compatible_topology = false;
@@ -1502,67 +1491,67 @@
}
}
- skip |= ValidateStatus(pCB, CBSTATUS_TESSELLATION_DOMAIN_ORIGIN_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_TESSELLATION_DOMAIN_ORIGIN_EXT_SET,
"Dynamic tessellation domain origin state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_DEPTH_CLAMP_ENABLE_SET, "Dynamic depth clamp enable state not set for this command buffer",
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_DEPTH_CLAMP_ENABLE_EXT_SET,
+ "Dynamic depth clamp enable state not set for this command buffer", kVUIDUndefined);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_POLYGON_MODE_EXT_SET, "Dynamic polygon mode state not set for this command buffer",
kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_POLYGON_MODE_SET, "Dynamic polygon mode state not set for this command buffer",
- kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_RASTERIZATION_SAMPLES_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_RASTERIZATION_SAMPLES_EXT_SET,
"Dynamic rasterization samples state not set for this command buffer", kVUIDUndefined);
- skip |=
- ValidateStatus(pCB, CBSTATUS_SAMPLE_MASK_SET, "Dynamic sample mask state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_ALPHA_TO_COVERAGE_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_SAMPLE_MASK_EXT_SET, "Dynamic sample mask state not set for this command buffer",
+ kVUIDUndefined);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_ALPHA_TO_COVERAGE_ENABLE_EXT_SET,
"Dynamic alpha to coverage enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_ALPHA_TO_ONE_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_ALPHA_TO_ONE_ENABLE_EXT_SET,
"Dynamic alpha to one enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_LOGIC_OP_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_LOGIC_OP_ENABLE_EXT_SET,
"Dynamic logic operation enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COLOR_BLEND_ENABLE_SET, "Dynamic color blend enable state not set for this command buffer",
- kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COLOR_BLEND_EQUATION_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COLOR_BLEND_ENABLE_EXT_SET,
+ "Dynamic color blend enable state not set for this command buffer", kVUIDUndefined);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COLOR_BLEND_EQUATION_EXT_SET,
"Dynamic color blend equation state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COLOR_WRITE_MASK_SET, "Dynamic color write mask state not set for this command buffer",
- kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_RASTERIZATION_STREAM_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COLOR_WRITE_MASK_EXT_SET,
+ "Dynamic color write mask state not set for this command buffer", kVUIDUndefined);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_RASTERIZATION_STREAM_EXT_SET,
"Dynamic rasterization stream state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_CONSERVATIVE_RASTERIZATION_MODE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_CONSERVATIVE_RASTERIZATION_MODE_EXT_SET,
"Dynamic conservative rasterization mode state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT_SET,
"Dynamic extra primitive overestimation size state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_DEPTH_CLIP_ENABLE_SET, "Dynamic depth clip enable state not set for this command buffer",
- kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_SAMPLE_LOCATIONS_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_DEPTH_CLIP_ENABLE_EXT_SET,
+ "Dynamic depth clip enable state not set for this command buffer", kVUIDUndefined);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_SAMPLE_LOCATIONS_ENABLE_EXT_SET,
"Dynamic sample locations enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COLOR_BLEND_ADVANCED_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COLOR_BLEND_ADVANCED_EXT_SET,
"Dynamic color blend advanced state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_PROVOKING_VERTEX_MODE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_PROVOKING_VERTEX_MODE_EXT_SET,
"Dynamic provoking vertex mode state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_LINE_RASTERIZATION_MODE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_LINE_RASTERIZATION_MODE_EXT_SET,
"Dynamic line rasterization mode state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_LINE_STIPPLE_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_LINE_STIPPLE_ENABLE_EXT_SET,
"Dynamic line stipple enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT_SET,
"Dynamic depth clip negative one to one state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_VIEWPORT_W_SCALING_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_VIEWPORT_W_SCALING_ENABLE_NV_SET,
"Dynamic viewport W scaling enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_VIEWPORT_SWIZZLE_SET, "Dynamic viewport swizzle state not set for this command buffer",
- kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COVERAGE_TO_COLOR_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_VIEWPORT_SWIZZLE_NV_SET,
+ "Dynamic viewport swizzle state not set for this command buffer", kVUIDUndefined);
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COVERAGE_TO_COLOR_ENABLE_NV_SET,
"Dynamic coverage to color enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COVERAGE_TO_COLOR_LOCATION_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COVERAGE_TO_COLOR_LOCATION_NV_SET,
"Dynamic coverage to color location state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COVERAGE_MODULATION_MODE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COVERAGE_MODULATION_MODE_NV_SET,
"Dynamic coverage modulation mode state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COVERAGE_MODULATION_TABLE_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COVERAGE_MODULATION_TABLE_ENABLE_NV_SET,
"Dynamic coverage modulation table enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COVERAGE_MODULATION_TABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COVERAGE_MODULATION_TABLE_NV_SET,
"Dynamic coverage modulation table state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_SHADING_RATE_IMAGE_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_SHADING_RATE_IMAGE_ENABLE_NV_SET,
"Dynamic shading rate image enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV_SET,
"Dynamic representative fragment test enable state not set for this command buffer", kVUIDUndefined);
- skip |= ValidateStatus(pCB, CBSTATUS_COVERAGE_REDUCTION_MODE_SET,
+ skip |= ValidateStatus(pCB, CB_DYNAMIC_COVERAGE_REDUCTION_MODE_NV_SET,
"Dynamic coverage reduction mode state not set for this command buffer", kVUIDUndefined);
if (pPipeline->fragment_output_state->dual_source_blending &&
diff --git a/layers/core_validation.h b/layers/core_validation.h
index 1f765b8..6fcdb47 100644
--- a/layers/core_validation.h
+++ b/layers/core_validation.h
@@ -223,7 +223,7 @@
const Location& loc) const;
bool ValidateMaxTimelineSemaphoreValueDifference(const Location& loc, const SEMAPHORE_STATE& semaphore_state,
uint64_t value) const;
- bool ValidateStatus(const CMD_BUFFER_STATE* pNode, CBStatus status, const char* fail_msg, const char* msg_code) const;
+ bool ValidateStatus(const CMD_BUFFER_STATE* pNode, CB_DYNAMIC_STATUS status, const char* fail_msg, const char* msg_code) const;
bool ValidateDrawStateFlags(const CMD_BUFFER_STATE* pCB, const PIPELINE_STATE* pPipe, const char* msg_code) const;
bool LogInvalidAttachmentMessage(const char* type1_string, const RENDER_PASS_STATE* rp1_state, const char* type2_string,
const RENDER_PASS_STATE* rp2_state, uint32_t primary_attach, uint32_t secondary_attach,
diff --git a/layers/generated/command_validation.cpp b/layers/generated/command_validation.cpp
index f89605e..3412a62 100644
--- a/layers/generated/command_validation.cpp
+++ b/layers/generated/command_validation.cpp
@@ -4,7 +4,7 @@
/***************************************************************************
*
- * Copyright (c) 2021 The Khronos Group Inc.
+ * Copyright (c) 2021-2022 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -986,3 +986,315 @@
return skip;
}
+
+static VkDynamicState ConvertToDynamicState(CB_DYNAMIC_STATUS flag) {
+ switch (flag) {
+ case CB_DYNAMIC_VIEWPORT_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT;
+ case CB_DYNAMIC_SCISSOR_SET:
+ return VK_DYNAMIC_STATE_SCISSOR;
+ case CB_DYNAMIC_LINE_WIDTH_SET:
+ return VK_DYNAMIC_STATE_LINE_WIDTH;
+ case CB_DYNAMIC_DEPTH_BIAS_SET:
+ return VK_DYNAMIC_STATE_DEPTH_BIAS;
+ case CB_DYNAMIC_BLEND_CONSTANTS_SET:
+ return VK_DYNAMIC_STATE_BLEND_CONSTANTS;
+ case CB_DYNAMIC_DEPTH_BOUNDS_SET:
+ return VK_DYNAMIC_STATE_DEPTH_BOUNDS;
+ case CB_DYNAMIC_STENCIL_COMPARE_MASK_SET:
+ return VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK;
+ case CB_DYNAMIC_STENCIL_WRITE_MASK_SET:
+ return VK_DYNAMIC_STATE_STENCIL_WRITE_MASK;
+ case CB_DYNAMIC_STENCIL_REFERENCE_SET:
+ return VK_DYNAMIC_STATE_STENCIL_REFERENCE;
+ case CB_DYNAMIC_CULL_MODE_SET:
+ return VK_DYNAMIC_STATE_CULL_MODE;
+ case CB_DYNAMIC_FRONT_FACE_SET:
+ return VK_DYNAMIC_STATE_FRONT_FACE;
+ case CB_DYNAMIC_PRIMITIVE_TOPOLOGY_SET:
+ return VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY;
+ case CB_DYNAMIC_VIEWPORT_WITH_COUNT_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT;
+ case CB_DYNAMIC_SCISSOR_WITH_COUNT_SET:
+ return VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT;
+ case CB_DYNAMIC_VERTEX_INPUT_BINDING_STRIDE_SET:
+ return VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE;
+ case CB_DYNAMIC_DEPTH_TEST_ENABLE_SET:
+ return VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE;
+ case CB_DYNAMIC_DEPTH_WRITE_ENABLE_SET:
+ return VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE;
+ case CB_DYNAMIC_DEPTH_COMPARE_OP_SET:
+ return VK_DYNAMIC_STATE_DEPTH_COMPARE_OP;
+ case CB_DYNAMIC_DEPTH_BOUNDS_TEST_ENABLE_SET:
+ return VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE;
+ case CB_DYNAMIC_STENCIL_TEST_ENABLE_SET:
+ return VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE;
+ case CB_DYNAMIC_STENCIL_OP_SET:
+ return VK_DYNAMIC_STATE_STENCIL_OP;
+ case CB_DYNAMIC_RASTERIZER_DISCARD_ENABLE_SET:
+ return VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE;
+ case CB_DYNAMIC_DEPTH_BIAS_ENABLE_SET:
+ return VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE;
+ case CB_DYNAMIC_PRIMITIVE_RESTART_ENABLE_SET:
+ return VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE;
+ case CB_DYNAMIC_VIEWPORT_W_SCALING_NV_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV;
+ case CB_DYNAMIC_DISCARD_RECTANGLE_EXT_SET:
+ return VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT;
+ case CB_DYNAMIC_SAMPLE_LOCATIONS_EXT_SET:
+ return VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT;
+ case CB_DYNAMIC_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_SET:
+ return VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR;
+ case CB_DYNAMIC_VIEWPORT_SHADING_RATE_PALETTE_NV_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV;
+ case CB_DYNAMIC_VIEWPORT_COARSE_SAMPLE_ORDER_NV_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV;
+ case CB_DYNAMIC_EXCLUSIVE_SCISSOR_NV_SET:
+ return VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV;
+ case CB_DYNAMIC_FRAGMENT_SHADING_RATE_KHR_SET:
+ return VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR;
+ case CB_DYNAMIC_LINE_STIPPLE_EXT_SET:
+ return VK_DYNAMIC_STATE_LINE_STIPPLE_EXT;
+ case CB_DYNAMIC_VERTEX_INPUT_EXT_SET:
+ return VK_DYNAMIC_STATE_VERTEX_INPUT_EXT;
+ case CB_DYNAMIC_PATCH_CONTROL_POINTS_EXT_SET:
+ return VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT;
+ case CB_DYNAMIC_LOGIC_OP_EXT_SET:
+ return VK_DYNAMIC_STATE_LOGIC_OP_EXT;
+ case CB_DYNAMIC_COLOR_WRITE_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT;
+ case CB_DYNAMIC_TESSELLATION_DOMAIN_ORIGIN_EXT_SET:
+ return VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT;
+ case CB_DYNAMIC_DEPTH_CLAMP_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT;
+ case CB_DYNAMIC_POLYGON_MODE_EXT_SET:
+ return VK_DYNAMIC_STATE_POLYGON_MODE_EXT;
+ case CB_DYNAMIC_RASTERIZATION_SAMPLES_EXT_SET:
+ return VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT;
+ case CB_DYNAMIC_SAMPLE_MASK_EXT_SET:
+ return VK_DYNAMIC_STATE_SAMPLE_MASK_EXT;
+ case CB_DYNAMIC_ALPHA_TO_COVERAGE_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT;
+ case CB_DYNAMIC_ALPHA_TO_ONE_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT;
+ case CB_DYNAMIC_LOGIC_OP_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT;
+ case CB_DYNAMIC_COLOR_BLEND_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT;
+ case CB_DYNAMIC_COLOR_BLEND_EQUATION_EXT_SET:
+ return VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT;
+ case CB_DYNAMIC_COLOR_WRITE_MASK_EXT_SET:
+ return VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT;
+ case CB_DYNAMIC_RASTERIZATION_STREAM_EXT_SET:
+ return VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT;
+ case CB_DYNAMIC_CONSERVATIVE_RASTERIZATION_MODE_EXT_SET:
+ return VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT;
+ case CB_DYNAMIC_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT_SET:
+ return VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT;
+ case CB_DYNAMIC_DEPTH_CLIP_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT;
+ case CB_DYNAMIC_SAMPLE_LOCATIONS_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT;
+ case CB_DYNAMIC_COLOR_BLEND_ADVANCED_EXT_SET:
+ return VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT;
+ case CB_DYNAMIC_PROVOKING_VERTEX_MODE_EXT_SET:
+ return VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT;
+ case CB_DYNAMIC_LINE_RASTERIZATION_MODE_EXT_SET:
+ return VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT;
+ case CB_DYNAMIC_LINE_STIPPLE_ENABLE_EXT_SET:
+ return VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT;
+ case CB_DYNAMIC_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT_SET:
+ return VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT;
+ case CB_DYNAMIC_VIEWPORT_W_SCALING_ENABLE_NV_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV;
+ case CB_DYNAMIC_VIEWPORT_SWIZZLE_NV_SET:
+ return VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV;
+ case CB_DYNAMIC_COVERAGE_TO_COLOR_ENABLE_NV_SET:
+ return VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV;
+ case CB_DYNAMIC_COVERAGE_TO_COLOR_LOCATION_NV_SET:
+ return VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV;
+ case CB_DYNAMIC_COVERAGE_MODULATION_MODE_NV_SET:
+ return VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV;
+ case CB_DYNAMIC_COVERAGE_MODULATION_TABLE_ENABLE_NV_SET:
+ return VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV;
+ case CB_DYNAMIC_COVERAGE_MODULATION_TABLE_NV_SET:
+ return VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV;
+ case CB_DYNAMIC_SHADING_RATE_IMAGE_ENABLE_NV_SET:
+ return VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV;
+ case CB_DYNAMIC_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV_SET:
+ return VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV;
+ case CB_DYNAMIC_COVERAGE_REDUCTION_MODE_NV_SET:
+ return VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV;
+ default:
+ return VK_DYNAMIC_STATE_MAX_ENUM;
+ }
+}
+
+static CB_DYNAMIC_STATUS ConvertToCBDynamicStatus(VkDynamicState state) {
+ switch (state) {
+ case VK_DYNAMIC_STATE_VIEWPORT:
+ return CB_DYNAMIC_VIEWPORT_SET;
+ case VK_DYNAMIC_STATE_SCISSOR:
+ return CB_DYNAMIC_SCISSOR_SET;
+ case VK_DYNAMIC_STATE_LINE_WIDTH:
+ return CB_DYNAMIC_LINE_WIDTH_SET;
+ case VK_DYNAMIC_STATE_DEPTH_BIAS:
+ return CB_DYNAMIC_DEPTH_BIAS_SET;
+ case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
+ return CB_DYNAMIC_BLEND_CONSTANTS_SET;
+ case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
+ return CB_DYNAMIC_DEPTH_BOUNDS_SET;
+ case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
+ return CB_DYNAMIC_STENCIL_COMPARE_MASK_SET;
+ case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
+ return CB_DYNAMIC_STENCIL_WRITE_MASK_SET;
+ case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
+ return CB_DYNAMIC_STENCIL_REFERENCE_SET;
+ case VK_DYNAMIC_STATE_CULL_MODE:
+ return CB_DYNAMIC_CULL_MODE_SET;
+ case VK_DYNAMIC_STATE_FRONT_FACE:
+ return CB_DYNAMIC_FRONT_FACE_SET;
+ case VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY:
+ return CB_DYNAMIC_PRIMITIVE_TOPOLOGY_SET;
+ case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT:
+ return CB_DYNAMIC_VIEWPORT_WITH_COUNT_SET;
+ case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT:
+ return CB_DYNAMIC_SCISSOR_WITH_COUNT_SET;
+ case VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE:
+ return CB_DYNAMIC_VERTEX_INPUT_BINDING_STRIDE_SET;
+ case VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE:
+ return CB_DYNAMIC_DEPTH_TEST_ENABLE_SET;
+ case VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE:
+ return CB_DYNAMIC_DEPTH_WRITE_ENABLE_SET;
+ case VK_DYNAMIC_STATE_DEPTH_COMPARE_OP:
+ return CB_DYNAMIC_DEPTH_COMPARE_OP_SET;
+ case VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE:
+ return CB_DYNAMIC_DEPTH_BOUNDS_TEST_ENABLE_SET;
+ case VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE:
+ return CB_DYNAMIC_STENCIL_TEST_ENABLE_SET;
+ case VK_DYNAMIC_STATE_STENCIL_OP:
+ return CB_DYNAMIC_STENCIL_OP_SET;
+ case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE:
+ return CB_DYNAMIC_RASTERIZER_DISCARD_ENABLE_SET;
+ case VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE:
+ return CB_DYNAMIC_DEPTH_BIAS_ENABLE_SET;
+ case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE:
+ return CB_DYNAMIC_PRIMITIVE_RESTART_ENABLE_SET;
+ case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
+ return CB_DYNAMIC_VIEWPORT_W_SCALING_NV_SET;
+ case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
+ return CB_DYNAMIC_DISCARD_RECTANGLE_EXT_SET;
+ case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
+ return CB_DYNAMIC_SAMPLE_LOCATIONS_EXT_SET;
+ case VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR:
+ return CB_DYNAMIC_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_SET;
+ case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
+ return CB_DYNAMIC_VIEWPORT_SHADING_RATE_PALETTE_NV_SET;
+ case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV:
+ return CB_DYNAMIC_VIEWPORT_COARSE_SAMPLE_ORDER_NV_SET;
+ case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
+ return CB_DYNAMIC_EXCLUSIVE_SCISSOR_NV_SET;
+ case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR:
+ return CB_DYNAMIC_FRAGMENT_SHADING_RATE_KHR_SET;
+ case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
+ return CB_DYNAMIC_LINE_STIPPLE_EXT_SET;
+ case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
+ return CB_DYNAMIC_VERTEX_INPUT_EXT_SET;
+ case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
+ return CB_DYNAMIC_PATCH_CONTROL_POINTS_EXT_SET;
+ case VK_DYNAMIC_STATE_LOGIC_OP_EXT:
+ return CB_DYNAMIC_LOGIC_OP_EXT_SET;
+ case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
+ return CB_DYNAMIC_COLOR_WRITE_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
+ return CB_DYNAMIC_TESSELLATION_DOMAIN_ORIGIN_EXT_SET;
+ case VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT:
+ return CB_DYNAMIC_DEPTH_CLAMP_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_POLYGON_MODE_EXT:
+ return CB_DYNAMIC_POLYGON_MODE_EXT_SET;
+ case VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT:
+ return CB_DYNAMIC_RASTERIZATION_SAMPLES_EXT_SET;
+ case VK_DYNAMIC_STATE_SAMPLE_MASK_EXT:
+ return CB_DYNAMIC_SAMPLE_MASK_EXT_SET;
+ case VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT:
+ return CB_DYNAMIC_ALPHA_TO_COVERAGE_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT:
+ return CB_DYNAMIC_ALPHA_TO_ONE_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT:
+ return CB_DYNAMIC_LOGIC_OP_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT:
+ return CB_DYNAMIC_COLOR_BLEND_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT:
+ return CB_DYNAMIC_COLOR_BLEND_EQUATION_EXT_SET;
+ case VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT:
+ return CB_DYNAMIC_COLOR_WRITE_MASK_EXT_SET;
+ case VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT:
+ return CB_DYNAMIC_RASTERIZATION_STREAM_EXT_SET;
+ case VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT:
+ return CB_DYNAMIC_CONSERVATIVE_RASTERIZATION_MODE_EXT_SET;
+ case VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT:
+ return CB_DYNAMIC_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT_SET;
+ case VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT:
+ return CB_DYNAMIC_DEPTH_CLIP_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT:
+ return CB_DYNAMIC_SAMPLE_LOCATIONS_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT:
+ return CB_DYNAMIC_COLOR_BLEND_ADVANCED_EXT_SET;
+ case VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT:
+ return CB_DYNAMIC_PROVOKING_VERTEX_MODE_EXT_SET;
+ case VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT:
+ return CB_DYNAMIC_LINE_RASTERIZATION_MODE_EXT_SET;
+ case VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT:
+ return CB_DYNAMIC_LINE_STIPPLE_ENABLE_EXT_SET;
+ case VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT:
+ return CB_DYNAMIC_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT_SET;
+ case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV:
+ return CB_DYNAMIC_VIEWPORT_W_SCALING_ENABLE_NV_SET;
+ case VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV:
+ return CB_DYNAMIC_VIEWPORT_SWIZZLE_NV_SET;
+ case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV:
+ return CB_DYNAMIC_COVERAGE_TO_COLOR_ENABLE_NV_SET;
+ case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV:
+ return CB_DYNAMIC_COVERAGE_TO_COLOR_LOCATION_NV_SET;
+ case VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV:
+ return CB_DYNAMIC_COVERAGE_MODULATION_MODE_NV_SET;
+ case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV:
+ return CB_DYNAMIC_COVERAGE_MODULATION_TABLE_ENABLE_NV_SET;
+ case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV:
+ return CB_DYNAMIC_COVERAGE_MODULATION_TABLE_NV_SET;
+ case VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV:
+ return CB_DYNAMIC_SHADING_RATE_IMAGE_ENABLE_NV_SET;
+ case VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV:
+ return CB_DYNAMIC_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV_SET;
+ case VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV:
+ return CB_DYNAMIC_COVERAGE_REDUCTION_MODE_NV_SET;
+ default:
+ return CB_DYNAMIC_STATUS_NUM;
+ }
+}
+
+std::string DynamicStateString(CBDynamicFlags const &dynamic_state) {
+ std::string ret;
+ for (int index = 0; index < CB_DYNAMIC_STATUS_NUM; ++index) {
+ CB_DYNAMIC_STATUS status = static_cast<CB_DYNAMIC_STATUS>(index);
+ if (dynamic_state[status]) {
+ if (!ret.empty()) ret.append("|");
+ ret.append(string_VkDynamicState(ConvertToDynamicState(status)));
+ }
+ }
+ if (ret.empty()) ret.append(string_VkDynamicState(ConvertToDynamicState(CB_DYNAMIC_STATUS_NUM)));
+ return ret;
+}
+
+CBDynamicFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *info) {
+ // initially assume everything is static state
+ CBDynamicFlags flags(~CBDynamicFlags(0));
+
+ if (info) {
+ for (uint32_t i = 0; i < info->dynamicStateCount; i++) {
+ flags.reset(ConvertToCBDynamicStatus(info->pDynamicStates[i]));
+ }
+ }
+ return flags;
+}
+
diff --git a/layers/generated/command_validation.h b/layers/generated/command_validation.h
index d110929..111cef4 100644
--- a/layers/generated/command_validation.h
+++ b/layers/generated/command_validation.h
@@ -4,7 +4,7 @@
/***************************************************************************
*
- * Copyright (c) 2021 The Khronos Group Inc.
+ * Copyright (c) 2021-2022 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@
#pragma once
#include <array>
+#include <bitset>
// Used as key for maps of all vkCmd* calls
// Does not include vkBeginCommandBuffer/vkEndCommandBuffer
@@ -479,3 +480,81 @@
"vkCmdWriteTimestamp2",
"vkCmdWriteTimestamp2KHR",
}};
+
+typedef enum CB_DYNAMIC_STATUS {
+ CB_DYNAMIC_VIEWPORT_SET = 1,
+ CB_DYNAMIC_SCISSOR_SET = 2,
+ CB_DYNAMIC_LINE_WIDTH_SET = 3,
+ CB_DYNAMIC_DEPTH_BIAS_SET = 4,
+ CB_DYNAMIC_BLEND_CONSTANTS_SET = 5,
+ CB_DYNAMIC_DEPTH_BOUNDS_SET = 6,
+ CB_DYNAMIC_STENCIL_COMPARE_MASK_SET = 7,
+ CB_DYNAMIC_STENCIL_WRITE_MASK_SET = 8,
+ CB_DYNAMIC_STENCIL_REFERENCE_SET = 9,
+ CB_DYNAMIC_CULL_MODE_SET = 10,
+ CB_DYNAMIC_FRONT_FACE_SET = 11,
+ CB_DYNAMIC_PRIMITIVE_TOPOLOGY_SET = 12,
+ CB_DYNAMIC_VIEWPORT_WITH_COUNT_SET = 13,
+ CB_DYNAMIC_SCISSOR_WITH_COUNT_SET = 14,
+ CB_DYNAMIC_VERTEX_INPUT_BINDING_STRIDE_SET = 15,
+ CB_DYNAMIC_DEPTH_TEST_ENABLE_SET = 16,
+ CB_DYNAMIC_DEPTH_WRITE_ENABLE_SET = 17,
+ CB_DYNAMIC_DEPTH_COMPARE_OP_SET = 18,
+ CB_DYNAMIC_DEPTH_BOUNDS_TEST_ENABLE_SET = 19,
+ CB_DYNAMIC_STENCIL_TEST_ENABLE_SET = 20,
+ CB_DYNAMIC_STENCIL_OP_SET = 21,
+ CB_DYNAMIC_RASTERIZER_DISCARD_ENABLE_SET = 22,
+ CB_DYNAMIC_DEPTH_BIAS_ENABLE_SET = 23,
+ CB_DYNAMIC_PRIMITIVE_RESTART_ENABLE_SET = 24,
+ CB_DYNAMIC_VIEWPORT_W_SCALING_NV_SET = 25,
+ CB_DYNAMIC_DISCARD_RECTANGLE_EXT_SET = 26,
+ CB_DYNAMIC_SAMPLE_LOCATIONS_EXT_SET = 27,
+ CB_DYNAMIC_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_SET = 28,
+ CB_DYNAMIC_VIEWPORT_SHADING_RATE_PALETTE_NV_SET = 29,
+ CB_DYNAMIC_VIEWPORT_COARSE_SAMPLE_ORDER_NV_SET = 30,
+ CB_DYNAMIC_EXCLUSIVE_SCISSOR_NV_SET = 31,
+ CB_DYNAMIC_FRAGMENT_SHADING_RATE_KHR_SET = 32,
+ CB_DYNAMIC_LINE_STIPPLE_EXT_SET = 33,
+ CB_DYNAMIC_VERTEX_INPUT_EXT_SET = 34,
+ CB_DYNAMIC_PATCH_CONTROL_POINTS_EXT_SET = 35,
+ CB_DYNAMIC_LOGIC_OP_EXT_SET = 36,
+ CB_DYNAMIC_COLOR_WRITE_ENABLE_EXT_SET = 37,
+ CB_DYNAMIC_TESSELLATION_DOMAIN_ORIGIN_EXT_SET = 38,
+ CB_DYNAMIC_DEPTH_CLAMP_ENABLE_EXT_SET = 39,
+ CB_DYNAMIC_POLYGON_MODE_EXT_SET = 40,
+ CB_DYNAMIC_RASTERIZATION_SAMPLES_EXT_SET = 41,
+ CB_DYNAMIC_SAMPLE_MASK_EXT_SET = 42,
+ CB_DYNAMIC_ALPHA_TO_COVERAGE_ENABLE_EXT_SET = 43,
+ CB_DYNAMIC_ALPHA_TO_ONE_ENABLE_EXT_SET = 44,
+ CB_DYNAMIC_LOGIC_OP_ENABLE_EXT_SET = 45,
+ CB_DYNAMIC_COLOR_BLEND_ENABLE_EXT_SET = 46,
+ CB_DYNAMIC_COLOR_BLEND_EQUATION_EXT_SET = 47,
+ CB_DYNAMIC_COLOR_WRITE_MASK_EXT_SET = 48,
+ CB_DYNAMIC_RASTERIZATION_STREAM_EXT_SET = 49,
+ CB_DYNAMIC_CONSERVATIVE_RASTERIZATION_MODE_EXT_SET = 50,
+ CB_DYNAMIC_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT_SET = 51,
+ CB_DYNAMIC_DEPTH_CLIP_ENABLE_EXT_SET = 52,
+ CB_DYNAMIC_SAMPLE_LOCATIONS_ENABLE_EXT_SET = 53,
+ CB_DYNAMIC_COLOR_BLEND_ADVANCED_EXT_SET = 54,
+ CB_DYNAMIC_PROVOKING_VERTEX_MODE_EXT_SET = 55,
+ CB_DYNAMIC_LINE_RASTERIZATION_MODE_EXT_SET = 56,
+ CB_DYNAMIC_LINE_STIPPLE_ENABLE_EXT_SET = 57,
+ CB_DYNAMIC_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT_SET = 58,
+ CB_DYNAMIC_VIEWPORT_W_SCALING_ENABLE_NV_SET = 59,
+ CB_DYNAMIC_VIEWPORT_SWIZZLE_NV_SET = 60,
+ CB_DYNAMIC_COVERAGE_TO_COLOR_ENABLE_NV_SET = 61,
+ CB_DYNAMIC_COVERAGE_TO_COLOR_LOCATION_NV_SET = 62,
+ CB_DYNAMIC_COVERAGE_MODULATION_MODE_NV_SET = 63,
+ CB_DYNAMIC_COVERAGE_MODULATION_TABLE_ENABLE_NV_SET = 64,
+ CB_DYNAMIC_COVERAGE_MODULATION_TABLE_NV_SET = 65,
+ CB_DYNAMIC_SHADING_RATE_IMAGE_ENABLE_NV_SET = 66,
+ CB_DYNAMIC_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV_SET = 67,
+ CB_DYNAMIC_COVERAGE_REDUCTION_MODE_NV_SET = 68,
+ CB_DYNAMIC_STATUS_NUM = 69
+} CB_DYNAMIC_STATUS;
+
+typedef std::bitset<CB_DYNAMIC_STATUS_NUM> CBDynamicFlags;
+std::string DynamicStateString(CBDynamicFlags const &dynamic_state);
+struct VkPipelineDynamicStateCreateInfo;
+CBDynamicFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *info);
+
diff --git a/layers/state_tracker.cpp b/layers/state_tracker.cpp
index d2b01bd..c33575d 100644
--- a/layers/state_tracker.cpp
+++ b/layers/state_tracker.cpp
@@ -2536,18 +2536,6 @@
}
}
-CBStatusFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *ds) {
- // initially assume everything is static state
- CBStatusFlags flags(~CBStatusFlags(1U << CBSTATUS_INDEX_BUFFER_BOUND));
-
- if (ds) {
- for (uint32_t i = 0; i < ds->dynamicStateCount; i++) {
- flags.reset(ConvertToCBStatus(ds->pDynamicStates[i]));
- }
- }
- return flags;
-}
-
// Validation cache:
// CV is the bottommost implementor of this extension. Don't pass calls down.
@@ -2566,14 +2554,14 @@
cb_state->status &= ~cb_state->static_status;
cb_state->static_status = MakeStaticStateMask(dynamic_state ? dynamic_state->ptr() : nullptr);
cb_state->status |= cb_state->static_status;
- cb_state->dynamic_status = ~CBStatusFlags(1U << CBSTATUS_INDEX_BUFFER_BOUND);
+ cb_state->dynamic_status = ~CBDynamicFlags(0);
cb_state->dynamic_status &= ~cb_state->static_status;
// Used to calculate CMD_BUFFER_STATE::usedViewportScissorCount upon draw command with this graphics pipeline.
// If rasterization disabled (no viewport/scissors used), or the actual number of viewports/scissors is dynamic (unknown at
// this time), then these are set to 0 to disable this checking.
- auto has_dynamic_viewport_count = cb_state->dynamic_status[CBSTATUS_VIEWPORT_WITH_COUNT_SET];
- auto has_dynamic_scissor_count = cb_state->dynamic_status[CBSTATUS_SCISSOR_WITH_COUNT_SET];
+ auto has_dynamic_viewport_count = cb_state->dynamic_status[CB_DYNAMIC_VIEWPORT_WITH_COUNT_SET];
+ auto has_dynamic_scissor_count = cb_state->dynamic_status[CB_DYNAMIC_SCISSOR_WITH_COUNT_SET];
cb_state->pipelineStaticViewportCount =
has_dynamic_viewport_count || !rasterization_enabled ? 0 : viewport_state->viewportCount;
cb_state->pipelineStaticScissorCount =
@@ -2585,14 +2573,14 @@
// I am taking the latter interpretation based on the implementation details of NVIDIA's Vulkan driver.
if (!has_dynamic_viewport_count) {
cb_state->trashedViewportCount = true;
- if (rasterization_enabled && (cb_state->static_status[CBSTATUS_VIEWPORT_SET])) {
+ if (rasterization_enabled && (cb_state->static_status[CB_DYNAMIC_VIEWPORT_SET])) {
cb_state->trashedViewportMask |= (uint32_t(1) << viewport_state->viewportCount) - 1u;
// should become = ~uint32_t(0) if the other interpretation is correct.
}
}
if (!has_dynamic_scissor_count) {
cb_state->trashedScissorCount = true;
- if (rasterization_enabled && (cb_state->static_status[CBSTATUS_SCISSOR_SET])) {
+ if (rasterization_enabled && (cb_state->static_status[CB_DYNAMIC_SCISSOR_SET])) {
cb_state->trashedScissorMask |= (uint32_t(1) << viewport_state->scissorCount) - 1u;
// should become = ~uint32_t(0) if the other interpretation is correct.
}
@@ -2607,7 +2595,7 @@
void ValidationStateTracker::PreCallRecordCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
uint32_t viewportCount, const VkViewport *pViewports) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETVIEWPORT, CBSTATUS_VIEWPORT_SET);
+ cb_state->RecordStateCmd(CMD_SETVIEWPORT, CB_DYNAMIC_VIEWPORT_SET);
uint32_t bits = ((1u << viewportCount) - 1u) << firstViewport;
cb_state->viewportMask |= bits;
cb_state->trashedViewportMask &= ~bits;
@@ -2622,7 +2610,7 @@
uint32_t exclusiveScissorCount,
const VkRect2D *pExclusiveScissors) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETEXCLUSIVESCISSORNV, CBSTATUS_EXCLUSIVE_SCISSOR_SET);
+ cb_state->RecordStateCmd(CMD_SETEXCLUSIVESCISSORNV, CB_DYNAMIC_EXCLUSIVE_SCISSOR_NV_SET);
// TODO: We don't have VUIDs for validating that all exclusive scissors have been set.
// cb_state->exclusiveScissorMask |= ((1u << exclusiveScissorCount) - 1u) << firstExclusiveScissor;
}
@@ -2644,7 +2632,7 @@
uint32_t viewportCount,
const VkShadingRatePaletteNV *pShadingRatePalettes) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETVIEWPORTSHADINGRATEPALETTENV, CBSTATUS_SHADING_RATE_PALETTE_SET);
+ cb_state->RecordStateCmd(CMD_SETVIEWPORTSHADINGRATEPALETTENV, CB_DYNAMIC_VIEWPORT_SHADING_RATE_PALETTE_NV_SET);
// TODO: We don't have VUIDs for validating that all shading rate palettes have been set.
// cb_state->shadingRatePaletteMask |= ((1u << viewportCount) - 1u) << firstViewport;
}
@@ -2912,30 +2900,30 @@
uint32_t viewportCount,
const VkViewportWScalingNV *pViewportWScalings) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETVIEWPORTWSCALINGNV, CBSTATUS_VIEWPORT_W_SCALING_SET);
+ cb_state->RecordStateCmd(CMD_SETVIEWPORTWSCALINGNV, CB_DYNAMIC_VIEWPORT_W_SCALING_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETLINEWIDTH, CBSTATUS_LINE_WIDTH_SET);
+ cb_state->RecordStateCmd(CMD_SETLINEWIDTH, CB_DYNAMIC_LINE_WIDTH_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
uint16_t lineStipplePattern) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETLINESTIPPLEEXT, CBSTATUS_LINE_STIPPLE_SET);
+ cb_state->RecordStateCmd(CMD_SETLINESTIPPLEEXT, CB_DYNAMIC_LINE_STIPPLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
float depthBiasClamp, float depthBiasSlopeFactor) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHBIAS, CBSTATUS_DEPTH_BIAS_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHBIAS, CB_DYNAMIC_DEPTH_BIAS_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
const VkRect2D *pScissors) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSCISSOR, CBSTATUS_SCISSOR_SET);
+ cb_state->RecordStateCmd(CMD_SETSCISSOR, CB_DYNAMIC_SCISSOR_SET);
uint32_t bits = ((1u << scissorCount) - 1u) << firstScissor;
cb_state->scissorMask |= bits;
cb_state->trashedScissorMask &= ~bits;
@@ -2943,31 +2931,31 @@
void ValidationStateTracker::PreCallRecordCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETBLENDCONSTANTS, CBSTATUS_BLEND_CONSTANTS_SET);
+ cb_state->RecordStateCmd(CMD_SETBLENDCONSTANTS, CB_DYNAMIC_BLEND_CONSTANTS_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
float maxDepthBounds) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHBOUNDS, CBSTATUS_DEPTH_BOUNDS_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHBOUNDS, CB_DYNAMIC_DEPTH_BOUNDS_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t compareMask) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILCOMPAREMASK, CBSTATUS_STENCIL_READ_MASK_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILCOMPAREMASK, CB_DYNAMIC_STENCIL_COMPARE_MASK_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t writeMask) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILWRITEMASK, CBSTATUS_STENCIL_WRITE_MASK_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILWRITEMASK, CB_DYNAMIC_STENCIL_WRITE_MASK_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t reference) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILREFERENCE, CBSTATUS_STENCIL_REFERENCE_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILREFERENCE, CB_DYNAMIC_STENCIL_REFERENCE_SET);
}
// Update the bound state for the bind point, including the effects of incompatible pipeline layouts
@@ -4681,42 +4669,42 @@
void ValidationStateTracker::PreCallRecordCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCULLMODEEXT, CBSTATUS_CULL_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETCULLMODEEXT, CB_DYNAMIC_CULL_MODE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCULLMODE, CBSTATUS_CULL_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETCULLMODE, CB_DYNAMIC_CULL_MODE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETFRONTFACEEXT, CBSTATUS_FRONT_FACE_SET);
+ cb_state->RecordStateCmd(CMD_SETFRONTFACEEXT, CB_DYNAMIC_FRONT_FACE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETFRONTFACE, CBSTATUS_FRONT_FACE_SET);
+ cb_state->RecordStateCmd(CMD_SETFRONTFACE, CB_DYNAMIC_FRONT_FACE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
VkPrimitiveTopology primitiveTopology) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPRIMITIVETOPOLOGYEXT, CBSTATUS_PRIMITIVE_TOPOLOGY_SET);
+ cb_state->RecordStateCmd(CMD_SETPRIMITIVETOPOLOGYEXT, CB_DYNAMIC_PRIMITIVE_TOPOLOGY_SET);
cb_state->primitiveTopology = primitiveTopology;
}
void ValidationStateTracker::PreCallRecordCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
VkPrimitiveTopology primitiveTopology) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPRIMITIVETOPOLOGY, CBSTATUS_PRIMITIVE_TOPOLOGY_SET);
+ cb_state->RecordStateCmd(CMD_SETPRIMITIVETOPOLOGY, CB_DYNAMIC_PRIMITIVE_TOPOLOGY_SET);
cb_state->primitiveTopology = primitiveTopology;
}
void ValidationStateTracker::RecordCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
const VkViewport *pViewports, CMD_TYPE cmdType) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(cmdType, CBSTATUS_VIEWPORT_WITH_COUNT_SET);
+ cb_state->RecordStateCmd(cmdType, CB_DYNAMIC_VIEWPORT_WITH_COUNT_SET);
uint32_t bits = (1u << viewportCount) - 1u;
cb_state->viewportWithCountMask |= bits;
cb_state->trashedViewportMask &= ~bits;
@@ -4742,7 +4730,7 @@
void ValidationStateTracker::RecordCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
const VkRect2D *pScissors, CMD_TYPE cmdType) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(cmdType, CBSTATUS_SCISSOR_WITH_COUNT_SET);
+ cb_state->RecordStateCmd(cmdType, CB_DYNAMIC_SCISSOR_WITH_COUNT_SET);
uint32_t bits = (1u << scissorCount) - 1u;
cb_state->scissorWithCountMask |= bits;
cb_state->trashedScissorMask &= ~bits;
@@ -4766,7 +4754,7 @@
const VkDeviceSize *pStrides, CMD_TYPE cmd_type) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
if (pStrides) {
- cb_state->RecordStateCmd(cmd_type, CBSTATUS_VERTEX_INPUT_BINDING_STRIDE_SET);
+ cb_state->RecordStateCmd(cmd_type, CB_DYNAMIC_VERTEX_INPUT_BINDING_STRIDE_SET);
}
uint32_t end = firstBinding + bindingCount;
@@ -4805,81 +4793,81 @@
void ValidationStateTracker::PreCallRecordCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHTESTENABLEEXT, CBSTATUS_DEPTH_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHTESTENABLEEXT, CB_DYNAMIC_DEPTH_TEST_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHTESTENABLE, CBSTATUS_DEPTH_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHTESTENABLE, CB_DYNAMIC_DEPTH_TEST_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHWRITEENABLEEXT, CBSTATUS_DEPTH_WRITE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHWRITEENABLEEXT, CB_DYNAMIC_DEPTH_WRITE_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHWRITEENABLE, CBSTATUS_DEPTH_WRITE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHWRITEENABLE, CB_DYNAMIC_DEPTH_WRITE_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHCOMPAREOPEXT, CBSTATUS_DEPTH_COMPARE_OP_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHCOMPAREOPEXT, CB_DYNAMIC_DEPTH_COMPARE_OP_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHCOMPAREOP, CBSTATUS_DEPTH_COMPARE_OP_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHCOMPAREOP, CB_DYNAMIC_DEPTH_COMPARE_OP_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 depthBoundsTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHBOUNDSTESTENABLEEXT, CBSTATUS_DEPTH_BOUNDS_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHBOUNDSTESTENABLEEXT, CB_DYNAMIC_DEPTH_BOUNDS_TEST_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
VkBool32 depthBoundsTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHBOUNDSTESTENABLE, CBSTATUS_DEPTH_BOUNDS_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHBOUNDSTESTENABLE, CB_DYNAMIC_DEPTH_BOUNDS_TEST_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILTESTENABLEEXT, CBSTATUS_STENCIL_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILTESTENABLEEXT, CB_DYNAMIC_STENCIL_TEST_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILTESTENABLE, CBSTATUS_STENCIL_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILTESTENABLE, CB_DYNAMIC_STENCIL_TEST_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
VkCompareOp compareOp) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILOPEXT, CBSTATUS_STENCIL_OP_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILOPEXT, CB_DYNAMIC_STENCIL_OP_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
VkCompareOp compareOp) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSTENCILOP, CBSTATUS_STENCIL_OP_SET);
+ cb_state->RecordStateCmd(CMD_SETSTENCILOP, CB_DYNAMIC_STENCIL_OP_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
const VkRect2D *pDiscardRectangles) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDISCARDRECTANGLEEXT, CBSTATUS_DISCARD_RECTANGLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDISCARDRECTANGLEEXT, CB_DYNAMIC_DISCARD_RECTANGLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
const VkSampleLocationsInfoEXT *pSampleLocationsInfo) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSAMPLELOCATIONSEXT, CBSTATUS_SAMPLE_LOCATIONS_SET);
+ cb_state->RecordStateCmd(CMD_SETSAMPLELOCATIONSEXT, CB_DYNAMIC_SAMPLE_LOCATIONS_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
@@ -4887,53 +4875,53 @@
uint32_t customSampleOrderCount,
const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOARSESAMPLEORDERNV, CBSTATUS_COARSE_SAMPLE_ORDER_SET);
+ cb_state->RecordStateCmd(CMD_SETCOARSESAMPLEORDERNV, CB_DYNAMIC_VIEWPORT_COARSE_SAMPLE_ORDER_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPATCHCONTROLPOINTSEXT, CBSTATUS_PATCH_CONTROL_POINTS_SET);
+ cb_state->RecordStateCmd(CMD_SETPATCHCONTROLPOINTSEXT, CB_DYNAMIC_PATCH_CONTROL_POINTS_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETLOGICOPEXT, CBSTATUS_LOGIC_OP_SET);
+ cb_state->RecordStateCmd(CMD_SETLOGICOPEXT, CB_DYNAMIC_LOGIC_OP_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 rasterizerDiscardEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETRASTERIZERDISCARDENABLEEXT, CBSTATUS_RASTERIZER_DISCARD_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETRASTERIZERDISCARDENABLEEXT, CB_DYNAMIC_RASTERIZER_DISCARD_ENABLE_SET);
cb_state->rasterization_disabled = rasterizerDiscardEnable == VK_TRUE;
}
void ValidationStateTracker::PreCallRecordCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
VkBool32 rasterizerDiscardEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETRASTERIZERDISCARDENABLE, CBSTATUS_RASTERIZER_DISCARD_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETRASTERIZERDISCARDENABLE, CB_DYNAMIC_RASTERIZER_DISCARD_ENABLE_SET);
cb_state->rasterization_disabled = rasterizerDiscardEnable == VK_TRUE;
}
void ValidationStateTracker::PreCallRecordCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHBIASENABLEEXT, CBSTATUS_DEPTH_BIAS_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHBIASENABLEEXT, CB_DYNAMIC_DEPTH_BIAS_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHBIASENABLE, CBSTATUS_DEPTH_BIAS_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHBIASENABLE, CB_DYNAMIC_DEPTH_BIAS_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 primitiveRestartEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPRIMITIVERESTARTENABLEEXT, CBSTATUS_PRIMITIVE_RESTART_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETPRIMITIVERESTARTENABLEEXT, CB_DYNAMIC_PRIMITIVE_RESTART_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
VkBool32 primitiveRestartEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPRIMITIVERESTARTENABLE, CBSTATUS_PRIMITIVE_RESTART_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETPRIMITIVERESTARTENABLE, CB_DYNAMIC_PRIMITIVE_RESTART_ENABLE_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetVertexInputEXT(
@@ -4941,8 +4929,8 @@
const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount,
const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- CBStatusFlags status_flags;
- status_flags.set(CBSTATUS_VERTEX_INPUT_SET);
+ CBDynamicFlags status_flags;
+ status_flags.set(CB_DYNAMIC_VERTEX_INPUT_EXT_SET);
const auto lv_bind_point = ConvertToLvlBindPoint(VK_PIPELINE_BIND_POINT_GRAPHICS);
const auto pipeline_state = cb_state->lastBound[lv_bind_point].pipeline_state;
@@ -4951,7 +4939,7 @@
if (dynamic_state) {
for (uint32_t i = 0; i < dynamic_state->dynamicStateCount; ++i) {
if (dynamic_state->pDynamicStates[i] == VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT) {
- status_flags.set(CBSTATUS_VERTEX_INPUT_BINDING_STRIDE_SET);
+ status_flags.set(CB_DYNAMIC_VERTEX_INPUT_BINDING_STRIDE_SET);
break;
}
}
@@ -4963,193 +4951,193 @@
void ValidationStateTracker::PreCallRecordCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
const VkBool32 *pColorWriteEnables) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordColorWriteEnableStateCmd(CMD_SETCOLORWRITEENABLEEXT, CBSTATUS_COLOR_WRITE_ENABLE_SET, attachmentCount);
+ cb_state->RecordColorWriteEnableStateCmd(CMD_SETCOLORWRITEENABLEEXT, CB_DYNAMIC_COLOR_WRITE_ENABLE_EXT_SET, attachmentCount);
}
void ValidationStateTracker::PreCallRecordCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer,
VkTessellationDomainOrigin domainOrigin) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETTESSELLATIONDOMAINORIGINEXT, CBSTATUS_TESSELLATION_DOMAIN_ORIGIN_SET);
+ cb_state->RecordStateCmd(CMD_SETTESSELLATIONDOMAINORIGINEXT, CB_DYNAMIC_TESSELLATION_DOMAIN_ORIGIN_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHCLAMPENABLEEXT, CBSTATUS_DEPTH_CLAMP_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHCLAMPENABLEEXT, CB_DYNAMIC_DEPTH_CLAMP_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPOLYGONMODEEXT, CBSTATUS_POLYGON_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETPOLYGONMODEEXT, CB_DYNAMIC_POLYGON_MODE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer,
VkSampleCountFlagBits rasterizationSamples) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETRASTERIZATIONSAMPLESEXT, CBSTATUS_RASTERIZATION_SAMPLES_SET);
+ cb_state->RecordStateCmd(CMD_SETRASTERIZATIONSAMPLESEXT, CB_DYNAMIC_RASTERIZATION_SAMPLES_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples,
const VkSampleMask *pSampleMask) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSAMPLEMASKEXT, CBSTATUS_SAMPLE_MASK_SET);
+ cb_state->RecordStateCmd(CMD_SETSAMPLEMASKEXT, CB_DYNAMIC_SAMPLE_MASK_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 alphaToCoverageEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETALPHATOCOVERAGEENABLEEXT, CBSTATUS_ALPHA_TO_COVERAGE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETALPHATOCOVERAGEENABLEEXT, CB_DYNAMIC_ALPHA_TO_COVERAGE_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETALPHATOONEENABLEEXT, CBSTATUS_ALPHA_TO_ONE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETALPHATOONEENABLEEXT, CB_DYNAMIC_ALPHA_TO_ONE_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETLOGICOPENABLEEXT, CBSTATUS_LOGIC_OP_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETLOGICOPENABLEEXT, CB_DYNAMIC_LOGIC_OP_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
uint32_t attachmentCount, const VkBool32 *pColorBlendEnables) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOLORBLENDENABLEEXT, CBSTATUS_COLOR_BLEND_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETCOLORBLENDENABLEEXT, CB_DYNAMIC_COLOR_BLEND_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
uint32_t attachmentCount,
const VkColorBlendEquationEXT *pColorBlendEquations) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOLORBLENDEQUATIONEXT, CBSTATUS_COLOR_BLEND_EQUATION_SET);
+ cb_state->RecordStateCmd(CMD_SETCOLORBLENDEQUATIONEXT, CB_DYNAMIC_COLOR_BLEND_EQUATION_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
uint32_t attachmentCount,
const VkColorComponentFlags *pColorWriteMasks) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOLORWRITEMASKEXT, CBSTATUS_COLOR_WRITE_MASK_SET);
+ cb_state->RecordStateCmd(CMD_SETCOLORWRITEMASKEXT, CB_DYNAMIC_COLOR_WRITE_MASK_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer,
uint32_t rasterizationStream) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETRASTERIZATIONSTREAMEXT, CBSTATUS_RASTERIZATION_STREAM_SET);
+ cb_state->RecordStateCmd(CMD_SETRASTERIZATIONSTREAMEXT, CB_DYNAMIC_RASTERIZATION_STREAM_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetConservativeRasterizationModeEXT(
VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCONSERVATIVERASTERIZATIONMODEEXT, CBSTATUS_CONSERVATIVE_RASTERIZATION_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETCONSERVATIVERASTERIZATIONMODEEXT, CB_DYNAMIC_CONSERVATIVE_RASTERIZATION_MODE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer,
float extraPrimitiveOverestimationSize) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETEXTRAPRIMITIVEOVERESTIMATIONSIZEEXT, CBSTATUS_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_SET);
+ cb_state->RecordStateCmd(CMD_SETEXTRAPRIMITIVEOVERESTIMATIONSIZEEXT, CB_DYNAMIC_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHCLIPENABLEEXT, CBSTATUS_DEPTH_CLIP_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHCLIPENABLEEXT, CB_DYNAMIC_DEPTH_CLIP_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 sampleLocationsEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSAMPLELOCATIONSENABLEEXT, CBSTATUS_SAMPLE_LOCATIONS_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETSAMPLELOCATIONSENABLEEXT, CB_DYNAMIC_SAMPLE_LOCATIONS_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
uint32_t attachmentCount,
const VkColorBlendAdvancedEXT *pColorBlendAdvanced) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOLORBLENDADVANCEDEXT, CBSTATUS_COLOR_BLEND_ADVANCED_SET);
+ cb_state->RecordStateCmd(CMD_SETCOLORBLENDADVANCEDEXT, CB_DYNAMIC_COLOR_BLEND_ADVANCED_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer,
VkProvokingVertexModeEXT provokingVertexMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETPROVOKINGVERTEXMODEEXT, CBSTATUS_PROVOKING_VERTEX_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETPROVOKINGVERTEXMODEEXT, CB_DYNAMIC_PROVOKING_VERTEX_MODE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer,
VkLineRasterizationModeEXT lineRasterizationMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETLINERASTERIZATIONMODEEXT, CBSTATUS_LINE_RASTERIZATION_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETLINERASTERIZATIONMODEEXT, CB_DYNAMIC_LINE_RASTERIZATION_MODE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETLINESTIPPLEENABLEEXT, CBSTATUS_LINE_STIPPLE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETLINESTIPPLEENABLEEXT, CB_DYNAMIC_LINE_STIPPLE_ENABLE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer,
VkBool32 negativeOneToOne) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETDEPTHCLIPNEGATIVEONETOONEEXT, CBSTATUS_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_SET);
+ cb_state->RecordStateCmd(CMD_SETDEPTHCLIPNEGATIVEONETOONEEXT, CB_DYNAMIC_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer,
VkBool32 viewportWScalingEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETVIEWPORTWSCALINGENABLENV, CBSTATUS_VIEWPORT_W_SCALING_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETVIEWPORTWSCALINGENABLENV, CB_DYNAMIC_VIEWPORT_W_SCALING_ENABLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
uint32_t viewportCount,
const VkViewportSwizzleNV *pViewportSwizzles) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETVIEWPORTSWIZZLENV, CBSTATUS_VIEWPORT_SWIZZLE_SET);
+ cb_state->RecordStateCmd(CMD_SETVIEWPORTSWIZZLENV, CB_DYNAMIC_VIEWPORT_SWIZZLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer,
VkBool32 coverageToColorEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOVERAGETOCOLORENABLENV, CBSTATUS_COVERAGE_TO_COLOR_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETCOVERAGETOCOLORENABLENV, CB_DYNAMIC_COVERAGE_TO_COLOR_ENABLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer,
uint32_t coverageToColorLocation) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOVERAGETOCOLORLOCATIONNV, CBSTATUS_COVERAGE_TO_COLOR_LOCATION_SET);
+ cb_state->RecordStateCmd(CMD_SETCOVERAGETOCOLORLOCATIONNV, CB_DYNAMIC_COVERAGE_TO_COLOR_LOCATION_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer,
VkCoverageModulationModeNV coverageModulationMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOVERAGEMODULATIONMODENV, CBSTATUS_COVERAGE_MODULATION_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETCOVERAGEMODULATIONMODENV, CB_DYNAMIC_COVERAGE_MODULATION_MODE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer,
VkBool32 coverageModulationTableEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOVERAGEMODULATIONTABLEENABLENV, CBSTATUS_COVERAGE_MODULATION_TABLE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETCOVERAGEMODULATIONTABLEENABLENV, CB_DYNAMIC_COVERAGE_MODULATION_TABLE_ENABLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer,
uint32_t coverageModulationTableCount,
const float *pCoverageModulationTable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOVERAGEMODULATIONTABLENV, CBSTATUS_COVERAGE_MODULATION_TABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETCOVERAGEMODULATIONTABLENV, CB_DYNAMIC_COVERAGE_MODULATION_TABLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer,
VkBool32 shadingRateImageEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETSHADINGRATEIMAGEENABLENV, CBSTATUS_SHADING_RATE_IMAGE_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETSHADINGRATEIMAGEENABLENV, CB_DYNAMIC_SHADING_RATE_IMAGE_ENABLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer,
VkBool32 representativeFragmentTestEnable) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETREPRESENTATIVEFRAGMENTTESTENABLENV, CBSTATUS_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_SET);
+ cb_state->RecordStateCmd(CMD_SETREPRESENTATIVEFRAGMENTTESTENABLENV, CB_DYNAMIC_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV_SET);
}
void ValidationStateTracker::PreCallRecordCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer,
VkCoverageReductionModeNV coverageReductionMode) {
auto cb_state = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
- cb_state->RecordStateCmd(CMD_SETCOVERAGEREDUCTIONMODENV, CBSTATUS_COVERAGE_REDUCTION_MODE_SET);
+ cb_state->RecordStateCmd(CMD_SETCOVERAGEREDUCTIONMODENV, CB_DYNAMIC_COVERAGE_REDUCTION_MODE_NV_SET);
}
void ValidationStateTracker::RecordGetBufferDeviceAddress(const VkBufferDeviceAddressInfo *pInfo, VkDeviceAddress address) {
diff --git a/scripts/command_validation_generator.py b/scripts/command_validation_generator.py
index 67d56b2..66ef598 100644
--- a/scripts/command_validation_generator.py
+++ b/scripts/command_validation_generator.py
@@ -1,6 +1,6 @@
#!/usr/bin/python3 -i
#
-# Copyright (c) 2021 The Khronos Group Inc.
+# Copyright (c) 2021-2022 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -93,6 +93,7 @@
self.alias_dict = dict() # Dict of cmd aliases
self.header_file = False # Header file generation flag
self.source_file = False # Source file generation flag
+ self.dynamic_states = [] # VkDynamicState enum values
#
# Walk the JSON-derived dict and find all "vuid" key values
@@ -142,7 +143,7 @@
copyright += '\n'
copyright += '/***************************************************************************\n'
copyright += ' *\n'
- copyright += ' * Copyright (c) 2021 The Khronos Group Inc.\n'
+ copyright += ' * Copyright (c) 2021-2022 The Khronos Group Inc.\n'
copyright += ' *\n'
copyright += ' * Licensed under the Apache License, Version 2.0 (the "License");\n'
copyright += ' * you may not use this file except in compliance with the License.\n'
@@ -167,6 +168,7 @@
elif self.header_file:
write('#pragma once', file=self.outFile)
write('#include <array>', file=self.outFile)
+ write('#include <bitset>', file=self.outFile)
#
# Write generated file content to output file
@@ -174,12 +176,14 @@
if self.header_file:
write(self.commandTypeEnum(), file=self.outFile)
write(self.commandNameList(), file=self.outFile)
+ write(self.dynamicTypeEnum(), file=self.outFile)
elif self.source_file:
write(self.commandRecordingList(), file=self.outFile)
write(self.commandQueueTypeList(), file=self.outFile)
write(self.commandRenderPassList(), file=self.outFile)
write(self.commandBufferLevelList(), file=self.outFile)
write(self.validateFunction(), file=self.outFile)
+ write(self.dynamicFunction(), file=self.outFile)
# Finish processing in superclass
OutputGenerator.endFile(self)
@@ -206,7 +210,13 @@
self.commands[name] = cmdinfo
if alias is not None:
self.alias_dict[name] = alias
-
+ #
+ # List the enum for the commands
+ def genGroup(self, groupinfo, name, alias):
+ if (name == 'VkDynamicState'):
+ for elem in groupinfo.elem.findall('enum'):
+ if elem.get('alias') is None:
+ self.dynamic_states.append(elem.get('name'))
#
# List the enum for the commands
def commandTypeEnum(self):
@@ -238,6 +248,28 @@
return output
#
+ # List the enum for the dynamic command buffer status flags
+ def dynamicTypeEnum(self):
+ output = '''
+typedef enum CB_DYNAMIC_STATUS {\n'''
+ counter = 1
+ for name in self.dynamic_states:
+ state_name = name[17:] # VK_DYNAMIC_STATE_LINE_WIDTH -> LINE_WIDTH
+ output += ' CB_DYNAMIC_{}_SET = {},\n'.format(state_name, str(counter))
+ counter += 1
+
+ output += ' CB_DYNAMIC_STATUS_NUM = ' + str(counter)
+ output += '''
+} CB_DYNAMIC_STATUS;
+
+typedef std::bitset<CB_DYNAMIC_STATUS_NUM> CBDynamicFlags;
+std::string DynamicStateString(CBDynamicFlags const &dynamic_state);
+struct VkPipelineDynamicStateCreateInfo;
+CBDynamicFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *info);
+'''
+ return output
+
+ #
# For each CMD_TYPE give a string name add a *-recording VUID
# Each vkCmd* will have one
def commandRecordingList(self):
@@ -414,3 +446,59 @@
return skip;
}'''
return output
+
+ #
+ # List the enum for the dynamic command buffer status flags
+ def dynamicFunction(self):
+ output = '''
+static VkDynamicState ConvertToDynamicState(CB_DYNAMIC_STATUS flag) {
+ switch (flag) {\n'''
+ for name in self.dynamic_states:
+ state_name = name[17:] # VK_DYNAMIC_STATE_LINE_WIDTH -> LINE_WIDTH
+ output += ' case CB_DYNAMIC_{}_SET:\n'.format(state_name)
+ output += ' return {};\n'.format(name)
+ output += ''' default:
+ return VK_DYNAMIC_STATE_MAX_ENUM;
+ }
+}
+'''
+ output += '''
+static CB_DYNAMIC_STATUS ConvertToCBDynamicStatus(VkDynamicState state) {
+ switch (state) {\n'''
+ for name in self.dynamic_states:
+ state_name = name[17:] # VK_DYNAMIC_STATE_LINE_WIDTH -> LINE_WIDTH
+ output += ' case {}:\n'.format(name)
+ output += ' return CB_DYNAMIC_{}_SET;\n'.format(state_name)
+ output += ''' default:
+ return CB_DYNAMIC_STATUS_NUM;
+ }
+}
+'''
+
+ output += '''
+std::string DynamicStateString(CBDynamicFlags const &dynamic_state) {
+ std::string ret;
+ for (int index = 0; index < CB_DYNAMIC_STATUS_NUM; ++index) {
+ CB_DYNAMIC_STATUS status = static_cast<CB_DYNAMIC_STATUS>(index);
+ if (dynamic_state[status]) {
+ if (!ret.empty()) ret.append("|");
+ ret.append(string_VkDynamicState(ConvertToDynamicState(status)));
+ }
+ }
+ if (ret.empty()) ret.append(string_VkDynamicState(ConvertToDynamicState(CB_DYNAMIC_STATUS_NUM)));
+ return ret;
+}
+
+CBDynamicFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *info) {
+ // initially assume everything is static state
+ CBDynamicFlags flags(~CBDynamicFlags(0));
+
+ if (info) {
+ for (uint32_t i = 0; i < info->dynamicStateCount; i++) {
+ flags.reset(ConvertToCBDynamicStatus(info->pDynamicStates[i]));
+ }
+ }
+ return flags;
+}
+'''
+ return output
\ No newline at end of file
