bug 14921 part 1: sed renames
Workaround header bug (ALLOC_INFO vs AllocateInfo) in vk_helper.py. This
affects the debug extensions as well.
s/NONDISP/NON_DISPATCHABLE/g
s/CmdBuffer/CommandBuffer/g
s/cmdBuffer/commandBuffer/g
s/CMD_BUFFER/COMMAND_BUFFER/g
s/AllocMemory/AllocateMemory/g
s/AllocDescriptorSets/AllocateDescriptorSets/g
s/AllocCommandBuffers/AllocateCommandBuffers/g
s/VkAllocCallbacks/VkAllocationCallbacks/g
s/VkSystemAllocScope/VkSystemAllocationScope/g
s/allocScope/allocationScope/g
s/allocType/allocationType/g
s/pfnAlloc\b/pfnAllocation/g
s/pfnRealloc\b/pfnReallocation/g
s/VK_SYSTEM_ALLOC_/VK_SYSTEM_ALLOCATION_/g
s/extName/extensionName/g
s/implVersion/implementationVersion/g
s/pAppInfo/pApplicationInfo/g
s/pMem\b/pMemory/g
s/VkMemoryAllocInfo/VkMemoryAllocateInfo/g
s/VkDescriptorSetAllocInfo/VkDescriptorSetAllocateInfo/g
s/CmdPool/CommandPool/g
s/cmdPool/commandPool/g
s/CMD_POOL/COMMAND_POOL/g
s/VkCommandBufferAllocInfo/VkCommandBufferAllocateInfo/g
s/maxTessellationGenLevel/maxTessellationGenerationLevel/g
s/maxFragmentDualSourceAttachments/maxFragmentDualSrcAttachments/g
s/destSubpass/dstSubpass/g
s/destStageMask/dstStageMask/g
s/dualSourceBlend/dualSrcBlend/g
s/destBlendColor/dstBlendColor/g
s/destBlendAlpha/dstBlendAlpha/g
s/VK_FORMAT_NUM/VK_FORMAT_RANGE_SIZE/g
s/VK_DYNAMIC_STATE_NUM/VK_DYNAMIC_STATE_RANGE_SIZE/g
s/pAppName/pApplicationName/g
s/appVersion/applicationVersion/g
s/numLevels/levelCount/g
s/numLayers/layerCount/g
s/destOffset/dstOffset/g
s/destSubresource/dstSubresource/g
s/VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL/VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL/g
s/VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL/VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL/g
s/VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT/VK_IMAGE_USAGE_TRANSFER_SRC_BIT/g
s/VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT/VK_IMAGE_USAGE_TRANSFER_DST_BIT/g
s/destBuffer/dstBuffer/g
s/destQueueFamilyIndex/dstQueueFamilyIndex/g
s/destSet/dstSet/g
s/destBinding/dstBinding/g
s/destArrayElement/dstArrayElement/g
s/VK_BLEND_DEST_COLOR/VK_BLEND_DST_COLOR/g
s/VK_BLEND_ONE_MINUS_DEST_COLOR/VK_BLEND_ONE_MINUS_DST_COLOR/g
s/VK_BLEND_DEST_ALPHA/VK_BLEND_DST_ALPHA/g
s/VK_BLEND_ONE_MINUS_DEST_ALPHA/VK_BLEND_ONE_MINUS_DST_ALPHA/g
s/VK_FORMAT_FEATURE_BLIT_SOURCE_BIT/VK_FORMAT_FEATURE_BLIT_SRC_BIT/g
s/VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT/VK_FORMAT_FEATURE_BLIT_DST_BIT/g
s/VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT/VK_BUFFER_USAGE_TRANSFER_SRC_BIT/g
s/VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT/VK_BUFFER_USAGE_TRANSFER_DST_BIT/g
s/VK_COMPARE_OP_LESS_EQUAL/VK_COMPARE_OP_LESS_OR_EQUAL/g
s/VK_COMPARE_OP_GREATER_EQUAL/VK_COMPARE_OP_GREATER_OR_EQUAL/g
s/VkPipelineRasterStateCreateInfo/VkPipelineRasterizationStateCreateInfo/g
s/rasterSamples/rasterizationSamples/g
s/pRasterState/pRasterizationState/g
s/VK_FRONT_FACE_CCW/VK_FRONT_FACE_COUNTER_CLOCKWISE/g
s/VK_FRONT_FACE_CW/VK_FRONT_FACE_CLOCKWISE/g
s/VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ/VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY/g
s/VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ/VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY/g
s/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY/g
s/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY/g
s/VK_STENCIL_OP_INC_CLAMP/VK_STENCIL_OP_INCREMENT_AND_CLAMP/g
s/VK_STENCIL_OP_DEC_CLAMP/VK_STENCIL_OP_DECREMENT_AND_CLAMP/g
s/VK_STENCIL_OP_INC_WRAP/VK_STENCIL_OP_INCREMENT_AND_WRAP/g
s/VK_STENCIL_OP_DEC_WRAP/VK_STENCIL_OP_DECREMENT_AND_WRAP/g
s/VK_LOGIC_OP_NOOP/VK_LOGIC_OP_NO_OP/g
s/VK_LOGIC_OP_EQUIV\b/VK_LOGIC_OP_EQUIVALENT/g
s/memBarrierCount/memoryBarrierCount/g
s/ppMemBarriers/ppMemoryBarriers/g
s/destImage/dstImage/g
s/destImageLayout/dstImageLayout/g
s/destCache/dstCache/g
s/memOffset/memoryOffset/g
s/vk_print_vkmemoryallocinfo/vk_print_vkmemoryallocateinfo/g
s/pAllocInfo/pAllocateInfo/g
s/memRangeCount/memoryRangeCount/g
s/pMemRanges/pMemoryRanges/g
s/VK_IMAGE_TYPE_NUM/VK_IMAGE_TYPE_RANGE_SIZE/g
s/VK_PIPELINE_BIND_POINT_NUM/VK_PIPELINE_BIND_POINT_RANGE_SIZE/g
s/vk_size_vkdescriptorsetallocinfo/vk_size_vkdescriptorsetallocateinfo/g
s/remap_cmdbuffers/remap_commandbuffers/g
s/remap_cmdpool/remap_commandpool/g
s/add_to_cmdbuffers_map/add_to_commandbuffers_map/g
https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14921
a
diff --git a/layers/README.md b/layers/README.md
index 4e53ed8..8ee47b9 100644
--- a/layers/README.md
+++ b/layers/README.md
@@ -10,7 +10,7 @@
available layers and their properties. Layers can intercept Vulkan instance level entry points
in which case they are called an Instance Layer. Layers can intercept device entry points
in which case they are called a Device Layer. Instance level entry points are those with VkInstance
-or VkPhysicalDevice as first parameter. Device level entry points are those with VkDevice, VkCmdBuffer,
+or VkPhysicalDevice as first parameter. Device level entry points are those with VkDevice, VkCommandBuffer,
or VkQueue as the first parameter. Layers that want to intercept both instance and device
level entrypoints are called Global Layers. vkXXXXGetProcAddr is used internally by the Layers and
Loader to initialize dispatch tables. Device Layers are activated at vkCreateDevice time. Instance
diff --git a/layers/apidump.h b/layers/apidump.h
index fb8dcf1..28eab02 100644
--- a/layers/apidump.h
+++ b/layers/apidump.h
@@ -37,7 +37,7 @@
{
"Generic",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: APIDump",
}
};
@@ -47,7 +47,7 @@
{
"Generic",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: APIDump",
}
};
diff --git a/layers/basic.cpp b/layers/basic.cpp
index f416d5a..a87ab59 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -34,7 +34,7 @@
{
"Basic",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: Basic",
}
};
@@ -95,7 +95,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
VkResult result = device_dispatch_table(*pDevice)->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
@@ -104,7 +104,7 @@
}
/* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
device_dispatch_table(device)->DestroyDevice(device, pAllocator);
@@ -112,7 +112,7 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator);
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index 41b0b6f..89d5885 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -158,7 +158,7 @@
pCount, pProperties);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
@@ -178,7 +178,7 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -317,20 +317,20 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t viewportCount,
const VkViewport* pViewports)
{
VkBool32 skipCall = VK_FALSE;
/* TODO: Verify viewportCount < maxViewports from VkPhysicalDeviceLimits */
if (VK_FALSE == skipCall) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- my_data->device_dispatch_table->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ my_data->device_dispatch_table->CmdSetViewport(commandBuffer, viewportCount, pViewports);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t scissorCount,
const VkRect2D* pScissors)
{
@@ -338,8 +338,8 @@
/* TODO: Verify scissorCount < maxViewports from VkPhysicalDeviceLimits */
/* TODO: viewportCount and scissorCount must match at draw time */
if (VK_FALSE == skipCall) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- my_data->device_dispatch_table->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ my_data->device_dispatch_table->CmdSetScissor(commandBuffer, scissorCount, pScissors);
}
}
@@ -387,7 +387,7 @@
return skipCall;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
VkBool32 skipCall = VK_FALSE;
layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
@@ -429,7 +429,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
// Free device lifetime allocations
dispatch_key key = get_dispatch_key(device);
@@ -440,33 +440,33 @@
layer_data_map.erase(key);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
{
// TODO : Verify that requested QueueFamilyIndex for this pool exists
- VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+ VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, cmdPool, pAllocator);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, commandPool, pAllocator);
}
-VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
+VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
{
- VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->ResetCommandPool(device, cmdPool, flags);
+ VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->ResetCommandPool(device, commandPool, flags);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pCreateInfo, VkCommandBuffer* pCommandBuffer)
{
- VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+ VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
return result;
}
-VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers)
+VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t count, const VkCommandBuffer* pCommandBuffers)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, commandPool, count, pCommandBuffers);
}
VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
@@ -490,7 +490,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImage *pImage)
{
VkBool32 skipCall = VK_FALSE;
@@ -543,63 +543,63 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const uint32_t* pData)
{
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
- // destOffset is the byte offset into the buffer to start updating and must be a multiple of 4.
- if (destOffset & 3) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ // dstOffset is the byte offset into the buffer to start updating and must be a multiple of 4.
+ if (dstOffset & 3) {
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
- "vkCmdUpdateBuffer parameter, VkDeviceSize destOffset, is not a multiple of 4")) {
+ "vkCmdUpdateBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4")) {
return;
}
}
// dataSize is the number of bytes to update, which must be a multiple of 4.
if (dataSize & 3) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
"vkCmdUpdateBuffer parameter, VkDeviceSize dataSize, is not a multiple of 4")) {
return;
}
}
- dev_data->device_dispatch_table->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+ dev_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data)
{
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
- // destOffset is the byte offset into the buffer to start filling and must be a multiple of 4.
- if (destOffset & 3) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ // dstOffset is the byte offset into the buffer to start filling and must be a multiple of 4.
+ if (dstOffset & 3) {
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
- "vkCmdFillBuffer parameter, VkDeviceSize destOffset, is not a multiple of 4")) {
+ "vkCmdFillBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4")) {
return;
}
}
// size is the number of bytes to fill, which must be a multiple of 4.
if (size & 3) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
"vkCmdFillBuffer parameter, VkDeviceSize size, is not a multiple of 4")) {
return;
}
}
- dev_data->device_dispatch_table->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+ dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -656,8 +656,8 @@
return (PFN_vkVoidFunction) vkDestroyCommandPool;
if (!strcmp(funcName, "ResetCommandPool"))
return (PFN_vkVoidFunction) vkResetCommandPool;
- if (!strcmp(funcName, "vkAllocCommandBuffers"))
- return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+ if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+ return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
if (!strcmp(funcName, "vkFreeCommandBuffers"))
return (PFN_vkVoidFunction) vkFreeCommandBuffers;
if (!strcmp(funcName, "vkCmdUpdateBuffer"))
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index cf73369..d170830 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -75,7 +75,7 @@
unordered_map<VkPipelineLayout, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
unordered_map<VkShader, VkShaderStageFlagBits> shaderStageMap;
// Map for layout chains
- unordered_map<void*, GLOBAL_CB_NODE*> cmdBufferMap;
+ unordered_map<void*, GLOBAL_CB_NODE*> commandBufferMap;
unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
@@ -226,11 +226,11 @@
static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0};
-// TODO : Should be tracking lastBound per cmdBuffer and when draws occur, report based on that cmd buffer lastBound
+// TODO : Should be tracking lastBound per commandBuffer and when draws occur, report based on that cmd buffer lastBound
// Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
// to that same cmd buffer by separate thread are not changing state from underneath us
// Track the last cmd buffer touched by this thread
-static VkCmdBuffer g_lastCmdBuffer[MAX_TID] = {NULL};
+static VkCommandBuffer g_lastCommandBuffer[MAX_TID] = {NULL};
// Track the last group of CBs touched for displaying to dot file
static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
static uint32_t g_lastTouchedCBIndex = 0;
@@ -239,11 +239,11 @@
static PIPELINE_NODE* g_lastBoundPipeline = NULL;
#define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
// prototype
-static GLOBAL_CB_NODE* getCBNode(layer_data*, const VkCmdBuffer);
-// Update global ptrs to reflect that specified cmdBuffer has been used
+static GLOBAL_CB_NODE* getCBNode(layer_data*, const VkCommandBuffer);
+// Update global ptrs to reflect that specified commandBuffer has been used
static void updateCBTracking(GLOBAL_CB_NODE* pCB)
{
- g_lastCmdBuffer[getTIDIndex()] = pCB->cmdBuffer;
+ g_lastCommandBuffer[getTIDIndex()] = pCB->commandBuffer;
loader_platform_thread_lock_mutex(&globalLock);
g_lastGlobalCB = pCB;
// TODO : This is a dumb algorithm. Need smart LRU that drops off oldest
@@ -274,7 +274,7 @@
if ((pNode->status & status_mask) != status_flag) {
// TODO : How to pass dispatchable objects as srcObject? Here src obj should be cmd buffer
return log_msg(my_data->report_data, msg_flags, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, error_code, "DS",
- "CB object %#" PRIxLEAST64 ": %s", reinterpret_cast<uint64_t>(pNode->cmdBuffer), fail_msg);
+ "CB object %#" PRIxLEAST64 ": %s", reinterpret_cast<uint64_t>(pNode->commandBuffer), fail_msg);
}
}
return VK_FALSE;
@@ -518,9 +518,9 @@
memcpy((void*)&pPipeline->vpStateCI, pCreateInfo->pViewportState, sizeof(VkPipelineViewportStateCreateInfo));
pPipeline->graphicsPipelineCI.pViewportState = &pPipeline->vpStateCI;
}
- if (pCreateInfo->pRasterState != NULL) {
- memcpy((void*)&pPipeline->rsStateCI, pCreateInfo->pRasterState, sizeof(VkPipelineRasterStateCreateInfo));
- pPipeline->graphicsPipelineCI.pRasterState = &pPipeline->rsStateCI;
+ if (pCreateInfo->pRasterizationState != NULL) {
+ memcpy((void*)&pPipeline->rsStateCI, pCreateInfo->pRasterizationState, sizeof(VkPipelineRasterizationStateCreateInfo));
+ pPipeline->graphicsPipelineCI.pRasterizationState = &pPipeline->rsStateCI;
}
if (pCreateInfo->pMultisampleState != NULL) {
memcpy((void*)&pPipeline->msStateCI, pCreateInfo->pMultisampleState, sizeof(VkPipelineMultisampleStateCreateInfo));
@@ -584,7 +584,7 @@
{
PIPELINE_NODE* pPipe = my_data->pipelineMap[pipeline];
if (VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
- return pPipe->msStateCI.rasterSamples;
+ return pPipe->msStateCI.rasterizationSamples;
}
return 1;
}
@@ -1018,7 +1018,7 @@
// Validate Write updates
uint32_t i = 0;
for (i=0; i < descriptorWriteCount; i++) {
- VkDescriptorSet ds = pWDS[i].destSet;
+ VkDescriptorSet ds = pWDS[i].dstSet;
SET_NODE* pSet = my_data->setMap[ds];
GENERIC_HEADER* pUpdate = (GENERIC_HEADER*) &pWDS[i];
pLayout = pSet->pLayout;
@@ -1027,14 +1027,14 @@
break;
}
uint32_t binding = 0, endIndex = 0;
- binding = pWDS[i].destBinding;
+ binding = pWDS[i].dstBinding;
// Make sure that layout being updated has the binding being updated
if (pLayout->createInfo.bindingCount < binding) {
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
"Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, binding, string_VkStructureType(pUpdate->sType));
} else {
// Next verify that update falls within size of given binding
- endIndex = getUpdateEndIndex(my_data, device, pLayout, binding, pWDS[i].destArrayElement, pUpdate);
+ endIndex = getUpdateEndIndex(my_data, device, pLayout, binding, pWDS[i].dstArrayElement, pUpdate);
if (getBindingEndIndex(pLayout, binding) < endIndex) {
pLayoutCI = &pLayout->createInfo;
string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
@@ -1042,7 +1042,7 @@
"Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str());
} else { // TODO : should we skip update on a type mismatch or force it?
uint32_t startIndex;
- startIndex = getUpdateStartIndex(my_data, device, pLayout, binding, pWDS[i].destArrayElement, pUpdate);
+ startIndex = getUpdateStartIndex(my_data, device, pLayout, binding, pWDS[i].dstArrayElement, pUpdate);
// Layout bindings match w/ update, now verify that update type & stageFlags are the same for entire update
if ((skipCall = validateUpdateConsistency(my_data, device, pLayout, pUpdate, startIndex, endIndex)) == VK_FALSE) {
// The update is within bounds and consistent, but need to make sure contents make sense as well
@@ -1076,7 +1076,7 @@
uint32_t srcStartIndex = 0, srcEndIndex = 0, dstStartIndex = 0, dstEndIndex = 0;
// For each copy make sure that update falls within given layout and that types match
pSrcSet = my_data->setMap[pCDS[i].srcSet];
- pDstSet = my_data->setMap[pCDS[i].destSet];
+ pDstSet = my_data->setMap[pCDS[i].dstSet];
pSrcLayout = pSrcSet->pLayout;
pDstLayout = pDstSet->pLayout;
// Validate that src binding is valid for src set layout
@@ -1084,27 +1084,27 @@
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
"Copy descriptor update %u has srcBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.bindingCount-1);
- } else if (pDstLayout->createInfo.bindingCount < pCDS[i].destBinding) {
+ } else if (pDstLayout->createInfo.bindingCount < pCDS[i].dstBinding) {
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
- "Copy descriptor update %u has destBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
- i, pCDS[i].destBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.bindingCount-1);
+ "Copy descriptor update %u has dstBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
+ i, pCDS[i].dstBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.bindingCount-1);
} else {
// Proceed with validation. Bindings are ok, but make sure update is within bounds of given layout
srcEndIndex = getUpdateEndIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
- dstEndIndex = getUpdateEndIndex(my_data, device, pDstLayout, pCDS[i].destBinding, pCDS[i].destArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
+ dstEndIndex = getUpdateEndIndex(my_data, device, pDstLayout, pCDS[i].dstBinding, pCDS[i].dstArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
if (getBindingEndIndex(pSrcLayout, pCDS[i].srcBinding) < srcEndIndex) {
pLayoutCI = &pSrcLayout->createInfo;
string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
"Copy descriptor src update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].srcBinding, DSstr.c_str());
- } else if (getBindingEndIndex(pDstLayout, pCDS[i].destBinding) < dstEndIndex) {
+ } else if (getBindingEndIndex(pDstLayout, pCDS[i].dstBinding) < dstEndIndex) {
pLayoutCI = &pDstLayout->createInfo;
string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
- "Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].destBinding, DSstr.c_str());
+ "Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].dstBinding, DSstr.c_str());
} else {
srcStartIndex = getUpdateStartIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
- dstStartIndex = getUpdateStartIndex(my_data, device, pDstLayout, pCDS[i].destBinding, pCDS[i].destArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
+ dstStartIndex = getUpdateStartIndex(my_data, device, pDstLayout, pCDS[i].dstBinding, pCDS[i].dstArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
for (uint32_t j=0; j<pCDS[i].descriptorCount; ++j) {
// For copy just make sure that the types match and then perform the update
if (pSrcLayout->descriptorTypes[srcStartIndex+j] != pDstLayout->descriptorTypes[dstStartIndex+j]) {
@@ -1131,7 +1131,7 @@
LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pSetLayouts[i]);
if (NULL == pLayout) {
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
- "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pSetLayouts[i]);
+ "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pSetLayouts[i]);
} else {
uint32_t typeIndex = 0, typeCount = 0;
for (j=0; j<pLayout->createInfo.bindingCount; ++j) {
@@ -1282,26 +1282,26 @@
}
}
// For given CB object, fetch associated CB Node from map
-static GLOBAL_CB_NODE* getCBNode(layer_data* my_data, const VkCmdBuffer cb)
+static GLOBAL_CB_NODE* getCBNode(layer_data* my_data, const VkCommandBuffer cb)
{
loader_platform_thread_lock_mutex(&globalLock);
- if (my_data->cmdBufferMap.find(cb) == my_data->cmdBufferMap.end()) {
+ if (my_data->commandBufferMap.find(cb) == my_data->commandBufferMap.end()) {
loader_platform_thread_unlock_mutex(&globalLock);
// TODO : How to pass cb as srcObj here?
- log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
- "Attempt to use CmdBuffer %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast<uint64_t>(cb));
+ log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS",
+ "Attempt to use CommandBuffer %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast<uint64_t>(cb));
return NULL;
}
loader_platform_thread_unlock_mutex(&globalLock);
- return my_data->cmdBufferMap[cb];
+ return my_data->commandBufferMap[cb];
}
// Free all CB Nodes
// NOTE : Calls to this function should be wrapped in mutex
-static void deleteCmdBuffers(layer_data* my_data)
+static void deleteCommandBuffers(layer_data* my_data)
{
- if (my_data->cmdBufferMap.size() <= 0)
+ if (my_data->commandBufferMap.size() <= 0)
return;
- for (auto ii=my_data->cmdBufferMap.begin(); ii!=my_data->cmdBufferMap.end(); ++ii) {
+ for (auto ii=my_data->commandBufferMap.begin(); ii!=my_data->commandBufferMap.end(); ++ii) {
vector<CMD_NODE*> cmd_node_list = (*ii).second->pCmds;
while (!cmd_node_list.empty()) {
CMD_NODE* cmd_node = cmd_node_list.back();
@@ -1310,12 +1310,12 @@
}
delete (*ii).second;
}
- my_data->cmdBufferMap.clear();
+ my_data->commandBufferMap.clear();
}
-static VkBool32 report_error_no_cb_begin(const layer_data* dev_data, const VkCmdBuffer cb, const char* caller_name)
+static VkBool32 report_error_no_cb_begin(const layer_data* dev_data, const VkCommandBuffer cb, const char* caller_name)
{
// TODO : How to pass cb as srcObj here?
- return log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_CMD_BUFFER, "DS",
+ return log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_COMMAND_BUFFER, "DS",
"You must call vkBeginCommandBuffer() before this call to %s", (void*)caller_name);
}
static VkBool32 addCmd(const layer_data* my_data, GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd)
@@ -1331,11 +1331,11 @@
} else {
// TODO : How to pass cb as srcObj here?
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
- "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %#" PRIxLEAST64, reinterpret_cast<uint64_t>(pCB->cmdBuffer));
+ "Out of memory while attempting to allocate new CMD_NODE for commandBuffer %#" PRIxLEAST64, reinterpret_cast<uint64_t>(pCB->commandBuffer));
}
return skipCall;
}
-static void resetCB(layer_data* my_data, const VkCmdBuffer cb)
+static void resetCB(layer_data* my_data, const VkCommandBuffer cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb);
if (pCB) {
@@ -1346,9 +1346,9 @@
}
pCB->pCmds.clear();
// Reset CB state (need to save createInfo)
- VkCmdBufferAllocInfo saveCBCI = pCB->createInfo;
+ VkCommandBufferAllocateInfo saveCBCI = pCB->createInfo;
memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
- pCB->cmdBuffer = cb;
+ pCB->commandBuffer = cb;
pCB->createInfo = saveCBCI;
pCB->lastVtxBinding = MAX_BINDING;
}
@@ -1413,7 +1413,7 @@
}
}
// Print the last bound Gfx Pipeline
-static VkBool32 printPipeline(layer_data* my_data, const VkCmdBuffer cb)
+static VkBool32 printPipeline(layer_data* my_data, const VkCommandBuffer cb)
{
VkBool32 skipCall = VK_FALSE;
GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb);
@@ -1429,7 +1429,7 @@
return skipCall;
}
// Print details of DS config to stdout
-static VkBool32 printDSConfig(layer_data* my_data, const VkCmdBuffer cb)
+static VkBool32 printDSConfig(layer_data* my_data, const VkCommandBuffer cb)
{
VkBool32 skipCall = VK_FALSE;
char ds_config_str[1024*256] = {0}; // TODO : Currently making this buffer HUGE w/o overrun protection. Need to be smarter, start smaller, and grow as needed.
@@ -1478,7 +1478,7 @@
return skipCall;
}
-static void printCB(layer_data* my_data, const VkCmdBuffer cb)
+static void printCB(layer_data* my_data, const VkCommandBuffer cb)
{
GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb);
if (pCB && pCB->pCmds.size() > 0) {
@@ -1495,7 +1495,7 @@
}
}
-static VkBool32 synchAndPrintDSConfig(layer_data* my_data, const VkCmdBuffer cb)
+static VkBool32 synchAndPrintDSConfig(layer_data* my_data, const VkCommandBuffer cb)
{
VkBool32 skipCall = VK_FALSE;
if (!(my_data->report_data->active_flags & VK_DBG_REPORT_INFO_BIT)) {
@@ -1513,7 +1513,7 @@
VkBool32 inside = VK_FALSE;
if (pCB->activeRenderPass) {
inside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
+ (uint64_t)pCB->commandBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
"%s: It is invalid to issue this call inside an active render pass (%#" PRIxLEAST64 ")",
apiName, (uint64_t) pCB->activeRenderPass);
}
@@ -1527,7 +1527,7 @@
VkBool32 outside = VK_FALSE;
if (!pCB->activeRenderPass) {
outside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
+ (uint64_t)pCB->commandBuffer, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
"%s: This call must be issued inside an active render pass.", apiName);
}
return outside;
@@ -1565,7 +1565,7 @@
}
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
@@ -1585,7 +1585,7 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -1625,7 +1625,7 @@
}
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
@@ -1638,7 +1638,7 @@
}
// prototype
static void deleteRenderPasses(layer_data*);
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data* dev_data = get_my_data_ptr(key, layer_data_map);
@@ -1646,7 +1646,7 @@
loader_platform_thread_lock_mutex(&globalLock);
deletePipelines(dev_data);
deleteRenderPasses(dev_data);
- deleteCmdBuffers(dev_data);
+ deleteCommandBuffers(dev_data);
deletePools(dev_data);
deleteLayouts(dev_data);
dev_data->imageViewMap.clear();
@@ -1737,15 +1737,15 @@
pCB = getCBNode(dev_data, submit->pCommandBuffers[i]);
loader_platform_thread_lock_mutex(&globalLock);
pCB->submitCount++; // increment submit count
- if ((pCB->beginInfo.flags & VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS",
- "CB %#" PRIxLEAST64 " was begun w/ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted %#" PRIxLEAST64 " times.", reinterpret_cast<uint64_t>(pCB->cmdBuffer), pCB->submitCount);
+ if ((pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) {
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS",
+ "CB %#" PRIxLEAST64 " was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted %#" PRIxLEAST64 " times.", reinterpret_cast<uint64_t>(pCB->commandBuffer), pCB->submitCount);
}
if (CB_UPDATE_COMPLETE != pCB->state) {
// Flag error for using CB w/o vkEndCommandBuffer() called
// TODO : How to pass cb as srcObj?
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_CMD_BUFFER, "DS",
- "You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast<uint64_t>(pCB->cmdBuffer));
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_COMMAND_BUFFER, "DS",
+ "You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast<uint64_t>(pCB->commandBuffer));
loader_platform_thread_unlock_mutex(&globalLock);
return VK_ERROR_VALIDATION_FAILED;
}
@@ -1757,119 +1757,119 @@
return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFence(device, fence, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyEvent(device, event, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyQueryPool(device, queryPool, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
dev_data->bufferMap.erase(buffer);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
dev_data->device_dispatch_table->DestroyBufferView(device, bufferView, pAllocator);
dev_data->bufferViewMap.erase(bufferView);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
dev_data->imageMap.erase(image);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyImageView(device, imageView, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShaderModule(device, shaderModule, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
dev_data->device_dispatch_table->DestroyShader(device, shader, pAllocator);
dev_data->shaderStageMap.erase(shader);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipeline(device, pipeline, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySampler(device, sampler, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorPool(device, descriptorPool, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer *pCommandBuffers)
+VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t count, const VkCommandBuffer *pCommandBuffers)
{
- get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+ get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, commandPool, count, pCommandBuffers);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFramebuffer(device, framebuffer, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
{
get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyRenderPass(device, renderPass, pAllocator);
// TODO : Clean up any internal data structures using this obj.
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
@@ -1882,7 +1882,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
@@ -1894,7 +1894,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
@@ -1906,7 +1906,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
@@ -1921,7 +1921,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShader *pShader)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1940,7 +1940,7 @@
VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1951,7 +1951,7 @@
void VKAPI vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache, pAllocator);
@@ -1970,16 +1970,16 @@
VkResult VKAPI vkMergePipelineCaches(
VkDevice device,
- VkPipelineCache destCache,
+ VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
+ VkResult result = dev_data->device_dispatch_table->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
VkResult result = VK_SUCCESS;
//TODO What to do with pipelineCache?
@@ -2021,7 +2021,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
@@ -2033,7 +2033,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
@@ -2082,7 +2082,7 @@
return result;
}
-VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
@@ -2101,7 +2101,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
@@ -2136,36 +2136,36 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
{
VkBool32 skipCall = VK_FALSE;
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
// Verify that requested descriptorSets are available in pool
- POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
+ POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool);
if (!pPoolNode) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
- "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->descriptorPool);
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocateInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
+ "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->descriptorPool);
} else { // Make sure pool has all the available descriptors before calling down chain
- skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->setLayoutCount, pAllocInfo->pSetLayouts);
+ skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocateInfo->setLayoutCount, pAllocateInfo->pSetLayouts);
}
if (skipCall)
return VK_ERROR_VALIDATION_FAILED;
- VkResult result = dev_data->device_dispatch_table->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+ VkResult result = dev_data->device_dispatch_table->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
if (VK_SUCCESS == result) {
- POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
+ POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool);
if (pPoolNode) {
- if (pAllocInfo->setLayoutCount == 0) {
- log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS",
- "AllocDescriptorSets called with 0 count");
+ if (pAllocateInfo->setLayoutCount == 0) {
+ log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocateInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS",
+ "AllocateDescriptorSets called with 0 count");
}
- for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
+ for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) {
log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
"Created Descriptor Set %#" PRIxLEAST64, (uint64_t) pDescriptorSets[i]);
// Create new set node and add to head of pool nodes
SET_NODE* pNewNode = new SET_NODE;
if (NULL == pNewNode) {
if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
- "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()"))
+ "Out of memory while attempting to allocate SET_NODE in vkAllocateDescriptorSets()"))
return VK_ERROR_VALIDATION_FAILED;
} else {
memset(pNewNode, 0, sizeof(SET_NODE));
@@ -2175,14 +2175,14 @@
// Insert set at head of Set LL for this pool
pNewNode->pNext = pPoolNode->pSets;
pPoolNode->pSets = pNewNode;
- LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocInfo->pSetLayouts[i]);
+ LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocateInfo->pSetLayouts[i]);
if (NULL == pLayout) {
- if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
- "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->pSetLayouts[i]))
+ if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocateInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+ "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->pSetLayouts[i]))
return VK_ERROR_VALIDATION_FAILED;
}
pNewNode->pLayout = pLayout;
- pNewNode->pool = pAllocInfo->descriptorPool;
+ pNewNode->pool = pAllocateInfo->descriptorPool;
pNewNode->set = pDescriptorSets[i];
pNewNode->descriptorCount = pLayout->endIndex + 1;
if (pNewNode->descriptorCount) {
@@ -2237,84 +2237,84 @@
}
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pCreateInfo, VkCommandBuffer* pCommandBuffer)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+ VkResult result = dev_data->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
- pCB->cmdBuffer = *pCmdBuffer;
+ pCB->commandBuffer = *pCommandBuffer;
pCB->createInfo = *pCreateInfo;
pCB->lastVtxBinding = MAX_BINDING;
pCB->level = pCreateInfo->level;
- dev_data->cmdBufferMap[*pCmdBuffer] = pCB;
+ dev_data->commandBufferMap[*pCommandBuffer] = pCB;
loader_platform_thread_unlock_mutex(&globalLock);
updateCBTracking(pCB);
}
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
+VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
{
VkBool32 skipCall = false;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// Validate command buffer level
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
- if (pCB->level == VK_CMD_BUFFER_LEVEL_PRIMARY) {
+ if (pCB->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
if (pBeginInfo->renderPass || pBeginInfo->framebuffer) {
// These should be NULL for a Primary CB
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
- "vkAllocCommandBuffers(): Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
+ "vkAllocateCommandBuffers(): Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)commandBuffer);
}
} else {
if (!pBeginInfo->renderPass || !pBeginInfo->framebuffer) {
// These should NOT be null for an Secondary CB
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
- "vkAllocCommandBuffers(): Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
+ "vkAllocateCommandBuffers(): Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)commandBuffer);
}
}
pCB->beginInfo = *pBeginInfo;
} else {
- // TODO : Need to pass cmdBuffer as objType here
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
- "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
+ // TODO : Need to pass commandBuffer as objType here
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS",
+ "In vkBeginCommandBuffer() and unable to find CommandBuffer Node for CB %p!", (void*)commandBuffer);
}
if (skipCall) {
return VK_ERROR_VALIDATION_FAILED;
}
- VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo);
if (VK_SUCCESS == result) {
if (CB_NEW != pCB->state)
- resetCB(dev_data, cmdBuffer);
+ resetCB(dev_data, commandBuffer);
pCB->state = CB_UPDATE_ACTIVE;
updateCBTracking(pCB);
}
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
{
VkBool32 skipCall = VK_FALSE;
VkResult result = VK_SUCCESS;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
/* TODO: preference is to always call API function after reporting any validation errors */
if (pCB) {
if (pCB->state != CB_UPDATE_ACTIVE) {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkEndCommandBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkEndCommandBuffer()");
}
}
if (VK_FALSE == skipCall) {
- result = dev_data->device_dispatch_table->EndCommandBuffer(cmdBuffer);
+ result = dev_data->device_dispatch_table->EndCommandBuffer(commandBuffer);
if (VK_SUCCESS == result) {
updateCBTracking(pCB);
pCB->state = CB_UPDATE_COMPLETE;
// Reset CB status flags
pCB->status = 0;
- printCB(dev_data, cmdBuffer);
+ printCB(dev_data, commandBuffer);
}
} else {
result = VK_ERROR_VALIDATION_FAILED;
@@ -2322,22 +2322,22 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
+VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
{
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- VkResult result = dev_data->device_dispatch_table->ResetCommandBuffer(cmdBuffer, flags);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ VkResult result = dev_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags);
if (VK_SUCCESS == result) {
- resetCB(dev_data, cmdBuffer);
- updateCBTracking(getCBNode(dev_data, cmdBuffer));
+ resetCB(dev_data, commandBuffer);
+ updateCBTracking(getCBNode(dev_data, commandBuffer));
}
return result;
}
-VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2367,21 +2367,21 @@
}
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindPipeline()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindPipeline()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ dev_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t viewportCount,
const VkViewport* pViewports)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2392,21 +2392,21 @@
memcpy(pCB->viewports.data(), pViewports, viewportCount * sizeof(VkViewport));
loader_platform_thread_unlock_mutex(&globalLock);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetViewport()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetViewport()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+ dev_data->device_dispatch_table->CmdSetViewport(commandBuffer, viewportCount, pViewports);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t scissorCount,
const VkRect2D* pScissors)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2417,18 +2417,18 @@
memcpy(pCB->scissors.data(), pScissors, scissorCount * sizeof(VkRect2D));
loader_platform_thread_unlock_mutex(&globalLock);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetScissor()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetScissor()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+ dev_data->device_dispatch_table->CmdSetScissor(commandBuffer, scissorCount, pScissors);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2439,22 +2439,22 @@
pCB->lineWidth = lineWidth;
loader_platform_thread_unlock_mutex(&globalLock);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindDynamicLineWidthState()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDynamicLineWidthState()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetLineWidth(cmdBuffer, lineWidth);
+ dev_data->device_dispatch_table->CmdSetLineWidth(commandBuffer, lineWidth);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2464,18 +2464,18 @@
pCB->depthBiasClamp = depthBiasClamp;
pCB->depthBiasSlopeFactor = depthBiasSlopeFactor;
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetDepthBias()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetDepthBias()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+ dev_data->device_dispatch_table->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4])
+VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2483,21 +2483,21 @@
pCB->status |= CBSTATUS_BLEND_SET;
memcpy(pCB->blendConstants, blendConstants, 4 * sizeof(float));
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetBlendConstants()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetBlendConstants()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetBlendConstants(cmdBuffer, blendConstants);
+ dev_data->device_dispatch_table->CmdSetBlendConstants(commandBuffer, blendConstants);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2506,21 +2506,21 @@
pCB->minDepthBounds = minDepthBounds;
pCB->maxDepthBounds = maxDepthBounds;
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetDepthBounds()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetDepthBounds()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+ dev_data->device_dispatch_table->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilCompareMask)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2535,21 +2535,21 @@
/* TODO: We aren't capturing the faceMask, do we need to? */
pCB->status |= CBSTATUS_STENCIL_READ_MASK_SET;
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetStencilCompareMask()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetStencilCompareMask()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+ dev_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilWriteMask)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2562,21 +2562,21 @@
}
pCB->status |= CBSTATUS_STENCIL_WRITE_MASK_SET;
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetStencilWriteMask()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetStencilWriteMask()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+ dev_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilReference)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
@@ -2589,18 +2589,18 @@
}
pCB->status |= CBSTATUS_STENCIL_REFERENCE_SET;
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetStencilReference()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetStencilReference()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+ dev_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
}
-VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
// TODO : Validate dynamic offsets
// If any of the sets being bound include dynamic uniform or storage buffers,
// then pDynamicOffsets must include one element for each array element
@@ -2638,18 +2638,18 @@
skipCall |= addCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS);
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindDescriptorSets()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDescriptorSets()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ dev_data->device_dispatch_table->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
-VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
VkDeviceSize offset_align = 0;
@@ -2669,26 +2669,26 @@
"vkCmdBindIndexBuffer() offset (%#" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", offset, string_VkIndexType(indexType));
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindIndexBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindIndexBuffer()");
}
pCB->status |= CBSTATUS_INDEX_BUFFER_BOUND;
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_BINDINDEXBUFFER);
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+ dev_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t startBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
/* TODO: Need to track all the vertex buffers, not just last one */
@@ -2696,317 +2696,317 @@
updateCBTracking(pCB);
addCmd(dev_data, pCB, CMD_BINDVERTEXBUFFER);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindVertexBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindVertexBuffer()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ dev_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
pCB->drawCount[DRAW]++;
skipCall |= validate_draw_state(dev_data, pCB, VK_FALSE);
- // TODO : Need to pass cmdBuffer as srcObj here
+ // TODO : Need to pass commandBuffer as srcObj here
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
"vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
- skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+ skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
if (VK_FALSE == skipCall) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_DRAW);
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDraw()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDraw()");
}
skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDraw");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+ dev_data->device_dispatch_table->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
{
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
VkBool32 skipCall = VK_FALSE;
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
pCB->drawCount[DRAW_INDEXED]++;
skipCall |= validate_draw_state(dev_data, pCB, VK_TRUE);
- // TODO : Need to pass cmdBuffer as srcObj here
+ // TODO : Need to pass commandBuffer as srcObj here
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
"vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
- skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+ skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
if (VK_FALSE == skipCall) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXED);
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDrawIndexed()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDrawIndexed()");
}
skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexed");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+ dev_data->device_dispatch_table->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
{
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
VkBool32 skipCall = VK_FALSE;
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
pCB->drawCount[DRAW_INDIRECT]++;
skipCall |= validate_draw_state(dev_data, pCB, VK_FALSE);
- // TODO : Need to pass cmdBuffer as srcObj here
+ // TODO : Need to pass commandBuffer as srcObj here
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
"vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
- skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+ skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
if (VK_FALSE == skipCall) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDIRECT);
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDrawIndirect()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDrawIndirect()");
}
skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndirect");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+ dev_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
skipCall |= validate_draw_state(dev_data, pCB, VK_TRUE);
- // TODO : Need to pass cmdBuffer as srcObj here
+ // TODO : Need to pass commandBuffer as srcObj here
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
"vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
- skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+ skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
if (VK_FALSE == skipCall) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXEDINDIRECT);
}
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDrawIndexedIndirect()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDrawIndexedIndirect()");
}
skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexedIndirect");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+ dev_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_DISPATCH);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDispatch()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDispatch()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatch");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdDispatch(cmdBuffer, x, y, z);
+ dev_data->device_dispatch_table->CmdDispatch(commandBuffer, x, y, z);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_DISPATCHINDIRECT);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDispatchIndirect()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDispatchIndirect()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatchIndirect");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+ dev_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset);
}
-VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_COPYBUFFER);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyBuffer()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyBuffer");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+ dev_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
-VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount, const VkImageCopy* pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_COPYIMAGE);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyImage()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyImage()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyImage");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ dev_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
-VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCommandBuffer commandBuffer,
VkImage srcImage, VkImageLayout srcImageLayout,
- VkImage destImage, VkImageLayout destImageLayout,
+ VkImage dstImage, VkImageLayout dstImageLayout,
uint32_t regionCount, const VkImageBlit* pRegions,
VkFilter filter)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_BLITIMAGE);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBlitImage()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBlitImage()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdBlitImage");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+ dev_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
-VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage, VkImageLayout destImageLayout,
+ VkImage dstImage, VkImageLayout dstImageLayout,
uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_COPYBUFFERTOIMAGE);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyBufferToImage()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyBufferToImage()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyBufferToImage");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+ dev_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
-VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
VkImage srcImage, VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_COPYIMAGETOBUFFER);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyImageToBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyImageToBuffer()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyImageToBuffer");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+ dev_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
-VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_UPDATEBUFFER);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdUpdateBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdUpdateBuffer()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyUpdateBuffer");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+ dev_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
-VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_FILLBUFFER);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdFillBuffer()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdFillBuffer()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyFillBuffer");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+ dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearAttachments(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
// Warn if this is issued prior to Draw Cmd
if (!hasDrawCmd(pCB)) {
- // TODO : cmdBuffer should be srcObj
+ // TODO : commandBuffer should be srcObj
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS",
"vkCmdClearAttachments() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds."
- " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", reinterpret_cast<uint64_t>(cmdBuffer));
+ " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", reinterpret_cast<uint64_t>(commandBuffer));
}
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_CLEARATTACHMENTS);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdClearAttachments()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdClearAttachments()");
}
skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdClearAttachments");
}
@@ -3028,7 +3028,7 @@
}
if (VK_FALSE == found) {
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
+ (uint64_t)commandBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
"vkCmdClearAttachments() attachment index %d not found in attachment reference array of active subpass %d",
attachment->colorAttachment, pCB->activeSubpass);
}
@@ -3036,7 +3036,7 @@
/* TODO: Is this a good test for depth/stencil? */
if (!pSD->pDepthStencilAttachment || pSD->pDepthStencilAttachment->attachment != attachment->colorAttachment) {
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
+ (uint64_t)commandBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
"vkCmdClearAttachments() attachment index %d does not match depthStencilAttachment.attachment (%d) found in active subpass %d",
attachment->colorAttachment,
(pSD->pDepthStencilAttachment) ? pSD->pDepthStencilAttachment->attachment : VK_ATTACHMENT_UNUSED,
@@ -3046,236 +3046,236 @@
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+ dev_data->device_dispatch_table->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image, VkImageLayout imageLayout,
const VkClearColorValue *pColor,
uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_CLEARCOLORIMAGE);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdClearColorImage()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdClearColorImage()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdClearColorImage");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ dev_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image, VkImageLayout imageLayout,
const VkClearDepthStencilValue *pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_CLEARDEPTHSTENCILIMAGE);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdClearDepthStencilImage()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdClearDepthStencilImage()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdClearDepthStencilImage");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+ dev_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
-VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCommandBuffer commandBuffer,
VkImage srcImage, VkImageLayout srcImageLayout,
- VkImage destImage, VkImageLayout destImageLayout,
+ VkImage dstImage, VkImageLayout dstImageLayout,
uint32_t regionCount, const VkImageResolve* pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_RESOLVEIMAGE);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdResolveImage()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResolveImage()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdResolveImage");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ dev_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_SETEVENT);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetEvent()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetEvent()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdSetEvent(cmdBuffer, event, stageMask);
+ dev_data->device_dispatch_table->CmdSetEvent(commandBuffer, event, stageMask);
}
-VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_RESETEVENT);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdResetEvent()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetEvent()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdResetEvent(cmdBuffer, event, stageMask);
+ dev_data->device_dispatch_table->CmdResetEvent(commandBuffer, event, stageMask);
}
-VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_WAITEVENTS);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdWaitEvents()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWaitEvents()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
+ dev_data->device_dispatch_table->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
}
-VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_PIPELINEBARRIER);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdPipelineBarrier()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdPipelineBarrier()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+ dev_data->device_dispatch_table->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
}
-VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_BEGINQUERY);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBeginQuery()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBeginQuery()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ dev_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
}
-VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_ENDQUERY);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdEndQuery()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdEndQuery()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdEndQuery(cmdBuffer, queryPool, slot);
+ dev_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot);
}
-VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_RESETQUERYPOOL);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdResetQueryPool()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetQueryPool()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdQueryPool");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ dev_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
}
-VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery,
- uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery,
+ uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize stride, VkQueryResultFlags flags)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_COPYQUERYPOOLRESULTS);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyQueryPoolResults()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyQueryPoolResults()");
}
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyQueryPoolResults");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdCopyQueryPoolResults(cmdBuffer, queryPool,
- startQuery, queryCount, destBuffer, destOffset, stride, flags);
+ dev_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool,
+ startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
-VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pCB->state == CB_UPDATE_ACTIVE) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_WRITETIMESTAMP);
} else {
- skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdWriteTimestamp()");
+ skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWriteTimestamp()");
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+ dev_data->device_dispatch_table->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
@@ -3393,12 +3393,12 @@
}
for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) {
const VkSubpassDependency& dependency = pCreateInfo->pDependencies[i];
- if (dependency.srcSubpass > dependency.destSubpass) {
+ if (dependency.srcSubpass > dependency.dstSubpass) {
skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS",
"Dependency graph must be specified such that an earlier pass cannot depend on a later pass.");
}
- subpass_to_node[dependency.destSubpass].prev.push_back(dependency.srcSubpass);
- subpass_to_node[dependency.srcSubpass].next.push_back(dependency.destSubpass);
+ subpass_to_node[dependency.dstSubpass].prev.push_back(dependency.srcSubpass);
+ subpass_to_node[dependency.srcSubpass].next.push_back(dependency.dstSubpass);
}
// Find for each attachment the subpasses that use them.
for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
@@ -3443,7 +3443,7 @@
return skip_call;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
if (validateDependencies(dev_data, device, pCreateInfo)) {
@@ -3536,11 +3536,11 @@
}
my_data->renderPassMap.clear();
}
-VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
if (pRenderPassBegin && pRenderPassBegin->renderPass) {
skipCall |= insideRenderPass(dev_data, pCB, "vkCmdBeginRenderPass");
@@ -3558,14 +3558,14 @@
}
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+ dev_data->device_dispatch_table->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
}
-VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
+VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_NEXTSUBPASS);
@@ -3576,14 +3576,14 @@
skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass");
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdNextSubpass(cmdBuffer, contents);
+ dev_data->device_dispatch_table->CmdNextSubpass(commandBuffer, contents);
}
-VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
skipCall |= outsideRenderPass(dev_data, pCB, "vkEndRenderpass");
updateCBTracking(pCB);
@@ -3592,31 +3592,31 @@
pCB->activeSubpass = 0;
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdEndRenderPass(cmdBuffer);
+ dev_data->device_dispatch_table->CmdEndRenderPass(commandBuffer);
}
-VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
+VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
GLOBAL_CB_NODE* pSubCB = NULL;
- for (uint32_t i=0; i<cmdBuffersCount; i++) {
- pSubCB = getCBNode(dev_data, pCmdBuffers[i]);
+ for (uint32_t i=0; i<commandBuffersCount; i++) {
+ pSubCB = getCBNode(dev_data, pCommandBuffers[i]);
if (!pSubCB) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, "DS",
- "vkCmdExecuteCommands() called w/ invalid Cmd Buffer %p in element %u of pCmdBuffers array.", (void*)pCmdBuffers[i], i);
- } else if (VK_CMD_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, "DS",
- "vkCmdExecuteCommands() called w/ Primary Cmd Buffer %p in element %u of pCmdBuffers array. All cmd buffers in pCmdBuffers array must be secondary.", (void*)pCmdBuffers[i], i);
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS",
+ "vkCmdExecuteCommands() called w/ invalid Cmd Buffer %p in element %u of pCommandBuffers array.", (void*)pCommandBuffers[i], i);
+ } else if (VK_COMMAND_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) {
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS",
+ "vkCmdExecuteCommands() called w/ Primary Cmd Buffer %p in element %u of pCommandBuffers array. All cmd buffers in pCommandBuffers array must be secondary.", (void*)pCommandBuffers[i], i);
}
}
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_EXECUTECOMMANDS);
}
if (VK_FALSE == skipCall)
- dev_data->device_dispatch_table->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
+ dev_data->device_dispatch_table->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -3647,13 +3647,13 @@
return res;
}
-VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCommandBuffer commandBuffer, const char* pMarker)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (!dev_data->device_extensions.debug_marker_enabled) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
"Attempt to use CmdDbgMarkerBegin but extension disabled!");
return;
} else if (pCB) {
@@ -3661,16 +3661,16 @@
skipCall |= addCmd(dev_data, pCB, CMD_DBGMARKERBEGIN);
}
if (VK_FALSE == skipCall)
- debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerBegin(cmdBuffer, pMarker);
+ debug_marker_dispatch_table(commandBuffer)->CmdDbgMarkerBegin(commandBuffer, pMarker);
}
-VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCommandBuffer commandBuffer)
{
VkBool32 skipCall = VK_FALSE;
- layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+ layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
if (!dev_data->device_extensions.debug_marker_enabled) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
"Attempt to use CmdDbgMarkerEnd but extension disabled!");
return;
} else if (pCB) {
@@ -3678,7 +3678,7 @@
skipCall |= addCmd(dev_data, pCB, CMD_DBGMARKEREND);
}
if (VK_FALSE == skipCall)
- debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerEnd(cmdBuffer);
+ debug_marker_dispatch_table(commandBuffer)->CmdDbgMarkerEnd(commandBuffer);
}
VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
@@ -3772,14 +3772,14 @@
return (PFN_vkVoidFunction) vkCreateDescriptorPool;
if (!strcmp(funcName, "vkResetDescriptorPool"))
return (PFN_vkVoidFunction) vkResetDescriptorPool;
- if (!strcmp(funcName, "vkAllocDescriptorSets"))
- return (PFN_vkVoidFunction) vkAllocDescriptorSets;
+ if (!strcmp(funcName, "vkAllocateDescriptorSets"))
+ return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
if (!strcmp(funcName, "vkFreeDescriptorSets"))
return (PFN_vkVoidFunction) vkFreeDescriptorSets;
if (!strcmp(funcName, "vkUpdateDescriptorSets"))
return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
- if (!strcmp(funcName, "vkAllocCommandBuffers"))
- return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+ if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+ return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
if (!strcmp(funcName, "vkBeginCommandBuffer"))
return (PFN_vkVoidFunction) vkBeginCommandBuffer;
if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 6ded670..a5833fd 100755
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -39,7 +39,7 @@
DRAWSTATE_INVALID_LAYOUT, // Invalid DS layout
DRAWSTATE_INVALID_PIPELINE, // Invalid Pipeline handle referenced
DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, // Attempt to create a pipeline with invalid state
- DRAWSTATE_INVALID_CMD_BUFFER, // Invalid CmdBuffer referenced
+ DRAWSTATE_INVALID_COMMAND_BUFFER, // Invalid CommandBuffer referenced
DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, // binding in vkCmdBindVertexData() too large for PSO's pVertexBindingDescriptions array
DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, // binding offset in vkCmdBindIndexBuffer() out of alignment based on indexType
//DRAWSTATE_MISSING_DOT_PROGRAM, // No "dot" program in order to generate png image
@@ -52,10 +52,10 @@
DRAWSTATE_INVALID_UPDATE_INDEX, // Index of requested update is invalid for specified descriptors set
DRAWSTATE_INVALID_UPDATE_STRUCT, // Struct in DS Update tree is of invalid type
DRAWSTATE_NUM_SAMPLES_MISMATCH, // Number of samples in bound PSO does not match number in FB of current RenderPass
- DRAWSTATE_NO_END_CMD_BUFFER, // Must call vkEndCommandBuffer() before QueueSubmit on that cmdBuffer
- 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_USAGE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times
- DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, // vkCmdExecuteCommands() called with a primary cmdBuffer in pCmdBuffers array
+ DRAWSTATE_NO_END_COMMAND_BUFFER, // Must call vkEndCommandBuffer() before QueueSubmit on that commandBuffer
+ DRAWSTATE_NO_BEGIN_COMMAND_BUFFER, // Binding cmds or calling End on CB that never had vkBeginCommandBuffer() called on it
+ DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, // Cmd Buffer created with VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times
+ DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, // vkCmdExecuteCommands() called with a primary commandBuffer in pCommandBuffers array
DRAWSTATE_VIEWPORT_NOT_BOUND, // Draw submitted with no viewport state bound
DRAWSTATE_SCISSOR_NOT_BOUND, // Draw submitted with no scissor state bound
DRAWSTATE_LINE_WIDTH_NOT_BOUND, // Draw submitted with no line width state bound
@@ -69,7 +69,7 @@
DRAWSTATE_INVALID_RENDERPASS_CMD, // Invalid cmd submitted while a RenderPass is active
DRAWSTATE_NO_ACTIVE_RENDERPASS, // Rendering cmd submitted without an active RenderPass
DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, // DescriptorSet bound but it was never updated. This is a warning code.
- DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, // Clear cmd issued before any Draw in CmdBuffer, should use RenderPass Ops instead
+ DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, // Clear cmd issued before any Draw in CommandBuffer, should use RenderPass Ops instead
DRAWSTATE_BEGIN_CB_INVALID_STATE, // Primary/Secondary CB created with mismatched FB/RP information
DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, // Count for viewports and scissors mismatch and/or state doesn't match count
DRAWSTATE_INVALID_IMAGE_ASPECT, // Image aspect is invalid for the current operation
@@ -110,7 +110,7 @@
VkPipelineInputAssemblyStateCreateInfo iaStateCI;
VkPipelineTessellationStateCreateInfo tessStateCI;
VkPipelineViewportStateCreateInfo vpStateCI;
- VkPipelineRasterStateCreateInfo rsStateCI;
+ VkPipelineRasterizationStateCreateInfo rsStateCI;
VkPipelineMultisampleStateCreateInfo msStateCI;
VkPipelineColorBlendStateCreateInfo cbStateCI;
VkPipelineDepthStencilStateCreateInfo dsStateCI;
@@ -303,9 +303,9 @@
// Cmd Buffer Wrapper Struct
typedef struct _GLOBAL_CB_NODE {
- VkCmdBuffer cmdBuffer;
- VkCmdBufferAllocInfo createInfo;
- VkCmdBufferBeginInfo beginInfo;
+ VkCommandBuffer commandBuffer;
+ VkCommandBufferAllocateInfo createInfo;
+ VkCommandBufferBeginInfo beginInfo;
VkFence fence; // fence tracking this cmd buffer
uint64_t numCmds; // number of cmds in this CB
uint64_t drawCount[NUM_DRAW_TYPES]; // Count of each type of draw in this CB
@@ -334,6 +334,6 @@
VkRenderPass activeRenderPass;
uint32_t activeSubpass;
VkFramebuffer framebuffer;
- VkCmdBufferLevel level;
+ VkCommandBufferLevel level;
vector<VkDescriptorSet> boundDescriptorSets;
} GLOBAL_CB_NODE;
diff --git a/layers/generic.h b/layers/generic.h
index c1e5621..cc1c7a6 100644
--- a/layers/generic.h
+++ b/layers/generic.h
@@ -48,7 +48,7 @@
{
"Generic",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: Generic",
}
};
@@ -57,7 +57,7 @@
{
"Generic",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: Generic",
}
};
diff --git a/layers/image.cpp b/layers/image.cpp
index b9d49b3..f63a9af 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -112,7 +112,7 @@
return res;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
@@ -127,7 +127,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
@@ -148,7 +148,7 @@
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
@@ -162,7 +162,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -240,7 +240,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -267,14 +267,14 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
{
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
device_data->imageMap.erase(image);
device_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
@@ -352,7 +352,7 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -370,12 +370,12 @@
<< pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
}
- if (!pCreateInfo->subresourceRange.numLevels) {
+ if (!pCreateInfo->subresourceRange.levelCount) {
std::stringstream ss;
ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.mipLevels.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
}
- if (!pCreateInfo->subresourceRange.numLayers) {
+ if (!pCreateInfo->subresourceRange.layerCount) {
std::stringstream ss;
ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.arraySize.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
@@ -460,7 +460,7 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue *pColor,
@@ -468,24 +468,24 @@
const VkImageSubresourceRange *pRanges)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// For each range, image aspect must be color only
for (uint32_t i = 0; i < rangeCount; i++) {
if (pRanges[i].aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdClearColorImage(cmdBuffer, image, imageLayout,
- pColor, rangeCount, pRanges);
+ device_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout,
+ pColor, rangeCount, pRanges);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue *pDepthStencil,
@@ -493,7 +493,7 @@
const VkImageSubresourceRange *pRanges)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// For each range, Image aspect must be depth or stencil or both
for (uint32_t i = 0; i < rangeCount; i++) {
if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) &&
@@ -502,102 +502,102 @@
char const str[] = "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be "
"set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdClearDepthStencilImage(cmdBuffer,
+ device_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer,
image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy *pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
auto srcImageEntry = device_data->imageMap.find(srcImage);
- auto destImageEntry = device_data->imageMap.find(destImage);
+ auto dstImageEntry = device_data->imageMap.find(dstImage);
// For each region, src and dst number of layers should not be zero
// For each region, src and dst number of layers must match
// For each region, src aspect mask must match dest aspect mask
// For each region, color aspects cannot be mixed with depth/stencil aspects
for (uint32_t i = 0; i < regionCount; i++) {
- if(pRegions[i].srcSubresource.numLayers == 0)
+ if(pRegions[i].srcSubresource.layerCount == 0)
{
char const str[] = "vkCmdCopyImage: number of layers in source subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
- if(pRegions[i].destSubresource.numLayers == 0)
+ if(pRegions[i].dstSubresource.layerCount == 0)
{
char const str[] = "vkCmdCopyImage: number of layers in destination subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
- if(pRegions[i].srcSubresource.numLayers != pRegions[i].destSubresource.numLayers)
+ if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount)
{
char const str[] = "vkCmdCopyImage: number of layers in source and destination subresources must match";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
- if (pRegions[i].srcSubresource.aspect != pRegions[i].destSubresource.aspect) {
+ if (pRegions[i].srcSubresource.aspect != pRegions[i].dstSubresource.aspect) {
char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
if ((pRegions[i].srcSubresource.aspect & VK_IMAGE_ASPECT_COLOR_BIT) &&
(pRegions[i].srcSubresource.aspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
}
}
if ((srcImageEntry != device_data->imageMap.end())
- && (destImageEntry != device_data->imageMap.end())) {
- if (srcImageEntry->second.imageType != destImageEntry->second.imageType) {
+ && (dstImageEntry != device_data->imageMap.end())) {
+ if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) {
char const str[] = "vkCmdCopyImage called with unmatched source and dest image types.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
}
// Check that format is same size or exact stencil/depth
if (is_depth_format(srcImageEntry->second.format)) {
- if (srcImageEntry->second.format != destImageEntry->second.format) {
+ if (srcImageEntry->second.format != dstImageEntry->second.format) {
char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
}
} else {
size_t srcSize = vk_format_get_size(srcImageEntry->second.format);
- size_t destSize = vk_format_get_size(destImageEntry->second.format);
+ size_t destSize = vk_format_get_size(dstImageEntry->second.format);
if (srcSize != destSize) {
char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
}
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdCopyImage(cmdBuffer, srcImage,
- srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ device_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage,
+ srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
}
void VKAPI vkCmdClearAttachments(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
@@ -605,7 +605,7 @@
{
VkBool32 skipCall = VK_FALSE;
VkImageAspectFlags aspectMask;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
for (uint32_t i = 0; i < attachmentCount; i++) {
aspectMask = pAttachments[i].aspectMask;
if (aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
@@ -613,7 +613,7 @@
// VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this attachment
char const str[] = "vkCmdClearAttachments aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
}
} else {
// Image aspect must be depth or stencil or both
@@ -622,35 +622,35 @@
{
char const str[] = "vkCmdClearAttachments aspectMask [%d] must be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
}
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdClearAttachments(cmdBuffer,
+ device_data->device_dispatch_table->CmdClearAttachments(commandBuffer,
attachmentCount, pAttachments, rectCount, pRects);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy *pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// For each region, the number of layers in the image subresource should not be zero
// Image aspect must be ONE OF color, depth, stencil
for (uint32_t i = 0; i < regionCount; i++) {
- if(pRegions[i].imageSubresource.numLayers == 0)
+ if(pRegions[i].imageSubresource.layerCount == 0)
{
char const str[] = "vkCmdCopyImageToBuffer: number of layers in image subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
VkImageAspectFlags aspect = pRegions[i].imageSubresource.aspect;
@@ -659,34 +659,34 @@
(aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdCopyImageToBuffer(cmdBuffer,
- srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+ device_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer,
+ srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy *pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// For each region, the number of layers in the image subresource should not be zero
// Image aspect must be ONE OF color, depth, stencil
for (uint32_t i = 0; i < regionCount; i++) {
- if(pRegions[i].imageSubresource.numLayers == 0)
+ if(pRegions[i].imageSubresource.layerCount == 0)
{
char const str[] = "vkCmdCopyBufferToImage: number of layers in image subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
VkImageAspectFlags aspect = pRegions[i].imageSubresource.aspect;
@@ -695,47 +695,47 @@
(aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdCopyBufferToImage(cmdBuffer,
- srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+ device_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer,
+ srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit *pRegions,
VkFilter filter)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
auto srcImageEntry = device_data->imageMap.find(srcImage);
- auto destImageEntry = device_data->imageMap.find(destImage);
+ auto dstImageEntry = device_data->imageMap.find(dstImage);
if ((srcImageEntry != device_data->imageMap.end()) &&
- (destImageEntry != device_data->imageMap.end())) {
+ (dstImageEntry != device_data->imageMap.end())) {
VkFormat srcFormat = srcImageEntry->second.format;
- VkFormat dstFormat = destImageEntry->second.format;
+ VkFormat dstFormat = dstImageEntry->second.format;
// Validate consistency for signed and unsigned formats
if ((vk_format_is_sint(srcFormat) && !vk_format_is_sint(dstFormat)) ||
(vk_format_is_uint(srcFormat) && !vk_format_is_uint(dstFormat))) {
std::stringstream ss;
- ss << "vkCmdBlitImage: If one of srcImage and destImage images has signed/unsigned integer format, "
+ ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed/unsigned integer format, "
<< "the other one must also have signed/unsigned integer format. "
<< "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat);
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
}
// Validate aspect bits and formats for depth/stencil images
@@ -743,67 +743,67 @@
vk_format_is_depth_or_stencil(dstFormat)) {
if (srcFormat != dstFormat) {
std::stringstream ss;
- ss << "vkCmdBlitImage: If one of srcImage and destImage images has a format of depth, stencil or depth "
+ ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth "
<< "stencil, the other one must have exactly the same format. "
<< "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat);
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
}
for (uint32_t i = 0; i < regionCount; i++) {
- if(pRegions[i].srcSubresource.numLayers == 0)
+ if(pRegions[i].srcSubresource.layerCount == 0)
{
char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
- if(pRegions[i].destSubresource.numLayers == 0)
+ if(pRegions[i].dstSubresource.layerCount == 0)
{
char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
- if(pRegions[i].srcSubresource.numLayers != pRegions[i].destSubresource.numLayers)
+ if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount)
{
char const str[] = "vkCmdBlitImage: number of layers in source and destination subresources must match";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspect;
- VkImageAspectFlags dstAspect = pRegions[i].destSubresource.aspect;
+ VkImageAspectFlags dstAspect = pRegions[i].dstSubresource.aspect;
if (srcAspect != dstAspect) {
std::stringstream ss;
ss << "vkCmdBlitImage: Image aspects of depth/stencil images should match";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
if (vk_format_is_depth_and_stencil(srcFormat)) {
if (srcAspect != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
std::stringstream ss;
ss << "vkCmdBlitImage: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT "
- << "and VK_IMAGE_ASPECT_STENCIL_BIT set in both the srcImage and destImage";
+ << "and VK_IMAGE_ASPECT_STENCIL_BIT set in both the srcImage and dstImage";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
} else if (vk_format_is_stencil_only(srcFormat)) {
if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) {
std::stringstream ss;
ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT "
- << "set in both the srcImage and destImage";
+ << "set in both the srcImage and dstImage";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
} else if (vk_format_is_depth_only(srcFormat)) {
if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) {
std::stringstream ss;
ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH "
- << "set in both the srcImage and destImage";
+ << "set in both the srcImage and dstImage";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
}
}
@@ -817,81 +817,81 @@
ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, depth stencil or integer-based format "
<< "then filter must be VK_FILTER_NEAREST.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FILTER, "IMAGE", ss.str().c_str());
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_FILTER, "IMAGE", ss.str().c_str());
}
}
}
- device_data->device_dispatch_table->CmdBlitImage(cmdBuffer, srcImage,
- srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+ device_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage,
+ srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve *pRegions)
{
VkBool32 skipCall = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
auto srcImageEntry = device_data->imageMap.find(srcImage);
- auto destImageEntry = device_data->imageMap.find(destImage);
+ auto dstImageEntry = device_data->imageMap.find(dstImage);
// For each region, the number of layers in the image subresource should not be zero
// For each region, src and dest image aspect must be color only
for (uint32_t i = 0; i < regionCount; i++) {
- if(pRegions[i].srcSubresource.numLayers == 0)
+ if(pRegions[i].srcSubresource.layerCount == 0)
{
char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
- if(pRegions[i].destSubresource.numLayers == 0)
+ if(pRegions[i].dstSubresource.layerCount == 0)
{
char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
}
if ((pRegions[i].srcSubresource.aspect != VK_IMAGE_ASPECT_COLOR_BIT) ||
- (pRegions[i].destSubresource.aspect != VK_IMAGE_ASPECT_COLOR_BIT)) {
+ (pRegions[i].dstSubresource.aspect != VK_IMAGE_ASPECT_COLOR_BIT)) {
char const str[] = "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
}
}
if ((srcImageEntry != device_data->imageMap.end()) &&
- (destImageEntry != device_data->imageMap.end())) {
- if (srcImageEntry->second.format != destImageEntry->second.format) {
+ (dstImageEntry != device_data->imageMap.end())) {
+ if (srcImageEntry->second.format != dstImageEntry->second.format) {
char const str[] = "vkCmdResolveImage called with unmatched source and dest formats.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
}
- if (srcImageEntry->second.imageType != destImageEntry->second.imageType) {
+ if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) {
char const str[] = "vkCmdResolveImage called with unmatched source and dest image types.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
}
if (srcImageEntry->second.samples <= 1) {
char const str[] = "vkCmdResolveImage called with source sample count less than 2.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
}
- if (destImageEntry->second.samples > 1) {
+ if (dstImageEntry->second.samples > 1) {
char const str[] = "vkCmdResolveImage called with dest sample count greater than 1.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
- (uint64_t)cmdBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
+ (uint64_t)commandBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
}
}
if (VK_FALSE == skipCall) {
- device_data->device_dispatch_table->CmdResolveImage(cmdBuffer, srcImage,
- srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ device_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage,
+ srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
}
diff --git a/layers/image.h b/layers/image.h
index 868ecfe..dcfb81a 100644
--- a/layers/image.h
+++ b/layers/image.h
@@ -52,7 +52,7 @@
uint32_t samples;
VkImageType imageType;
VkExtent3D extent;
- _IMAGE_STATE():mipLevels(0), arraySize(0), format(VK_FORMAT_UNDEFINED), samples(0), imageType(VK_IMAGE_TYPE_NUM), extent{} {};
+ _IMAGE_STATE():mipLevels(0), arraySize(0), format(VK_FORMAT_UNDEFINED), samples(0), imageType(VK_IMAGE_TYPE_RANGE_SIZE), extent{} {};
_IMAGE_STATE(const VkImageCreateInfo* pCreateInfo):
mipLevels(pCreateInfo->mipLevels),
arraySize(pCreateInfo->arrayLayers),
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 258e7e5..b2bd0eb 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -56,7 +56,7 @@
bool wsi_enabled;
uint64_t currentFenceId;
// Maps for tracking key structs related to MemTracker state
- unordered_map<VkCmdBuffer, MT_CB_INFO> cbMap;
+ unordered_map<VkCommandBuffer, MT_CB_INFO> cbMap;
unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO> memObjMap;
unordered_map<VkFence, MT_FENCE_INFO> fenceMap; // Map fence to fence info
unordered_map<VkQueue, MT_QUEUE_INFO> queueMap;
@@ -136,14 +136,14 @@
// Add new CBInfo for this cb to map container
static void add_cmd_buf_info(layer_data* my_data,
- const VkCmdBuffer cb)
+ const VkCommandBuffer cb)
{
- my_data->cbMap[cb].cmdBuffer = cb;
+ my_data->cbMap[cb].commandBuffer = cb;
}
// Return ptr to Info in CB map, or NULL if not found
static MT_CB_INFO* get_cmd_buf_info(layer_data* my_data,
- const VkCmdBuffer cb)
+ const VkCommandBuffer cb)
{
auto item = my_data->cbMap.find(cb);
if (item != my_data->cbMap.end()) {
@@ -354,11 +354,11 @@
static void add_mem_obj_info(layer_data* my_data,
void* object,
const VkDeviceMemory mem,
- const VkMemoryAllocInfo* pAllocInfo)
+ const VkMemoryAllocateInfo* pAllocateInfo)
{
assert(object != NULL);
- memcpy(&my_data->memObjMap[mem].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
+ memcpy(&my_data->memObjMap[mem].allocInfo, pAllocateInfo, sizeof(VkMemoryAllocateInfo));
// TODO: Update for real hardware, actually process allocation info structures
my_data->memObjMap[mem].allocInfo.pNext = NULL;
my_data->memObjMap[mem].object = object;
@@ -370,7 +370,7 @@
// Find Mem Obj Info and add CB reference to list container
static VkBool32 update_cmd_buf_and_mem_references(
layer_data *my_data,
- const VkCmdBuffer cb,
+ const VkCommandBuffer cb,
const VkDeviceMemory mem,
const char *apiName)
{
@@ -388,8 +388,8 @@
} else {
// Search for cmd buffer object in memory object's binding list
VkBool32 found = VK_FALSE;
- if (pMemInfo->pCmdBufferBindings.size() > 0) {
- for (list<VkCmdBuffer>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
+ if (pMemInfo->pCommandBufferBindings.size() > 0) {
+ for (list<VkCommandBuffer>::iterator it = pMemInfo->pCommandBufferBindings.begin(); it != pMemInfo->pCommandBufferBindings.end(); ++it) {
if ((*it) == cb) {
found = VK_TRUE;
break;
@@ -398,7 +398,7 @@
}
// If not present, add to list
if (found == VK_FALSE) {
- pMemInfo->pCmdBufferBindings.push_front(cb);
+ pMemInfo->pCommandBufferBindings.push_front(cb);
pMemInfo->refCount++;
}
// Now update CBInfo's Mem reference list
@@ -430,7 +430,7 @@
// Free bindings related to CB
static VkBool32 clear_cmd_buf_and_mem_references(layer_data* my_data,
- const VkCmdBuffer cb)
+ const VkCommandBuffer cb)
{
VkBool32 skipCall = VK_FALSE;
MT_CB_INFO* pCBInfo = get_cmd_buf_info(my_data, cb);
@@ -442,7 +442,7 @@
list<VkDeviceMemory> mem_obj_list = pCBInfo->pMemObjList;
for (list<VkDeviceMemory>::iterator it=mem_obj_list.begin(); it!=mem_obj_list.end(); ++it) {
MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(my_data, *it);
- pInfo->pCmdBufferBindings.remove(cb);
+ pInfo->pCommandBufferBindings.remove(cb);
pInfo->refCount--;
}
}
@@ -455,7 +455,7 @@
static VkBool32 delete_cmd_buf_info_list(layer_data* my_data)
{
VkBool32 skipCall = VK_FALSE;
- for (unordered_map<VkCmdBuffer, MT_CB_INFO>::iterator ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) {
+ for (unordered_map<VkCommandBuffer, MT_CB_INFO>::iterator ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) {
skipCall |= clear_cmd_buf_and_mem_references(my_data, (*ii).first);
}
my_data->cbMap.clear();
@@ -467,23 +467,23 @@
MT_MEM_OBJ_INFO* pMemObjInfo)
{
VkBool32 skipCall = VK_FALSE;
- size_t cmdBufRefCount = pMemObjInfo->pCmdBufferBindings.size();
+ size_t cmdBufRefCount = pMemObjInfo->pCommandBufferBindings.size();
size_t objRefCount = pMemObjInfo->pObjBindings.size();
- if ((pMemObjInfo->pCmdBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
+ if ((pMemObjInfo->pCommandBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pMemObjInfo->mem, 0, MEMTRACK_FREED_MEM_REF, "MEM",
"Attempting to free memory object %#" PRIxLEAST64 " which still contains %lu references",
(uint64_t) pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
}
- if (cmdBufRefCount > 0 && pMemObjInfo->pCmdBufferBindings.size() > 0) {
- for (list<VkCmdBuffer>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
- // TODO : cmdBuffer should be source Obj here
+ if (cmdBufRefCount > 0 && pMemObjInfo->pCommandBufferBindings.size() > 0) {
+ for (list<VkCommandBuffer>::const_iterator it = pMemObjInfo->pCommandBufferBindings.begin(); it != pMemObjInfo->pCommandBufferBindings.end(); ++it) {
+ // TODO : CommandBuffer should be source Obj here
log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_FREED_MEM_REF, "MEM",
"Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), (uint64_t) pMemObjInfo->mem);
}
// Clear the list of hanging references
- pMemObjInfo->pCmdBufferBindings.clear();
+ pMemObjInfo->pCommandBufferBindings.clear();
}
if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) {
@@ -514,7 +514,7 @@
// Check if fence for given CB is completed
static VkBool32 checkCBCompleted(layer_data* my_data,
- const VkCmdBuffer cb,
+ const VkCommandBuffer cb,
VkBool32 *complete)
{
VkBool32 skipCall = VK_FALSE;
@@ -558,13 +558,13 @@
// Clear any CB bindings for completed CBs
// TODO : Is there a better place to do this?
- VkBool32 cmdBufferComplete = VK_FALSE;
+ VkBool32 commandBufferComplete = VK_FALSE;
assert(pInfo->object != VK_NULL_HANDLE);
- list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin();
- list<VkCmdBuffer>::iterator temp;
- while (pInfo->pCmdBufferBindings.size() > 0 && it != pInfo->pCmdBufferBindings.end()) {
- skipCall |= checkCBCompleted(my_data, *it, &cmdBufferComplete);
- if (VK_TRUE == cmdBufferComplete) {
+ list<VkCommandBuffer>::iterator it = pInfo->pCommandBufferBindings.begin();
+ list<VkCommandBuffer>::iterator temp;
+ while (pInfo->pCommandBufferBindings.size() > 0 && it != pInfo->pCommandBufferBindings.end()) {
+ skipCall |= checkCBCompleted(my_data, *it, &commandBufferComplete);
+ if (VK_TRUE == commandBufferComplete) {
temp = it;
++temp;
skipCall |= clear_cmd_buf_and_mem_references(my_data, *it);
@@ -825,7 +825,7 @@
log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" Ref Count: %u", pInfo->refCount);
if (0 != pInfo->allocInfo.allocationSize) {
- string pAllocInfoMsg = vk_print_vkmemoryallocinfo(&pInfo->allocInfo, "MEM(INFO): ");
+ string pAllocInfoMsg = vk_print_vkmemoryallocateinfo(&pInfo->allocInfo, "MEM(INFO): ");
log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
} else {
@@ -843,10 +843,10 @@
}
log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
- " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
- if (pInfo->pCmdBufferBindings.size() > 0)
+ " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCommandBufferBindings.size());
+ if (pInfo->pCommandBufferBindings.size() > 0)
{
- for (list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
+ for (list<VkCommandBuffer>::iterator it = pInfo->pCommandBufferBindings.begin(); it != pInfo->pCommandBufferBindings.end(); ++it) {
log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" VK CB %p", (*it));
}
@@ -877,7 +877,7 @@
log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %#" PRIxLEAST64,
- (void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
+ (void*)pCBInfo, (void*)pCBInfo->commandBuffer, pCBInfo->fenceId,
(uint64_t) pCBInfo->lastSubmittedFence);
if (pCBInfo->pMemObjList.size() <= 0)
@@ -925,7 +925,7 @@
}
// hook DestroyInstance to remove tableInstanceMap entry
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
@@ -952,7 +952,7 @@
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -994,7 +994,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDevice *pDevice)
{
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
@@ -1010,7 +1010,7 @@
VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
VkDevice device,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
@@ -1195,17 +1195,17 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateMemory(
VkDevice device,
- const VkMemoryAllocInfo *pAllocInfo,
- const VkAllocCallbacks* pAllocator,
- VkDeviceMemory *pMem)
+ const VkMemoryAllocateInfo *pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory *pMemory)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->AllocMemory(device, pAllocInfo, pAllocator, pMem);
+ VkResult result = my_data->device_dispatch_table->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
// TODO : Track allocations and overall size here
loader_platform_thread_lock_mutex(&globalLock);
- add_mem_obj_info(my_data, device, *pMem, pAllocInfo);
+ add_mem_obj_info(my_data, device, *pMemory, pAllocateInfo);
print_mem_list(my_data, device);
loader_platform_thread_unlock_mutex(&globalLock);
return result;
@@ -1214,7 +1214,7 @@
VK_LAYER_EXPORT void VKAPI vkFreeMemory(
VkDevice device,
VkDeviceMemory mem,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
/* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
@@ -1265,7 +1265,7 @@
my_data->device_dispatch_table->UnmapMemory(device, mem);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
loader_platform_thread_lock_mutex(&globalLock);
@@ -1278,7 +1278,7 @@
my_data->device_dispatch_table->DestroyFence(device, fence, pAllocator);
}
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
@@ -1294,7 +1294,7 @@
}
}
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
@@ -1314,7 +1314,7 @@
VkDevice device,
VkBuffer buffer,
VkDeviceMemory mem,
- VkDeviceSize memOffset)
+ VkDeviceSize memoryOffset)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED;
@@ -1325,7 +1325,7 @@
print_mem_list(my_data, device);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- result = my_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memOffset);
+ result = my_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memoryOffset);
}
return result;
}
@@ -1334,7 +1334,7 @@
VkDevice device,
VkImage image,
VkDeviceMemory mem,
- VkDeviceSize memOffset)
+ VkDeviceSize memoryOffset)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED;
@@ -1345,7 +1345,7 @@
print_mem_list(my_data, device);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- result = my_data->device_dispatch_table->BindImageMemory(device, image, mem, memOffset);
+ result = my_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset);
}
return result;
}
@@ -1426,7 +1426,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFence *pFence)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1566,7 +1566,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBuffer *pBuffer)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1582,7 +1582,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImage *pImage)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1598,7 +1598,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImageView *pView)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1617,7 +1617,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBufferView *pView)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1634,99 +1634,99 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(
VkDevice device,
- const VkCmdBufferAllocInfo *pCreateInfo,
- VkCmdBuffer *pCmdBuffer)
+ const VkCommandBufferAllocateInfo *pCreateInfo,
+ VkCommandBuffer *pCommandBuffer)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = my_data->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+ VkResult result = my_data->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
// At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
loader_platform_thread_lock_mutex(&globalLock);
- if (*pCmdBuffer)
- add_cmd_buf_info(my_data, *pCmdBuffer);
+ if (*pCommandBuffer)
+ add_cmd_buf_info(my_data, *pCommandBuffer);
printCBList(my_data, device);
loader_platform_thread_unlock_mutex(&globalLock);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
- VkCmdBuffer cmdBuffer,
- const VkCmdBufferBeginInfo *pBeginInfo)
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo *pBeginInfo)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED;
VkBool32 skipCall = VK_FALSE;
- VkBool32 cmdBufferComplete = VK_FALSE;
+ VkBool32 commandBufferComplete = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
// This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references
- skipCall = checkCBCompleted(my_data, cmdBuffer, &cmdBufferComplete);
+ skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete);
- if (VK_FALSE == cmdBufferComplete) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
+ if (VK_FALSE == commandBufferComplete) {
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Calling vkBeginCommandBuffer() on active CB %p before it has completed. "
- "You must check CB flag before this call.", cmdBuffer);
+ "You must check CB flag before this call.", commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- result = my_data->device_dispatch_table->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ result = my_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo);
}
loader_platform_thread_lock_mutex(&globalLock);
- clear_cmd_buf_and_mem_references(my_data, cmdBuffer);
+ clear_cmd_buf_and_mem_references(my_data, commandBuffer);
loader_platform_thread_unlock_mutex(&globalLock);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
- VkCmdBuffer cmdBuffer)
+ VkCommandBuffer commandBuffer)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Anything to do here?
- VkResult result = my_data->device_dispatch_table->EndCommandBuffer(cmdBuffer);
+ VkResult result = my_data->device_dispatch_table->EndCommandBuffer(commandBuffer);
return result;
}
VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
- VkCmdBuffer cmdBuffer,
- VkCmdBufferResetFlags flags)
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED;
VkBool32 skipCall = VK_FALSE;
- VkBool32 cmdBufferComplete = VK_FALSE;
+ VkBool32 commandBufferComplete = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
// Verify that CB is complete (not in-flight)
- skipCall = checkCBCompleted(my_data, cmdBuffer, &cmdBufferComplete);
- if (VK_FALSE == cmdBufferComplete) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
+ skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete);
+ if (VK_FALSE == commandBufferComplete) {
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Resetting CB %p before it has completed. You must check CB "
- "flag before calling vkResetCommandBuffer().", cmdBuffer);
+ "flag before calling vkResetCommandBuffer().", commandBuffer);
}
// Clear memory references as this point.
- skipCall |= clear_cmd_buf_and_mem_references(my_data, cmdBuffer);
+ skipCall |= clear_cmd_buf_and_mem_references(my_data, commandBuffer);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- result = my_data->device_dispatch_table->ResetCommandBuffer(cmdBuffer, flags);
+ result = my_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags);
}
return result;
}
// TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
-// need to account for that mem now having binding to given cmdBuffer
+// need to account for that mem now having binding to given commandBuffer
VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
#if 0
- // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
+ // TODO : If memory bound to pipeline, then need to tie that mem to commandBuffer
if (getPipeline(pipeline)) {
- MT_CB_INFO *pCBInfo = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCBInfo = get_cmd_buf_info(my_data, commandBuffer);
if (pCBInfo) {
pCBInfo->pipelines[pipelineBindPoint] = pipeline;
} else {
- "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, cmdBuffer);
- layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
+ "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, commandBuffer);
+ layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, commandBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
}
}
else {
@@ -1734,179 +1734,179 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
}
#endif
- my_data->device_dispatch_table->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ my_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t viewportCount,
const VkViewport* pViewports)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+ my_data->device_dispatch_table->CmdSetViewport(commandBuffer, viewportCount, pViewports);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t scissorCount,
const VkRect2D* pScissors)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+ my_data->device_dispatch_table->CmdSetScissor(commandBuffer, scissorCount, pScissors);
}
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetLineWidth(cmdBuffer, lineWidth);
+ my_data->device_dispatch_table->CmdSetLineWidth(commandBuffer, lineWidth);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+ my_data->device_dispatch_table->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const float blendConstants[4])
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetBlendConstants(cmdBuffer, blendConstants);
+ my_data->device_dispatch_table->CmdSetBlendConstants(commandBuffer, blendConstants);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+ my_data->device_dispatch_table->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilCompareMask)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+ my_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilWriteMask)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+ my_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilReference)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+ MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
if (!pCmdBuf) {
- skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
- MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+ skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+ MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+ my_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
@@ -1915,378 +1915,378 @@
uint32_t dynamicOffsetCount,
const uint32_t *pDynamicOffsets)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
my_data->device_dispatch_table->CmdBindDescriptorSets(
- cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t startBinding,
uint32_t bindingCount,
const VkBuffer *pBuffers,
const VkDeviceSize *pOffsets)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Somewhere need to verify that VBs have correct usage state flagged
- my_data->device_dispatch_table->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ my_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Somewhere need to verify that IBs have correct usage state flagged
- my_data->device_dispatch_table->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+ my_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
uint32_t stride)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
loader_platform_thread_lock_mutex(&globalLock);
- VkBool32 skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdDrawIndirect");
+ VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDrawIndirect");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+ my_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
uint32_t stride)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
loader_platform_thread_lock_mutex(&globalLock);
- VkBool32 skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdDrawIndexedIndirect");
+ VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDrawIndexedIndirect");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+ my_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
loader_platform_thread_lock_mutex(&globalLock);
- VkBool32 skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdDispatchIndirect");
+ VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDispatchIndirect");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+ my_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy *pRegions)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBuffer");
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBuffer");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBuffer");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBuffer");
// Validate that SRC & DST buffers have correct usage flags set
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+ my_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize destStride,
VkQueryResultFlags flags)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyQueryPoolResults");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyQueryPoolResults");
// Validate that DST buffer has correct usage flags set
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
+ my_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, destStride, flags);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy *pRegions)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
// Validate that src & dst images have correct usage flags set
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImage");
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImage");
- skipCall |= validate_image_usage_flags(my_data, cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
- skipCall |= validate_image_usage_flags(my_data, cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImage");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImage");
+ skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
+ skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
my_data->device_dispatch_table->CmdCopyImage(
- cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit *pRegions,
VkFilter filter)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
// Validate that src & dst images have correct usage flags set
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdBlitImage");
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdBlitImage");
- skipCall |= validate_image_usage_flags(my_data, cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
- skipCall |= validate_image_usage_flags(my_data, cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdBlitImage");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdBlitImage");
+ skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
+ skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
my_data->device_dispatch_table->CmdBlitImage(
- cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+ commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy *pRegions)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBufferToImage");
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBufferToImage");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBufferToImage");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBufferToImage");
// Validate that src buff & dst image have correct usage flags set
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
- skipCall |= validate_image_usage_flags(my_data, cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyBufferToImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
+ skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBufferToImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
my_data->device_dispatch_table->CmdCopyBufferToImage(
- cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+ commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy *pRegions)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImageToBuffer");
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImageToBuffer");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImageToBuffer");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImageToBuffer");
// Validate that dst buff & src image have correct usage flags set
- skipCall |= validate_image_usage_flags(my_data, cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
my_data->device_dispatch_table->CmdCopyImageToBuffer(
- cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+ commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const uint32_t *pData)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdUpdateBuffer");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdUpdateBuffer");
// Validate that dst buff has correct usage flags set
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+ my_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdFillBuffer");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdFillBuffer");
// Validate that dst buff has correct usage flags set
- skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+ skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+ my_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue *pColor,
uint32_t rangeCount,
const VkImageSubresourceRange *pRanges)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdClearColorImage");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdClearColorImage");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
- my_data->device_dispatch_table->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ my_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdClearDepthStencilImage");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdClearDepthStencilImage");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
my_data->device_dispatch_table->CmdClearDepthStencilImage(
- cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+ commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve *pRegions)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
VkDeviceMemory mem;
- skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdResolveImage");
- skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
- skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdResolveImage");
+ skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdResolveImage");
+ skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdResolveImage");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
my_data->device_dispatch_table->CmdResolveImage(
- cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
}
VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot,
VkFlags flags)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- my_data->device_dispatch_table->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ my_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
}
VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- my_data->device_dispatch_table->CmdEndQuery(cmdBuffer, queryPool, slot);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ my_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot);
}
VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount)
{
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- my_data->device_dispatch_table->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ my_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -2433,7 +2433,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSemaphore *pSemaphore)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -2449,7 +2449,7 @@
VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
loader_platform_thread_lock_mutex(&globalLock);
@@ -2483,8 +2483,8 @@
return (PFN_vkVoidFunction) vkDestroyDevice;
if (!strcmp(funcName, "vkQueueSubmit"))
return (PFN_vkVoidFunction) vkQueueSubmit;
- if (!strcmp(funcName, "vkAllocMemory"))
- return (PFN_vkVoidFunction) vkAllocMemory;
+ if (!strcmp(funcName, "vkAllocateMemory"))
+ return (PFN_vkVoidFunction) vkAllocateMemory;
if (!strcmp(funcName, "vkFreeMemory"))
return (PFN_vkVoidFunction) vkFreeMemory;
if (!strcmp(funcName, "vkMapMemory"))
@@ -2531,8 +2531,8 @@
return (PFN_vkVoidFunction) vkCreateImageView;
if (!strcmp(funcName, "vkCreateBufferView"))
return (PFN_vkVoidFunction) vkCreateBufferView;
- if (!strcmp(funcName, "vkAllocCommandBuffers"))
- return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+ if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+ return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
if (!strcmp(funcName, "vkBeginCommandBuffer"))
return (PFN_vkVoidFunction) vkBeginCommandBuffer;
if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index b09c247..b638ce4 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -99,9 +99,9 @@
void* object; // Dispatchable object used to create this memory (device of swapchain)
uint32_t refCount; // Count of references (obj bindings or CB use)
VkDeviceMemory mem;
- VkMemoryAllocInfo allocInfo;
+ VkMemoryAllocateInfo allocInfo;
list<MT_OBJ_HANDLE_TYPE> pObjBindings; // list container of objects bound to this memory
- list<VkCmdBuffer> pCmdBufferBindings; // list container of cmd buffers that reference this mem object
+ list<VkCommandBuffer> pCommandBufferBindings; // list container of cmd buffers that reference this mem object
};
// This only applies to Buffers and Images, which can have memory bound to them
@@ -115,10 +115,10 @@
// Track all command buffers
typedef struct _MT_CB_INFO {
- VkCmdBufferAllocInfo createInfo;
- VkPipeline pipelines[VK_PIPELINE_BIND_POINT_NUM];
+ VkCommandBufferAllocateInfo createInfo;
+ VkPipeline pipelines[VK_PIPELINE_BIND_POINT_RANGE_SIZE];
uint32_t attachmentCount;
- VkCmdBuffer cmdBuffer;
+ VkCommandBuffer commandBuffer;
uint64_t fenceId;
VkFence lastSubmittedFence;
VkQueue lastSubmittedQueue;
@@ -139,7 +139,7 @@
struct MT_QUEUE_INFO {
uint64_t lastRetiredId;
uint64_t lastSubmittedId;
- list<VkCmdBuffer> pQueueCmdBuffers;
+ list<VkCommandBuffer> pQueueCommandBuffers;
list<VkDeviceMemory> pMemRefList;
};
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 5234462..14cb954 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -40,7 +40,7 @@
/******************************** Layer multi1 functions **************************/
/* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
dispatch_key key = get_dispatch_key(device);
@@ -51,7 +51,7 @@
printf("Completed multi1 layer vkDestroyDevice()\n");
}
-VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
@@ -66,7 +66,7 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
@@ -140,7 +140,7 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, instance);
dispatch_key key = get_dispatch_key(instance);
diff --git a/layers/object_track.h b/layers/object_track.h
index f3a1252..4982b87 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -115,8 +115,8 @@
{
switch ((VkDbgObjectType)input_value)
{
- case VK_OBJECT_TYPE_CMD_POOL:
- return "VK_OBJECT_TYPE_CMD_POOL";
+ case VK_OBJECT_TYPE_COMMAND_POOL:
+ return "VK_OBJECT_TYPE_COMMAND_POOL";
case VK_OBJECT_TYPE_BUFFER:
return "VK_OBJECT_TYPE_BUFFER";
case VK_OBJECT_TYPE_BUFFER_VIEW:
@@ -422,9 +422,9 @@
static void create_obj(VkDevice dispatchable_object, VkDescriptorSet object, VkDbgObjectType objType);
static void create_obj(VkDevice dispatchable_object, VkQueue vkObj, VkDbgObjectType objType);
static VkBool32 validate_object(VkQueue dispatchable_object, VkImage object);
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkImage object);
-static VkBool32 validate_object(VkQueue dispatchable_object, VkCmdBuffer object);
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkDescriptorSet object);
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkImage object);
+static VkBool32 validate_object(VkQueue dispatchable_object, VkCommandBuffer object);
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkDescriptorSet object);
static VkBool32 validate_object(VkInstance dispatchable_object, VkInstance object);
static VkBool32 validate_object(VkDevice dispatchable_object, VkDevice object);
static VkBool32 validate_object(VkDevice dispatchable_object, VkDescriptorPool object);
@@ -446,7 +446,7 @@
extern unordered_map<const void*, OBJTRACK_NODE*> VkBufferMap;
extern unordered_map<const void*, OBJTRACK_NODE*> VkFenceMap;
extern unordered_map<const void*, OBJTRACK_NODE*> VkSemaphoreMap;
-extern unordered_map<const void*, OBJTRACK_NODE*> VkCmdBufferMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkCommandBufferMap;
extern unordered_map<const void*, OBJTRACK_NODE*> VkSwapchainKHRMap;
static VkBool32 validate_object(VkQueue dispatchable_object, VkImage object)
@@ -459,7 +459,7 @@
return VK_FALSE;
}
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkImage object)
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkImage object)
{
if ((VkImageMap.find((void*)object) == VkImageMap.end()) &&
(swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {
@@ -469,16 +469,16 @@
return VK_FALSE;
}
-static VkBool32 validate_object(VkQueue dispatchable_object, VkCmdBuffer object)
+static VkBool32 validate_object(VkQueue dispatchable_object, VkCommandBuffer object)
{
- if (VkCmdBufferMap.find(object) == VkCmdBufferMap.end()) {
+ if (VkCommandBufferMap.find(object) == VkCommandBufferMap.end()) {
return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkCmdBuffer Object %p",reinterpret_cast<uint64_t>(object));
+ "Invalid VkCommandBuffer Object %p",reinterpret_cast<uint64_t>(object));
}
return VK_FALSE;
}
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkDescriptorSet object)
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkDescriptorSet object)
{
if (VkDescriptorSetMap.find((void*)object) == VkDescriptorSetMap.end()) {
return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
@@ -523,11 +523,11 @@
return VK_FALSE;
}
-static VkBool32 validate_object(VkDevice dispatchable_object, VkCmdBuffer object)
+static VkBool32 validate_object(VkDevice dispatchable_object, VkCommandBuffer object)
{
- if (VkCmdBufferMap.find(object) == VkCmdBufferMap.end()) {
+ if (VkCommandBufferMap.find(object) == VkCommandBufferMap.end()) {
return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkCmdBuffer Object %p",reinterpret_cast<uint64_t>(object));
+ "Invalid VkCommandBuffer Object %p",reinterpret_cast<uint64_t>(object));
}
return VK_FALSE;
}
@@ -548,7 +548,7 @@
numTotalObjs++;
}
-static void create_obj(VkDevice dispatchable_object, VkCmdBuffer vkObj, VkDbgObjectType objType)
+static void create_obj(VkDevice dispatchable_object, VkCommandBuffer vkObj, VkDbgObjectType objType)
{
log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<uint64_t>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",
"OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
@@ -558,7 +558,7 @@
pNewObjNode->objType = objType;
pNewObjNode->status = OBJSTATUS_NONE;
pNewObjNode->vkObj = reinterpret_cast<uint64_t>(vkObj);
- VkCmdBufferMap[vkObj] = pNewObjNode;
+ VkCommandBufferMap[vkObj] = pNewObjNode;
uint32_t objIndex = objTypeToIndex(objType);
numObjs[objIndex]++;
numTotalObjs++;
@@ -634,7 +634,7 @@
VkResult
explicit_CreateInstance(
const VkInstanceCreateInfo *pCreateInfo,
- const VkAllocCallbacks * pAllocator,
+ const VkAllocationCallbacks * pAllocator,
VkInstance * pInstance)
{
@@ -674,7 +674,7 @@
explicit_CreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
- const VkAllocCallbacks *pAllocator,
+ const VkAllocationCallbacks *pAllocator,
VkDevice *pDevice)
{
loader_platform_thread_lock_mutex(&objLock);
@@ -798,27 +798,27 @@
}
VkResult
-explicit_AllocDescriptorSets(
+explicit_AllocateDescriptorSets(
VkDevice device,
- const VkDescriptorSetAllocInfo *pAllocInfo,
+ const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets)
{
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&objLock);
skipCall |= validate_object(device, device);
- skipCall |= validate_object(device, pAllocInfo->descriptorPool);
- for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
- skipCall |= validate_object(device, pAllocInfo->pSetLayouts[i]);
+ skipCall |= validate_object(device, pAllocateInfo->descriptorPool);
+ for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) {
+ skipCall |= validate_object(device, pAllocateInfo->pSetLayouts[i]);
}
loader_platform_thread_unlock_mutex(&objLock);
if (skipCall)
return VK_ERROR_VALIDATION_FAILED;
- VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocDescriptorSets(
- device, pAllocInfo, pDescriptorSets);
+ VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocateDescriptorSets(
+ device, pAllocateInfo, pDescriptorSets);
loader_platform_thread_lock_mutex(&objLock);
- for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
+ for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) {
create_obj(device, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
}
loader_platform_thread_unlock_mutex(&objLock);
@@ -854,7 +854,7 @@
explicit_FreeMemory(
VkDevice device,
VkDeviceMemory mem,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
loader_platform_thread_lock_mutex(&objLock);
validate_object(device, device);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 2181e44..ce64cf4 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -287,8 +287,8 @@
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT |
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
- VK_FORMAT_FEATURE_BLIT_SOURCE_BIT |
- VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT);
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+ VK_FORMAT_FEATURE_BLIT_DST_BIT);
if(enumerator & (~allFlags))
{
return false;
@@ -346,13 +346,13 @@
{
strings.push_back("VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
}
- if(enumerator & VK_FORMAT_FEATURE_BLIT_SOURCE_BIT)
+ if(enumerator & VK_FORMAT_FEATURE_BLIT_SRC_BIT)
{
- strings.push_back("VK_FORMAT_FEATURE_BLIT_SOURCE_BIT");
+ strings.push_back("VK_FORMAT_FEATURE_BLIT_SRC_BIT");
}
- if(enumerator & VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT)
+ if(enumerator & VK_FORMAT_FEATURE_BLIT_DST_BIT)
{
- strings.push_back("VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT");
+ strings.push_back("VK_FORMAT_FEATURE_BLIT_DST_BIT");
}
std::string enumeratorString;
@@ -377,9 +377,9 @@
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_STORAGE_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT |
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT |
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT);
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
if(enumerator & (~allFlags))
{
return false;
@@ -417,17 +417,17 @@
{
strings.push_back("VK_IMAGE_USAGE_SAMPLED_BIT");
}
- if(enumerator & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT)
+ if(enumerator & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
{
- strings.push_back("VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+ strings.push_back("VK_IMAGE_USAGE_TRANSFER_DST_BIT");
}
if(enumerator & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)
{
strings.push_back("VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
}
- if(enumerator & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT)
+ if(enumerator & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
{
- strings.push_back("VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
+ strings.push_back("VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
}
std::string enumeratorString;
@@ -888,9 +888,9 @@
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
- VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT |
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT |
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
- VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT |
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
if(enumerator & (~allFlags))
{
@@ -929,17 +929,17 @@
{
strings.push_back("VK_BUFFER_USAGE_STORAGE_BUFFER_BIT");
}
- if(enumerator & VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT)
+ if(enumerator & VK_BUFFER_USAGE_TRANSFER_DST_BIT)
{
- strings.push_back("VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+ strings.push_back("VK_BUFFER_USAGE_TRANSFER_DST_BIT");
}
if(enumerator & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
{
strings.push_back("VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT");
}
- if(enumerator & VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT)
+ if(enumerator & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
{
- strings.push_back("VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
+ strings.push_back("VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
}
if(enumerator & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
{
@@ -1506,10 +1506,10 @@
}
static
-bool ValidateEnumerator(VkCmdPoolCreateFlagBits const& enumerator)
+bool ValidateEnumerator(VkCommandPoolCreateFlagBits const& enumerator)
{
- VkCmdPoolCreateFlagBits allFlags = (VkCmdPoolCreateFlagBits)(VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
- VK_CMD_POOL_CREATE_TRANSIENT_BIT);
+ VkCommandPoolCreateFlagBits allFlags = (VkCommandPoolCreateFlagBits)(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
+ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT);
if(enumerator & (~allFlags))
{
return false;
@@ -1519,7 +1519,7 @@
}
static
-std::string EnumeratorString(VkCmdPoolCreateFlagBits const& enumerator)
+std::string EnumeratorString(VkCommandPoolCreateFlagBits const& enumerator)
{
if(!ValidateEnumerator(enumerator))
{
@@ -1527,13 +1527,13 @@
}
std::vector<std::string> strings;
- if(enumerator & VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
+ if(enumerator & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
{
- strings.push_back("VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT");
+ strings.push_back("VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT");
}
- if(enumerator & VK_CMD_POOL_CREATE_TRANSIENT_BIT)
+ if(enumerator & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)
{
- strings.push_back("VK_CMD_POOL_CREATE_TRANSIENT_BIT");
+ strings.push_back("VK_COMMAND_POOL_CREATE_TRANSIENT_BIT");
}
std::string enumeratorString;
@@ -1551,9 +1551,9 @@
}
static
-bool ValidateEnumerator(VkCmdPoolResetFlagBits const& enumerator)
+bool ValidateEnumerator(VkCommandPoolResetFlagBits const& enumerator)
{
- VkCmdPoolResetFlagBits allFlags = (VkCmdPoolResetFlagBits)(VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT);
+ VkCommandPoolResetFlagBits allFlags = (VkCommandPoolResetFlagBits)(VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
if(enumerator & (~allFlags))
{
return false;
@@ -1563,7 +1563,7 @@
}
static
-std::string EnumeratorString(VkCmdPoolResetFlagBits const& enumerator)
+std::string EnumeratorString(VkCommandPoolResetFlagBits const& enumerator)
{
if(!ValidateEnumerator(enumerator))
{
@@ -1571,9 +1571,9 @@
}
std::vector<std::string> strings;
- if(enumerator & VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT)
+ if(enumerator & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT)
{
- strings.push_back("VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT");
+ strings.push_back("VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT");
}
std::string enumeratorString;
@@ -1591,11 +1591,11 @@
}
static
-bool ValidateEnumerator(VkCmdBufferUsageFlags const& enumerator)
+bool ValidateEnumerator(VkCommandBufferUsageFlags const& enumerator)
{
- VkCmdBufferUsageFlags allFlags = (VkCmdBufferUsageFlags)(VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
- VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
- VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
+ VkCommandBufferUsageFlags allFlags = (VkCommandBufferUsageFlags)(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
+ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
+ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
if(enumerator & (~allFlags))
{
return false;
@@ -1605,7 +1605,7 @@
}
static
-std::string EnumeratorString(VkCmdBufferUsageFlags const& enumerator)
+std::string EnumeratorString(VkCommandBufferUsageFlags const& enumerator)
{
if(!ValidateEnumerator(enumerator))
{
@@ -1613,17 +1613,17 @@
}
std::vector<std::string> strings;
- if(enumerator & VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
+ if(enumerator & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
{
- strings.push_back("VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT");
+ strings.push_back("VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT");
}
- if(enumerator & VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
+ if(enumerator & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
{
- strings.push_back("VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT");
+ strings.push_back("VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT");
}
- if(enumerator & VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)
+ if(enumerator & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)
{
- strings.push_back("VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
+ strings.push_back("VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
}
std::string enumeratorString;
@@ -1641,9 +1641,9 @@
}
static
-bool ValidateEnumerator(VkCmdBufferResetFlagBits const& enumerator)
+bool ValidateEnumerator(VkCommandBufferResetFlagBits const& enumerator)
{
- VkCmdBufferResetFlagBits allFlags = (VkCmdBufferResetFlagBits)(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT);
+ VkCommandBufferResetFlagBits allFlags = (VkCommandBufferResetFlagBits)(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
if(enumerator & (~allFlags))
{
return false;
@@ -1653,7 +1653,7 @@
}
static
-std::string EnumeratorString(VkCmdBufferResetFlagBits const& enumerator)
+std::string EnumeratorString(VkCommandBufferResetFlagBits const& enumerator)
{
if(!ValidateEnumerator(enumerator))
{
@@ -1661,9 +1661,9 @@
}
std::vector<std::string> strings;
- if(enumerator & VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT)
+ if(enumerator & VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)
{
- strings.push_back("VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT");
+ strings.push_back("VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT");
}
std::string enumeratorString;
@@ -1777,7 +1777,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, *pInstance);
@@ -1796,7 +1796,7 @@
VK_LAYER_EXPORT void VKAPI vkDestroyInstance(
VkInstance instance,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
@@ -2042,7 +2042,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice)
{
/*
@@ -2066,7 +2066,7 @@
VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
VkDevice device,
- const VkAllocCallbacks* pAllocator)
+ const VkAllocationCallbacks* pAllocator)
{
layer_debug_report_destroy_device(device);
@@ -2210,16 +2210,16 @@
return result;
}
-bool PreAllocMemory(
+bool PreAllocateMemory(
VkDevice device,
- const VkMemoryAllocInfo* pAllocInfo)
+ const VkMemoryAllocateInfo* pAllocateInfo)
{
- if(pAllocInfo != nullptr)
+ if(pAllocateInfo != nullptr)
{
- if(pAllocInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
+ if(pAllocateInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkAllocMemory parameter, VkStructureType pAllocInfo->sType, is an invalid enumerator");
+ "vkAllocateMemory parameter, VkStructureType pAllocateInfo->sType, is an invalid enumerator");
return false;
}
}
@@ -2227,19 +2227,19 @@
return true;
}
-bool PostAllocMemory(
+bool PostAllocateMemory(
VkDevice device,
- VkDeviceMemory* pMem,
+ VkDeviceMemory* pMemory,
VkResult result)
{
- if(pMem != nullptr)
+ if(pMemory != nullptr)
{
}
if(result < VK_SUCCESS)
{
- std::string reason = "vkAllocMemory parameter, VkResult result, is " + EnumeratorString(result);
+ std::string reason = "vkAllocateMemory 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;
}
@@ -2247,17 +2247,17 @@
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateMemory(
VkDevice device,
- const VkMemoryAllocInfo* pAllocInfo,
- const VkAllocCallbacks* pAllocator,
- VkDeviceMemory* pMem)
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
{
- PreAllocMemory(device, pAllocInfo);
+ PreAllocateMemory(device, pAllocateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pAllocator, pMem);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
- PostAllocMemory(device, pMem, result);
+ PostAllocateMemory(device, pMemory, result);
return result;
}
@@ -2307,14 +2307,14 @@
bool PreFlushMappedMemoryRanges(
VkDevice device,
- const VkMappedMemoryRange* pMemRanges)
+ const VkMappedMemoryRange* pMemoryRanges)
{
- if(pMemRanges != nullptr)
+ if(pMemoryRanges != nullptr)
{
- if(pMemRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
+ if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkFlushMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is an invalid enumerator");
+ "vkFlushMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator");
return false;
}
}
@@ -2324,7 +2324,7 @@
bool PostFlushMappedMemoryRanges(
VkDevice device,
- uint32_t memRangeCount,
+ uint32_t memoryRangeCount,
VkResult result)
{
@@ -2341,28 +2341,28 @@
VK_LAYER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(
VkDevice device,
- uint32_t memRangeCount,
- const VkMappedMemoryRange* pMemRanges)
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
{
- PreFlushMappedMemoryRanges(device, pMemRanges);
+ PreFlushMappedMemoryRanges(device, pMemoryRanges);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
- PostFlushMappedMemoryRanges(device, memRangeCount, result);
+ PostFlushMappedMemoryRanges(device, memoryRangeCount, result);
return result;
}
bool PreInvalidateMappedMemoryRanges(
VkDevice device,
- const VkMappedMemoryRange* pMemRanges)
+ const VkMappedMemoryRange* pMemoryRanges)
{
- if(pMemRanges != nullptr)
+ if(pMemoryRanges != nullptr)
{
- if(pMemRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
+ if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is an invalid enumerator");
+ "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator");
return false;
}
}
@@ -2372,7 +2372,7 @@
bool PostInvalidateMappedMemoryRanges(
VkDevice device,
- uint32_t memRangeCount,
+ uint32_t memoryRangeCount,
VkResult result)
{
@@ -2389,14 +2389,14 @@
VK_LAYER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(
VkDevice device,
- uint32_t memRangeCount,
- const VkMappedMemoryRange* pMemRanges)
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
{
- PreInvalidateMappedMemoryRanges(device, pMemRanges);
+ PreInvalidateMappedMemoryRanges(device, pMemoryRanges);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
- PostInvalidateMappedMemoryRanges(device, memRangeCount, result);
+ PostInvalidateMappedMemoryRanges(device, memoryRangeCount, result);
return result;
}
@@ -2429,7 +2429,7 @@
VkDevice device,
VkBuffer buffer,
VkDeviceMemory mem,
- VkDeviceSize memOffset,
+ VkDeviceSize memoryOffset,
VkResult result)
{
@@ -2450,11 +2450,11 @@
VkDevice device,
VkBuffer buffer,
VkDeviceMemory mem,
- VkDeviceSize memOffset)
+ VkDeviceSize memoryOffset)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->BindBufferMemory(device, buffer, mem, memOffset);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->BindBufferMemory(device, buffer, mem, memoryOffset);
- PostBindBufferMemory(device, buffer, mem, memOffset, result);
+ PostBindBufferMemory(device, buffer, mem, memoryOffset, result);
return result;
}
@@ -2463,7 +2463,7 @@
VkDevice device,
VkImage image,
VkDeviceMemory mem,
- VkDeviceSize memOffset,
+ VkDeviceSize memoryOffset,
VkResult result)
{
@@ -2484,11 +2484,11 @@
VkDevice device,
VkImage image,
VkDeviceMemory mem,
- VkDeviceSize memOffset)
+ VkDeviceSize memoryOffset)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->BindImageMemory(device, image, mem, memOffset);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->BindImageMemory(device, image, mem, memoryOffset);
- PostBindImageMemory(device, image, mem, memOffset, result);
+ PostBindImageMemory(device, image, mem, memoryOffset, result);
return result;
}
@@ -2735,7 +2735,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
PreCreateFence(device, pCreateInfo);
@@ -2905,7 +2905,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore)
{
PreCreateSemaphore(device, pCreateInfo);
@@ -2957,7 +2957,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent)
{
PreCreateEvent(device, pCreateInfo);
@@ -3100,7 +3100,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
PreCreateQueryPool(device, pCreateInfo);
@@ -3209,7 +3209,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer)
{
PreCreateBuffer(device, pCreateInfo);
@@ -3268,7 +3268,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBufferView* pView)
{
PreCreateBufferView(device, pCreateInfo);
@@ -3351,7 +3351,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImage* pImage)
{
PreCreateImage(device, pCreateInfo);
@@ -3490,7 +3490,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImageView* pView)
{
PreCreateImageView(device, pCreateInfo);
@@ -3543,7 +3543,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
PreCreateShaderModule(device, pCreateInfo);
@@ -3595,7 +3595,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShader* pShader)
{
PreCreateShader(device, pCreateInfo);
@@ -3650,7 +3650,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
PreCreatePipelineCache(device, pCreateInfo);
@@ -3715,7 +3715,7 @@
bool PostMergePipelineCaches(
VkDevice device,
- VkPipelineCache destCache,
+ VkPipelineCache dstCache,
uint32_t srcCacheCount,
VkResult result)
{
@@ -3734,15 +3734,15 @@
VK_LAYER_EXPORT VkResult VKAPI vkMergePipelineCaches(
VkDevice device,
- VkPipelineCache destCache,
+ VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches)
{
PreMergePipelineCaches(device, pSrcCaches);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
- PostMergePipelineCaches(device, destCache, srcCacheCount, result);
+ PostMergePipelineCaches(device, dstCache, srcCacheCount, result);
return result;
}
@@ -3840,32 +3840,32 @@
return false;
}
}
- if(pCreateInfos->pRasterState != nullptr)
+ if(pCreateInfos->pRasterizationState != nullptr)
{
- if(pCreateInfos->pRasterState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO)
+ if(pCreateInfos->pRasterizationState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterState->sType, is an invalid enumerator");
+ "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterizationState->sType, is an invalid enumerator");
return false;
}
- if(pCreateInfos->pRasterState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
- pCreateInfos->pRasterState->fillMode > VK_FILL_MODE_END_RANGE)
+ if(pCreateInfos->pRasterizationState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
+ pCreateInfos->pRasterizationState->fillMode > VK_FILL_MODE_END_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateGraphicsPipelines parameter, VkFillMode pCreateInfos->pRasterState->fillMode, is an unrecognized enumerator");
+ "vkCreateGraphicsPipelines parameter, VkFillMode pCreateInfos->pRasterizationState->fillMode, is an unrecognized enumerator");
return false;
}
- if(pCreateInfos->pRasterState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK)
+ if(pCreateInfos->pRasterizationState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateGraphicsPipelines parameter, VkCullMode pCreateInfos->pRasterState->cullMode, is an unrecognized enumerator");
+ "vkCreateGraphicsPipelines parameter, VkCullMode pCreateInfos->pRasterizationState->cullMode, is an unrecognized enumerator");
return false;
}
- if(pCreateInfos->pRasterState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
- pCreateInfos->pRasterState->frontFace > VK_FRONT_FACE_END_RANGE)
+ if(pCreateInfos->pRasterizationState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
+ pCreateInfos->pRasterizationState->frontFace > VK_FRONT_FACE_END_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateGraphicsPipelines parameter, VkFrontFace pCreateInfos->pRasterState->frontFace, is an unrecognized enumerator");
+ "vkCreateGraphicsPipelines parameter, VkFrontFace pCreateInfos->pRasterizationState->frontFace, is an unrecognized enumerator");
return false;
}
}
@@ -3975,11 +3975,11 @@
"vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->srcBlendColor, is an unrecognized enumerator");
return false;
}
- if(pCreateInfos->pColorBlendState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE ||
- pCreateInfos->pColorBlendState->pAttachments->destBlendColor > VK_BLEND_END_RANGE)
+ if(pCreateInfos->pColorBlendState->pAttachments->dstBlendColor < VK_BLEND_BEGIN_RANGE ||
+ pCreateInfos->pColorBlendState->pAttachments->dstBlendColor > VK_BLEND_END_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->destBlendColor, is an unrecognized enumerator");
+ "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->dstBlendColor, is an unrecognized enumerator");
return false;
}
if(pCreateInfos->pColorBlendState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
@@ -3996,11 +3996,11 @@
"vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->srcBlendAlpha, is an unrecognized enumerator");
return false;
}
- if(pCreateInfos->pColorBlendState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE ||
- pCreateInfos->pColorBlendState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE)
+ if(pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha < VK_BLEND_BEGIN_RANGE ||
+ pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha > VK_BLEND_END_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->destBlendAlpha, is an unrecognized enumerator");
+ "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha, is an unrecognized enumerator");
return false;
}
if(pCreateInfos->pColorBlendState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
@@ -4051,7 +4051,7 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
PreCreateGraphicsPipelines(device, pCreateInfos);
@@ -4124,7 +4124,7 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
PreCreateComputePipelines(device, pCreateInfos);
@@ -4182,7 +4182,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
PreCreatePipelineLayout(device, pCreateInfo);
@@ -4290,7 +4290,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler)
{
PreCreateSampler(device, pCreateInfo);
@@ -4355,7 +4355,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
PreCreateDescriptorSetLayout(device, pCreateInfo);
@@ -4420,7 +4420,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
PreCreateDescriptorPool(device, pCreateInfo);
@@ -4461,7 +4461,7 @@
return result;
}
-bool PreAllocDescriptorSets(
+bool PreAllocateDescriptorSets(
VkDevice device,
const VkDescriptorSetLayout* pSetLayouts)
{
@@ -4472,7 +4472,7 @@
return true;
}
-bool PostAllocDescriptorSets(
+bool PostAllocateDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t count,
@@ -4487,7 +4487,7 @@
if(result < VK_SUCCESS)
{
- std::string reason = "vkAllocDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
+ std::string reason = "vkAllocateDescriptorSets 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;
}
@@ -4495,16 +4495,16 @@
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateDescriptorSets(
VkDevice device,
- const VkDescriptorSetAllocInfo* pAllocInfo,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets)
{
- PreAllocDescriptorSets(device, pAllocInfo->pSetLayouts);
+ PreAllocateDescriptorSets(device, pAllocateInfo->pSetLayouts);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
- PostAllocDescriptorSets(device, pAllocInfo->descriptorPool, pAllocInfo->setLayoutCount, pDescriptorSets, result);
+ PostAllocateDescriptorSets(device, pAllocateInfo->descriptorPool, pAllocateInfo->setLayoutCount, pDescriptorSets, result);
return result;
}
@@ -4656,7 +4656,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
PreCreateFramebuffer(device, pCreateInfo);
@@ -4821,7 +4821,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
PreCreateRenderPass(device, pCreateInfo);
@@ -4859,11 +4859,11 @@
bool PreCreateCommandPool(
VkDevice device,
- const VkCmdPoolCreateInfo* pCreateInfo)
+ const VkCommandPoolCreateInfo* pCreateInfo)
{
if(pCreateInfo != nullptr)
{
- if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCreateCommandPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
@@ -4876,11 +4876,11 @@
bool PostCreateCommandPool(
VkDevice device,
- VkCmdPool* pCmdPool,
+ VkCommandPool* pCommandPool,
VkResult result)
{
- if(pCmdPool != nullptr)
+ if(pCommandPool != nullptr)
{
}
@@ -4896,23 +4896,23 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
VkDevice device,
- const VkCmdPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
- VkCmdPool* pCmdPool)
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
{
PreCreateCommandPool(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
- PostCreateCommandPool(device, pCmdPool, result);
+ PostCreateCommandPool(device, pCommandPool, result);
return result;
}
bool PostResetCommandPool(
VkDevice device,
- VkCmdPool cmdPool,
- VkCmdPoolResetFlags flags,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags,
VkResult result)
{
@@ -4930,33 +4930,33 @@
VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(
VkDevice device,
- VkCmdPool cmdPool,
- VkCmdPoolResetFlags flags)
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
{
- VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetCommandPool(device, cmdPool, flags);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetCommandPool(device, commandPool, flags);
- PostResetCommandPool(device, cmdPool, flags, result);
+ PostResetCommandPool(device, commandPool, flags, result);
return result;
}
bool PreCreateCommandBuffer(
VkDevice device,
- const VkCmdBufferAllocInfo* pCreateInfo)
+ const VkCommandBufferAllocateInfo* pCreateInfo)
{
if(pCreateInfo != nullptr)
{
- if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
+ if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkAllocCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+ "vkAllocateCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
return false;
}
- if(pCreateInfo->level < VK_CMD_BUFFER_LEVEL_BEGIN_RANGE ||
- pCreateInfo->level > VK_CMD_BUFFER_LEVEL_END_RANGE)
+ if(pCreateInfo->level < VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE ||
+ pCreateInfo->level > VK_COMMAND_BUFFER_LEVEL_END_RANGE)
{
log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkAllocCommandBuffers parameter, VkCmdBufferLevel pCreateInfo->level, is an unrecognized enumerator");
+ "vkAllocateCommandBuffers parameter, VkCommandBufferLevel pCreateInfo->level, is an unrecognized enumerator");
return false;
}
}
@@ -4966,17 +4966,17 @@
bool PostCreateCommandBuffer(
VkDevice device,
- VkCmdBuffer* pCmdBuffer,
+ VkCommandBuffer* pCommandBuffer,
VkResult result)
{
- if(pCmdBuffer != nullptr)
+ if(pCommandBuffer != nullptr)
{
}
if(result < VK_SUCCESS)
{
- std::string reason = "vkAllocCommandBuffers parameter, VkResult result, is " + EnumeratorString(result);
+ std::string reason = "vkAllocateCommandBuffers 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;
}
@@ -4984,29 +4984,29 @@
return true;
}
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(
VkDevice device,
- const VkCmdBufferAllocInfo* pCreateInfo,
- VkCmdBuffer* pCmdBuffer)
+ const VkCommandBufferAllocateInfo* pCreateInfo,
+ VkCommandBuffer* pCommandBuffer)
{
PreCreateCommandBuffer(device, pCreateInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+ VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
- PostCreateCommandBuffer(device, pCmdBuffer, result);
+ PostCreateCommandBuffer(device, pCommandBuffer, result);
return result;
}
bool PreBeginCommandBuffer(
- VkCmdBuffer cmdBuffer,
- const VkCmdBufferBeginInfo* pBeginInfo)
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
{
if(pBeginInfo != nullptr)
{
- if(pBeginInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO)
+ if(pBeginInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkBeginCommandBuffer parameter, VkStructureType pBeginInfo->sType, is an invalid enumerator");
return false;
}
@@ -5016,14 +5016,14 @@
}
bool PostBeginCommandBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkResult result)
{
if(result < VK_SUCCESS)
{
std::string reason = "vkBeginCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
return false;
}
@@ -5031,27 +5031,27 @@
}
VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
- VkCmdBuffer cmdBuffer,
- const VkCmdBufferBeginInfo* pBeginInfo)
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
{
- PreBeginCommandBuffer(cmdBuffer, pBeginInfo);
+ PreBeginCommandBuffer(commandBuffer, pBeginInfo);
- VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo);
- PostBeginCommandBuffer(cmdBuffer, result);
+ PostBeginCommandBuffer(commandBuffer, result);
return result;
}
bool PostEndCommandBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkResult result)
{
if(result < VK_SUCCESS)
{
std::string reason = "vkEndCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
return false;
}
@@ -5059,18 +5059,18 @@
}
VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
- VkCmdBuffer cmdBuffer)
+ VkCommandBuffer commandBuffer)
{
- VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
+ VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->EndCommandBuffer(commandBuffer);
- PostEndCommandBuffer(cmdBuffer, result);
+ PostEndCommandBuffer(commandBuffer, result);
return result;
}
bool PostResetCommandBuffer(
- VkCmdBuffer cmdBuffer,
- VkCmdBufferResetFlags flags,
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags,
VkResult result)
{
@@ -5078,7 +5078,7 @@
if(result < VK_SUCCESS)
{
std::string reason = "vkResetCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
return false;
}
@@ -5086,18 +5086,18 @@
}
VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
- VkCmdBuffer cmdBuffer,
- VkCmdBufferResetFlags flags)
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags)
{
- VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer, flags);
+ VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->ResetCommandBuffer(commandBuffer, flags);
- PostResetCommandBuffer(cmdBuffer, flags, result);
+ PostResetCommandBuffer(commandBuffer, flags, result);
return result;
}
bool PostCmdBindPipeline(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline)
{
@@ -5105,7 +5105,7 @@
if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBindPipeline parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator");
return false;
}
@@ -5115,62 +5115,62 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
- PostCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ PostCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports)
+VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetViewport(commandBuffer, viewportCount, pViewports);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
+VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, scissorCount, pScissors);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetLineWidth(cmdBuffer, lineWidth);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4])
+VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetBlendConstants(cmdBuffer, blendConstants);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds)
+VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
}
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
}
bool PreCmdBindDescriptorSets(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkDescriptorSet* pDescriptorSets,
const uint32_t* pDynamicOffsets)
{
@@ -5186,7 +5186,7 @@
}
bool PostCmdBindDescriptorSets(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
@@ -5197,7 +5197,7 @@
if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBindDescriptorSets parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator");
return false;
}
@@ -5210,7 +5210,7 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
@@ -5219,15 +5219,15 @@
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets)
{
- PreCmdBindDescriptorSets(cmdBuffer, pDescriptorSets, pDynamicOffsets);
+ PreCmdBindDescriptorSets(commandBuffer, pDescriptorSets, pDynamicOffsets);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
- PostCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
+ PostCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
}
bool PostCmdBindIndexBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType)
@@ -5238,7 +5238,7 @@
if(indexType < VK_INDEX_TYPE_BEGIN_RANGE ||
indexType > VK_INDEX_TYPE_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBindIndexBuffer parameter, VkIndexType indexType, is an unrecognized enumerator");
return false;
}
@@ -5247,18 +5247,18 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
- PostCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+ PostCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
bool PreCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets)
{
@@ -5274,7 +5274,7 @@
}
bool PostCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t startBinding,
uint32_t bindingCount)
{
@@ -5285,21 +5285,21 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t startBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets)
{
- PreCmdBindVertexBuffers(cmdBuffer, pBuffers, pOffsets);
+ PreCmdBindVertexBuffers(commandBuffer, pBuffers, pOffsets);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
- PostCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount);
+ PostCmdBindVertexBuffers(commandBuffer, startBinding, bindingCount);
}
bool PostCmdDraw(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t firstVertex,
uint32_t vertexCount,
uint32_t firstInstance,
@@ -5314,19 +5314,19 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdDraw(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
- PostCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+ PostCmdDraw(commandBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
}
bool PostCmdDrawIndexed(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t firstIndex,
uint32_t indexCount,
int32_t vertexOffset,
@@ -5343,20 +5343,20 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
uint32_t firstInstance)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
- PostCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+ PostCmdDrawIndexed(commandBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
bool PostCmdDrawIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
@@ -5371,19 +5371,19 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
uint32_t stride)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
- PostCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+ PostCmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
}
bool PostCmdDrawIndexedIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
@@ -5398,19 +5398,19 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t count,
uint32_t stride)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
- PostCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+ PostCmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
}
bool PostCmdDispatch(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t x,
uint32_t y,
uint32_t z)
@@ -5423,18 +5423,18 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdDispatch(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t x,
uint32_t y,
uint32_t z)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDispatch(commandBuffer, x, y, z);
- PostCmdDispatch(cmdBuffer, x, y, z);
+ PostCmdDispatch(commandBuffer, x, y, z);
}
bool PostCmdDispatchIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset)
{
@@ -5445,17 +5445,17 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset);
- PostCmdDispatchIndirect(cmdBuffer, buffer, offset);
+ PostCmdDispatchIndirect(commandBuffer, buffer, offset);
}
bool PreCmdCopyBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkBufferCopy* pRegions)
{
if(pRegions != nullptr)
@@ -5466,9 +5466,9 @@
}
bool PostCmdCopyBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount)
{
@@ -5479,21 +5479,21 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions)
{
- PreCmdCopyBuffer(cmdBuffer, pRegions);
+ PreCmdCopyBuffer(commandBuffer, pRegions);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
- PostCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount);
+ PostCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount);
}
bool PreCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkImageCopy* pRegions)
{
if(pRegions != nullptr)
@@ -5501,15 +5501,15 @@
if ((pRegions->srcSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is an unrecognized enumerator");
return false;
}
- if ((pRegions->destSubresource.aspect &
+ if ((pRegions->dstSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdCopyImage parameter, VkImageAspect pRegions->destSubresource.aspect, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspect, is an unrecognized enumerator");
return false;
}
}
@@ -5518,11 +5518,11 @@
}
bool PostCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount)
{
@@ -5530,17 +5530,17 @@
if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdCopyImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
return false;
}
- if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
- destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+ if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+ dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdCopyImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdCopyImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
return false;
}
@@ -5549,23 +5549,23 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy* pRegions)
{
- PreCmdCopyImage(cmdBuffer, pRegions);
+ PreCmdCopyImage(commandBuffer, pRegions);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
- PostCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
+ PostCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount);
}
bool PreCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkImageBlit* pRegions)
{
if(pRegions != nullptr)
@@ -5573,15 +5573,15 @@
if ((pRegions->srcSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is an unrecognized enumerator");
return false;
}
- if ((pRegions->destSubresource.aspect &
+ if ((pRegions->dstSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdCopyImage parameter, VkImageAspect pRegions->destSubresource.aspect, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspect, is an unrecognized enumerator");
return false;
}
}
@@ -5590,11 +5590,11 @@
}
bool PostCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
VkFilter filter)
{
@@ -5603,17 +5603,17 @@
if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBlitImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
return false;
}
- if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
- destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+ if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+ dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdBlitImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdBlitImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
return false;
}
@@ -5621,7 +5621,7 @@
if(filter < VK_FILTER_BEGIN_RANGE ||
filter > VK_FILTER_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBlitImage parameter, VkFilter filter, is an unrecognized enumerator");
return false;
}
@@ -5630,24 +5630,24 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
VkFilter filter)
{
- PreCmdBlitImage(cmdBuffer, pRegions);
+ PreCmdBlitImage(commandBuffer, pRegions);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
- PostCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, filter);
+ PostCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, filter);
}
bool PreCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkBufferImageCopy* pRegions)
{
if(pRegions != nullptr)
@@ -5655,7 +5655,7 @@
if ((pRegions->imageSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdCopyBufferToImage parameter, VkImageAspect pRegions->imageSubresource.aspect, is an unrecognized enumerator");
return false;
}
@@ -5665,20 +5665,20 @@
}
bool PostCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount)
{
- if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
- destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+ if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+ dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdCopyBufferToImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdCopyBufferToImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
return false;
}
@@ -5687,22 +5687,22 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
- PreCmdCopyBufferToImage(cmdBuffer, pRegions);
+ PreCmdCopyBufferToImage(commandBuffer, pRegions);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
- PostCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount);
+ PostCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount);
}
bool PreCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkBufferImageCopy* pRegions)
{
if(pRegions != nullptr)
@@ -5710,7 +5710,7 @@
if ((pRegions->imageSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspect, is an unrecognized enumerator");
return false;
}
@@ -5720,10 +5720,10 @@
}
bool PostCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount)
{
@@ -5731,7 +5731,7 @@
if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdCopyImageToBuffer parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
return false;
}
@@ -5742,22 +5742,22 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
- PreCmdCopyImageToBuffer(cmdBuffer, pRegions);
+ PreCmdCopyImageToBuffer(commandBuffer, pRegions);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
- PostCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount);
+ PostCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount);
}
bool PreCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const uint32_t* pData)
{
if(pData != nullptr)
@@ -5768,9 +5768,9 @@
}
bool PostCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize dataSize)
{
@@ -5781,23 +5781,23 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const uint32_t* pData)
{
- PreCmdUpdateBuffer(cmdBuffer, pData);
+ PreCmdUpdateBuffer(commandBuffer, pData);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
- PostCmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize);
+ PostCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize);
}
bool PostCmdFillBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data)
{
@@ -5810,19 +5810,19 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
- PostCmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+ PostCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
bool PreCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkClearColorValue* pColor,
const VkImageSubresourceRange* pRanges)
{
@@ -5839,7 +5839,7 @@
}
bool PostCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
uint32_t rangeCount)
@@ -5849,7 +5849,7 @@
if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdClearColorImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator");
return false;
}
@@ -5859,22 +5859,22 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
- PreCmdClearColorImage(cmdBuffer, pColor, pRanges);
+ PreCmdClearColorImage(commandBuffer, pColor, pRanges);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
- PostCmdClearColorImage(cmdBuffer, image, imageLayout, rangeCount);
+ PostCmdClearColorImage(commandBuffer, image, imageLayout, rangeCount);
}
bool PreCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkImageSubresourceRange* pRanges)
{
if(pRanges != nullptr)
@@ -5890,7 +5890,7 @@
}
bool PostCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
@@ -5901,7 +5901,7 @@
if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdClearDepthStencilImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator");
return false;
}
@@ -5913,22 +5913,22 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
- PreCmdClearDepthStencilImage(cmdBuffer, pRanges);
+ PreCmdClearDepthStencilImage(commandBuffer, pRanges);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
- PostCmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount);
+ PostCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount);
}
bool PreCmdClearAttachments(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkClearColorValue* pColor,
const VkClearRect* pRects)
{
@@ -5944,21 +5944,21 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdClearAttachments(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects)
{
for (uint32_t i = 0; i < attachmentCount; i++) {
- PreCmdClearAttachments(cmdBuffer, &pAttachments[i].clearValue.color, pRects);
+ PreCmdClearAttachments(commandBuffer, &pAttachments[i].clearValue.color, pRects);
}
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
bool PreCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkImageResolve* pRegions)
{
if(pRegions != nullptr)
@@ -5966,15 +5966,15 @@
if ((pRegions->srcSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdResolveImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is an unrecognized enumerator");
return false;
}
- if ((pRegions->destSubresource.aspect &
+ if ((pRegions->dstSubresource.aspect &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdResolveImage parameter, VkImageAspect pRegions->destSubresource.aspect, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdResolveImage parameter, VkImageAspect pRegions->dstSubresource.aspect, is an unrecognized enumerator");
return false;
}
}
@@ -5983,11 +5983,11 @@
}
bool PostCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount)
{
@@ -5995,17 +5995,17 @@
if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdResolveImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
return false;
}
- if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
- destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+ if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+ dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
- "vkCmdResolveImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ "vkCmdResolveImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
return false;
}
@@ -6014,23 +6014,23 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve* pRegions)
{
- PreCmdResolveImage(cmdBuffer, pRegions);
+ PreCmdResolveImage(commandBuffer, pRegions);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
- PostCmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
+ PostCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount);
}
bool PostCmdSetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask)
{
@@ -6041,17 +6041,17 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask);
- PostCmdSetEvent(cmdBuffer, event, stageMask);
+ PostCmdSetEvent(commandBuffer, event, stageMask);
}
bool PostCmdResetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask)
{
@@ -6062,25 +6062,25 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask);
- PostCmdResetEvent(cmdBuffer, event, stageMask);
+ PostCmdResetEvent(commandBuffer, event, stageMask);
}
bool PreCmdWaitEvents(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkEvent* pEvents,
- const void* const* ppMemBarriers)
+ const void* const* ppMemoryBarriers)
{
if(pEvents != nullptr)
{
}
- if(ppMemBarriers != nullptr)
+ if(ppMemoryBarriers != nullptr)
{
}
@@ -6088,11 +6088,11 @@
}
bool PostCmdWaitEvents(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t eventCount,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
- uint32_t memBarrierCount)
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount)
{
@@ -6103,26 +6103,26 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
- uint32_t memBarrierCount,
- const void* const* ppMemBarriers)
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const void* const* ppMemoryBarriers)
{
- PreCmdWaitEvents(cmdBuffer, pEvents, ppMemBarriers);
+ PreCmdWaitEvents(commandBuffer, pEvents, ppMemoryBarriers);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
- PostCmdWaitEvents(cmdBuffer, eventCount, srcStageMask, destStageMask, memBarrierCount);
+ PostCmdWaitEvents(commandBuffer, eventCount, srcStageMask, dstStageMask, memoryBarrierCount);
}
bool PreCmdPipelineBarrier(
- VkCmdBuffer cmdBuffer,
- const void* const* ppMemBarriers)
+ VkCommandBuffer commandBuffer,
+ const void* const* ppMemoryBarriers)
{
- if(ppMemBarriers != nullptr)
+ if(ppMemoryBarriers != nullptr)
{
}
@@ -6130,11 +6130,11 @@
}
bool PostCmdPipelineBarrier(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
+ VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
- uint32_t memBarrierCount)
+ uint32_t memoryBarrierCount)
{
@@ -6145,22 +6145,22 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
+ VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
- uint32_t memBarrierCount,
- const void* const* ppMemBarriers)
+ uint32_t memoryBarrierCount,
+ const void* const* ppMemoryBarriers)
{
- PreCmdPipelineBarrier(cmdBuffer, ppMemBarriers);
+ PreCmdPipelineBarrier(commandBuffer, ppMemoryBarriers);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
- PostCmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount);
+ PostCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount);
}
bool PostCmdBeginQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot,
VkQueryControlFlags flags)
@@ -6173,18 +6173,18 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot,
VkQueryControlFlags flags)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
- PostCmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ PostCmdBeginQuery(commandBuffer, queryPool, slot, flags);
}
bool PostCmdEndQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot)
{
@@ -6195,17 +6195,17 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdEndQuery(commandBuffer, queryPool, slot);
- PostCmdEndQuery(cmdBuffer, queryPool, slot);
+ PostCmdEndQuery(commandBuffer, queryPool, slot);
}
bool PostCmdResetQueryPool(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount)
@@ -6218,18 +6218,18 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
- PostCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ PostCmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
}
bool PostCmdWriteTimestamp(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t slot)
@@ -6241,23 +6241,23 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t slot)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
- PostCmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+ PostCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
}
bool PostCmdCopyQueryPoolResults(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags)
{
@@ -6273,22 +6273,22 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
- PostCmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+ PostCmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
bool PreCmdPushConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const void* values)
{
if(values != nullptr)
@@ -6299,7 +6299,7 @@
}
bool PostCmdPushConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
@@ -6314,29 +6314,29 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdPushConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
const void* values)
{
- PreCmdPushConstants(cmdBuffer, values);
+ PreCmdPushConstants(commandBuffer, values);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
- PostCmdPushConstants(cmdBuffer, layout, stageFlags, offset, size);
+ PostCmdPushConstants(commandBuffer, layout, stageFlags, offset, size);
}
bool PreCmdBeginRenderPass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin)
{
if(pRenderPassBegin != nullptr)
{
if(pRenderPassBegin->sType != VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBeginRenderPass parameter, VkStructureType pRenderPassBegin->sType, is an invalid enumerator");
return false;
}
@@ -6349,14 +6349,14 @@
}
bool PostCmdBeginRenderPass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkRenderPassContents contents)
{
if(contents < VK_RENDER_PASS_CONTENTS_BEGIN_RANGE ||
contents > VK_RENDER_PASS_CONTENTS_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdBeginRenderPass parameter, VkRenderPassContents contents, is an unrecognized enumerator");
return false;
}
@@ -6365,26 +6365,26 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkRenderPassContents contents)
{
- PreCmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+ PreCmdBeginRenderPass(commandBuffer, pRenderPassBegin);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
- PostCmdBeginRenderPass(cmdBuffer, contents);
+ PostCmdBeginRenderPass(commandBuffer, contents);
}
bool PostCmdNextSubpass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkRenderPassContents contents)
{
if(contents < VK_RENDER_PASS_CONTENTS_BEGIN_RANGE ||
contents > VK_RENDER_PASS_CONTENTS_END_RANGE)
{
- log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+ log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
"vkCmdNextSubpass parameter, VkRenderPassContents contents, is an unrecognized enumerator");
return false;
}
@@ -6393,34 +6393,34 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkRenderPassContents contents)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdNextSubpass(cmdBuffer, contents);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents);
- PostCmdNextSubpass(cmdBuffer, contents);
+ PostCmdNextSubpass(commandBuffer, contents);
}
bool PostCmdEndRenderPass(
- VkCmdBuffer cmdBuffer)
+ VkCommandBuffer commandBuffer)
{
return true;
}
VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(
- VkCmdBuffer cmdBuffer)
+ VkCommandBuffer commandBuffer)
{
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdEndRenderPass(commandBuffer);
- PostCmdEndRenderPass(cmdBuffer);
+ PostCmdEndRenderPass(commandBuffer);
}
bool PreCmdExecuteCommands(
- VkCmdBuffer cmdBuffer,
- const VkCmdBuffer* pCmdBuffers)
+ VkCommandBuffer commandBuffer,
+ const VkCommandBuffer* pCommandBuffers)
{
- if(pCmdBuffers != nullptr)
+ if(pCommandBuffers != nullptr)
{
}
@@ -6428,8 +6428,8 @@
}
bool PostCmdExecuteCommands(
- VkCmdBuffer cmdBuffer,
- uint32_t cmdBuffersCount)
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBuffersCount)
{
@@ -6437,15 +6437,15 @@
}
VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(
- VkCmdBuffer cmdBuffer,
- uint32_t cmdBuffersCount,
- const VkCmdBuffer* pCmdBuffers)
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBuffersCount,
+ const VkCommandBuffer* pCommandBuffers)
{
- PreCmdExecuteCommands(cmdBuffer, pCmdBuffers);
+ PreCmdExecuteCommands(commandBuffer, pCommandBuffers);
- get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
+ get_dispatch_table(pc_device_table_map, commandBuffer)->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
- PostCmdExecuteCommands(cmdBuffer, cmdBuffersCount);
+ PostCmdExecuteCommands(commandBuffer, commandBuffersCount);
}
VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
@@ -6472,8 +6472,8 @@
return (PFN_vkVoidFunction) vkQueueWaitIdle;
if (!strcmp(funcName, "vkDeviceWaitIdle"))
return (PFN_vkVoidFunction) vkDeviceWaitIdle;
- if (!strcmp(funcName, "vkAllocMemory"))
- return (PFN_vkVoidFunction) vkAllocMemory;
+ if (!strcmp(funcName, "vkAllocateMemory"))
+ return (PFN_vkVoidFunction) vkAllocateMemory;
if (!strcmp(funcName, "vkMapMemory"))
return (PFN_vkVoidFunction) vkMapMemory;
if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
@@ -6530,8 +6530,8 @@
return (PFN_vkVoidFunction) vkCreateDescriptorPool;
if (!strcmp(funcName, "vkResetDescriptorPool"))
return (PFN_vkVoidFunction) vkResetDescriptorPool;
- if (!strcmp(funcName, "vkAllocDescriptorSets"))
- return (PFN_vkVoidFunction) vkAllocDescriptorSets;
+ if (!strcmp(funcName, "vkAllocateDescriptorSets"))
+ return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
if (!strcmp(funcName, "vkCmdSetViewport"))
return (PFN_vkVoidFunction) vkCmdSetViewport;
if (!strcmp(funcName, "vkCmdSetScissor"))
@@ -6550,8 +6550,8 @@
return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
if (!strcmp(funcName, "vkCmdSetStencilReference"))
return (PFN_vkVoidFunction) vkCmdSetStencilReference;
- if (!strcmp(funcName, "vkAllocCommandBuffers"))
- return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+ if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+ return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
if (!strcmp(funcName, "vkBeginCommandBuffer"))
return (PFN_vkVoidFunction) vkBeginCommandBuffer;
if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 26bd8a3..6a85aeb 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -74,11 +74,11 @@
} ImageMapStruct;
static unordered_map<VkImage, ImageMapStruct *> imageMap;
-// unordered map: associates a device with a queue, cmdPool, and physical device
+// unordered map: associates a device with a queue, commandPool, and physical device
typedef struct
{
VkQueue queue;
- VkCmdPool cmdPool;
+ VkCommandPool commandPool;
VkPhysicalDevice physicalDevice;
} DeviceMapStruct;
static unordered_map<VkDevice, DeviceMapStruct *> deviceMap;
@@ -139,7 +139,7 @@
int x, y;
const char *ptr;
VkDeviceMemory mem2;
- VkCmdBuffer cmdBuffer;
+ VkCommandBuffer commandBuffer;
VkDevice device = imageMap[image1]->device;
VkPhysicalDevice physicalDevice = deviceMap[device]->physicalDevice;
VkInstance instance = physDeviceMap[physicalDevice]->instance;
@@ -160,25 +160,25 @@
1,
1,
VK_IMAGE_TILING_LINEAR,
- (VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT|VK_IMAGE_USAGE_STORAGE_BIT),
+ (VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_STORAGE_BIT),
};
- VkMemoryAllocInfo memAllocInfo = {
+ VkMemoryAllocateInfo memAllocInfo = {
VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
NULL,
0, // allocationSize, queried later
0 // memoryTypeIndex, queried later
};
- const VkCmdBufferAllocInfo allocCommandBufferInfo = {
- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
+ const VkCommandBufferAllocateInfo allocCommandBufferInfo = {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO,
NULL,
- deviceMap[device]->cmdPool,
- VK_CMD_BUFFER_LEVEL_PRIMARY,
+ deviceMap[device]->commandPool,
+ VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1
};
- const VkCmdBufferBeginInfo cmdBufferBeginInfo = {
- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
+ const VkCommandBufferBeginInfo commandBufferBeginInfo = {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
NULL,
- VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
const VkImageCopy imageCopyRegion = {
{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0},
@@ -193,7 +193,7 @@
VkLayerDispatchTable* pTableDevice = get_dispatch_table(screenshot_device_table_map, device);
VkLayerDispatchTable* pTableQueue = get_dispatch_table(screenshot_device_table_map, queue);
VkLayerInstanceDispatchTable* pInstanceTable;
- VkLayerDispatchTable* pTableCmdBuffer;
+ VkLayerDispatchTable* pTableCommandBuffer;
VkPhysicalDeviceMemoryProperties memory_properties;
if (imageMap.empty() || imageMap.find(image1) == imageMap.end())
@@ -222,26 +222,26 @@
&memAllocInfo.memoryTypeIndex);
assert(pass);
- err = pTableDevice->AllocMemory(device, &memAllocInfo, NULL, &mem2);
+ err = pTableDevice->AllocateMemory(device, &memAllocInfo, NULL, &mem2);
assert(!err);
err = pTableQueue->BindImageMemory(device, image2, mem2, 0);
assert(!err);
- err = pTableDevice->AllocCommandBuffers(device, &allocCommandBufferInfo, &cmdBuffer);
+ err = pTableDevice->AllocateCommandBuffers(device, &allocCommandBufferInfo, &commandBuffer);
assert(!err);
- screenshot_device_table_map.emplace(cmdBuffer, pTableDevice);
- pTableCmdBuffer = screenshot_device_table_map[cmdBuffer];
+ screenshot_device_table_map.emplace(commandBuffer, pTableDevice);
+ pTableCommandBuffer = screenshot_device_table_map[commandBuffer];
- err = pTableCmdBuffer->BeginCommandBuffer(cmdBuffer, &cmdBufferBeginInfo);
+ err = pTableCommandBuffer->BeginCommandBuffer(commandBuffer, &commandBufferBeginInfo);
assert(!err);
// TODO: We need to transition images to match these layouts, then restore the original layouts
- pTableCmdBuffer->CmdCopyImage(cmdBuffer, image1, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
- image2, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, &imageCopyRegion);
+ pTableCommandBuffer->CmdCopyImage(commandBuffer, image1, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+ image2, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopyRegion);
- err = pTableCmdBuffer->EndCommandBuffer(cmdBuffer);
+ err = pTableCommandBuffer->EndCommandBuffer(commandBuffer);
assert(!err);
VkFence nullFence = { VK_NULL_HANDLE };
@@ -251,7 +251,7 @@
submit_info.waitSemaphoreCount = 0;
submit_info.pWaitSemaphores = NULL;
submit_info.commandBufferCount = 1;
- submit_info.pCommandBuffers = &cmdBuffer;
+ submit_info.pCommandBuffers = &commandBuffer;
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
@@ -309,7 +309,7 @@
// Clean up
pTableDevice->UnmapMemory(device, mem2);
pTableDevice->FreeMemory(device, mem2, NULL);
- pTableDevice->FreeCommandBuffers(device, deviceMap[device]->cmdPool, 1, &cmdBuffer);
+ pTableDevice->FreeCommandBuffers(device, deviceMap[device]->commandPool, 1, &commandBuffer);
}
@@ -336,7 +336,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
VkPhysicalDevice gpu,
const VkDeviceCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDevice *pDevice)
{
VkLayerDispatchTable *pDisp = get_dispatch_table(screenshot_device_table_map, *pDevice);
@@ -461,12 +461,12 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
VkDevice device,
- const VkCmdPoolCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
- VkCmdPool *pCmdPool)
+ const VkCommandPoolCreateInfo *pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool *pCommandPool)
{
VkLayerDispatchTable* pTable = screenshot_device_table_map[device];
- VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+ VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
loader_platform_thread_lock_mutex(&globalLock);
if (screenshotEnvQueried && screenshotFrames.empty()) {
@@ -475,13 +475,13 @@
return result;
}
- // Create a mapping from a device to a cmdPool
+ // Create a mapping from a device to a commandPool
if (deviceMap[device] == NULL)
{
DeviceMapStruct *deviceMapElem = new DeviceMapStruct;
deviceMap[device] = deviceMapElem;
}
- deviceMap[device]->cmdPool = *pCmdPool;
+ deviceMap[device]->commandPool = *pCommandPool;
loader_platform_thread_unlock_mutex(&globalLock);
return result;
}
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 9e417f6..d7a9aa9 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -138,7 +138,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -159,7 +159,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -604,7 +604,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShaderModule *pShaderModule)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -629,7 +629,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShader *pShader)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -644,7 +644,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo *pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkRenderPass *pRenderPass)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1135,7 +1135,7 @@
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo *pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline *pPipelines)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1156,7 +1156,7 @@
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
@@ -1168,7 +1168,7 @@
}
/* hook DextroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(device);
layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
@@ -1179,7 +1179,7 @@
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1200,7 +1200,7 @@
}
/* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 0075b6f..7f428b8 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -197,7 +197,7 @@
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
// Call down the call chain:
@@ -218,7 +218,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
VkBool32 skipCall = VK_FALSE;
dispatch_key key = get_dispatch_key(instance);
@@ -299,7 +299,7 @@
return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
VkResult result = VK_SUCCESS;
VkBool32 skipCall = VK_FALSE;
@@ -329,7 +329,7 @@
return result;
}
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
{
VkBool32 skipCall = VK_FALSE;
dispatch_key key = get_dispatch_key(device);
diff --git a/layers/swapchain.h b/layers/swapchain.h
index cc9e501..8d104e8 100644
--- a/layers/swapchain.h
+++ b/layers/swapchain.h
@@ -40,7 +40,7 @@
{
"Swapchain",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: Swapchain",
}
};
@@ -49,7 +49,7 @@
{
"Swapchain",
VK_API_VERSION, // specVersion
- VK_MAKE_VERSION(0, 1, 0), // implVersion
+ VK_MAKE_VERSION(0, 1, 0), // implementationVersion
"layer: Swapchain",
}
};
diff --git a/layers/vk_layer_debug_marker_table.cpp b/layers/vk_layer_debug_marker_table.cpp
index b3b54c1..fbfe9a2 100644
--- a/layers/vk_layer_debug_marker_table.cpp
+++ b/layers/vk_layer_debug_marker_table.cpp
@@ -30,7 +30,7 @@
* are created from that "parent" object. Thus use pointer to dispatch table
* as the key to these table maps.
* Instance -> PhysicalDevice
- * Device -> CmdBuffer or Queue
+ * Device -> CommandBuffer or Queue
* If use the object themselves as key to map then implies Create entrypoints have to be intercepted
* and a new key inserted into map */
VkLayerDebugMarkerDispatchTable * initDebugMarkerTable(VkDevice device)
diff --git a/layers/vk_layer_table.cpp b/layers/vk_layer_table.cpp
index cbe80be..67217ff 100644
--- a/layers/vk_layer_table.cpp
+++ b/layers/vk_layer_table.cpp
@@ -128,7 +128,7 @@
* are created from that "parent" object. Thus use pointer to dispatch table
* as the key to these table maps.
* Instance -> PhysicalDevice
- * Device -> CmdBuffer or Queue
+ * Device -> CommandBuffer or Queue
* If use the object themselves as key to map then implies Create entrypoints have to be intercepted
* and a new key inserted into map */
VkLayerInstanceDispatchTable * initInstanceTable(instance_table_map &map, const VkBaseLayerObject *instancew)
diff --git a/layers/vk_layer_utils.cpp b/layers/vk_layer_utils.cpp
index b0a483a..3fbf7e1 100644
--- a/layers/vk_layer_utils.cpp
+++ b/layers/vk_layer_utils.cpp
@@ -35,7 +35,7 @@
// Set up data structure with number of bytes and number of channels
// for each Vulkan format.
-static const VULKAN_FORMAT_INFO vk_format_table[VK_FORMAT_NUM] = {
+static const VULKAN_FORMAT_INFO vk_format_table[VK_FORMAT_RANGE_SIZE] = {
{ 0, 0 }, // [VK_FORMAT_UNDEFINED]
{ 1, 2 }, // [VK_FORMAT_R4G4_UNORM]
{ 1, 2 }, // [VK_FORMAT_R4G4_USCALED]
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index bbeb0fa..f13c2b0 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -14,24 +14,24 @@
| ----- | -------- | ---------------- | ------------ | -------- | ---------- |
| Valid Pipeline Layouts | Validates that pipeline layout from bound descriptor set matches the current pipeline layout | PIPELINE_LAYOUT_MISMATCH | vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect | TBD | None |
| Validate DbgMarker exensions | Validates that DbgMarker extensions have been enabled before use | INVALID_EXTENSION | vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd | TBD | None |
-| Valid BeginCommandBuffer level-related parameters | Primary command buffers must specify VK_NULL_HANDLE for RenderPass or Framebuffer parameters, while secondary command buffers must provide non-null parameters | BEGIN_CB_INVALID_STATE | vkBeginCommandBuffer | PrimaryCmdBufferFramebufferAndRenderpass SecondaryCmdBufferFramebufferAndRenderpass | None |
-| PSO Bound | Verify that a properly created and valid pipeline object is bound to the CmdBuffer specified in these calls | NO_PIPELINE_BOUND | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | PipelineNotBound | This check is currently more related to DrawState data structures and less about verifying that PSO is bound at all appropriate points in API. For API purposes, need to make sure this is checked at Draw time and any other relevant calls. |
-| Valid DescriptorPool | Verifies that the descriptor set pool object was properly created and is valid | INVALID_POOL | vkResetDescriptorPool vkAllocDescriptorSets | None | This is just an internal layer data structure check. ParamChecker or ObjectTracker should really catch bad DSPool |
+| Valid BeginCommandBuffer level-related parameters | Primary command buffers must specify VK_NULL_HANDLE for RenderPass or Framebuffer parameters, while secondary command buffers must provide non-null parameters | BEGIN_CB_INVALID_STATE | vkBeginCommandBuffer | PrimaryCommandBufferFramebufferAndRenderpass SecondaryCommandBufferFramebufferAndRenderpass | None |
+| PSO Bound | Verify that a properly created and valid pipeline object is bound to the CommandBuffer specified in these calls | NO_PIPELINE_BOUND | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | PipelineNotBound | This check is currently more related to DrawState data structures and less about verifying that PSO is bound at all appropriate points in API. For API purposes, need to make sure this is checked at Draw time and any other relevant calls. |
+| Valid DescriptorPool | Verifies that the descriptor set pool object was properly created and is valid | INVALID_POOL | vkResetDescriptorPool vkAllocateDescriptorSets | None | This is just an internal layer data structure check. ParamChecker or ObjectTracker should really catch bad DSPool |
| Valid DescriptorSet | Validate that descriptor set was properly created and is currently valid | INVALID_SET | vkCmdBindDescriptorSets | None | Is this needed other places (like Update/Clear descriptors) |
-| Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocDescriptorSets | None | Anywhere else to check this? |
+| Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocateDescriptorSets | None | Anywhere else to check this? |
| Valid Pipeline | Flag VkPipeline object that was not properly created | INVALID_PIPELINE | vkCmdBindPipeline | InvalidPipeline | NA |
| Valid Pipeline Create Info | Tests for the following: That compute shaders are not specified for the graphics pipeline, tess evaluation and tess control shaders are included or excluded as a pair, that VK_PRIMITIVE_TOPOLOGY_PATCH is set as IA topology for tessellation pipelines, that VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only set for tessellation pipelines, and that Vtx Shader specified | INVALID_PIPELINE_CREATE_STATE | vkCreateGraphicsPipelines | InvalidPipelineCreateState | NA |
-| Valid CmdBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_CMD_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkAllocCommandBuffers | None | NA |
+| Valid CommandBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_COMMAND_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkAllocateCommandBuffers | None | NA |
| Vtx Buffer Bounds | Check if VBO index too large for PSO Vtx binding count, and that at least one vertex buffer is attached to pipeline object | VTX_INDEX_OUT_OF_BOUNDS | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | VtxBufferBadIndex | NA |
| Idx Buffer Alignment | Verify that offset of Index buffer falls on an alignment boundary as defined by IdxBufferAlignmentError param | VTX_INDEX_ALIGNMENT_ERROR | vkCmdBindIndexBuffer | IdxBufferAlignmentError | NA |
-| Cmd Buffer End | Verifies that EndCommandBuffer was called for this cmdBuffer at QueueSubmit time | NO_END_CMD_BUFFER | vkQueueSubmit | NoEndCmdBuffer | NA |
-| Cmd Buffer Begin | Check that BeginCommandBuffer was called for this command buffer when binding commands or calling end | NO_BEGIN_CMD_BUFFER | vkEndCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetBlendConstants vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp | NoBeginCmdBuffer | NA |
-| Cmd Buffer Submit Count | Verify that ONE_TIME submit cmdbuffer is not submitted multiple times | CMD_BUFFER_SINGLE_SUBMIT_VIOLATION | vkBeginCommandBuffer, vkQueueSubmit | CmdBufferTwoSubmits | NA |
-| Valid Secondary CmdBuffer | Validates that no primary command buffers are sent to vkCmdExecuteCommands() are | INVALID_SECONDARY_CMD_BUFFER | vkCmdExecuteCommands | ExecuteCommandsPrimaryCB | NA |
+| Cmd Buffer End | Verifies that EndCommandBuffer was called for this commandBuffer at QueueSubmit time | NO_END_COMMAND_BUFFER | vkQueueSubmit | NoEndCommandBuffer | NA |
+| Cmd Buffer Begin | Check that BeginCommandBuffer was called for this command buffer when binding commands or calling end | NO_BEGIN_COMMAND_BUFFER | vkEndCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetBlendConstants vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp | NoBeginCommandBuffer | NA |
+| Cmd Buffer Submit Count | Verify that ONE_TIME submit cmdbuffer is not submitted multiple times | COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION | vkBeginCommandBuffer, vkQueueSubmit | CommandBufferTwoSubmits | NA |
+| Valid Secondary CommandBuffer | Validates that no primary command buffers are sent to vkCmdExecuteCommands() are | INVALID_SECONDARY_COMMAND_BUFFER | vkCmdExecuteCommands | ExecuteCommandsPrimaryCB | NA |
| Descriptor Type | Verify Descriptor type in bound descriptor set layout matches descriptor type specified in update. This also includes mismatches in the TYPES of copied descriptors. | DESCRIPTOR_TYPE_MISMATCH | vkUpdateDescriptorSets | DSTypeMismatch CopyDescriptorUpdateErrors | NA |
| Descriptor StageFlags | Verify all descriptors within a single write update have the same stageFlags | DESCRIPTOR_STAGEFLAGS_MISMATCH | vkUpdateDescriptorSets | NONE | Test this case |
| DS Update Size | DS update out of bounds for given layout section. | DESCRIPTOR_UPDATE_OUT_OF_BOUNDS | vkUpdateDescriptorSets | DSUpdateOutOfBounds CopyDescriptorUpdateErrors | NA |
-| Descriptor Pool empty | Attempt to allocate descriptor type from descriptor pool when no more of that type are available to be allocated. | DESCRIPTOR_POOL_EMPTY | vkAllocDescriptorSets | AllocDescriptorFromEmptyPool | NA |
+| Descriptor Pool empty | Attempt to allocate descriptor type from descriptor pool when no more of that type are available to be allocated. | DESCRIPTOR_POOL_EMPTY | vkAllocateDescriptorSets | AllocDescriptorFromEmptyPool | NA |
| Free from NON_FREE Pool | It's invalid to call vkFreeDescriptorSets() on Sets that were allocated from a Pool created with NON_FREE usage. | CANT_FREE_FROM_NON_FREE_POOL | vkFreeDescriptorSets | None | NA |
| DS Update Index | DS update binding too large for layout binding count. | INVALID_UPDATE_INDEX | vkUpdateDescriptorSets | InvalidDSUpdateIndex CopyDescriptorUpdateErrors | NA |
| DS Update Type | Verifies that structs in DS Update tree are properly created, currenly valid, and of the right type | INVALID_UPDATE_STRUCT | vkUpdateDescriptorSets | InvalidDSUpdateStruct | NA |
@@ -84,7 +84,7 @@
26. vkFreeDescriptorSets must not be called for sets created on top of one-shot pool
27. If Cmd Buffer one-time submit flag is set, then verify that cmd buffer is only submitted once
28. Verify that all relevent dynamic state objects are bound (See https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14323)
- 29. Flag an error if CmdBuffer has Begin called while it's being constructed - this is not a reset, this is a violation
+ 29. Flag an error if CommandBuffer has Begin called while it's being constructed - this is not a reset, this is a violation
30. At PSO creation time, there is no case when NOT including a FS should flag an error since there exist dynamic state configurations that can be set to cause a FS to not be required. Instead, in the case when no FS is in the PSO, validation should detect at runtime if dynamic state will require a FS, and in those case issue a runtime warning about undefined behavior. (see bug https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14429)
31. Error if a cmdbuffer is submitted on a queue whose family doesn't match the family of the pool from which it was created.
32. Update Gfx Pipe Create Info shadowing to remove new/delete and instead use unique_ptrs for auto clean-up
@@ -99,8 +99,8 @@
| Check | Overview | ENUM | Relevant API | Testname | Notes/TODO |
| ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparse vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkAllocCommandBuffers vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA |
-| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparse vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkAllocCommandBuffers vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
+| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocateMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparse vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkAllocateCommandBuffers vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA |
+| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocateMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparse vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkAllocateCommandBuffers vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
| NA | Enum used for informational messages | NONE | | NA | None |
### ParamChecker Pending Work
@@ -162,7 +162,7 @@
| Bind Invalid Memory | Validate that memory object was correctly created, that the command buffer object was correctly created, and that both are currently valid objects. | MEMORY_BINDING_ERROR | vkQueueBindSparse vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage | NA | The valid Object checks are primarily the responsibilty of ObjectTracker layer, so these checks are more of a backup in case ObjectTracker is not enabled |
| Objects Not Destroyed | Verify all objects destroyed at DestroyDevice time | MEMORY_LEAK | vkDestroyDevice | NA | NA |
| Memory Mapping State | Verifies that mapped memory is CPU-visible | INVALID_STATE | vkMapMemory | MapMemWithoutHostVisibleBit | NA |
-| Command Buffer Synchronization | Command Buffer must be complete before BeginCommandBuffer or ResetCommandBuffer can be called | RESET_CB_WHILE_IN_FLIGHT | vkBeginCommandBuffer vkResetCommandBuffer | CallBeginCmdBufferBeforeCompletion CallBeginCmdBufferBeforeCompletion | NA |
+| Command Buffer Synchronization | Command Buffer must be complete before BeginCommandBuffer or ResetCommandBuffer can be called | RESET_CB_WHILE_IN_FLIGHT | vkBeginCommandBuffer vkResetCommandBuffer | CallBeginCommandBufferBeforeCompletion CallBeginCommandBufferBeforeCompletion | NA |
| Submitted Fence Status | Verifies that: The fence is not submitted in an already signaled state, that ResetFences is not called with a fence in an unsignaled state, and that fences being checked have been submitted | INVALID_FENCE_STATE | vkResetFences vkWaitForFences vkQueueSubmit vkGetFenceStatus | SubmitSignaledFence ResetUnsignaledFence | Create test(s) for case where an unsubmitted fence is having its status checked |
| Immutable Memory Binding | Validates that non-sparse memory bindings are immutable, so objects are not re-boundt | REBIND_OBJECT | vkBindBufferMemory, vkBindImageMemory | RebindMemory | NA |
| Image/Buffer Usage bits | Verify correct USAGE bits set based on how Images and Buffers are used | INVALID_USAGE_FLAG | vkCreateImage, vkCreateBuffer, vkCreateBufferView, vkCmdCopyBuffer, vkCmdCopyQueryPoolResults, vkCmdCopyImage, vkCmdBlitImage, vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer, vkCmdUpdateBuffer, vkCmdFillBuffer | InvalidUsageBits | NA |
@@ -226,7 +226,7 @@
| Check | Overview | ENUM OBJTRACK_* | Relevant API | Testname | Notes/TODO |
| ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkAllocCommandBuffers vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkFreeCommandBuffers vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparse vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | BindInvalidMemory BindMemoryToDestroyedObject | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
+| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocateDescriptorSets vkAllocateMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkAllocateCommandBuffers vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkFreeCommandBuffers vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparse vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | BindInvalidMemory BindMemoryToDestroyedObject | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
| Object Cleanup | Verify that object properly destroyed | DESTROY_OBJECT_FAILED | vkDestroyInstance, vkDestroyDevice, vkFreeMemory | ? | NA |
| Objects Leak | When an Instance or Device object is destroyed, validates that all objects belonging to that device/instance have previously been destroyed | OBJECT_LEAK | vkDestroyDevice vkDestroyInstance | ? | NA |
| Object Count | Flag error if number of objects requested from extenstion functions exceeds max number of actual objects | OBJCOUNT_MAX_EXCEEDED | objTrackGetObjects objTrackGetObjectsOfType | ? | NA |
@@ -253,8 +253,8 @@
See [bug 13433](https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13433) and
<https://cvs.khronos.org/svn/repos/oglc/trunk/nextgen/vulkan/function_properties.csv>
for threading rules.
-Objects that may need a mutex include VkQueue, VkDeviceMemory, VkObject, VkBuffer, VkImage, VkDescriptorSet, VkDescriptorPool, VkCmdBuffer, and VkSemaphore.
-The most common case is that a VkCmdBuffer passed to VkCmd* calls must be used by only one thread at a time.
+Objects that may need a mutex include VkQueue, VkDeviceMemory, VkObject, VkBuffer, VkImage, VkDescriptorSet, VkDescriptorPool, VkCommandBuffer, and VkSemaphore.
+The most common case is that a VkCommandBuffer passed to VkCmd* calls must be used by only one thread at a time.
In addition to reporting threading rule violations, the layer will enforce a mutex for those calls.
That can allow an application to continue running without actually crashing due to the reported threading problem.
@@ -273,8 +273,8 @@
| Check | Overview | ENUM THREADING_CHECKER_* | Relevant API | Testname | Notes/TODO |
| ----- | -------- | ---------------- | ---------------- | -------- | ---------- |
-| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
-| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetBlendConstants vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
+| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
+| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetBlendConstants vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
| NA | Enum used for informational messages | NONE | | NA | None |
### Threading Pending Work
@@ -362,7 +362,7 @@
### APIDump Pending Work
- 1. vkAllocDescriptorSets does not correctly print out all of the created DescriptorSets (no array printing following main API txt)
+ 1. vkAllocateDescriptorSets does not correctly print out all of the created DescriptorSets (no array printing following main API txt)
## General Pending Work