From 5e4125d22120c99efe93e9ed44e671c42a5486dc Mon Sep 17 00:00:00 2001 From: Cody Northrop Date: Wed, 26 Aug 2015 10:01:32 -0600 Subject: v156: Bug 14451 - Rename dynamic state objects --- layers/draw_state.cpp | 256 +++++++++++++++++++++++++------------------------- 1 file changed, 128 insertions(+), 128 deletions(-) (limited to 'layers/draw_state.cpp') diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index a05fc659..bbadcaf4 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -65,10 +65,10 @@ unordered_map imageMap; unordered_map viewMap; unordered_map bufferMap; unordered_map dynamicVpStateMap; -unordered_map dynamicRasterLineStateMap; -unordered_map dynamicRasterDepthBiasStateMap; -unordered_map dynamicCbStateMap; -unordered_map dynamicDepthStateMap; +unordered_map dynamicLineWidthStateMap; +unordered_map dynamicDepthBiasStateMap; +unordered_map dynamicBlendStateMap; +unordered_map dynamicDepthBoundsStateMap; unordered_map> dynamicStencilStateMap; unordered_map pipelineMap; unordered_map poolMap; @@ -142,14 +142,14 @@ static string cmdTypeToString(CMD_TYPE cmd) return "CMD_BINDPIPELINEDELTA"; case CMD_BINDDYNAMICVIEWPORTSTATE: return "CMD_BINDDYNAMICVIEWPORTSTATE"; - case CMD_BINDDYNAMICRASTERLINESTATE: - return "CMD_BINDDYNAMICRASTERLINESTATE"; - case CMD_BINDDYNAMICRASTERDEPTHBIASSTATE: - return "CMD_BINDDYNAMICRASTERDEPTHBIASSTATE"; - case CMD_BINDDYNAMICCOLORBLENDSTATE: - return "CMD_BINDDYNAMICCOLORBLENDSTATE"; - case CMD_BINDDYNAMICDEPTHSTATE: - return "CMD_BINDDYNAMICDEPTHSTATE"; + case CMD_BINDDYNAMICLINEWIDTHSTATE: + return "CMD_BINDDYNAMICLINEWIDTHSTATE"; + case CMD_BINDDYNAMICDEPTHBIASSTATE: + return "CMD_BINDDYNAMICDEPTHBIASSTATE"; + case CMD_BINDDYNAMICBLENDSTATE: + return "CMD_BINDDYNAMICBLENDSTATE"; + case CMD_BINDDYNAMICDEPTHBOUNDSSTATE: + return "CMD_BINDDYNAMICDEPTHBOUNDSSTATE"; case CMD_BINDDYNAMICSTENCILSTATE: return "CMD_BINDDYNAMICSTENCILSTATE"; case CMD_BINDDESCRIPTORSETS: @@ -263,10 +263,10 @@ static void deleteDynamicState() delete[] (*ii).second.pViewports; } dynamicVpStateMap.clear(); - dynamicRasterLineStateMap.clear(); - dynamicRasterDepthBiasStateMap.clear(); - dynamicCbStateMap.clear(); - dynamicDepthStateMap.clear(); + dynamicLineWidthStateMap.clear(); + dynamicDepthBiasStateMap.clear(); + dynamicBlendStateMap.clear(); + dynamicDepthBoundsStateMap.clear(); dynamicStencilStateMap.clear(); } // Free all sampler nodes @@ -366,14 +366,14 @@ static void* getDynamicStateCreateInfo(const uint64_t handle, const DYNAMIC_STAT switch (type) { case VK_STATE_BIND_POINT_VIEWPORT: return (void*)&dynamicVpStateMap[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: - return (void*)&dynamicDepthStateMap[handle]; + case VK_STATE_BIND_POINT_LINE_WIDTH: + return (void*)&dynamicLineWidthStateMap[handle]; + case VK_STATE_BIND_POINT_DEPTH_BIAS: + return (void*)&dynamicDepthBiasStateMap[handle]; + case VK_STATE_BIND_POINT_BLEND: + return (void*)&dynamicBlendStateMap[handle]; + case VK_STATE_BIND_POINT_DEPTH_BOUNDS: + return (void*)&dynamicDepthBoundsStateMap[handle]; case VK_STATE_BIND_POINT_STENCIL: return (void*)&dynamicStencilStateMap[handle]; default: @@ -421,10 +421,10 @@ static PIPELINE_NODE* getPipeline(VkPipeline pipeline) 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_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_WRITE_ENABLE, CBSTATUS_DEPTH_BOUND, CBSTATUS_DEPTH_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_NOT_BOUND, "Depth object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_LINE_WIDTH_BOUND, CBSTATUS_LINE_WIDTH_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_LINE_WIDTH_NOT_BOUND, "Line width object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_DEPTH_BIAS_BOUND, CBSTATUS_DEPTH_BIAS_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BIAS_NOT_BOUND, "Depth bias object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_BLEND_BOUND, CBSTATUS_BLEND_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_BLEND_NOT_BOUND, "Blend object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_DEPTH_WRITE_ENABLE, CBSTATUS_DEPTH_BOUNDS_BOUND, CBSTATUS_DEPTH_BOUNDS_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, "Depth bounds object not bound to this command buffer"); result &= validate_status(pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_BOUND, CBSTATUS_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Stencil object not bound to this command buffer"); if (indexedDraw) result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_INDEX_BUFFER_BOUND, CBSTATUS_INDEX_BUFFER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_INDEX_BUFFER_NOT_BOUND, "Index buffer object not bound to this command buffer when Index Draw attempted"); @@ -1153,14 +1153,14 @@ static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe) 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_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) { - pNode->status |= CBSTATUS_DEPTH_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_LINE_WIDTH) { + pNode->status |= CBSTATUS_LINE_WIDTH_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_BIAS) { + pNode->status |= CBSTATUS_DEPTH_BIAS_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_BLEND) { + pNode->status |= CBSTATUS_BLEND_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_BOUNDS) { + pNode->status |= CBSTATUS_DEPTH_BOUNDS_BOUND; } else if (stateBindPoint == VK_STATE_BIND_POINT_STENCIL) { pNode->status |= CBSTATUS_STENCIL_BOUND; } @@ -1627,30 +1627,30 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState); // TODO : Clean up any internal data structures using this obj. return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState); // TODO : Clean up any internal data structures using this obj. return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicColorBlendState(device, dynamicColorBlendState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState); // TODO : Clean up any internal data structures using this obj. return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(VkDevice device, VkDynamicDepthState dynamicDepthState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState); // TODO : Clean up any internal data structures using this obj. return result; } @@ -1987,42 +1987,42 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, con return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* 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); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicLineWidthState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_LINE_WIDTH); loader_platform_thread_lock_mutex(&globalLock); - dynamicRasterLineStateMap[pState->handle] = *pCreateInfo; + dynamicLineWidthStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState) { - 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); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthBiasState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_BIAS); loader_platform_thread_lock_mutex(&globalLock); - dynamicRasterDepthBiasStateMap[pState->handle] = *pCreateInfo; + dynamicDepthBiasStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicBlendState(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); - //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_COLOR_BLEND); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicBlendState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_BLEND); loader_platform_thread_lock_mutex(&globalLock); - dynamicCbStateMap[pState->handle] = *pCreateInfo; + dynamicBlendStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState(VkDevice device, const VkDynamicDepthStateCreateInfo* pCreateInfo, VkDynamicDepthState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState); - //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthBoundsState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_BOUNDS); loader_platform_thread_lock_mutex(&globalLock); - dynamicDepthStateMap[pState->handle] = *pCreateInfo; + dynamicDepthBoundsStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } @@ -2187,111 +2187,111 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicLineWidthState(VkCmdBuffer cmdBuffer, VkDynamicLineWidthState dynamicLineWidthState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICRASTERLINESTATE); + addCmd(pCB, CMD_BINDDYNAMICLINEWIDTHSTATE); 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."); + "Incorrect call to vkCmdBindDynamicLineWidthState() 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); + pCB->status |= CBSTATUS_LINE_WIDTH_BOUND; + if (dynamicLineWidthStateMap.find(dynamicLineWidthState.handle) == dynamicLineWidthStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE, dynamicLineWidthState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicLineWidthState object %#" PRIxLEAST64 ", was it ever created?", dynamicLineWidthState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_LINE_WIDTH] = dynamicLineWidthState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_LINE_WIDTH] = dynamicLineWidthState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicLineWidthState(cmdBuffer, dynamicLineWidthState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterLineState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicLineWidthState()"); } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicDepthBiasState dynamicDepthBiasState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICRASTERDEPTHBIASSTATE); + addCmd(pCB, CMD_BINDDYNAMICDEPTHBIASSTATE); 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 vkCmdBindDynamicRasterDepthBiasState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicDepthBiasState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - 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); + pCB->status |= CBSTATUS_DEPTH_BIAS_BOUND; + if (dynamicDepthBiasStateMap.find(dynamicDepthBiasState.handle) == dynamicDepthBiasStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE, dynamicDepthBiasState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicDepthBiasState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthBiasState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BIAS] = dynamicDepthBiasState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BIAS] = dynamicDepthBiasState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthBiasState(cmdBuffer, dynamicDepthBiasState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterDepthBiasState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthBiasState()"); } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicBlendState(VkCmdBuffer cmdBuffer, VkDynamicBlendState dynamicBlendState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICCOLORBLENDSTATE); + addCmd(pCB, CMD_BINDDYNAMICBLENDSTATE); 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 vkCmdBindDynamicColorBlendState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicBlendState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - pCB->status |= CBSTATUS_COLOR_BLEND_BOUND; - if (dynamicCbStateMap.find(dynamicColorBlendState.handle) == dynamicCbStateMap.end()) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, dynamicColorBlendState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", - "Unable to find VkDynamicColorBlendState object %#" PRIxLEAST64 ", was it ever created?", dynamicColorBlendState.handle); + pCB->status |= CBSTATUS_BLEND_BOUND; + if (dynamicBlendStateMap.find(dynamicBlendState.handle) == dynamicBlendStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE, dynamicBlendState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicBlendState object %#" PRIxLEAST64 ", was it ever created?", dynamicBlendState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_COLOR_BLEND] = dynamicColorBlendState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_COLOR_BLEND] = dynamicColorBlendState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_BLEND] = dynamicBlendState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_BLEND] = dynamicBlendState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicBlendState(cmdBuffer, dynamicBlendState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicColorBlendState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicBlendState()"); } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthState(VkCmdBuffer cmdBuffer, VkDynamicDepthState dynamicDepthState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState(VkCmdBuffer cmdBuffer, VkDynamicDepthBoundsState dynamicDepthBoundsState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICDEPTHSTATE); + addCmd(pCB, CMD_BINDDYNAMICDEPTHBOUNDSSTATE); 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 vkCmdBindDynamicDepthState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicDepthBoundsState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - pCB->status |= CBSTATUS_DEPTH_BOUND; - if (dynamicDepthStateMap.find(dynamicDepthState.handle) == dynamicDepthStateMap.end()) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, dynamicDepthState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", - "Unable to find VkDynamicDepthState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthState.handle); + pCB->status |= CBSTATUS_DEPTH_BOUNDS_BOUND; + if (dynamicDepthBoundsStateMap.find(dynamicDepthBoundsState.handle) == dynamicDepthBoundsStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE, dynamicDepthBoundsState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicDepthBoundsState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthBoundsState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BOUNDS] = dynamicDepthBoundsState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BOUNDS] = dynamicDepthBoundsState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthBoundsState(cmdBuffer, dynamicDepthBoundsState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthBoundsState()"); } } } @@ -3177,14 +3177,14 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const return (PFN_vkVoidFunction) vkDestroyDescriptorPool; if (!strcmp(funcName, "vkDestroyDynamicViewportState")) return (PFN_vkVoidFunction) vkDestroyDynamicViewportState; - 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, "vkDestroyDynamicDepthState")) - return (PFN_vkVoidFunction) vkDestroyDynamicDepthState; + if (!strcmp(funcName, "vkDestroyDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkDestroyDynamicLineWidthState; + if (!strcmp(funcName, "vkDestroyDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkDestroyDynamicDepthBiasState; + if (!strcmp(funcName, "vkDestroyDynamicBlendState")) + return (PFN_vkVoidFunction) vkDestroyDynamicBlendState; + if (!strcmp(funcName, "vkDestroyDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkDestroyDynamicDepthBoundsState; if (!strcmp(funcName, "vkDestroyDynamicStencilState")) return (PFN_vkVoidFunction) vkDestroyDynamicStencilState; if (!strcmp(funcName, "vkDestroyCommandBuffer")) @@ -3227,14 +3227,14 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const return (PFN_vkVoidFunction) vkUpdateDescriptorSets; if (!strcmp(funcName, "vkCreateDynamicViewportState")) return (PFN_vkVoidFunction) vkCreateDynamicViewportState; - 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, "vkCreateDynamicDepthState")) - return (PFN_vkVoidFunction) vkCreateDynamicDepthState; + if (!strcmp(funcName, "vkCreateDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCreateDynamicLineWidthState; + if (!strcmp(funcName, "vkCreateDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBiasState; + if (!strcmp(funcName, "vkCreateDynamicBlendState")) + return (PFN_vkVoidFunction) vkCreateDynamicBlendState; + if (!strcmp(funcName, "vkCreateDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBoundsState; if (!strcmp(funcName, "vkCreateDynamicStencilState")) return (PFN_vkVoidFunction) vkCreateDynamicStencilState; if (!strcmp(funcName, "vkCreateCommandBuffer")) @@ -3249,14 +3249,14 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const return (PFN_vkVoidFunction) vkCmdBindPipeline; if (!strcmp(funcName, "vkCmdBindDynamicViewportState")) return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState; - 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, "vkCmdBindDynamicDepthState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicDepthState; + if (!strcmp(funcName, "vkCmdBindDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicLineWidthState; + if (!strcmp(funcName, "vkCmdBindDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicDepthBiasState; + if (!strcmp(funcName, "vkCmdBindDynamicBlendState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicBlendState; + if (!strcmp(funcName, "vkCmdBindDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicDepthBoundsState; if (!strcmp(funcName, "vkCmdBindDynamicStencilState")) return (PFN_vkVoidFunction) vkCmdBindDynamicStencilState; if (!strcmp(funcName, "vkCmdBindDescriptorSets")) -- cgit v1.2.3