layers: Make dispatch table thread safe
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 6540195..4178973 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -45,6 +45,7 @@
// being used:
#include "loader_platform.h"
#include "layers_msg.h"
+#include "layers_table.h"
#include "layers_debug_marker_table.h"
unordered_map<VkSampler, SAMPLER_NODE*> sampleMap;
@@ -64,8 +65,6 @@
bool debug_marker_enabled;
};
-static std::unordered_map<void *, VkLayerDispatchTable *> tableMap;
-static std::unordered_map<void *, VkLayerInstanceDispatchTable *> tableInstanceMap;
static std::unordered_map<void *, struct devExts> deviceExtMap;
static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
@@ -1447,50 +1446,6 @@
}
}
-static VkLayerDispatchTable * initDeviceTable(const VkBaseLayerObject *devw)
-{
- VkLayerDispatchTable *pTable;
-
- assert(devw);
- VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) (devw->baseObject);
-
- std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap.find((void *) *ppDisp);
- if (it == tableMap.end())
- {
- pTable = new VkLayerDispatchTable;
- tableMap[(void *) *ppDisp] = pTable;
-
- } else
- {
- return it->second;
- }
-
- layer_initialize_dispatch_table(pTable, devw);
-
- return pTable;
-}
-
-static VkLayerInstanceDispatchTable * initInstanceTable(const VkBaseLayerObject *instw)
-{
- VkLayerInstanceDispatchTable *pTable;
- assert(instw);
- VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instw->baseObject;
-
- std::unordered_map<void *, VkLayerInstanceDispatchTable *>::const_iterator it = tableInstanceMap.find((void *) *ppDisp);
- if (it == tableInstanceMap.end())
- {
- pTable = new VkLayerInstanceDispatchTable;
- tableInstanceMap[(void *) *ppDisp] = pTable;
- } else
- {
- return it->second;
- }
-
- layer_init_instance_dispatch_table(pTable, instw);
-
- return pTable;
-}
-
static void initDrawState(void)
{
const char *strOpt;
@@ -1545,8 +1500,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
{
VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) instance;
- VkLayerInstanceDispatchTable *pTable = tableInstanceMap[pDisp];
- VkResult res = pTable->DestroyInstance(instance);
+ VkResult res = instance_dispatch_table(instance)->DestroyInstance(instance);
tableInstanceMap.erase(pDisp);
return res;
}
@@ -1569,9 +1523,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
{
- VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) gpu;
- VkLayerInstanceDispatchTable* pInstTable = tableInstanceMap[*ppDisp];
- VkResult result = pInstTable->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkResult result = instance_dispatch_table(gpu)->CreateDevice(gpu, pCreateInfo, pDevice);
createDeviceRegisterExtensions(pCreateInfo, *pDevice);
return result;
}
@@ -1591,8 +1543,7 @@
loader_platform_thread_unlock_mutex(&globalLock);
VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->DestroyDevice(device);
+ VkResult result = device_dispatch_table(device)->DestroyDevice(device);
tableMap.erase(pDisp);
tableDebugMarkerMap.erase(pDisp);
deviceExtMap.erase(pDisp);
@@ -1673,26 +1624,20 @@
loader_platform_thread_unlock_mutex(&globalLock);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) queue;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+ VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object)
{
// TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->DestroyObject(device, objType, object);
+ VkResult result = device_dispatch_table(device)->DestroyObject(device, objType, object);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateBufferView(device, pCreateInfo, pView);
+ VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pView);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
BUFFER_NODE* pNewNode = new BUFFER_NODE;
@@ -1706,9 +1651,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateImageView(device, pCreateInfo, pView);
+ VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pView);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
IMAGE_NODE *pNewNode = new IMAGE_NODE;
@@ -1733,9 +1676,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ VkResult result = device_dispatch_table(device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
// Create LL HEAD for this Pipeline
char str[1024];
sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
@@ -1752,9 +1693,7 @@
VkPipeline basePipeline,
VkPipeline* pPipeline)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+ VkResult result = device_dispatch_table(device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
// Create LL HEAD for this Pipeline
char str[1024];
sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
@@ -1769,9 +1708,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateSampler(device, pCreateInfo, pSampler);
+ VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pSampler);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
SAMPLER_NODE* pNewNode = new SAMPLER_NODE;
@@ -1785,9 +1722,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
if (VK_SUCCESS == result) {
LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
if (NULL == pNewNode) {
@@ -1833,9 +1768,7 @@
VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+ VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
if (VK_SUCCESS == result) {
// TODO : Need to capture the pipeline layout
}
@@ -1844,9 +1777,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+ VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
if (VK_SUCCESS == result) {
// Insert this pool into Global Pool LL at head
char str[1024];
@@ -1883,9 +1814,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->ResetDescriptorPool(device, descriptorPool);
+ VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool);
if (VK_SUCCESS == result) {
clearDescriptorPool(descriptorPool);
}
@@ -1894,9 +1823,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+ VkResult result = device_dispatch_table(device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
if ((VK_SUCCESS == result) || (*pCount > 0)) {
POOL_NODE *pPoolNode = getPoolNode(descriptorPool);
if (!pPoolNode) {
@@ -1950,63 +1877,49 @@
for (uint32_t i = 0; i < count; i++) {
clearDescriptorSet(pDescriptorSets[i]);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+ device_dispatch_table(device)->ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets);
}
VK_LAYER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
if (dsUpdate(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, writeCount, pDescriptorWrites) &&
dsUpdate(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, copyCount, pDescriptorCopies)) {
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- return pTable->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
+ return device_dispatch_table(device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
return VK_ERROR_UNKNOWN;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateDynamicViewportState(device, pCreateInfo, pState);
+ VkResult result = device_dispatch_table(device)->CreateDynamicViewportState(device, pCreateInfo, pState);
insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_VIEWPORT);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateDynamicRasterState(device, pCreateInfo, pState);
+ VkResult result = device_dispatch_table(device)->CreateDynamicRasterState(device, pCreateInfo, pState);
insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateDynamicColorBlendState(device, pCreateInfo, pState);
+ VkResult result = device_dispatch_table(device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_COLOR_BLEND);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+ VkResult result = device_dispatch_table(device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_STENCIL);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ VkResult result = device_dispatch_table(device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
@@ -2024,9 +1937,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VkResult result = device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
if (VK_SUCCESS == result) {
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2052,9 +1963,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->EndCommandBuffer(cmdBuffer);
+ VkResult result = device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmdBuffer);
if (VK_SUCCESS == result) {
GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
if (pCB) {
@@ -2076,9 +1985,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->ResetCommandBuffer(cmdBuffer);
+ VkResult result = device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmdBuffer);
if (VK_SUCCESS == result) {
resetCB(cmdBuffer);
updateCBTracking(cmdBuffer);
@@ -2099,9 +2006,7 @@
g_lastBoundPipeline = pPN;
loader_platform_thread_unlock_mutex(&globalLock);
validatePipelineState(pCB, pipelineBindPoint, pipeline);
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
else {
char str[1024];
@@ -2119,9 +2024,7 @@
VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state)
{
setLastBoundDynamicState(cmdBuffer, state, stateBindPoint);
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
+ device_dispatch_table(cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
@@ -2148,9 +2051,7 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", str);
}
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
}
else {
@@ -2173,9 +2074,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+ device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
@@ -2192,9 +2091,7 @@
addCmd(pCB, CMD_BINDVERTEXBUFFER);
pCB->lastVtxBinding = startBinding + bindingCount -1;
if (validateBoundPipeline(cmdBuffer)) {
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
}
} else {
char str[1024];
@@ -2225,9 +2122,7 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
if (valid) {
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+ device_dispatch_table(cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
}
}
@@ -2253,9 +2148,7 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
if (valid) {
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+ device_dispatch_table(cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
}
@@ -2281,9 +2174,7 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
if (valid) {
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+ device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
}
}
@@ -2309,9 +2200,7 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
if (valid) {
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+ device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
}
}
@@ -2327,9 +2216,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdDispatch(cmdBuffer, x, y, z);
+ device_dispatch_table(cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
}
VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
@@ -2344,9 +2231,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+ device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
@@ -2361,9 +2246,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+ device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
@@ -2383,9 +2266,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ device_dispatch_table(cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
@@ -2404,9 +2285,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+ device_dispatch_table(cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
@@ -2424,9 +2303,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+ device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
@@ -2444,9 +2321,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+ device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
@@ -2461,9 +2336,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+ device_dispatch_table(cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
}
VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
@@ -2478,9 +2351,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
+ device_dispatch_table(cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
@@ -2499,9 +2370,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer,
@@ -2519,9 +2388,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+ device_dispatch_table(cmdBuffer)->CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
}
VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
@@ -2539,9 +2406,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ device_dispatch_table(cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
@@ -2556,9 +2421,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdSetEvent(cmdBuffer, event, pipeEvent);
+ device_dispatch_table(cmdBuffer)->CmdSetEvent(cmdBuffer, event, pipeEvent);
}
VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
@@ -2573,9 +2436,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdResetEvent(cmdBuffer, event, pipeEvent);
+ device_dispatch_table(cmdBuffer)->CmdResetEvent(cmdBuffer, event, pipeEvent);
}
VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
@@ -2590,9 +2451,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+ device_dispatch_table(cmdBuffer)->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
}
VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
@@ -2607,9 +2466,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+ device_dispatch_table(cmdBuffer)->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
}
VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
@@ -2624,9 +2481,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ device_dispatch_table(cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
}
VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
@@ -2641,9 +2496,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdEndQuery(cmdBuffer, queryPool, slot);
+ device_dispatch_table(cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
}
VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
@@ -2658,9 +2511,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ device_dispatch_table(cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
@@ -2675,9 +2526,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
+ device_dispatch_table(cmdBuffer)->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
}
VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
@@ -2692,9 +2541,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
+ device_dispatch_table(cmdBuffer)->CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
}
VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset)
@@ -2709,9 +2556,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
+ device_dispatch_table(cmdBuffer)->CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
}
VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkDeviceSize destOffset)
@@ -2726,16 +2571,12 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
+ device_dispatch_table(cmdBuffer)->CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+ VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
if (VK_SUCCESS == result) {
// Shadow create info and store in map
VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
@@ -2754,9 +2595,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
{
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- VkResult result = pTable->CreateRenderPass(device, pCreateInfo, pRenderPass);
+ VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
if (VK_SUCCESS == result) {
// Shadow create info and store in map
VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
@@ -2793,9 +2632,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+ device_dispatch_table(cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
}
VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass)
@@ -2811,9 +2648,7 @@
sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
}
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
- VkLayerDispatchTable *pTable = tableMap[pDisp];
- pTable->CmdEndRenderPass(cmdBuffer, renderPass);
+ device_dispatch_table(cmdBuffer)->CmdEndRenderPass(cmdBuffer, renderPass);
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -2823,8 +2658,7 @@
void* pUserData,
VkDbgMsgCallback* pMsgCallback)
{
- VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) instance;
- VkLayerInstanceDispatchTable *pTable = tableInstanceMap[pDisp];
+ VkLayerInstanceDispatchTable *pTable = instance_dispatch_table(instance);
return layer_create_msg_callback(instance, pTable, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
}
@@ -2832,8 +2666,7 @@
VkInstance instance,
VkDbgMsgCallback msgCallback)
{
- VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) instance;
- VkLayerInstanceDispatchTable *pTable = tableInstanceMap[pDisp];
+ VkLayerInstanceDispatchTable *pTable = instance_dispatch_table(instance);
return layer_destroy_msg_callback(instance, pTable, msgCallback);
}
@@ -3089,7 +2922,7 @@
return (void*) vkDbgSetObjectName;
}
{
- VkLayerDispatchTable* pTable = tableMap[pDisp];
+ VkLayerDispatchTable* pTable = device_dispatch_table(dev);
if (pTable->GetDeviceProcAddr == NULL)
return NULL;
return pTable->GetDeviceProcAddr(dev, funcName);
@@ -3121,8 +2954,7 @@
return fptr;
{
- VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instance;
- VkLayerInstanceDispatchTable* pTable = tableInstanceMap[*ppDisp];
+ VkLayerInstanceDispatchTable* pTable = instance_dispatch_table(instance);
if (pTable->GetInstanceProcAddr == NULL)
return NULL;
return pTable->GetInstanceProcAddr(instance, funcName);