VkPipeline pipeline;
VkDynamicViewportState viewport;
- VkDynamicRasterState raster;
+ VkDynamicRasterLineState raster_line;
+ VkDynamicRasterDepthBiasState raster_depth_bias;
VkDynamicColorBlendState color_blend;
VkDynamicDepthStencilState depth_stencil;
0, 1, &demo->desc_set, 0, NULL);
vkCmdBindDynamicViewportState(cmd_buf, demo->viewport);
- vkCmdBindDynamicRasterState(cmd_buf, demo->raster);
+ vkCmdBindDynamicRasterLineState(cmd_buf, demo->raster_line);
+ vkCmdBindDynamicRasterDepthBiasState(cmd_buf, demo->raster_depth_bias);
vkCmdBindDynamicColorBlendState(cmd_buf, demo->color_blend);
vkCmdBindDynamicDepthStencilState(cmd_buf, demo->depth_stencil);
rs.cullMode = VK_CULL_MODE_BACK;
rs.frontFace = VK_FRONT_FACE_CCW;
rs.depthClipEnable = VK_TRUE;
+ rs.rasterizerDiscardEnable = VK_FALSE;
+ rs.depthBiasEnable = VK_FALSE;
memset(&cb, 0, sizeof(cb));
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
static void demo_prepare_dynamic_states(struct demo *demo)
{
VkDynamicViewportStateCreateInfo viewport_create;
- VkDynamicRasterStateCreateInfo raster;
+ VkDynamicRasterLineStateCreateInfo raster_line;
+ VkDynamicRasterDepthBiasStateCreateInfo raster_depth_bias;
VkDynamicColorBlendStateCreateInfo color_blend;
VkDynamicDepthStencilStateCreateInfo depth_stencil;
VkResult U_ASSERT_ONLY err;
scissor.offset.y = 0;
viewport_create.pScissors = &scissor;
- memset(&raster, 0, sizeof(raster));
- raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO;
- raster.lineWidth = 1.0;
+ memset(&raster_line, 0, sizeof(raster_line));
+ raster_line.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO;
+ raster_line.lineWidth = 1.0;
+
+ memset(&raster_depth_bias, 0, sizeof(raster_depth_bias));
+ raster_depth_bias.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO;
+ raster_depth_bias.depthBias = 0.0f;
+ raster_depth_bias.depthBiasClamp = 0.0f;
+ raster_depth_bias.slopeScaledDepthBias = 0.0f;
memset(&color_blend, 0, sizeof(color_blend));
color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO;
err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport);
assert(!err);
- err = vkCreateDynamicRasterState(demo->device, &raster, &demo->raster);
+ err = vkCreateDynamicRasterLineState(demo->device, &raster_line, &demo->raster_line);
+ assert(!err);
+
+ err = vkCreateDynamicRasterDepthBiasState(demo->device, &raster_depth_bias, &demo->raster_depth_bias);
assert(!err);
err = vkCreateDynamicColorBlendState(demo->device,
vkDestroyDescriptorPool(demo->device, demo->desc_pool);
vkDestroyDynamicViewportState(demo->device, demo->viewport);
- vkDestroyDynamicRasterState(demo->device, demo->raster);
+ vkDestroyDynamicRasterLineState(demo->device, demo->raster_line);
+ vkDestroyDynamicRasterDepthBiasState(demo->device, demo->raster_depth_bias);
vkDestroyDynamicColorBlendState(demo->device, demo->color_blend);
vkDestroyDynamicDepthStencilState(demo->device, demo->depth_stencil);
VkPipeline pipeline;
VkDynamicViewportState viewport;
- VkDynamicRasterState raster;
+ VkDynamicRasterLineState raster_line;
+ VkDynamicRasterDepthBiasState raster_depth_bias;
VkDynamicColorBlendState color_blend;
VkDynamicDepthStencilState depth_stencil;
0, 1, & demo->desc_set, 0, NULL);
vkCmdBindDynamicViewportState(demo->draw_cmd, demo->viewport);
- vkCmdBindDynamicRasterState(demo->draw_cmd, demo->raster);
+ vkCmdBindDynamicRasterLineState(demo->draw_cmd, demo->raster_line);
+ vkCmdBindDynamicRasterDepthBiasState(demo->draw_cmd, demo->raster_depth_bias);
vkCmdBindDynamicColorBlendState(demo->draw_cmd, demo->color_blend);
vkCmdBindDynamicDepthStencilState(demo->draw_cmd, demo->depth_stencil);
rs.cullMode = VK_CULL_MODE_BACK;
rs.frontFace = VK_FRONT_FACE_CW;
rs.depthClipEnable = VK_TRUE;
+ rs.rasterizerDiscardEnable = VK_FALSE;
+ rs.depthBiasEnable = VK_FALSE;
memset(&cb, 0, sizeof(cb));
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
static void demo_prepare_dynamic_states(struct demo *demo)
{
VkDynamicViewportStateCreateInfo viewport_create;
- VkDynamicRasterStateCreateInfo raster;
+ VkDynamicRasterLineStateCreateInfo raster_line;
+ VkDynamicRasterDepthBiasStateCreateInfo raster_depth_bias;
VkDynamicColorBlendStateCreateInfo color_blend;
VkDynamicDepthStencilStateCreateInfo depth_stencil;
VkResult U_ASSERT_ONLY err;
scissor.offset.y = 0;
viewport_create.pScissors = &scissor;
- memset(&raster, 0, sizeof(raster));
- raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO;
- raster.lineWidth = 1.0;
+ memset(&raster_line, 0, sizeof(raster_line));
+ raster_line.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO;
+ raster_line.lineWidth = 1.0;
+
+ memset(&raster_depth_bias, 0, sizeof(raster_depth_bias));
+ raster_depth_bias.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO;
+ raster_depth_bias.depthBias = 0.0f;
+ raster_depth_bias.depthBiasClamp = 0.0f;
+ raster_depth_bias.slopeScaledDepthBias = 0.0f;
memset(&color_blend, 0, sizeof(color_blend));
color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO;
err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport);
assert(!err);
- err = vkCreateDynamicRasterState(demo->device, &raster, &demo->raster);
+ err = vkCreateDynamicRasterLineState(demo->device, &raster_line, &demo->raster_line);
+ assert(!err);
+
+ err = vkCreateDynamicRasterDepthBiasState(demo->device, &raster_depth_bias, &demo->raster_depth_bias);
assert(!err);
err = vkCreateDynamicColorBlendState(demo->device,
vkDestroyCommandPool(demo->device, demo->cmd_pool);
vkDestroyDynamicViewportState(demo->device, demo->viewport);
- vkDestroyDynamicRasterState(demo->device, demo->raster);
+ vkDestroyDynamicRasterLineState(demo->device, demo->raster_line);
+ vkDestroyDynamicRasterDepthBiasState(demo->device, demo->raster_depth_bias);
vkDestroyDynamicColorBlendState(demo->device, demo->color_blend);
vkDestroyDynamicDepthStencilState(demo->device, demo->depth_stencil);
return VK_SUCCESS;
}
-static VkResult nulldrv_raster_state_create(struct nulldrv_dev *dev,
- const VkDynamicRasterStateCreateInfo *info,
- struct nulldrv_dynamic_rs **state_ret)
+static VkResult nulldrv_raster_line_state_create(struct nulldrv_dev *dev,
+ const VkDynamicRasterLineStateCreateInfo *info,
+ struct nulldrv_dynamic_rs_line **state_ret)
{
- struct nulldrv_dynamic_rs *state;
+ struct nulldrv_dynamic_rs_line *state;
- state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev,
- sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE);
+ state = (struct nulldrv_dynamic_rs_line *) nulldrv_base_create(dev,
+ sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE);
+ if (!state)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ *state_ret = state;
+
+ return VK_SUCCESS;
+}
+
+static VkResult nulldrv_raster_depth_bias_state_create(struct nulldrv_dev *dev,
+ const VkDynamicRasterDepthBiasStateCreateInfo *info,
+ struct nulldrv_dynamic_rs_depth_bias **state_ret)
+{
+ struct nulldrv_dynamic_rs_depth_bias *state;
+
+ state = (struct nulldrv_dynamic_rs_depth_bias *) nulldrv_base_create(dev,
+ sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE);
if (!state)
return VK_ERROR_OUT_OF_HOST_MEMORY;
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void VKAPI vkCmdBindDynamicRasterState(
+ICD_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(
VkCmdBuffer cmdBuffer,
- VkDynamicRasterState state)
+ VkDynamicRasterLineState state)
+{
+ NULLDRV_LOG_FUNC;
+}
+
+ICD_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicRasterDepthBiasState state)
{
NULLDRV_LOG_FUNC;
}
return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
+ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(
VkDevice device,
- const VkDynamicRasterStateCreateInfo* pCreateInfo,
- VkDynamicRasterState* pState)
+ const VkDynamicRasterLineStateCreateInfo* pCreateInfo,
+ VkDynamicRasterLineState* pState)
+{
+ NULLDRV_LOG_FUNC;
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_raster_line_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_rs_line **) pState);
+}
+
+ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(
+ VkDevice device,
+ const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo,
+ VkDynamicRasterDepthBiasState* pState)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
- return nulldrv_raster_state_create(dev, pCreateInfo,
- (struct nulldrv_dynamic_rs **) pState);
+ return nulldrv_raster_depth_bias_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_rs_depth_bias **) pState);
+}
+
+ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterLinesState(
+ VkDevice device,
+ VkDynamicRasterLineState dynamicRasterLineState)
+{
+ NULLDRV_LOG_FUNC;
+ return VK_SUCCESS;
}
-ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(
+ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(
VkDevice device,
- VkDynamicRasterState dynamicRasterState)
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
{
NULLDRV_LOG_FUNC;
return VK_SUCCESS;
struct nulldrv_obj obj;
};
-struct nulldrv_dynamic_rs {
+struct nulldrv_dynamic_rs_line {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_rs_depth_bias {
struct nulldrv_obj obj;
};
VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 18,
VK_OBJECT_TYPE_DESCRIPTOR_POOL = 19,
VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE = 20,
- VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE = 21,
- VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 22,
- VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 23,
- VK_OBJECT_TYPE_FENCE = 24,
- VK_OBJECT_TYPE_SEMAPHORE = 25,
- VK_OBJECT_TYPE_EVENT = 26,
- VK_OBJECT_TYPE_QUERY_POOL = 27,
- VK_OBJECT_TYPE_FRAMEBUFFER = 28,
- VK_OBJECT_TYPE_RENDER_PASS = 29,
- VK_OBJECT_TYPE_PIPELINE_CACHE = 30,
- VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 31,
- VK_OBJECT_TYPE_CMD_POOL = 32,
+ VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE = 21,
+ VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE = 22,
+ VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 23,
+ VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 24,
+ VK_OBJECT_TYPE_FENCE = 25,
+ VK_OBJECT_TYPE_SEMAPHORE = 26,
+ VK_OBJECT_TYPE_EVENT = 27,
+ VK_OBJECT_TYPE_QUERY_POOL = 28,
+ VK_OBJECT_TYPE_FRAMEBUFFER = 29,
+ VK_OBJECT_TYPE_RENDER_PASS = 30,
+ VK_OBJECT_TYPE_PIPELINE_CACHE = 31,
+ VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 32,
+ VK_OBJECT_TYPE_CMD_POOL = 33,
VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_CMD_POOL,
VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_CMD_POOL - VK_OBJECT_TYPE_INSTANCE + 1),
return "VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE";
case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE:
return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE";
- case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
- return "VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE";
+ case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE:
+ return "VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE";
+ case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE:
+ return "VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE";
case VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE:
return "VK_OBJECT_TYPE_DYNAMIC_VIEPORT_STATE";
case VK_OBJECT_TYPE_EVENT:
PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
PFN_vkCreateDynamicViewportState CreateDynamicViewportState;
PFN_vkDestroyDynamicViewportState DestroyDynamicViewportState;
- PFN_vkCreateDynamicRasterState CreateDynamicRasterState;
- PFN_vkDestroyDynamicRasterState DestroyDynamicRasterState;
+ PFN_vkCreateDynamicRasterLineState CreateDynamicRasterLineState;
+ PFN_vkDestroyDynamicRasterLineState DestroyDynamicRasterLineState;
+ PFN_vkCreateDynamicRasterDepthBiasState CreateDynamicRasterDepthBiasState;
+ PFN_vkDestroyDynamicRasterDepthBiasState DestroyDynamicRasterDepthBiasState;
PFN_vkCreateDynamicColorBlendState CreateDynamicColorBlendState;
PFN_vkDestroyDynamicColorBlendState DestroyDynamicColorBlendState;
PFN_vkCreateDynamicDepthStencilState CreateDynamicDepthStencilState;
PFN_vkResetCommandBuffer ResetCommandBuffer;
PFN_vkCmdBindPipeline CmdBindPipeline;
PFN_vkCmdBindDynamicViewportState CmdBindDynamicViewportState;
- PFN_vkCmdBindDynamicRasterState CmdBindDynamicRasterState;
+ PFN_vkCmdBindDynamicRasterLineState CmdBindDynamicRasterLineState;
+ PFN_vkCmdBindDynamicRasterDepthBiasState CmdBindDynamicRasterDepthBiasState;
PFN_vkCmdBindDynamicColorBlendState CmdBindDynamicColorBlendState;
PFN_vkCmdBindDynamicDepthStencilState CmdBindDynamicDepthStencilState;
PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool)
VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet)
VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState)
-VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState)
+VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterLineState)
+VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterDepthBiasState)
VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState)
VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState)
VK_DEFINE_NONDISP_HANDLE(VkFramebuffer)
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9,
VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10,
- VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11,
- VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12,
- VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13,
- VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14,
- VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15,
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16,
- VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17,
- VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18,
- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20,
- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21,
- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22,
- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23,
- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24,
- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25,
- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26,
- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28,
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29,
- VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30,
- VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31,
- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32,
- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33,
- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37,
- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38,
- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39,
- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40,
- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41,
- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42,
- VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43,
- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44,
- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45,
- VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46,
- VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47,
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48,
- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49,
+ VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO = 12,
+ VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 13,
+ VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 16,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 17,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 18,
+ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 19,
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 20,
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 22,
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 23,
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 27,
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 28,
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 29,
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 30,
+ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 31,
+ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 32,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 33,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 34,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 35,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42,
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44,
+ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46,
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47,
+ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49,
+ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 50,
VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
VkFillMode fillMode;
VkCullMode cullMode;
VkFrontFace frontFace;
+ VkBool32 depthBiasEnable;
} VkPipelineRasterStateCreateInfo;
typedef struct {
typedef struct {
VkStructureType sType;
const void* pNext;
+ float lineWidth;
+} VkDynamicRasterLineStateCreateInfo;
+
+typedef struct {
+ VkStructureType sType;
+ const void* pNext;
float depthBias;
float depthBiasClamp;
float slopeScaledDepthBias;
- float lineWidth;
-} VkDynamicRasterStateCreateInfo;
+} VkDynamicRasterDepthBiasStateCreateInfo;
typedef struct {
VkStructureType sType;
typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState);
-typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState);
-typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterLineState)(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterLineState)(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState);
+typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterDepthBiasState)(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState);
+typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterDepthBiasState)(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState);
typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState);
typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState);
typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState);
-typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicRasterLineState)(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState);
+typedef void (VKAPI *PFN_vkCmdBindDynamicRasterDepthBiasState)(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState);
typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState);
typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState);
typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
VkDevice device,
VkDynamicViewportState dynamicViewportState);
-VkResult VKAPI vkCreateDynamicRasterState(
+VkResult VKAPI vkCreateDynamicRasterLineState(
+ VkDevice device,
+ const VkDynamicRasterLineStateCreateInfo* pCreateInfo,
+ VkDynamicRasterLineState* pState);
+
+VkResult VKAPI vkDestroyDynamicRasterLineState(
+ VkDevice device,
+ VkDynamicRasterLineState dynamicRasterLineState);
+
+VkResult VKAPI vkCreateDynamicRasterDepthBiasState(
VkDevice device,
- const VkDynamicRasterStateCreateInfo* pCreateInfo,
- VkDynamicRasterState* pState);
+ const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo,
+ VkDynamicRasterDepthBiasState* pState);
-VkResult VKAPI vkDestroyDynamicRasterState(
+VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(
VkDevice device,
- VkDynamicRasterState dynamicRasterState);
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState);
VkResult VKAPI vkCreateDynamicColorBlendState(
VkDevice device,
VkCmdBuffer cmdBuffer,
VkDynamicViewportState dynamicViewportState);
-void VKAPI vkCmdBindDynamicRasterState(
+void VKAPI vkCmdBindDynamicRasterLineState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicRasterLineState dynamicRasterLineState);
+
+void VKAPI vkCmdBindDynamicRasterDepthBiasState(
VkCmdBuffer cmdBuffer,
- VkDynamicRasterState dynamicRasterState);
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState);
void VKAPI vkCmdBindDynamicColorBlendState(
VkCmdBuffer cmdBuffer,
unordered_map<uint64_t, VkAttachmentViewCreateInfo> viewMap;
unordered_map<uint64_t, BUFFER_NODE*> bufferMap;
unordered_map<uint64_t, VkDynamicViewportStateCreateInfo> dynamicVpStateMap;
-unordered_map<uint64_t, VkDynamicRasterStateCreateInfo> dynamicRsStateMap;
+unordered_map<uint64_t, VkDynamicRasterLineStateCreateInfo> dynamicRasterLineStateMap;
+unordered_map<uint64_t, VkDynamicRasterDepthBiasStateCreateInfo> dynamicRasterDepthBiasStateMap;
unordered_map<uint64_t, VkDynamicColorBlendStateCreateInfo> dynamicCbStateMap;
unordered_map<uint64_t, VkDynamicDepthStencilStateCreateInfo> dynamicDsStateMap;
unordered_map<uint64_t, PIPELINE_NODE*> pipelineMap;
return "CMD_BINDPIPELINEDELTA";
case CMD_BINDDYNAMICVIEWPORTSTATE:
return "CMD_BINDDYNAMICVIEWPORTSTATE";
- case CMD_BINDDYNAMICRASTERSTATE:
- return "CMD_BINDDYNAMICRASTERSTATE";
+ case CMD_BINDDYNAMICRASTERLINESTATE:
+ return "CMD_BINDDYNAMICRASTERLINESTATE";
+ case CMD_BINDDYNAMICRASTERDEPTHBIASSTATE:
+ return "CMD_BINDDYNAMICRASTERDEPTHBIASSTATE";
case CMD_BINDDYNAMICCOLORBLENDSTATE:
return "CMD_BINDDYNAMICCOLORBLENDSTATE";
case CMD_BINDDYNAMICDEPTHSTENCILSTATE:
delete[] (*ii).second.pViewports;
}
dynamicVpStateMap.clear();
- dynamicRsStateMap.clear();
+ dynamicRasterLineStateMap.clear();
+ dynamicRasterDepthBiasStateMap.clear();
dynamicCbStateMap.clear();
dynamicDsStateMap.clear();
}
switch (type) {
case VK_STATE_BIND_POINT_VIEWPORT:
return (void*)&dynamicVpStateMap[handle];
- case VK_STATE_BIND_POINT_RASTER:
- return (void*)&dynamicRsStateMap[handle];
+ case VK_STATE_BIND_POINT_RASTER_LINE:
+ return (void*)&dynamicRasterLineStateMap[handle];
+ case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS:
+ return (void*)&dynamicRasterDepthBiasStateMap[handle];
case VK_STATE_BIND_POINT_COLOR_BLEND:
return (void*)&dynamicCbStateMap[handle];
case VK_STATE_BIND_POINT_DEPTH_STENCIL:
static VkBool32 validate_draw_state_flags(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) {
VkBool32 result;
result = validate_status(pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_BOUND, CBSTATUS_VIEWPORT_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");
- result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_BOUND, CBSTATUS_RASTER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_NOT_BOUND, "Raster object not bound to this command buffer");
+ result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_LINE_BOUND, CBSTATUS_RASTER_LINE_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_LINE_NOT_BOUND, "Raster line object not bound to this command buffer");
+ result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_DEPTH_BIAS_BOUND, CBSTATUS_RASTER_DEPTH_BIAS_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_DEPTH_BIAS_NOT_BOUND, "Raster depth bias object not bound to this command buffer");
result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_COLOR_BLEND_BOUND, CBSTATUS_COLOR_BLEND_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_COLOR_BLEND_NOT_BOUND, "Color-blend object not bound to this command buffer");
result &= validate_status(pCB, CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE, CBSTATUS_DEPTH_STENCIL_BOUND, CBSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");
if (indexedDraw)
static void set_cb_dyn_status(GLOBAL_CB_NODE* pNode, DYNAMIC_STATE_BIND_POINT stateBindPoint) {
if (stateBindPoint == VK_STATE_BIND_POINT_VIEWPORT) {
pNode->status |= CBSTATUS_VIEWPORT_BOUND;
- } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER) {
- pNode->status |= CBSTATUS_RASTER_BOUND;
+ } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER_LINE) {
+ pNode->status |= CBSTATUS_RASTER_LINE_BOUND;
+ } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS) {
+ pNode->status |= CBSTATUS_RASTER_DEPTH_BIAS_BOUND;
} else if (stateBindPoint == VK_STATE_BIND_POINT_COLOR_BLEND) {
pNode->status |= CBSTATUS_COLOR_BLEND_BOUND;
} else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_STENCIL) {
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState);
+ VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
+ // TODO : Clean up any internal data structures using this obj.
+ return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+ VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
// TODO : Clean up any internal data structures using this obj.
return result;
}
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState)
+{
+ VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState);
+ //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER_LINE);
+ loader_platform_thread_lock_mutex(&globalLock);
+ dynamicRasterLineStateMap[pState->handle] = *pCreateInfo;
+ loader_platform_thread_unlock_mutex(&globalLock);
+ return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState)
{
- VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
- //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER);
+ VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+ //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS);
loader_platform_thread_lock_mutex(&globalLock);
- dynamicRsStateMap[pState->handle] = *pCreateInfo;
+ dynamicRasterDepthBiasStateMap[pState->handle] = *pCreateInfo;
loader_platform_thread_unlock_mutex(&globalLock);
return result;
}
}
}
}
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState)
+{
+ GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
+ if (pCB) {
+ if (pCB->state == CB_UPDATE_ACTIVE) {
+ updateCBTracking(cmdBuffer);
+ addCmd(pCB, CMD_BINDDYNAMICRASTERLINESTATE);
+ if (!pCB->activeRenderPass) {
+ log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
+ "Incorrect call to vkCmdBindDynamicRasterLineState() without an active RenderPass.");
+ }
+ loader_platform_thread_lock_mutex(&globalLock);
+ pCB->status |= CBSTATUS_RASTER_LINE_BOUND;
+ if (dynamicRasterLineStateMap.find(dynamicRasterLineState.handle) == dynamicRasterLineStateMap.end()) {
+ log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, dynamicRasterLineState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+ "Unable to find VkDynamicRasterLineState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterLineState.handle);
+ } else {
+ pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle;
+ g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle;
+ }
+ loader_platform_thread_unlock_mutex(&globalLock);
+ get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
+ } else {
+ report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterLineState()");
+ }
+ }
+}
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
{
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(cmdBuffer);
- addCmd(pCB, CMD_BINDDYNAMICRASTERSTATE);
+ addCmd(pCB, CMD_BINDDYNAMICRASTERDEPTHBIASSTATE);
if (!pCB->activeRenderPass) {
log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
- "Incorrect call to vkCmdBindDynamicRasterState() without an active RenderPass.");
+ "Incorrect call to vkCmdBindDynamicRasterDepthBiasState() without an active RenderPass.");
}
loader_platform_thread_lock_mutex(&globalLock);
- pCB->status |= CBSTATUS_RASTER_BOUND;
- if (dynamicRsStateMap.find(dynamicRasterState.handle) == dynamicRsStateMap.end()) {
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
- "Unable to find VkDynamicRasterState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle);
+ pCB->status |= CBSTATUS_RASTER_DEPTH_BIAS_BOUND;
+ if (dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle) == dynamicRasterDepthBiasStateMap.end()) {
+ log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, dynamicRasterDepthBiasState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+ "Unable to find VkDynamicRasterDepthBiasState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterDepthBiasState.handle);
} else {
- pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
- g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
+ pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle;
+ g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle;
}
loader_platform_thread_unlock_mutex(&globalLock);
- get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+ get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
} else {
- report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterState()");
+ report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterDepthBiasState()");
}
}
}
return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
if (!strcmp(funcName, "vkDestroyDynamicViewportState"))
return (PFN_vkVoidFunction) vkDestroyDynamicViewportState;
- if (!strcmp(funcName, "vkDestroyDynamicRasterState"))
- return (PFN_vkVoidFunction) vkDestroyDynamicRasterState;
+ if (!strcmp(funcName, "vkDestroyDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState;
+ if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
if (!strcmp(funcName, "vkCreateDynamicViewportState"))
return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
- if (!strcmp(funcName, "vkCreateDynamicRasterState"))
- return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
return (PFN_vkVoidFunction) vkCmdBindPipeline;
if (!strcmp(funcName, "vkCmdBindDynamicViewportState"))
return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState;
- if (!strcmp(funcName, "vkCmdBindDynamicRasterState"))
- return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState;
+ if (!strcmp(funcName, "vkCmdBindDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState;
+ if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
DRAWSTATE_NO_BEGIN_CMD_BUFFER, // Binding cmds or calling End on CB that never had vkBeginCommandBuffer() called on it
DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, // Cmd Buffer created with VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times
DRAWSTATE_VIEWPORT_NOT_BOUND, // Draw submitted with no viewport state object bound
- DRAWSTATE_RASTER_NOT_BOUND, // Draw submitted with no raster state object bound
+ DRAWSTATE_RASTER_LINE_NOT_BOUND, // Draw submitted with no raster line state object bound
+ DRAWSTATE_RASTER_DEPTH_BIAS_NOT_BOUND, // Draw submitted with no raster depth bias state object bound
DRAWSTATE_COLOR_BLEND_NOT_BOUND, // Draw submitted with no color blend state object bound when color write enabled
DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, // Draw submitted with no depth-stencil state object bound when depth write enabled
DRAWSTATE_INDEX_BUFFER_NOT_BOUND, // Draw submitted with no depth-stencil state object bound when depth write enabled
CMD_BINDPIPELINE,
CMD_BINDPIPELINEDELTA,
CMD_BINDDYNAMICVIEWPORTSTATE,
- CMD_BINDDYNAMICRASTERSTATE,
+ CMD_BINDDYNAMICRASTERLINESTATE,
+ CMD_BINDDYNAMICRASTERDEPTHBIASSTATE,
CMD_BINDDYNAMICCOLORBLENDSTATE,
CMD_BINDDYNAMICDEPTHSTENCILSTATE,
CMD_BINDDESCRIPTORSETS,
{
CBSTATUS_NONE = 0x00000000, // No status is set
CBSTATUS_VIEWPORT_BOUND = 0x00000001, // Viewport state object has been bound
- CBSTATUS_RASTER_BOUND = 0x00000002, // Raster state object has been bound
- CBSTATUS_COLOR_BLEND_WRITE_ENABLE = 0x00000004, // PSO w/ CB Enable set has been bound
- CBSTATUS_COLOR_BLEND_BOUND = 0x00000008, // CB state object has been bound
- CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE = 0x00000010, // PSO w/ DS Enable set has been bound
- CBSTATUS_DEPTH_STENCIL_BOUND = 0x00000020, // DS state object has been bound
- CBSTATUS_INDEX_BUFFER_BOUND = 0x00000040, // Index buffer has been bound
+ CBSTATUS_RASTER_LINE_BOUND = 0x00000002, // Raster state object has been bound
+ CBSTATUS_RASTER_DEPTH_BIAS_BOUND = 0x00000004, // Raster state object has been bound
+ CBSTATUS_COLOR_BLEND_WRITE_ENABLE = 0x00000008, // PSO w/ CB Enable set has been bound
+ CBSTATUS_COLOR_BLEND_BOUND = 0x00000010, // CB state object has been bound
+ CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE = 0x00000020, // PSO w/ DS Enable set has been bound
+ CBSTATUS_DEPTH_STENCIL_BOUND = 0x00000040, // DS state object has been bound
+ CBSTATUS_INDEX_BUFFER_BOUND = 0x00000080, // Index buffer has been bound
} CBStatusFlagBits;
// Cmd Buffer Wrapper Struct
typedef enum _DYNAMIC_STATE_BIND_POINT
{
VK_STATE_BIND_POINT_VIEWPORT,
- VK_STATE_BIND_POINT_RASTER,
+ VK_STATE_BIND_POINT_RASTER_LINE,
+ VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS,
VK_STATE_BIND_POINT_COLOR_BLEND,
VK_STATE_BIND_POINT_DEPTH_STENCIL,
VK_NUM_STATE_BIND_POINT // Used for array sizing
{
case VK_STATE_BIND_POINT_VIEWPORT:
return "VIEWPORT";
- case VK_STATE_BIND_POINT_RASTER:
- return "RASTER";
+ case VK_STATE_BIND_POINT_RASTER_LINE:
+ return "RASTER_LINE";
+ case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS:
+ return "RASTER_DEPTH_BIAS";
case VK_STATE_BIND_POINT_COLOR_BLEND:
return "COLOR_BLEND";
case VK_STATE_BIND_POINT_DEPTH_STENCIL:
{
case VK_STATE_BIND_POINT_VIEWPORT:
return VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE;
- case VK_STATE_BIND_POINT_RASTER:
- return VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE;
+ case VK_STATE_BIND_POINT_RASTER_LINE:
+ return VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE;
+ case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS:
+ return VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE;
case VK_STATE_BIND_POINT_COLOR_BLEND:
return VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE;
case VK_STATE_BIND_POINT_DEPTH_STENCIL:
unordered_map<uint64_t, VkFramebufferCreateInfo> framebufferMap;
//unordered_map<uint64_t, VkDescriptorSetCreateInfo> descriptorSetMap;
unordered_map<uint64_t, VkDynamicViewportStateCreateInfo> dynamicViewportStateMap;
-unordered_map<uint64_t, VkDynamicRasterStateCreateInfo> dynamicRasterStateMap;
+unordered_map<uint64_t, VkDynamicRasterLineStateCreateInfo> dynamicRasterLineStateMap;
+unordered_map<uint64_t, VkDynamicRasterDepthBiasStateCreateInfo> dynamicRasterDepthBiasStateMap;
unordered_map<uint64_t, VkDynamicColorBlendStateCreateInfo> dynamicColorBlendStateMap;
unordered_map<uint64_t, VkDynamicDepthStencilStateCreateInfo> dynamicDepthStencilStateMap;
return (void*)&(*it).second;
break;
}
- case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
+ case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE:
{
- auto it = dynamicRasterStateMap.find(handle);
- if (it != dynamicRasterStateMap.end())
+ auto it = dynamicRasterLineStateMap.find(handle);
+ if (it != dynamicRasterLineStateMap.end())
+ return (void*)&(*it).second;
+ break;
+ }
+ case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE:
+ {
+ auto it = dynamicRasterDepthBiasStateMap.find(handle);
+ if (it != dynamicRasterDepthBiasStateMap.end())
return (void*)&(*it).second;
break;
}
memcpy(pCI, pCreateInfo, sizeof(VkDynamicViewportStateCreateInfo));
break;
}
- case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
+ case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE:
+ {
+ auto pCI = &dynamicRasterLineStateMap[handle];
+ memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterLineStateCreateInfo));
+ break;
+ }
+ case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE:
{
- auto pCI = &dynamicRasterStateMap[handle];
- memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterStateCreateInfo));
+ auto pCI = &dynamicRasterDepthBiasStateMap[handle];
+ memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterDepthBiasStateCreateInfo));
break;
}
case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE:
print_object_map_members(dispObj, renderPassMap, VK_OBJECT_TYPE_RENDER_PASS, "RenderPass");
print_object_map_members(dispObj, framebufferMap, VK_OBJECT_TYPE_FRAMEBUFFER, "Framebuffer");
print_object_map_members(dispObj, dynamicViewportStateMap, VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE, "DynamicViewportState");
- print_object_map_members(dispObj, dynamicRasterStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, "DynamicRasterState");
+ print_object_map_members(dispObj, dynamicRasterLineStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, "DynamicRasterLineState");
+ print_object_map_members(dispObj, dynamicRasterDepthBiasStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, "DynamicRasterDepthBiasState");
print_object_map_members(dispObj, dynamicColorBlendStateMap, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, "DynamicColorBlendState");
print_object_map_members(dispObj, dynamicDepthStencilStateMap, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, "DynamicDepthStencilState");
log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, 0, 0, MEMTRACK_NONE, "MEM", "*** End of Object lists ***");
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState)
{
loader_platform_thread_lock_mutex(&globalLock);
- auto item = dynamicRasterStateMap.find(dynamicRasterState.handle);
- if (item != dynamicRasterStateMap.end()) {
- dynamicRasterStateMap.erase(item);
+ auto item = dynamicRasterLineStateMap.find(dynamicRasterLineState.handle);
+ if (item != dynamicRasterLineStateMap.end()) {
+ dynamicRasterLineStateMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
+ return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+ loader_platform_thread_lock_mutex(&globalLock);
+ auto item = dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle);
+ if (item != dynamicRasterDepthBiasStateMap.end()) {
+ dynamicRasterDepthBiasStateMap.erase(item);
+ }
+ loader_platform_thread_unlock_mutex(&globalLock);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
return result;
}
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(
VkDevice device,
- const VkDynamicRasterStateCreateInfo *pCreateInfo,
- VkDynamicRasterState *pState)
+ const VkDynamicRasterLineStateCreateInfo *pCreateInfo,
+ VkDynamicRasterLineState *pState)
{
- VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, pCreateInfo);
+ add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, pCreateInfo);
+ loader_platform_thread_unlock_mutex(&globalLock);
+ }
+ return result;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(
+ VkDevice device,
+ const VkDynamicRasterDepthBiasStateCreateInfo *pCreateInfo,
+ VkDynamicRasterDepthBiasState *pState)
+{
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+ if (result == VK_SUCCESS) {
+ loader_platform_thread_lock_mutex(&globalLock);
+ add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, pCreateInfo);
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
}
-void VKAPI vkCmdBindDynamicRasterState(
+void VKAPI vkCmdBindDynamicRasterLineState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicRasterLineState dynamicRasterLineState)
+{
+ VkDynamicRasterLineStateCreateInfo* pCI;
+ loader_platform_thread_lock_mutex(&globalLock);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer);
+ if (!pCmdBuf) {
+ // TODO : Want cmdBuffer to be srcObj here
+ log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, MEMTRACK_INVALID_CB, "MEM",
+ "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ }
+ pCI = (VkDynamicRasterLineStateCreateInfo*)get_object_create_info(dynamicRasterLineState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE);
+ if (!pCI) {
+ log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, dynamicRasterLineState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
+ "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterLineState.handle);
+ }
+ pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle;
+ loader_platform_thread_unlock_mutex(&globalLock);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
+}
+
+void VKAPI vkCmdBindDynamicRasterDepthBiasState(
VkCmdBuffer cmdBuffer,
- VkDynamicRasterState dynamicRasterState)
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
{
- VkDynamicRasterStateCreateInfo* pCI;
+ VkDynamicRasterDepthBiasStateCreateInfo* pCI;
loader_platform_thread_lock_mutex(&globalLock);
MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer);
if (!pCmdBuf) {
log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, MEMTRACK_INVALID_CB, "MEM",
"Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
}
- pCI = (VkDynamicRasterStateCreateInfo*)get_object_create_info(dynamicRasterState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE);
+ pCI = (VkDynamicRasterDepthBiasStateCreateInfo*)get_object_create_info(dynamicRasterDepthBiasState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE);
if (!pCI) {
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
- "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle);
+ log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, dynamicRasterDepthBiasState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
+ "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterDepthBiasState.handle);
}
- pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
+ pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle;
loader_platform_thread_unlock_mutex(&globalLock);
- get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
}
void VKAPI vkCmdBindDynamicColorBlendState(
return (PFN_vkVoidFunction) vkDestroyFramebuffer;
if (!strcmp(funcName, "vkDestroyDynamicViewportState"))
return (PFN_vkVoidFunction) vkDestroyDynamicViewportState;
- if (!strcmp(funcName, "vkDestroyDynamicRasterState"))
- return (PFN_vkVoidFunction) vkDestroyDynamicRasterState;
+ if (!strcmp(funcName, "vkDestroyDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState;
+ if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
return (PFN_vkVoidFunction) vkCreateSampler;
if (!strcmp(funcName, "vkCreateDynamicViewportState"))
return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
- if (!strcmp(funcName, "vkCreateDynamicRasterState"))
- return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
return (PFN_vkVoidFunction) vkCmdBindPipeline;
if (!strcmp(funcName, "vkCmdBindDynamicViewportState"))
return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState;
- if (!strcmp(funcName, "vkCmdBindDynamicRasterState"))
- return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState;
+ if (!strcmp(funcName, "vkCmdBindDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState;
+ if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
return result;
}
-bool PreCreateDynamicRasterState(
+bool PreCreateDynamicRasterLineState(
VkDevice device,
- const VkDynamicRasterStateCreateInfo* pCreateInfo)
+ const VkDynamicRasterLineStateCreateInfo* pCreateInfo)
{
if(pCreateInfo != nullptr)
{
- if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateDynamicRasterState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+ "vkCreateDynamicRasterLineState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
return false;
}
}
return true;
}
-bool PostCreateDynamicRasterState(
+bool PostCreateDynamicRasterLineState(
VkDevice device,
- VkDynamicRasterState* pState,
+ VkDynamicRasterLineState* pState,
VkResult result)
{
if(result < VK_SUCCESS)
{
- std::string reason = "vkCreateDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result);
+ std::string reason = "vkCreateDynamicRasterLineState parameter, VkResult result, is " + EnumeratorString(result);
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
return false;
}
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(
VkDevice device,
- const VkDynamicRasterStateCreateInfo* pCreateInfo,
- VkDynamicRasterState* pState)
+ const VkDynamicRasterLineStateCreateInfo* pCreateInfo,
+ VkDynamicRasterLineState* pState)
{
- PreCreateDynamicRasterState(device, pCreateInfo);
+ PreCreateDynamicRasterLineState(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState);
- PostCreateDynamicRasterState(device, pState, result);
+ PostCreateDynamicRasterLineState(device, pState, result);
return result;
}
-bool PostDestroyDynamicRasterState(
+bool PostDestroyDynamicRasterLineState(
VkDevice device,
- VkDynamicRasterState dynamicRasterState,
+ VkDynamicRasterLineState dynamicRasterLineState,
VkResult result)
{
if(result < VK_SUCCESS)
{
- std::string reason = "vkDestroyDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result);
+ std::string reason = "vkDestroyDynamicRasterLineState parameter, VkResult result, is " + EnumeratorString(result);
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
return false;
}
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(
VkDevice device,
- VkDynamicRasterState dynamicRasterState)
+ VkDynamicRasterLineState dynamicRasterLineState)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
- PostDestroyDynamicRasterState(device, dynamicRasterState, result);
+ PostDestroyDynamicRasterLineState(device, dynamicRasterLineState, result);
+
+ return result;
+}
+
+bool PreCreateDynamicRasterDepthBiasState(
+ VkDevice device,
+ const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo)
+{
+ if(pCreateInfo != nullptr)
+ {
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO)
+ {
+ log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCreateDynamicRasterDepthBiasState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool PostCreateDynamicRasterDepthBiasState(
+ VkDevice device,
+ VkDynamicRasterDepthBiasState* pState,
+ VkResult result)
+{
+
+ if(pState != nullptr)
+ {
+ }
+
+ if(result < VK_SUCCESS)
+ {
+ std::string reason = "vkCreateDynamicRasterDepthBiasState parameter, VkResult result, is " + EnumeratorString(result);
+ log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+ return false;
+ }
+
+ return true;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(
+ VkDevice device,
+ const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo,
+ VkDynamicRasterDepthBiasState* pState)
+{
+ PreCreateDynamicRasterDepthBiasState(device, pCreateInfo);
+
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+
+ PostCreateDynamicRasterDepthBiasState(device, pState, result);
+
+ return result;
+}
+
+bool PostDestroyDynamicRasterDepthBiasState(
+ VkDevice device,
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState,
+ VkResult result)
+{
+
+
+ if(result < VK_SUCCESS)
+ {
+ std::string reason = "vkDestroyDynamicRasterDepthBiasState parameter, VkResult result, is " + EnumeratorString(result);
+ log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+ return false;
+ }
+
+ return true;
+}
+
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(
+ VkDevice device,
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
+
+ PostDestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState, result);
return result;
}
PostCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
}
-bool PostCmdBindDynamicRasterState(
+bool PostCmdBindDynamicRasterLineState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicRasterLineState dynamicRasterLineState)
+{
+
+
+ return true;
+}
+
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(
+ VkCmdBuffer cmdBuffer,
+ VkDynamicRasterLineState dynamicRasterLineState)
+{
+ get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
+
+ PostCmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState);
+}
+
+bool PostCmdBindDynamicRasterDepthBiasState(
VkCmdBuffer cmdBuffer,
- VkDynamicRasterState dynamicRasterState)
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
{
return true;
}
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState(
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(
VkCmdBuffer cmdBuffer,
- VkDynamicRasterState dynamicRasterState)
+ VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+ get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
- PostCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+ PostCmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState);
}
bool PostCmdBindDynamicColorBlendState(
return (PFN_vkVoidFunction) vkAllocDescriptorSets;
if (!strcmp(funcName, "vkCreateDynamicViewportState"))
return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
- if (!strcmp(funcName, "vkCreateDynamicRasterState"))
- return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterLineState"))
+ return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState;
+ if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState"))
+ return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState;
if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
return (void*) vkCreateDynamicViewportState;
if (!strcmp(name, "DestroyDynamicViewportState"))
return (void*) vkDestroyDynamicViewportState;
- if (!strcmp(name, "CreateDynamicRasterState"))
- return (void*) vkCreateDynamicRasterState;
- if (!strcmp(name, "DestroyDynamicRasterState"))
- return (void*) vkDestroyDynamicRasterState;
+ if (!strcmp(name, "CreateDynamicRasterLineState"))
+ return (void*) vkCreateDynamicRasterLineState;
+ if (!strcmp(name, "DestroyDynamicRasterLineState"))
+ return (void*) vkDestroyDynamicRasterLineState;
+ if (!strcmp(name, "CreateDynamicRasterDepthBiasState"))
+ return (void*) vkCreateDynamicRasterDepthBiasState;
+ if (!strcmp(name, "DestroyDynamicRasterDepthBiasState"))
+ return (void*) vkDestroyDynamicRasterDepthBiasState;
if (!strcmp(name, "CreateDynamicColorBlendState"))
return (void*) vkCreateDynamicColorBlendState;
if (!strcmp(name, "DestroyDynamicColorBlendState"))
return (void*) vkCmdBindPipeline;
if (!strcmp(name, "CmdBindDynamicViewportState"))
return (void*) vkCmdBindDynamicViewportState;
- if (!strcmp(name, "CmdBindDynamicRasterState"))
- return (void*) vkCmdBindDynamicRasterState;
+ if (!strcmp(name, "CmdBindDynamicRasterLineState"))
+ return (void*) vkCmdBindDynamicRasterLineState;
+ if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState"))
+ return (void*) vkCmdBindDynamicRasterDepthBiasState;
if (!strcmp(name, "CmdBindDynamicColorBlendState"))
return (void*) vkCmdBindDynamicColorBlendState;
if (!strcmp(name, "CmdBindDynamicDepthStencilState"))
table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets");
table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(dev, "vkCreateDynamicViewportState");
table->DestroyDynamicViewportState = (PFN_vkDestroyDynamicViewportState) gpa(dev, "vkDestroyDynamicViewportState");
- table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(dev, "vkCreateDynamicRasterState");
- table->DestroyDynamicRasterState = (PFN_vkDestroyDynamicRasterState) gpa(dev, "vkDestroyDynamicRasterState");
+ table->CreateDynamicRasterLineState = (PFN_vkCreateDynamicRasterLineState) gpa(dev, "vkCreateDynamicRasterLineState");
+ table->DestroyDynamicRasterLineState = (PFN_vkDestroyDynamicRasterLineState) gpa(dev, "vkDestroyDynamicRasterLineState");
+ table->CreateDynamicRasterDepthBiasState = (PFN_vkCreateDynamicRasterDepthBiasState) gpa(dev, "vkCreateDynamicRasterDepthBiasState");
+ table->DestroyDynamicRasterDepthBiasState = (PFN_vkDestroyDynamicRasterDepthBiasState) gpa(dev, "vkDestroyDynamicRasterDepthBiasState");
table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(dev, "vkCreateDynamicColorBlendState");
table->DestroyDynamicColorBlendState = (PFN_vkDestroyDynamicColorBlendState) gpa(dev, "vkDestroyDynamicColorBlendState");
table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(dev, "vkCreateDynamicDepthStencilState");
table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(dev, "vkResetCommandBuffer");
table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(dev, "vkCmdBindPipeline");
table->CmdBindDynamicViewportState = (PFN_vkCmdBindDynamicViewportState) gpa(dev, "vkCmdBindDynamicViewportState");
- table->CmdBindDynamicRasterState = (PFN_vkCmdBindDynamicRasterState) gpa(dev, "vkCmdBindDynamicRasterState");
+ table->CmdBindDynamicRasterLineState = (PFN_vkCmdBindDynamicRasterLineState) gpa(dev, "vkCmdBindDynamicRasterLineState");
+ table->CmdBindDynamicRasterDepthBiasState = (PFN_vkCmdBindDynamicRasterDepthBiasState) gpa(dev, "vkCmdBindDynamicRasterDepthBiasState");
table->CmdBindDynamicColorBlendState = (PFN_vkCmdBindDynamicColorBlendState) gpa(dev, "vkCmdBindDynamicColorBlendState");
table->CmdBindDynamicDepthStencilState = (PFN_vkCmdBindDynamicDepthStencilState) gpa(dev, "vkCmdBindDynamicDepthStencilState");
table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(dev, "vkCmdBindDescriptorSets");
return (void *) table->CreateDynamicViewportState;
if (!strcmp(name, "DestroyDynamicViewportState"))
return (void *) table->DestroyDynamicViewportState;
- if (!strcmp(name, "CreateDynamicRasterState"))
- return (void *) table->CreateDynamicRasterState;
- if (!strcmp(name, "DestroyDynamicRasterState"))
- return (void *) table->DestroyDynamicRasterState;
+ if (!strcmp(name, "CreateDynamicRasterLineState"))
+ return (void *) table->CreateDynamicRasterLineState;
+ if (!strcmp(name, "DestroyDynamicRasterLineState"))
+ return (void *) table->DestroyDynamicRasterLineState;
+ if (!strcmp(name, "CreateDynamicRasterDepthBiasState"))
+ return (void *) table->CreateDynamicRasterDepthBiasState;
+ if (!strcmp(name, "DestroyDynamicRasterDepthBiasState"))
+ return (void *) table->DestroyDynamicRasterDepthBiasState;
if (!strcmp(name, "CreateDynamicColorBlendState"))
return (void *) table->CreateDynamicColorBlendState;
if (!strcmp(name, "DestroyDynamicColorBlendState"))
return (void *) table->CmdBindPipeline;
if (!strcmp(name, "CmdBindDynamicViewportState"))
return (void *) table->CmdBindDynamicViewportState;
- if (!strcmp(name, "CmdBindDynamicRasterState"))
- return (void *) table->CmdBindDynamicRasterState;
+ if (!strcmp(name, "CmdBindDynamicRasterLineState"))
+ return (void *) table->CmdBindDynamicRasterLineState;
+ if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState"))
+ return (void *) table->CmdBindDynamicRasterDepthBiasState;
if (!strcmp(name, "CmdBindDynamicColorBlendState"))
return (void *) table->CmdBindDynamicColorBlendState;
if (!strcmp(name, "CmdBindDynamicDepthStencilState"))
return disp->DestroyDynamicViewportState(device, dynamicViewportState);
}
-LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->CreateDynamicRasterState(device, pCreateInfo, pState);
+ return disp->CreateDynamicRasterLineState(device, pCreateInfo, pState);
}
-LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->DestroyDynamicRasterState(device, dynamicRasterState);
+ return disp->DestroyDynamicRasterLineState(device, dynamicRasterLineState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState)
+{
+ const VkLayerDispatchTable *disp;
+
+ disp = loader_get_dispatch(device);
+
+ return disp->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState)
+{
+ const VkLayerDispatchTable *disp;
+
+ disp = loader_get_dispatch(device);
+
+ return disp->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState);
}
LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState)
disp->CmdBindDynamicViewportState(cmdBuffer, state);
}
-LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState state)
+LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState state)
+{
+ const VkLayerDispatchTable *disp;
+
+ disp = loader_get_dispatch(cmdBuffer);
+
+ disp->CmdBindDynamicRasterLineState(cmdBuffer, state);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState state)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(cmdBuffer);
- disp->CmdBindDynamicRasterState(cmdBuffer, state);
+ disp->CmdBindDynamicRasterDepthBiasState(cmdBuffer, state);
}
LOADER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState state)
def generate_command_buffer_validates(self):
cbv_txt = []
cbv_txt.append('%s' % self.lineinfo.get())
- for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState',
+ for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterLineState', 'VkDynamicRasterDepthBiasState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState',
'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']:
cbv_txt.append('static void validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o))
cbv_txt.append('{')
'VkDescriptorPool' : 'VK_OBJECT_TYPE_DESCRIPTOR_POOL',
'VkDescriptorSet' : 'VK_OBJECT_TYPE_DESCRIPTOR_SET',
'VkDynamicViewportState' : 'VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE',
- 'VkDynamicRasterState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE',
+ 'VkDynamicRasterLineState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE',
+ 'VkDynamicRasterDepthBiasState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE',
'VkDynamicColorBlendState' : 'VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE',
'VkDynamicDepthStencilState' : 'VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE',
'VkFramebuffer' : 'VK_OBJECT_TYPE_FRAMEBUFFER',
"VkDescriptorPool",
"VkDescriptorSet",
"VkDynamicViewportState",
- "VkDynamicRasterState",
+ "VkDynamicRasterLineState",
+ "VkDynamicRasterDepthBiasState",
"VkDynamicColorBlendState",
"VkDynamicDepthStencilState",
"VkRenderPass",
[Param("VkDevice", "device"),
Param("VkDynamicViewportState", "dynamicViewportState")]),
- Proto("VkResult", "CreateDynamicRasterState",
+ Proto("VkResult", "CreateDynamicRasterLineState",
[Param("VkDevice", "device"),
- Param("const VkDynamicRasterStateCreateInfo*", "pCreateInfo"),
- Param("VkDynamicRasterState*", "pState")]),
+ Param("const VkDynamicRasterLineStateCreateInfo*", "pCreateInfo"),
+ Param("VkDynamicRasterLineState*", "pState")]),
- Proto("VkResult", "DestroyDynamicRasterState",
+ Proto("VkResult", "DestroyDynamicRasterLineState",
[Param("VkDevice", "device"),
- Param("VkDynamicRasterState", "dynamicRasterState")]),
+ Param("VkDynamicRasterLineState", "dynamicRasterLineState")]),
+
+ Proto("VkResult", "CreateDynamicRasterDepthBiasState",
+ [Param("VkDevice", "device"),
+ Param("const VkDynamicRasterDepthBiasStateCreateInfo*", "pCreateInfo"),
+ Param("VkDynamicRasterDepthBiasState*", "pState")]),
+
+ Proto("VkResult", "DestroyDynamicRasterDepthBiasState",
+ [Param("VkDevice", "device"),
+ Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]),
Proto("VkResult", "CreateDynamicColorBlendState",
[Param("VkDevice", "device"),
[Param("VkCmdBuffer", "cmdBuffer"),
Param("VkDynamicViewportState", "dynamicViewportState")]),
- Proto("void", "CmdBindDynamicRasterState",
+ Proto("void", "CmdBindDynamicRasterLineState",
+ [Param("VkCmdBuffer", "cmdBuffer"),
+ Param("VkDynamicRasterLineState", "dynamicRasterLineState")]),
+
+ Proto("void", "CmdBindDynamicRasterDepthBiasState",
[Param("VkCmdBuffer", "cmdBuffer"),
- Param("VkDynamicRasterState", "dynamicRasterState")]),
+ Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]),
Proto("void", "CmdBindDynamicColorBlendState",
[Param("VkCmdBuffer", "cmdBuffer"),
"VkDescriptorPool",
"VkDescriptorSet",
"VkDynamicViewportState",
- "VkDynamicRasterState",
+ "VkDynamicRasterLineState",
+ "VkDynamicRasterDepthBiasState",
"VkDynamicColorBlendState",
"VkDynamicDepthStencilState",
"VkRenderPass",
projects / platform / upstream / Vulkan-Tools.git / commitdiff