blob: 09bb3ee20d7ec601224b9a5d25209727342c32cd [file] [log] [blame]
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001/*
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002 * Vulkan
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <unordered_map>
29
30#include "loader_platform.h"
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060031#include "vk_dispatch_table_helper.h"
32#include "vk_struct_string_helper_cpp.h"
Tony Barboura938abb2015-04-22 11:36:22 -060033#if defined(__GNUC__)
Tobin Ehlis63bb9482015-03-17 16:24:32 -060034#pragma GCC diagnostic ignored "-Wwrite-strings"
Tony Barboura938abb2015-04-22 11:36:22 -060035#endif
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060036#include "vk_struct_graphviz_helper.h"
Tony Barboura938abb2015-04-22 11:36:22 -060037#if defined(__GNUC__)
Tobin Ehlis63bb9482015-03-17 16:24:32 -060038#pragma GCC diagnostic warning "-Wwrite-strings"
Tony Barboura938abb2015-04-22 11:36:22 -060039#endif
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060040#include "vk_struct_size_helper.h"
Tobin Ehlis63bb9482015-03-17 16:24:32 -060041#include "draw_state.h"
42#include "layers_config.h"
43// The following is #included again to catch certain OS-specific functions
44// being used:
45#include "loader_platform.h"
46#include "layers_msg.h"
47
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060048unordered_map<VkSampler, SAMPLER_NODE*> sampleMap;
49unordered_map<VkImageView, IMAGE_NODE*> imageMap;
50unordered_map<VkBufferView, BUFFER_NODE*> bufferMap;
51unordered_map<VkDynamicStateObject, DYNAMIC_STATE_NODE*> dynamicStateMap;
52unordered_map<VkPipeline, PIPELINE_NODE*> pipelineMap;
53unordered_map<VkDescriptorPool, POOL_NODE*> poolMap;
54unordered_map<VkDescriptorSet, SET_NODE*> setMap;
55unordered_map<VkDescriptorSetLayout, LAYOUT_NODE*> layoutMap;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -060056// Map for layout chains
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060057unordered_map<VkCmdBuffer, GLOBAL_CB_NODE*> cmdBufferMap;
58unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
59unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060060
Jon Ashburn301c5f02015-04-06 10:58:22 -060061static VkLayerDispatchTable nextTable;
Jon Ashburnd9564002015-05-07 10:27:37 -060062static VkLayerInstanceDispatchTable nextInstanceTable;
Jon Ashburn301c5f02015-04-06 10:58:22 -060063static VkBaseLayerObject *pCurObj;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060064static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
Jon Ashburnd9564002015-05-07 10:27:37 -060065static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_tabDeviceOnce);
66static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_tabInstanceOnce);
67
Tobin Ehlis63bb9482015-03-17 16:24:32 -060068// TODO : This can be much smarter, using separate locks for separate global data
69static int globalLockInitialized = 0;
70static loader_platform_thread_mutex globalLock;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060071#define MAX_TID 513
72static loader_platform_thread_id g_tidMapping[MAX_TID] = {0};
73static uint32_t g_maxTID = 0;
74// Map actual TID to an index value and return that index
75// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs
76static uint32_t getTIDIndex() {
77 loader_platform_thread_id tid = loader_platform_get_thread_id();
78 for (uint32_t i = 0; i < g_maxTID; i++) {
79 if (tid == g_tidMapping[i])
80 return i;
81 }
82 // Don't yet have mapping, set it and return newly set index
83 uint32_t retVal = (uint32_t) g_maxTID;
84 g_tidMapping[g_maxTID++] = tid;
85 assert(g_maxTID < MAX_TID);
86 return retVal;
87}
88// Return a string representation of CMD_TYPE enum
89static string cmdTypeToString(CMD_TYPE cmd)
90{
91 switch (cmd)
92 {
93 case CMD_BINDPIPELINE:
94 return "CMD_BINDPIPELINE";
95 case CMD_BINDPIPELINEDELTA:
96 return "CMD_BINDPIPELINEDELTA";
97 case CMD_BINDDYNAMICSTATEOBJECT:
98 return "CMD_BINDDYNAMICSTATEOBJECT";
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -060099 case CMD_BINDDESCRIPTORSETS:
100 return "CMD_BINDDESCRIPTORSETS";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600101 case CMD_BINDINDEXBUFFER:
102 return "CMD_BINDINDEXBUFFER";
103 case CMD_BINDVERTEXBUFFER:
104 return "CMD_BINDVERTEXBUFFER";
105 case CMD_DRAW:
106 return "CMD_DRAW";
107 case CMD_DRAWINDEXED:
108 return "CMD_DRAWINDEXED";
109 case CMD_DRAWINDIRECT:
110 return "CMD_DRAWINDIRECT";
111 case CMD_DRAWINDEXEDINDIRECT:
112 return "CMD_DRAWINDEXEDINDIRECT";
113 case CMD_DISPATCH:
114 return "CMD_DISPATCH";
115 case CMD_DISPATCHINDIRECT:
116 return "CMD_DISPATCHINDIRECT";
117 case CMD_COPYBUFFER:
118 return "CMD_COPYBUFFER";
119 case CMD_COPYIMAGE:
120 return "CMD_COPYIMAGE";
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600121 case CMD_BLITIMAGE:
122 return "CMD_BLITIMAGE";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600123 case CMD_COPYBUFFERTOIMAGE:
124 return "CMD_COPYBUFFERTOIMAGE";
125 case CMD_COPYIMAGETOBUFFER:
126 return "CMD_COPYIMAGETOBUFFER";
127 case CMD_CLONEIMAGEDATA:
128 return "CMD_CLONEIMAGEDATA";
129 case CMD_UPDATEBUFFER:
130 return "CMD_UPDATEBUFFER";
131 case CMD_FILLBUFFER:
132 return "CMD_FILLBUFFER";
133 case CMD_CLEARCOLORIMAGE:
134 return "CMD_CLEARCOLORIMAGE";
135 case CMD_CLEARCOLORIMAGERAW:
136 return "CMD_CLEARCOLORIMAGERAW";
137 case CMD_CLEARDEPTHSTENCIL:
138 return "CMD_CLEARDEPTHSTENCIL";
139 case CMD_RESOLVEIMAGE:
140 return "CMD_RESOLVEIMAGE";
141 case CMD_SETEVENT:
142 return "CMD_SETEVENT";
143 case CMD_RESETEVENT:
144 return "CMD_RESETEVENT";
145 case CMD_WAITEVENTS:
146 return "CMD_WAITEVENTS";
147 case CMD_PIPELINEBARRIER:
148 return "CMD_PIPELINEBARRIER";
149 case CMD_BEGINQUERY:
150 return "CMD_BEGINQUERY";
151 case CMD_ENDQUERY:
152 return "CMD_ENDQUERY";
153 case CMD_RESETQUERYPOOL:
154 return "CMD_RESETQUERYPOOL";
155 case CMD_WRITETIMESTAMP:
156 return "CMD_WRITETIMESTAMP";
157 case CMD_INITATOMICCOUNTERS:
158 return "CMD_INITATOMICCOUNTERS";
159 case CMD_LOADATOMICCOUNTERS:
160 return "CMD_LOADATOMICCOUNTERS";
161 case CMD_SAVEATOMICCOUNTERS:
162 return "CMD_SAVEATOMICCOUNTERS";
163 case CMD_BEGINRENDERPASS:
164 return "CMD_BEGINRENDERPASS";
165 case CMD_ENDRENDERPASS:
166 return "CMD_ENDRENDERPASS";
167 case CMD_DBGMARKERBEGIN:
168 return "CMD_DBGMARKERBEGIN";
169 case CMD_DBGMARKEREND:
170 return "CMD_DBGMARKEREND";
171 default:
172 return "UNKNOWN";
173 }
174}
175// Block of code at start here for managing/tracking Pipeline state that this layer cares about
176// Just track 2 shaders for now
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600177#define VK_NUM_GRAPHICS_SHADERS VK_SHADER_STAGE_COMPUTE
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600178#define MAX_SLOTS 2048
179#define NUM_COMMAND_BUFFERS_TO_DISPLAY 10
180
181static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0};
182
183// TODO : Should be tracking lastBound per cmdBuffer and when draws occur, report based on that cmd buffer lastBound
184// Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
185// to that same cmd buffer by separate thread are not changing state from underneath us
186// Track the last cmd buffer touched by this thread
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600187static VkCmdBuffer g_lastCmdBuffer[MAX_TID] = {NULL};
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600188// Track the last group of CBs touched for displaying to dot file
189static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
190static uint32_t g_lastTouchedCBIndex = 0;
191// Track the last global DrawState of interest touched by any thread
192static GLOBAL_CB_NODE* g_lastGlobalCB = NULL;
193static PIPELINE_NODE* g_lastBoundPipeline = NULL;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600194static DYNAMIC_STATE_NODE* g_lastBoundDynamicState[VK_NUM_STATE_BIND_POINT] = {NULL};
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600195static VkDescriptorSet g_lastBoundDescriptorSet = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600196#define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
197
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600198//static DYNAMIC_STATE_NODE* g_pDynamicStateHead[VK_NUM_STATE_BIND_POINT] = {0};
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600199
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600200static void insertDynamicState(const VkDynamicStateObject state, const GENERIC_HEADER* pCreateInfo, VkStateBindPoint bindPoint)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600201{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600202 VkDynamicVpStateCreateInfo* pVPCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600203 size_t scSize = 0;
204 size_t vpSize = 0;
205 loader_platform_thread_lock_mutex(&globalLock);
206 DYNAMIC_STATE_NODE* pStateNode = new DYNAMIC_STATE_NODE;
207 pStateNode->stateObj = state;
208 switch (pCreateInfo->sType) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600209 case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600210 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo));
211 pVPCI = (VkDynamicVpStateCreateInfo*)pCreateInfo;
212 pStateNode->create_info.vpci.pScissors = new VkRect[pStateNode->create_info.vpci.viewportAndScissorCount];
213 pStateNode->create_info.vpci.pViewports = new VkViewport[pStateNode->create_info.vpci.viewportAndScissorCount];
214 scSize = pVPCI->viewportAndScissorCount * sizeof(VkRect);
215 vpSize = pVPCI->viewportAndScissorCount * sizeof(VkViewport);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600216 memcpy((void*)pStateNode->create_info.vpci.pScissors, pVPCI->pScissors, scSize);
217 memcpy((void*)pStateNode->create_info.vpci.pViewports, pVPCI->pViewports, vpSize);
218 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600219 case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600220 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600221 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600222 case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600223 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600224 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600225 case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600226 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600227 break;
228 default:
229 assert(0);
230 break;
231 }
232 pStateNode->pCreateInfo = (GENERIC_HEADER*)&pStateNode->create_info.cbci;
233 dynamicStateMap[state] = pStateNode;
234 loader_platform_thread_unlock_mutex(&globalLock);
235}
236// Free all allocated nodes for Dynamic State objs
Tobin Ehliseaf28662015-04-08 10:58:37 -0600237static void deleteDynamicState()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600238{
David Pinedof5997ab2015-04-27 16:36:17 -0600239 if (dynamicStateMap.size() <= 0)
240 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600241 for (unordered_map<VkDynamicStateObject, DYNAMIC_STATE_NODE*>::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600242 if (VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600243 delete[] (*ii).second->create_info.vpci.pScissors;
244 delete[] (*ii).second->create_info.vpci.pViewports;
245 }
246 delete (*ii).second;
247 }
248}
249// Free all sampler nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600250static void deleteSamplers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600251{
David Pinedof5997ab2015-04-27 16:36:17 -0600252 if (sampleMap.size() <= 0)
253 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600254 for (unordered_map<VkSampler, SAMPLER_NODE*>::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600255 delete (*ii).second;
256 }
257}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600258static VkImageViewCreateInfo* getImageViewCreateInfo(VkImageView view)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600259{
260 loader_platform_thread_lock_mutex(&globalLock);
261 if (imageMap.find(view) == imageMap.end()) {
262 loader_platform_thread_unlock_mutex(&globalLock);
263 return NULL;
264 }
265 else {
266 loader_platform_thread_unlock_mutex(&globalLock);
267 return &imageMap[view]->createInfo;
268 }
269}
270// Free all image nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600271static void deleteImages()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600272{
David Pinedof5997ab2015-04-27 16:36:17 -0600273 if (imageMap.size() <= 0)
274 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600275 for (unordered_map<VkImageView, IMAGE_NODE*>::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600276 delete (*ii).second;
277 }
278}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600279static VkBufferViewCreateInfo* getBufferViewCreateInfo(VkBufferView view)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600280{
281 loader_platform_thread_lock_mutex(&globalLock);
282 if (bufferMap.find(view) == bufferMap.end()) {
283 loader_platform_thread_unlock_mutex(&globalLock);
284 return NULL;
285 }
286 else {
287 loader_platform_thread_unlock_mutex(&globalLock);
288 return &bufferMap[view]->createInfo;
289 }
290}
291// Free all buffer nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600292static void deleteBuffers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600293{
David Pinedof5997ab2015-04-27 16:36:17 -0600294 if (bufferMap.size() <= 0)
295 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600296 for (unordered_map<VkBufferView, BUFFER_NODE*>::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600297 delete (*ii).second;
298 }
299}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600300static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600301
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600302static void updateCBTracking(VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600303{
304 g_lastCmdBuffer[getTIDIndex()] = cb;
305 GLOBAL_CB_NODE* pCB = getCBNode(cb);
306 loader_platform_thread_lock_mutex(&globalLock);
307 g_lastGlobalCB = pCB;
308 // TODO : This is a dumb algorithm. Need smart LRU that drops off oldest
309 for (uint32_t i = 0; i < NUM_COMMAND_BUFFERS_TO_DISPLAY; i++) {
310 if (g_pLastTouchedCB[i] == pCB) {
311 loader_platform_thread_unlock_mutex(&globalLock);
312 return;
313 }
314 }
315 g_pLastTouchedCB[g_lastTouchedCBIndex++] = pCB;
316 g_lastTouchedCBIndex = g_lastTouchedCBIndex % NUM_COMMAND_BUFFERS_TO_DISPLAY;
317 loader_platform_thread_unlock_mutex(&globalLock);
318}
Tobin Ehlis97866202015-06-10 12:57:07 -0600319// Check object status for selected flag state
320static bool32_t validate_status(VkCmdBuffer cb, CBStatusFlags enable_mask, CBStatusFlags status_mask, CBStatusFlags status_flag, VK_DBG_MSG_TYPE error_level, DRAW_STATE_ERROR error_code, const char* fail_msg) {
321 if (cmdBufferMap.find(cb) != cmdBufferMap.end()) {
322 GLOBAL_CB_NODE* pNode = cmdBufferMap[cb];
323 // If non-zero enable mask is present, check it against status but if enable_mask
324 // is 0 then no enable required so we should always just check status
325 if ((!enable_mask) || (enable_mask & pNode->status)) {
326 if ((pNode->status & status_mask) != status_flag) {
327 char str[1024];
328 sprintf(str, "CB object 0x%" PRIxLEAST64 ": %s", reinterpret_cast<VkUintPtrLeast64>(cb), fail_msg);
329 layerCbMsg(error_level, VK_VALIDATION_LEVEL_0, cb, 0, error_code, "DS", str);
330 return VK_FALSE;
331 }
332 }
333 return VK_TRUE;
334 }
335 else {
336 // If we do not find it print an error
337 char str[1024];
338 sprintf(str, "Unable to obtain status for non-existent CB object 0x%" PRIxLEAST64, reinterpret_cast<VkUintPtrLeast64>(cb));
339 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
340 return VK_FALSE;
341 }
342}
343static bool32_t validate_draw_state_flags(VkCmdBuffer cb) {
344 bool32_t result1, result2, result3, result4;
345 result1 = validate_status(cb, CBSTATUS_NONE, CBSTATUS_VIEWPORT_BOUND, CBSTATUS_VIEWPORT_BOUND, VK_DBG_MSG_ERROR, DRAWSTATE_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");
346 result2 = validate_status(cb, CBSTATUS_NONE, CBSTATUS_RASTER_BOUND, CBSTATUS_RASTER_BOUND, VK_DBG_MSG_ERROR, DRAWSTATE_RASTER_NOT_BOUND, "Raster object not bound to this command buffer");
347 result3 = validate_status(cb, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_COLOR_BLEND_BOUND, CBSTATUS_COLOR_BLEND_BOUND, VK_DBG_MSG_ERROR, DRAWSTATE_COLOR_BLEND_NOT_BOUND, "Color-blend object not bound to this command buffer");
348 result4 = validate_status(cb, CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE, CBSTATUS_DEPTH_STENCIL_BOUND, CBSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_MSG_ERROR, DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");
349 return ((result1 == VK_TRUE) && (result2 == VK_TRUE) && (result3 == VK_TRUE) && (result4 == VK_TRUE));
350}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600351// Print the last bound dynamic state
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600352static void printDynamicState(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600353{
354 GLOBAL_CB_NODE* pCB = getCBNode(cb);
355 if (pCB) {
356 loader_platform_thread_lock_mutex(&globalLock);
357 char str[4*1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600358 for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600359 if (pCB->lastBoundDynamicState[i]) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600360 sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VkStateBindPoint((VkStateBindPoint)i), pCB->lastBoundDynamicState[i]->stateObj);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600361 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str);
362 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, " ").c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600363 break;
364 }
365 else {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600366 sprintf(str, "No dynamic state of type %s bound", string_VkStateBindPoint((VkStateBindPoint)i));
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600367 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600368 }
369 }
370 loader_platform_thread_unlock_mutex(&globalLock);
371 }
372 else {
373 char str[1024];
374 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cb);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600375 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600376 }
377}
378// Retrieve pipeline node ptr for given pipeline object
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600379static PIPELINE_NODE* getPipeline(VkPipeline pipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600380{
381 loader_platform_thread_lock_mutex(&globalLock);
382 if (pipelineMap.find(pipeline) == pipelineMap.end()) {
383 loader_platform_thread_unlock_mutex(&globalLock);
384 return NULL;
385 }
386 loader_platform_thread_unlock_mutex(&globalLock);
387 return pipelineMap[pipeline];
388}
389
390// For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600391static VkSamplerCreateInfo* getSamplerCreateInfo(const VkSampler sampler)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600392{
393 loader_platform_thread_lock_mutex(&globalLock);
394 if (sampleMap.find(sampler) == sampleMap.end()) {
395 loader_platform_thread_unlock_mutex(&globalLock);
396 return NULL;
397 }
398 loader_platform_thread_unlock_mutex(&globalLock);
399 return &sampleMap[sampler]->createInfo;
400}
401
402// Init the pipeline mapping info based on pipeline create info LL tree
403// Threading note : Calls to this function should wrapped in mutex
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600404static void initPipeline(PIPELINE_NODE* pPipeline, const VkGraphicsPipelineCreateInfo* pCreateInfo)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600405{
406 // First init create info, we'll shadow the structs as we go down the tree
Tobin Ehlis2464b882015-04-01 08:40:34 -0600407 // TODO : Validate that no create info is incorrectly replicated
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600408 memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600409 GENERIC_HEADER* pTrav = (GENERIC_HEADER*)pCreateInfo->pNext;
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600410 GENERIC_HEADER* pPrev = (GENERIC_HEADER*)&pPipeline->graphicsPipelineCI; // Hold prev ptr to tie chain of structs together
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600411 size_t bufferSize = 0;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600412 VkPipelineVertexInputCreateInfo* pVICI = NULL;
413 VkPipelineCbStateCreateInfo* pCBCI = NULL;
414 VkPipelineShaderStageCreateInfo* pTmpPSSCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600415 while (pTrav) {
416 switch (pTrav->sType) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600417 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600418 pTmpPSSCI = (VkPipelineShaderStageCreateInfo*)pTrav;
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600419 switch (pTmpPSSCI->shader.stage) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600420 case VK_SHADER_STAGE_VERTEX:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600421 pPrev->pNext = &pPipeline->vsCI;
422 pPrev = (GENERIC_HEADER*)&pPipeline->vsCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600423 memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600424 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600425 case VK_SHADER_STAGE_TESS_CONTROL:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600426 pPrev->pNext = &pPipeline->tcsCI;
427 pPrev = (GENERIC_HEADER*)&pPipeline->tcsCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600428 memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600429 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600430 case VK_SHADER_STAGE_TESS_EVALUATION:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600431 pPrev->pNext = &pPipeline->tesCI;
432 pPrev = (GENERIC_HEADER*)&pPipeline->tesCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600433 memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600434 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600435 case VK_SHADER_STAGE_GEOMETRY:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600436 pPrev->pNext = &pPipeline->gsCI;
437 pPrev = (GENERIC_HEADER*)&pPipeline->gsCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600438 memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600439 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600440 case VK_SHADER_STAGE_FRAGMENT:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600441 pPrev->pNext = &pPipeline->fsCI;
442 pPrev = (GENERIC_HEADER*)&pPipeline->fsCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600443 memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600444 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600445 case VK_SHADER_STAGE_COMPUTE:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600446 // TODO : Flag error, CS is specified through VkComputePipelineCreateInfo
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600447 break;
448 default:
449 // TODO : Flag error
450 break;
451 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600452 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600453 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600454 pPrev->pNext = &pPipeline->vertexInputCI;
455 pPrev = (GENERIC_HEADER*)&pPipeline->vertexInputCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600456 memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VkPipelineVertexInputCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600457 // Copy embedded ptrs
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600458 pVICI = (VkPipelineVertexInputCreateInfo*)pTrav;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600459 pPipeline->vtxBindingCount = pVICI->bindingCount;
460 if (pPipeline->vtxBindingCount) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600461 pPipeline->pVertexBindingDescriptions = new VkVertexInputBindingDescription[pPipeline->vtxBindingCount];
462 bufferSize = pPipeline->vtxBindingCount * sizeof(VkVertexInputBindingDescription);
Tobin Ehlis9a70e5d2015-06-09 10:48:55 -0600463 memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VkPipelineVertexInputCreateInfo*)pTrav)->pVertexBindingDescriptions, bufferSize);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600464 }
465 pPipeline->vtxAttributeCount = pVICI->attributeCount;
466 if (pPipeline->vtxAttributeCount) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600467 pPipeline->pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[pPipeline->vtxAttributeCount];
468 bufferSize = pPipeline->vtxAttributeCount * sizeof(VkVertexInputAttributeDescription);
469 memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VkPipelineVertexInputCreateInfo*)pTrav)->pVertexAttributeDescriptions, bufferSize);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600470 }
471 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600472 case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600473 pPrev->pNext = &pPipeline->iaStateCI;
474 pPrev = (GENERIC_HEADER*)&pPipeline->iaStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600475 memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VkPipelineIaStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600476 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600477 case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600478 pPrev->pNext = &pPipeline->tessStateCI;
479 pPrev = (GENERIC_HEADER*)&pPipeline->tessStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600480 memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VkPipelineTessStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600481 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600482 case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600483 pPrev->pNext = &pPipeline->vpStateCI;
484 pPrev = (GENERIC_HEADER*)&pPipeline->vpStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600485 memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VkPipelineVpStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600486 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600487 case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600488 pPrev->pNext = &pPipeline->rsStateCI;
489 pPrev = (GENERIC_HEADER*)&pPipeline->rsStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600490 memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VkPipelineRsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600491 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600492 case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600493 pPrev->pNext = &pPipeline->msStateCI;
494 pPrev = (GENERIC_HEADER*)&pPipeline->msStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600495 memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VkPipelineMsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600496 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600497 case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600498 pPrev->pNext = &pPipeline->cbStateCI;
499 pPrev = (GENERIC_HEADER*)&pPipeline->cbStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600500 memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VkPipelineCbStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600501 // Copy embedded ptrs
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600502 pCBCI = (VkPipelineCbStateCreateInfo*)pTrav;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600503 pPipeline->attachmentCount = pCBCI->attachmentCount;
504 if (pPipeline->attachmentCount) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600505 pPipeline->pAttachments = new VkPipelineCbAttachmentState[pPipeline->attachmentCount];
506 bufferSize = pPipeline->attachmentCount * sizeof(VkPipelineCbAttachmentState);
507 memcpy((void*)pPipeline->pAttachments, ((VkPipelineCbStateCreateInfo*)pTrav)->pAttachments, bufferSize);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600508 }
509 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600510 case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600511 pPrev->pNext = &pPipeline->dsStateCI;
512 pPrev = (GENERIC_HEADER*)&pPipeline->dsStateCI;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600513 memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VkPipelineDsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600514 break;
515 default:
516 assert(0);
517 break;
518 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600519 pTrav = (GENERIC_HEADER*)pTrav->pNext;
520 }
521 pipelineMap[pPipeline->pipeline] = pPipeline;
522}
523// Free the Pipeline nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600524static void deletePipelines()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600525{
David Pinedof5997ab2015-04-27 16:36:17 -0600526 if (pipelineMap.size() <= 0)
527 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600528 for (unordered_map<VkPipeline, PIPELINE_NODE*>::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600529 if ((*ii).second->pVertexBindingDescriptions) {
530 delete[] (*ii).second->pVertexBindingDescriptions;
531 }
532 if ((*ii).second->pVertexAttributeDescriptions) {
533 delete[] (*ii).second->pVertexAttributeDescriptions;
534 }
535 if ((*ii).second->pAttachments) {
536 delete[] (*ii).second->pAttachments;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600537 }
538 delete (*ii).second;
539 }
540}
Tobin Ehlis2464b882015-04-01 08:40:34 -0600541// For given pipeline, return number of MSAA samples, or one if MSAA disabled
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600542static uint32_t getNumSamples(const VkPipeline pipeline)
Tobin Ehlis2464b882015-04-01 08:40:34 -0600543{
544 PIPELINE_NODE* pPipe = pipelineMap[pipeline];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600545 if (VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600546 if (pPipe->msStateCI.multisampleEnable)
547 return pPipe->msStateCI.samples;
Tobin Ehlis2464b882015-04-01 08:40:34 -0600548 }
549 return 1;
550}
551// Validate state related to the PSO
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600552static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VkPipelineBindPoint pipelineBindPoint, const VkPipeline pipeline)
Tobin Ehlis2464b882015-04-01 08:40:34 -0600553{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600554 if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
Tobin Ehlis2464b882015-04-01 08:40:34 -0600555 // Verify that any MSAA request in PSO matches sample# in bound FB
556 uint32_t psoNumSamples = getNumSamples(pipeline);
557 if (pCB->activeRenderPass) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600558 VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass];
559 VkFramebufferCreateInfo* pFBCI = frameBufferMap[pCB->framebuffer];
Tobin Ehlis63826ec2015-05-21 09:06:56 -0600560 if ((psoNumSamples != pFBCI->sampleCount) || (psoNumSamples != pRPCI->sampleCount)) {
Tobin Ehlis2464b882015-04-01 08:40:34 -0600561 char str[1024];
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600562 sprintf(str, "Num samples mismatch! Binding PSO (%p) with %u samples while current RenderPass (%p) w/ %u samples uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, pRPCI->sampleCount, (void*)pCB->framebuffer, pFBCI->sampleCount);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600563 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", str);
Tobin Ehlis2464b882015-04-01 08:40:34 -0600564 }
565 } else {
566 // TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
567 // Verify and flag error as appropriate
568 }
569 // TODO : Add more checks here
570 } else {
571 // TODO : Validate non-gfx pipeline updates
572 }
573}
574
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600575// Block of code at start here specifically for managing/tracking DSs
576
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600577// Return Pool node ptr for specified pool or else NULL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600578static POOL_NODE* getPoolNode(VkDescriptorPool pool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600579{
580 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600581 if (poolMap.find(pool) == poolMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600582 loader_platform_thread_unlock_mutex(&globalLock);
583 return NULL;
584 }
585 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600586 return poolMap[pool];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600587}
588// Return Set node ptr for specified set or else NULL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600589static SET_NODE* getSetNode(VkDescriptorSet set)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600590{
591 loader_platform_thread_lock_mutex(&globalLock);
592 if (setMap.find(set) == setMap.end()) {
593 loader_platform_thread_unlock_mutex(&globalLock);
594 return NULL;
595 }
596 loader_platform_thread_unlock_mutex(&globalLock);
597 return setMap[set];
598}
599
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600600static LAYOUT_NODE* getLayoutNode(const VkDescriptorSetLayout layout) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600601 loader_platform_thread_lock_mutex(&globalLock);
602 if (layoutMap.find(layout) == layoutMap.end()) {
603 loader_platform_thread_unlock_mutex(&globalLock);
604 return NULL;
605 }
606 loader_platform_thread_unlock_mutex(&globalLock);
607 return layoutMap[layout];
608}
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600609// Return 1 if update struct is of valid type, 0 otherwise
610static bool32_t validUpdateStruct(const GENERIC_HEADER* pUpdateStruct)
611{
612 char str[1024];
613 switch (pUpdateStruct->sType)
614 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800615 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
616 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600617 return 1;
618 default:
619 sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
620 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
621 return 0;
622 }
623}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600624// For given update struct, return binding
625static uint32_t getUpdateBinding(const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600626{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600627 char str[1024];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600628 switch (pUpdateStruct->sType)
629 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800630 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
631 return ((VkWriteDescriptorSet*)pUpdateStruct)->destBinding;
632 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
633 return ((VkCopyDescriptorSet*)pUpdateStruct)->destBinding;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600634 default:
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600635 sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
636 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
637 return 0xFFFFFFFF;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600638 }
639}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600640// Return count for given update struct
641static uint32_t getUpdateArrayIndex(const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600642{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600643 char str[1024];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600644 switch (pUpdateStruct->sType)
645 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800646 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
647 return ((VkWriteDescriptorSet*)pUpdateStruct)->destArrayElement;
648 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600649 // TODO : Need to understand this case better and make sure code is correct
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800650 return ((VkCopyDescriptorSet*)pUpdateStruct)->destArrayElement;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600651 default:
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600652 sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
653 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600654 return 0;
655 }
656}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600657// Return count for given update struct
658static uint32_t getUpdateCount(const GENERIC_HEADER* pUpdateStruct)
659{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600660 char str[1024];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600661 switch (pUpdateStruct->sType)
662 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800663 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
664 return ((VkWriteDescriptorSet*)pUpdateStruct)->count;
665 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600666 // TODO : Need to understand this case better and make sure code is correct
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800667 return ((VkCopyDescriptorSet*)pUpdateStruct)->count;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600668 default:
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600669 sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
670 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600671 return 0;
672 }
673}
674// For given Layout Node and binding, return index where that binding begins
675static uint32_t getBindingStartIndex(const LAYOUT_NODE* pLayout, const uint32_t binding)
676{
677 uint32_t offsetIndex = 0;
678 for (uint32_t i = 0; i<binding; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +0800679 offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600680 }
681 return offsetIndex;
682}
683// For given layout node and binding, return last index that is updated
684static uint32_t getBindingEndIndex(const LAYOUT_NODE* pLayout, const uint32_t binding)
685{
686 uint32_t offsetIndex = 0;
687 for (uint32_t i = 0; i<=binding; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +0800688 offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600689 }
690 return offsetIndex-1;
691}
692// For given layout and update, return the first overall index of the layout that is update
693static uint32_t getUpdateStartIndex(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
694{
695 return (getBindingStartIndex(pLayout, getUpdateBinding(pUpdateStruct))+getUpdateArrayIndex(pUpdateStruct));
696}
697// For given layout and update, return the last overall index of the layout that is update
698static uint32_t getUpdateEndIndex(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
699{
700 return (getBindingStartIndex(pLayout, getUpdateBinding(pUpdateStruct))+getUpdateArrayIndex(pUpdateStruct)+getUpdateCount(pUpdateStruct)-1);
701}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600702// Verify that the descriptor type in the update struct matches what's expected by the layout
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600703static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600704{
705 // First get actual type of update
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600706 VkDescriptorType actualType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600707 uint32_t i = 0;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600708 char str[1024];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600709 switch (pUpdateStruct->sType)
710 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800711 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
712 actualType = ((VkWriteDescriptorSet*)pUpdateStruct)->descriptorType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600713 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800714 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
715 /* no need to validate */
716 return 1;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600717 break;
718 default:
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600719 sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
720 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600721 return 0;
722 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600723 for (i = getUpdateStartIndex(pLayout, pUpdateStruct); i <= getUpdateEndIndex(pLayout, pUpdateStruct); i++) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600724 if (pLayout->pTypes[i] != actualType)
725 return 0;
726 }
727 return 1;
728}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600729// Determine the update type, allocate a new struct of that type, shadow the given pUpdate
730// struct into the new struct and return ptr to shadow struct cast as GENERIC_HEADER
731// NOTE : Calls to this function should be wrapped in mutex
732static GENERIC_HEADER* shadowUpdateNode(GENERIC_HEADER* pUpdate)
733{
734 GENERIC_HEADER* pNewNode = NULL;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800735 VkWriteDescriptorSet* pWDS = NULL;
736 VkCopyDescriptorSet* pCDS = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600737 size_t array_size = 0;
738 size_t base_array_size = 0;
739 size_t total_array_size = 0;
740 size_t baseBuffAddr = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600741 char str[1024];
742 switch (pUpdate->sType)
743 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800744 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
745 pWDS = new VkWriteDescriptorSet;
746 pNewNode = (GENERIC_HEADER*)pWDS;
747 memcpy(pWDS, pUpdate, sizeof(VkWriteDescriptorSet));
748 pWDS->pDescriptors = new VkDescriptorInfo[pWDS->count];
749 array_size = sizeof(VkDescriptorInfo) * pWDS->count;
750 memcpy((void*)pWDS->pDescriptors, ((VkWriteDescriptorSet*)pUpdate)->pDescriptors, array_size);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600751 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800752 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
753 pCDS = new VkCopyDescriptorSet;
754 pUpdate = (GENERIC_HEADER*)pCDS;
755 memcpy(pCDS, pUpdate, sizeof(VkCopyDescriptorSet));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600756 break;
757 default:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600758 sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdate->sType), pUpdate->sType);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600759 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600760 return NULL;
761 }
762 // Make sure that pNext for the end of shadow copy is NULL
763 pNewNode->pNext = NULL;
764 return pNewNode;
765}
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800766// update DS mappings based on ppUpdateArray
767static bool32_t dsUpdate(VkStructureType type, uint32_t updateCount, const void* pUpdateArray)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600768{
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800769 const VkWriteDescriptorSet *pWDS = NULL;
770 const VkCopyDescriptorSet *pCDS = NULL;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600771 bool32_t result = 1;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800772
773 if (type == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET)
774 pWDS = (const VkWriteDescriptorSet *) pUpdateArray;
775 else
776 pCDS = (const VkCopyDescriptorSet *) pUpdateArray;
777
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600778 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600779 LAYOUT_NODE* pLayout = NULL;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600780 VkDescriptorSetLayoutCreateInfo* pLayoutCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600781 // TODO : If pCIList is NULL, flag error
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600782 // Perform all updates
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600783 for (uint32_t i = 0; i < updateCount; i++) {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800784 VkDescriptorSet ds = (pWDS) ? pWDS->destSet : pCDS->destSet;
785 SET_NODE* pSet = setMap[ds]; // getSetNode() without locking
786 g_lastBoundDescriptorSet = pSet->set;
787 GENERIC_HEADER* pUpdate = (pWDS) ? (GENERIC_HEADER*) &pWDS[i] : (GENERIC_HEADER*) &pCDS[i];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600788 pLayout = pSet->pLayout;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600789 // First verify valid update struct
790 if (!validUpdateStruct(pUpdate)) {
791 result = 0;
792 break;
793 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600794 // Make sure that binding is within bounds
795 if (pLayout->createInfo.count < getUpdateBinding(pUpdate)) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600796 char str[1024];
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600797 sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VkStructureType(pUpdate->sType));
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600798 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600799 result = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600800 }
801 else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600802 // Next verify that update falls within size of given binding
803 if (getBindingEndIndex(pLayout, getUpdateBinding(pUpdate)) < getUpdateEndIndex(pLayout, pUpdate)) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600804 char str[48*1024]; // TODO : Keep count of layout CI structs and size this string dynamically based on that count
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600805 pLayoutCI = &pLayout->createInfo;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600806 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
807 sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str());
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600808 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600809 result = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600810 }
811 else { // TODO : should we skip update on a type mismatch or force it?
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600812 // Layout bindings match w/ update ok, now verify that update is of the right type
813 if (!validateUpdateType(pLayout, pUpdate)) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600814 char str[1024];
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600815 sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VkStructureType(pUpdate->sType));
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600816 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600817 result = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600818 }
819 else {
820 // Save the update info
821 // TODO : Info message that update successful
822 // Create new update struct for this set's shadow copy
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600823 GENERIC_HEADER* pNewNode = shadowUpdateNode(pUpdate);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600824 if (NULL == pNewNode) {
825 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600826 sprintf(str, "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
827 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600828 result = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600829 }
830 else {
831 // Insert shadow node into LL of updates for this set
832 pNewNode->pNext = pSet->pUpdateStructs;
833 pSet->pUpdateStructs = pNewNode;
834 // Now update appropriate descriptor(s) to point to new Update node
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600835 for (uint32_t j = getUpdateStartIndex(pLayout, pUpdate); j <= getUpdateEndIndex(pLayout, pUpdate); j++) {
836 assert(j<pSet->descriptorCount);
837 pSet->ppDescriptors[j] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600838 }
839 }
840 }
841 }
842 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600843 }
844 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600845 return result;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600846}
847// Free the shadowed update node for this Set
848// NOTE : Calls to this function should be wrapped in mutex
849static void freeShadowUpdateTree(SET_NODE* pSet)
850{
851 GENERIC_HEADER* pShadowUpdate = pSet->pUpdateStructs;
852 pSet->pUpdateStructs = NULL;
853 GENERIC_HEADER* pFreeUpdate = pShadowUpdate;
854 // Clear the descriptor mappings as they will now be invalid
855 memset(pSet->ppDescriptors, 0, pSet->descriptorCount*sizeof(GENERIC_HEADER*));
856 while(pShadowUpdate) {
857 pFreeUpdate = pShadowUpdate;
858 pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext;
859 uint32_t index = 0;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800860 VkWriteDescriptorSet * pWDS = NULL;
861 VkCopyDescriptorSet * pCDS = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600862 void** ppToFree = NULL;
863 switch (pFreeUpdate->sType)
864 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800865 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
866 pWDS = (VkWriteDescriptorSet*)pFreeUpdate;
867 if (pWDS->pDescriptors)
868 delete[] pWDS->pDescriptors;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600869 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800870 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600871 break;
872 default:
873 assert(0);
874 break;
875 }
Tobin Ehliseaf28662015-04-08 10:58:37 -0600876 delete pFreeUpdate;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600877 }
878}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600879// Free all DS Pools including their Sets & related sub-structs
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600880// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -0600881static void deletePools()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600882{
David Pinedof5997ab2015-04-27 16:36:17 -0600883 if (poolMap.size() <= 0)
884 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600885 for (unordered_map<VkDescriptorPool, POOL_NODE*>::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600886 SET_NODE* pSet = (*ii).second->pSets;
887 SET_NODE* pFreeSet = pSet;
888 while (pSet) {
889 pFreeSet = pSet;
890 pSet = pSet->pNext;
Tobin Ehliseaf28662015-04-08 10:58:37 -0600891 // Freeing layouts handled in deleteLayouts() function
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600892 // Free Update shadow struct tree
893 freeShadowUpdateTree(pFreeSet);
894 if (pFreeSet->ppDescriptors) {
Chris Forbes4506d3f2015-06-04 10:49:27 +1200895 delete[] pFreeSet->ppDescriptors;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600896 }
897 delete pFreeSet;
898 }
899 if ((*ii).second->createInfo.pTypeCount) {
Chris Forbes4506d3f2015-06-04 10:49:27 +1200900 delete[] (*ii).second->createInfo.pTypeCount;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600901 }
902 delete (*ii).second;
903 }
904}
Tobin Ehliseaf28662015-04-08 10:58:37 -0600905// WARN : Once deleteLayouts() called, any layout ptrs in Pool/Set data structure will be invalid
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600906// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -0600907static void deleteLayouts()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600908{
David Pinedof5997ab2015-04-27 16:36:17 -0600909 if (layoutMap.size() <= 0)
910 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600911 for (unordered_map<VkDescriptorSetLayout, LAYOUT_NODE*>::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600912 LAYOUT_NODE* pLayout = (*ii).second;
Tobin Ehliseaf28662015-04-08 10:58:37 -0600913 if (pLayout->createInfo.pBinding) {
914 for (uint32_t i=0; i<pLayout->createInfo.count; i++) {
915 if (pLayout->createInfo.pBinding[i].pImmutableSamplers)
916 delete[] pLayout->createInfo.pBinding[i].pImmutableSamplers;
917 }
918 delete[] pLayout->createInfo.pBinding;
919 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600920 if (pLayout->pTypes) {
Chris Forbes4506d3f2015-06-04 10:49:27 +1200921 delete[] pLayout->pTypes;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600922 }
923 delete pLayout;
924 }
925}
926// Currently clearing a set is removing all previous updates to that set
927// TODO : Validate if this is correct clearing behavior
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600928static void clearDescriptorSet(VkDescriptorSet set)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600929{
930 SET_NODE* pSet = getSetNode(set);
931 if (!pSet) {
932 // TODO : Return error
933 }
934 else {
935 loader_platform_thread_lock_mutex(&globalLock);
936 freeShadowUpdateTree(pSet);
937 loader_platform_thread_unlock_mutex(&globalLock);
938 }
939}
940
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600941static void clearDescriptorPool(VkDescriptorPool pool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600942{
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600943 POOL_NODE* pPool = getPoolNode(pool);
944 if (!pPool) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600945 char str[1024];
Tobin Ehlis28be0be2015-05-22 12:38:16 -0600946 sprintf(str, "Unable to find pool node for pool %p specified in vkResetDescriptorPool() call", (void*)pool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600947 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600948 }
949 else
950 {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600951 // For every set off of this pool, clear it
952 SET_NODE* pSet = pPool->pSets;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600953 while (pSet) {
954 clearDescriptorSet(pSet->set);
955 }
956 }
957}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600958// Code here to manage the Cmd buffer LL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600959static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600960{
961 loader_platform_thread_lock_mutex(&globalLock);
962 if (cmdBufferMap.find(cb) == cmdBufferMap.end()) {
963 loader_platform_thread_unlock_mutex(&globalLock);
964 return NULL;
965 }
966 loader_platform_thread_unlock_mutex(&globalLock);
967 return cmdBufferMap[cb];
968}
969// Free all CB Nodes
970// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -0600971static void deleteCmdBuffers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600972{
David Pinedof5997ab2015-04-27 16:36:17 -0600973 if (cmdBufferMap.size() <= 0)
974 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600975 for (unordered_map<VkCmdBuffer, GLOBAL_CB_NODE*>::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
Courtney Goeltzenleuchter09098a72015-04-27 15:04:43 -0600976 vector<CMD_NODE*> cmd_node_list = (*ii).second->pCmds;
977 while (!cmd_node_list.empty()) {
978 CMD_NODE* cmd_node = cmd_node_list.back();
979 delete cmd_node;
980 cmd_node_list.pop_back();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600981 }
982 delete (*ii).second;
983 }
984}
985static void addCmd(GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd)
986{
987 CMD_NODE* pCmd = new CMD_NODE;
988 if (pCmd) {
989 // init cmd node and append to end of cmd LL
990 memset(pCmd, 0, sizeof(CMD_NODE));
991 pCmd->cmdNumber = ++pCB->numCmds;
992 pCmd->type = cmd;
993 pCB->pCmds.push_back(pCmd);
994 }
995 else {
996 char str[1024];
997 sprintf(str, "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %p", (void*)pCB->cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600998 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600999 }
1000}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001001static void resetCB(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001002{
1003 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1004 if (pCB) {
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001005 vector<CMD_NODE*> cmd_list = pCB->pCmds;
1006 while (!cmd_list.empty()) {
1007 delete cmd_list.back();
1008 cmd_list.pop_back();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001009 }
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001010 pCB->pCmds.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001011 // Reset CB state
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001012 VkFlags saveFlags = pCB->flags;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -07001013 uint32_t saveQueueNodeIndex = pCB->queueNodeIndex;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001014 memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
1015 pCB->cmdBuffer = cb;
1016 pCB->flags = saveFlags;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -07001017 pCB->queueNodeIndex = saveQueueNodeIndex;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001018 pCB->lastVtxBinding = MAX_BINDING;
1019 }
1020}
Tobin Ehlis97866202015-06-10 12:57:07 -06001021// Set PSO-related status bits for CB
1022static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe)
1023{
1024 for (uint32_t i = 0; i < pPipe->cbStateCI.attachmentCount; i++) {
1025 if (0 != pPipe->pAttachments[i].channelWriteMask) {
1026 pCB->status |= CBSTATUS_COLOR_BLEND_WRITE_ENABLE;
1027 }
1028 }
1029 if (pPipe->dsStateCI.depthWriteEnable) {
1030 pCB->status |= CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE;
1031 }
1032}
1033// Set dyn-state related status bits for an object node
1034static void set_cb_dyn_status(GLOBAL_CB_NODE* pNode, VkStateBindPoint stateBindPoint) {
1035 if (stateBindPoint == VK_STATE_BIND_POINT_VIEWPORT) {
1036 pNode->status |= CBSTATUS_VIEWPORT_BOUND;
1037 } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER) {
1038 pNode->status |= CBSTATUS_RASTER_BOUND;
1039 } else if (stateBindPoint == VK_STATE_BIND_POINT_COLOR_BLEND) {
1040 pNode->status |= CBSTATUS_COLOR_BLEND_BOUND;
1041 } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_STENCIL) {
1042 pNode->status |= CBSTATUS_DEPTH_STENCIL_BOUND;
1043 }
1044}
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001045// Set the last bound dynamic state of given type
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001046static void setLastBoundDynamicState(const VkCmdBuffer cmdBuffer, const VkDynamicStateObject state, const VkStateBindPoint sType)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001047{
1048 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1049 if (pCB) {
1050 updateCBTracking(cmdBuffer);
1051 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis97866202015-06-10 12:57:07 -06001052 set_cb_dyn_status(pCB, sType);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001053 addCmd(pCB, CMD_BINDDYNAMICSTATEOBJECT);
1054 if (dynamicStateMap.find(state) == dynamicStateMap.end()) {
1055 char str[1024];
1056 sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001057 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, state, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001058 }
1059 else {
1060 pCB->lastBoundDynamicState[sType] = dynamicStateMap[state];
1061 g_lastBoundDynamicState[sType] = dynamicStateMap[state];
1062 }
1063 loader_platform_thread_unlock_mutex(&globalLock);
1064 }
1065 else {
1066 char str[1024];
1067 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001068 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001069 }
1070}
1071// Print the last bound Gfx Pipeline
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001072static void printPipeline(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001073{
1074 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1075 if (pCB) {
1076 PIPELINE_NODE *pPipeTrav = getPipeline(pCB->lastBoundPipeline);
1077 if (!pPipeTrav) {
1078 // nothing to print
1079 }
1080 else {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001081 string pipeStr = vk_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str();
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001082 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001083 }
1084 }
1085}
1086// Common Dot dumping code
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001087static void dsCoreDumpDot(const VkDescriptorSet ds, FILE* pOutFile)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001088{
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001089#if 0
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001090 SET_NODE* pSet = getSetNode(ds);
1091 if (pSet) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001092 POOL_NODE* pPool = getPoolNode(pSet->pool);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001093 char tmp_str[4*1024];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001094 fprintf(pOutFile, "subgraph cluster_DescriptorPool\n{\nlabel=\"Descriptor Pool\"\n");
1095 sprintf(tmp_str, "Pool (%p)", pPool->pool);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001096 char* pGVstr = vk_gv_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, tmp_str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001097 fprintf(pOutFile, "%s", pGVstr);
1098 free(pGVstr);
1099 fprintf(pOutFile, "subgraph cluster_DescriptorSet\n{\nlabel=\"Descriptor Set (%p)\"\n", pSet->set);
1100 sprintf(tmp_str, "Descriptor Set (%p)", pSet->set);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001101 LAYOUT_NODE* pLayout = pSet->pLayout;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001102 uint32_t layout_index = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001103 ++layout_index;
1104 sprintf(tmp_str, "LAYOUT%u", layout_index);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001105 pGVstr = vk_gv_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, tmp_str);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001106 fprintf(pOutFile, "%s", pGVstr);
1107 free(pGVstr);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001108 if (pSet->pUpdateStructs) {
1109 pGVstr = dynamic_gv_display(pSet->pUpdateStructs, "Descriptor Updates");
1110 fprintf(pOutFile, "%s", pGVstr);
1111 free(pGVstr);
1112 }
1113 if (pSet->ppDescriptors) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001114 fprintf(pOutFile, "\"DESCRIPTORS\" [\nlabel=<<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\"> <TR><TD COLSPAN=\"2\" PORT=\"desc\">DESCRIPTORS</TD></TR>");
1115 uint32_t i = 0;
1116 for (i=0; i < pSet->descriptorCount; i++) {
1117 if (pSet->ppDescriptors[i]) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001118 fprintf(pOutFile, "<TR><TD PORT=\"slot%u\">slot%u</TD><TD>%s</TD></TR>", i, i, string_VkStructureType(pSet->ppDescriptors[i]->sType));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001119 }
1120 }
1121#define NUM_COLORS 7
1122 vector<string> edgeColors;
1123 edgeColors.push_back("0000ff");
1124 edgeColors.push_back("ff00ff");
1125 edgeColors.push_back("ffff00");
1126 edgeColors.push_back("00ff00");
1127 edgeColors.push_back("000000");
1128 edgeColors.push_back("00ffff");
1129 edgeColors.push_back("ff0000");
1130 uint32_t colorIdx = 0;
1131 fprintf(pOutFile, "</TABLE>>\n];\n");
1132 // Now add the views that are mapped to active descriptors
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001133 VkUpdateSamplers* pUS = NULL;
1134 VkUpdateSamplerTextures* pUST = NULL;
1135 VkUpdateImages* pUI = NULL;
1136 VkUpdateBuffers* pUB = NULL;
1137 VkUpdateAsCopy* pUAC = NULL;
1138 VkSamplerCreateInfo* pSCI = NULL;
1139 VkImageViewCreateInfo* pIVCI = NULL;
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -06001140 VkBufferViewCreateInfo* pBVCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001141 void** ppNextPtr = NULL;
1142 void* pSaveNext = NULL;
1143 for (i=0; i < pSet->descriptorCount; i++) {
1144 if (pSet->ppDescriptors[i]) {
1145 switch (pSet->ppDescriptors[i]->sType)
1146 {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001147 case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001148 pUS = (VkUpdateSamplers*)pSet->ppDescriptors[i];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001149 pSCI = getSamplerCreateInfo(pUS->pSamplers[i-pUS->arrayIndex]);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001150 if (pSCI) {
1151 sprintf(tmp_str, "SAMPLER%u", i);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001152 fprintf(pOutFile, "%s", vk_gv_print_vksamplercreateinfo(pSCI, tmp_str));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001153 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
1154 }
1155 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001156 case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001157 pUST = (VkUpdateSamplerTextures*)pSet->ppDescriptors[i];
Courtney Goeltzenleuchterd38dcc92015-04-09 11:43:10 -06001158 pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].sampler);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001159 if (pSCI) {
1160 sprintf(tmp_str, "SAMPLER%u", i);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001161 fprintf(pOutFile, "%s", vk_gv_print_vksamplercreateinfo(pSCI, tmp_str));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001162 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
1163 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001164 pIVCI = getImageViewCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].pImageView->view);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001165 if (pIVCI) {
1166 sprintf(tmp_str, "IMAGE_VIEW%u", i);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001167 fprintf(pOutFile, "%s", vk_gv_print_vkimageviewcreateinfo(pIVCI, tmp_str));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001168 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
1169 }
1170 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001171 case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001172 pUI = (VkUpdateImages*)pSet->ppDescriptors[i];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001173 pIVCI = getImageViewCreateInfo(pUI->pImageViews[i-pUI->arrayIndex].view);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001174 if (pIVCI) {
1175 sprintf(tmp_str, "IMAGE_VIEW%u", i);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001176 fprintf(pOutFile, "%s", vk_gv_print_vkimageviewcreateinfo(pIVCI, tmp_str));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001177 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
1178 }
1179 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001180 case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001181 pUB = (VkUpdateBuffers*)pSet->ppDescriptors[i];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001182 pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001183 if (pBVCI) {
1184 sprintf(tmp_str, "BUFFER_VIEW%u", i);
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -06001185 fprintf(pOutFile, "%s", vk_gv_print_vkbufferviewcreateinfo(pBVCI, tmp_str));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001186 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
1187 }
1188 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001189 case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001190 pUAC = (VkUpdateAsCopy*)pSet->ppDescriptors[i];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001191 // TODO : Need to validate this code
1192 // Save off pNext and set to NULL while printing this struct, then restore it
1193 ppNextPtr = (void**)&pUAC->pNext;
1194 pSaveNext = *ppNextPtr;
1195 *ppNextPtr = NULL;
1196 sprintf(tmp_str, "UPDATE_AS_COPY%u", i);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001197 fprintf(pOutFile, "%s", vk_gv_print_vkupdateascopy(pUAC, tmp_str));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001198 fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
1199 // Restore next ptr
1200 *ppNextPtr = pSaveNext;
1201 break;
1202 default:
1203 break;
1204 }
1205 colorIdx = (colorIdx+1) % NUM_COLORS;
1206 }
1207 }
1208 }
1209 fprintf(pOutFile, "}\n");
1210 fprintf(pOutFile, "}\n");
1211 }
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001212#endif
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001213}
1214// Dump subgraph w/ DS info
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001215static void dsDumpDot(const VkCmdBuffer cb, FILE* pOutFile)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001216{
1217 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1218 if (pCB && pCB->lastBoundDescriptorSet) {
1219 dsCoreDumpDot(pCB->lastBoundDescriptorSet, pOutFile);
1220 }
1221}
1222// Dump a GraphViz dot file showing the Cmd Buffers
1223static void cbDumpDotFile(string outFileName)
1224{
1225 // Print CB Chain for each CB
1226 FILE* pOutFile;
1227 pOutFile = fopen(outFileName.c_str(), "w");
1228 fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
1229 fprintf(pOutFile, "subgraph cluster_cmdBuffers\n{\nlabel=\"Command Buffers\"\n");
1230 GLOBAL_CB_NODE* pCB = NULL;
1231 for (uint32_t i = 0; i < NUM_COMMAND_BUFFERS_TO_DISPLAY; i++) {
1232 pCB = g_pLastTouchedCB[i];
David Pinedof5997ab2015-04-27 16:36:17 -06001233 if (pCB && pCB->pCmds.size() > 0) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001234 fprintf(pOutFile, "subgraph cluster_cmdBuffer%u\n{\nlabel=\"Command Buffer #%u\"\n", i, i);
1235 uint32_t instNum = 0;
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001236 vector<CMD_NODE*> cmd_list = pCB->pCmds;
1237 for (vector<CMD_NODE*>::iterator ii= cmd_list.begin(); ii!= cmd_list.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001238 if (instNum) {
1239 fprintf(pOutFile, "\"CB%pCMD%u\" -> \"CB%pCMD%u\" [];\n", (void*)pCB->cmdBuffer, instNum-1, (void*)pCB->cmdBuffer, instNum);
1240 }
1241 if (pCB == g_lastGlobalCB) {
1242 fprintf(pOutFile, "\"CB%pCMD%u\" [\nlabel=<<TABLE BGCOLOR=\"#00FF00\" BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\"> <TR><TD>CMD#</TD><TD>%u</TD></TR><TR><TD>CMD Type</TD><TD>%s</TD></TR></TABLE>>\n];\n", (void*)pCB->cmdBuffer, instNum, instNum, cmdTypeToString((*ii)->type).c_str());
1243 }
1244 else {
1245 fprintf(pOutFile, "\"CB%pCMD%u\" [\nlabel=<<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\"> <TR><TD>CMD#</TD><TD>%u</TD></TR><TR><TD>CMD Type</TD><TD>%s</TD></TR></TABLE>>\n];\n", (void*)pCB->cmdBuffer, instNum, instNum, cmdTypeToString((*ii)->type).c_str());
1246 }
1247 ++instNum;
1248 }
1249 fprintf(pOutFile, "}\n");
1250 }
1251 }
1252 fprintf(pOutFile, "}\n");
1253 fprintf(pOutFile, "}\n"); // close main graph "g"
1254 fclose(pOutFile);
1255}
1256// Dump a GraphViz dot file showing the pipeline for last bound global state
1257static void dumpGlobalDotFile(char *outFileName)
1258{
1259 PIPELINE_NODE *pPipeTrav = g_lastBoundPipeline;
1260 if (pPipeTrav) {
1261 FILE* pOutFile;
1262 pOutFile = fopen(outFileName, "w");
1263 fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
1264 fprintf(pOutFile, "subgraph cluster_dynamicState\n{\nlabel=\"Dynamic State\"\n");
1265 char* pGVstr = NULL;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001266 for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001267 if (g_lastBoundDynamicState[i] && g_lastBoundDynamicState[i]->pCreateInfo) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001268 pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VkStateBindPoint((VkStateBindPoint)i));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001269 fprintf(pOutFile, "%s", pGVstr);
1270 free(pGVstr);
1271 }
1272 }
1273 fprintf(pOutFile, "}\n"); // close dynamicState subgraph
1274 fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n");
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001275 pGVstr = vk_gv_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001276 fprintf(pOutFile, "%s", pGVstr);
1277 free(pGVstr);
1278 fprintf(pOutFile, "}\n");
1279 dsCoreDumpDot(g_lastBoundDescriptorSet, pOutFile);
1280 fprintf(pOutFile, "}\n"); // close main graph "g"
1281 fclose(pOutFile);
1282 }
1283}
1284// Dump a GraphViz dot file showing the pipeline for a given CB
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001285static void dumpDotFile(const VkCmdBuffer cb, string outFileName)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001286{
1287 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1288 if (pCB) {
1289 PIPELINE_NODE *pPipeTrav = getPipeline(pCB->lastBoundPipeline);
1290 if (pPipeTrav) {
1291 FILE* pOutFile;
1292 pOutFile = fopen(outFileName.c_str(), "w");
1293 fprintf(pOutFile, "digraph g {\ngraph [\nrankdir = \"TB\"\n];\nnode [\nfontsize = \"16\"\nshape = \"plaintext\"\n];\nedge [\n];\n");
1294 fprintf(pOutFile, "subgraph cluster_dynamicState\n{\nlabel=\"Dynamic State\"\n");
1295 char* pGVstr = NULL;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001296 for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001297 if (pCB->lastBoundDynamicState[i] && pCB->lastBoundDynamicState[i]->pCreateInfo) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001298 pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VkStateBindPoint((VkStateBindPoint)i));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001299 fprintf(pOutFile, "%s", pGVstr);
1300 free(pGVstr);
1301 }
1302 }
1303 fprintf(pOutFile, "}\n"); // close dynamicState subgraph
1304 fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n");
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001305 pGVstr = vk_gv_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "PSO HEAD");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001306 fprintf(pOutFile, "%s", pGVstr);
1307 free(pGVstr);
1308 fprintf(pOutFile, "}\n");
1309 dsDumpDot(cb, pOutFile);
1310 fprintf(pOutFile, "}\n"); // close main graph "g"
1311 fclose(pOutFile);
1312 }
1313 }
1314}
Tobin Ehlise90b1712015-05-27 14:30:06 -06001315// Verify bound Pipeline State Object
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001316static bool validateBoundPipeline(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001317{
1318 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1319 if (pCB && pCB->lastBoundPipeline) {
1320 // First verify that we have a Node for bound pipeline
1321 PIPELINE_NODE *pPipeTrav = getPipeline(pCB->lastBoundPipeline);
1322 char str[1024];
1323 if (!pPipeTrav) {
1324 sprintf(str, "Can't find last bound Pipeline %p!", (void*)pCB->lastBoundPipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001325 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_PIPELINE_BOUND, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001326 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001327 }
1328 else {
1329 // Verify Vtx binding
1330 if (MAX_BINDING != pCB->lastVtxBinding) {
1331 if (pCB->lastVtxBinding >= pPipeTrav->vtxBindingCount) {
1332 if (0 == pPipeTrav->vtxBindingCount) {
1333 sprintf(str, "Vtx Buffer Index %u was bound, but no vtx buffers are attached to PSO.", pCB->lastVtxBinding);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001334 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001335 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001336 }
1337 else {
1338 sprintf(str, "Vtx binding Index of %u exceeds PSO pVertexBindingDescriptions max array index of %u.", pCB->lastVtxBinding, (pPipeTrav->vtxBindingCount - 1));
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001339 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001340 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001341 }
1342 }
1343 else {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001344 string tmpStr = vk_print_vkvertexinputbindingdescription(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str();
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001345 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001346 }
1347 }
1348 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001349 return true;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001350 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001351 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001352}
1353// Print details of DS config to stdout
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001354static void printDSConfig(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001355{
1356 char tmp_str[1024];
1357 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.
1358 GLOBAL_CB_NODE* pCB = getCBNode(cb);
Tobin Ehlis7297f192015-06-09 08:39:32 -06001359 if (pCB && pCB->lastBoundDescriptorSet) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001360 SET_NODE* pSet = getSetNode(pCB->lastBoundDescriptorSet);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001361 POOL_NODE* pPool = getPoolNode(pSet->pool);
1362 // Print out pool details
1363 sprintf(tmp_str, "Details for pool %p.", (void*)pPool->pool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001364 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001365 string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " ");
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001366 sprintf(ds_config_str, "%s", poolStr.c_str());
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001367 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001368 // Print out set details
1369 char prefix[10];
1370 uint32_t index = 0;
1371 sprintf(tmp_str, "Details for descriptor set %p.", (void*)pSet->set);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001372 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001373 LAYOUT_NODE* pLayout = pSet->pLayout;
1374 // Print layout details
1375 sprintf(tmp_str, "Layout #%u, (object %p) for DS %p.", index+1, (void*)pLayout->layout, (void*)pSet->set);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001376 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001377 sprintf(prefix, " [L%u] ", index);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001378 string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str();
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001379 sprintf(ds_config_str, "%s", DSLstr.c_str());
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001380 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001381 index++;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001382 GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
1383 if (pUpdate) {
1384 sprintf(tmp_str, "Update Chain [UC] for descriptor set %p:", (void*)pSet->set);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001385 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001386 sprintf(prefix, " [UC] ");
1387 sprintf(ds_config_str, "%s", dynamic_display(pUpdate, prefix).c_str());
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001388 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001389 // TODO : If there is a "view" associated with this update, print CI for that view
1390 }
1391 else {
Tobin Ehlis2bca8b02015-06-15 08:41:17 -06001392 if (0 != pSet->descriptorCount) {
1393 sprintf(tmp_str, "No Update Chain for descriptor set %p which has %u descriptors (vkUpdateDescriptors has not been called)", (void*)pSet->set, pSet->descriptorCount);
1394 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
1395 }
1396 else {
1397 sprintf(tmp_str, "FYI: No descriptors in descriptor set %p.", (void*)pSet->set);
1398 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str);
1399 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001400 }
1401 }
1402}
1403
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001404static void printCB(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001405{
1406 GLOBAL_CB_NODE* pCB = getCBNode(cb);
David Pinedof5997ab2015-04-27 16:36:17 -06001407 if (pCB && pCB->pCmds.size() > 0) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001408 char str[1024];
1409 sprintf(str, "Cmds in CB %p", (void*)cb);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001410 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
Courtney Goeltzenleuchtercf2a5362015-04-27 11:16:35 -06001411 vector<CMD_NODE*> pCmds = pCB->pCmds;
1412 for (vector<CMD_NODE*>::iterator ii=pCmds.begin(); ii!=pCmds.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001413 sprintf(str, " CMD#%lu: %s", (*ii)->cmdNumber, cmdTypeToString((*ii)->type).c_str());
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001414 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cb, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001415 }
1416 }
1417 else {
1418 // Nothing to print
1419 }
1420}
1421
1422
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001423static void synchAndPrintDSConfig(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001424{
1425 printDSConfig(cb);
1426 printPipeline(cb);
1427 printDynamicState(cb);
1428 static int autoDumpOnce = 0;
1429 if (autoDumpOnce) {
1430 autoDumpOnce = 0;
1431 dumpDotFile(cb, "pipeline_dump.dot");
1432 cbDumpDotFile("cb_dump.dot");
1433#if defined(_WIN32)
1434// FIXME: NEED WINDOWS EQUIVALENT
1435#else // WIN32
1436 // Convert dot to svg if dot available
1437 if(access( "/usr/bin/dot", X_OK) != -1) {
Tony Barbour22a30862015-04-22 09:02:32 -06001438 int retval = system("/usr/bin/dot pipeline_dump.dot -Tsvg -o pipeline_dump.svg");
1439 assert(retval != -1);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001440 }
1441#endif // WIN32
1442 }
1443}
1444
Jon Ashburnd9564002015-05-07 10:27:37 -06001445// TODO handle multiple GPUs/instances for both instance and device dispatch tables
1446static void initDeviceTable(void)
1447{
1448 PFN_vkGetProcAddr fpNextGPA;
1449 fpNextGPA = (PFN_vkGetProcAddr) pCurObj->pGPA;
1450 assert(fpNextGPA);
1451 layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalDevice) pCurObj->nextObject);
1452}
1453
1454static void initInstanceTable(void)
1455{
1456 PFN_vkGetInstanceProcAddr fpNextGPA;
1457 fpNextGPA = (PFN_vkGetInstanceProcAddr) pCurObj->pGPA;
1458 assert(fpNextGPA);
1459 layer_init_instance_dispatch_table(&nextInstanceTable, fpNextGPA, (VkInstance) pCurObj->nextObject);
1460}
1461
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001462static void initDrawState(void)
1463{
1464 const char *strOpt;
1465 // initialize DrawState options
1466 getLayerOptionEnum("DrawStateReportLevel", (uint32_t *) &g_reportingLevel);
1467 g_actionIsDefault = getLayerOptionEnum("DrawStateDebugAction", (uint32_t *) &g_debugAction);
1468
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001469 if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001470 {
1471 strOpt = getLayerOption("DrawStateLogFilename");
1472 if (strOpt)
1473 {
1474 g_logFile = fopen(strOpt, "w");
1475 }
1476 if (g_logFile == NULL)
1477 g_logFile = stdout;
1478 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001479
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001480 if (!globalLockInitialized)
1481 {
1482 // TODO/TBD: Need to delete this mutex sometime. How??? One
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001483 // suggestion is to call this during vkCreateInstance(), and then we
1484 // can clean it up during vkDestroyInstance(). However, that requires
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001485 // that the layer have per-instance locks. We need to come back and
1486 // address this soon.
1487 loader_platform_thread_create_mutex(&globalLock);
1488 globalLockInitialized = 1;
1489 }
1490}
1491
Tony Barbour8205d902015-04-16 15:59:00 -06001492VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001493{
Jon Ashburn630e44f2015-04-08 21:33:34 -06001494 VkResult result = nextTable.CreateDevice(gpu, pCreateInfo, pDevice);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001495 return result;
1496}
1497
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001498VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001499{
1500 // Free all the memory
1501 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehliseaf28662015-04-08 10:58:37 -06001502 deletePipelines();
1503 deleteSamplers();
1504 deleteImages();
1505 deleteBuffers();
1506 deleteCmdBuffers();
1507 deleteDynamicState();
1508 deletePools();
1509 deleteLayouts();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001510 loader_platform_thread_unlock_mutex(&globalLock);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001511 VkResult result = nextTable.DestroyDevice(device);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001512 return result;
1513}
1514
Jon Ashburneb2728b2015-04-10 14:33:07 -06001515struct extProps {
1516 uint32_t version;
1517 const char * const name;
1518};
Jon Ashburnbdcd7562015-04-14 14:12:59 -06001519#define DRAW_STATE_LAYER_EXT_ARRAY_SIZE 5
Jon Ashburneb2728b2015-04-10 14:33:07 -06001520static const struct extProps dsExts[DRAW_STATE_LAYER_EXT_ARRAY_SIZE] = {
1521 // TODO what is the version?
Jon Ashburnbdcd7562015-04-14 14:12:59 -06001522 0x10, "DrawState",
1523 0x10, "Validation",
1524 0x10, "drawStateDumpDotFile",
1525 0x10, "drawStateDumpCommandBufferDotFile",
1526 0x10, "drawStateDumpPngFile"
Jon Ashburneb2728b2015-04-10 14:33:07 -06001527};
1528
1529VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
1530 VkExtensionInfoType infoType,
1531 uint32_t extensionIndex,
1532 size_t* pDataSize,
1533 void* pData)
1534{
Jon Ashburneb2728b2015-04-10 14:33:07 -06001535 /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
1536 VkExtensionProperties *ext_props;
1537 uint32_t *count;
1538
1539 if (pDataSize == NULL)
1540 return VK_ERROR_INVALID_POINTER;
1541
1542 switch (infoType) {
1543 case VK_EXTENSION_INFO_TYPE_COUNT:
1544 *pDataSize = sizeof(uint32_t);
1545 if (pData == NULL)
1546 return VK_SUCCESS;
1547 count = (uint32_t *) pData;
1548 *count = DRAW_STATE_LAYER_EXT_ARRAY_SIZE;
1549 break;
1550 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
1551 *pDataSize = sizeof(VkExtensionProperties);
1552 if (pData == NULL)
1553 return VK_SUCCESS;
1554 if (extensionIndex >= DRAW_STATE_LAYER_EXT_ARRAY_SIZE)
1555 return VK_ERROR_INVALID_VALUE;
1556 ext_props = (VkExtensionProperties *) pData;
1557 ext_props->version = dsExts[extensionIndex].version;
1558 strncpy(ext_props->extName, dsExts[extensionIndex].name,
1559 VK_MAX_EXTENSION_NAME);
1560 ext_props->extName[VK_MAX_EXTENSION_NAME - 1] = '\0';
1561 break;
1562 default:
1563 return VK_ERROR_INVALID_VALUE;
1564 };
1565
1566 return VK_SUCCESS;
1567}
1568
Courtney Goeltzenleuchterbb1f3602015-04-20 11:04:54 -06001569VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001570{
1571 if (gpu != NULL)
1572 {
Jon Ashburn630e44f2015-04-08 21:33:34 -06001573 pCurObj = (VkBaseLayerObject *) gpu;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001574 loader_platform_thread_once(&g_initOnce, initDrawState);
Courtney Goeltzenleuchterbb1f3602015-04-20 11:04:54 -06001575 VkResult result = nextTable.EnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001576 return result;
Jon Ashburn630e44f2015-04-08 21:33:34 -06001577 } else {
Courtney Goeltzenleuchterbb1f3602015-04-20 11:04:54 -06001578 if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001579 return VK_ERROR_INVALID_POINTER;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001580 // This layer compatible with all GPUs
Courtney Goeltzenleuchterbb1f3602015-04-20 11:04:54 -06001581 *pLayerCount = 1;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001582 strncpy((char *) pOutLayers[0], "DrawState", maxStringSize);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001583 return VK_SUCCESS;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001584 }
1585}
1586
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001587VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001588{
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001589 GLOBAL_CB_NODE* pCB = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001590 for (uint32_t i=0; i < cmdBufferCount; i++) {
1591 // Validate that cmd buffers have been updated
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001592 pCB = getCBNode(pCmdBuffers[i]);
1593 loader_platform_thread_lock_mutex(&globalLock);
1594 if (CB_UPDATE_COMPLETE != pCB->state) {
1595 // Flag error for using CB w/o vkEndCommandBuffer() called
1596 char str[1024];
1597 sprintf(str, "You must call vkEndCommandBuffer() on CB %p before this call to vkQueueSubmit()!", pCB->cmdBuffer);
1598 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_NO_END_CMD_BUFFER, "DS", str);
Tobin Ehlise90b1712015-05-27 14:30:06 -06001599 loader_platform_thread_unlock_mutex(&globalLock);
1600 return VK_ERROR_UNKNOWN;
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001601 }
Tobin Ehlise9b700e2015-05-26 16:06:50 -06001602 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001603 }
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001604 VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001605 return result;
1606}
1607
Mike Stroyan230e6252015-04-17 12:36:38 -06001608VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001609{
1610 // TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory
Mike Stroyan230e6252015-04-17 12:36:38 -06001611 VkResult result = nextTable.DestroyObject(device, objType, object);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001612 return result;
1613}
1614
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001615VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001616{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001617 VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001618 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001619 loader_platform_thread_lock_mutex(&globalLock);
1620 BUFFER_NODE* pNewNode = new BUFFER_NODE;
1621 pNewNode->buffer = *pView;
1622 pNewNode->createInfo = *pCreateInfo;
1623 bufferMap[*pView] = pNewNode;
1624 loader_platform_thread_unlock_mutex(&globalLock);
1625 }
1626 return result;
1627}
1628
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001629VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001630{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001631 VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001632 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001633 loader_platform_thread_lock_mutex(&globalLock);
1634 IMAGE_NODE *pNewNode = new IMAGE_NODE;
1635 pNewNode->image = *pView;
1636 pNewNode->createInfo = *pCreateInfo;
1637 imageMap[*pView] = pNewNode;
1638 loader_platform_thread_unlock_mutex(&globalLock);
1639 }
1640 return result;
1641}
1642
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001643static void track_pipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001644{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001645 // Create LL HEAD for this Pipeline
1646 loader_platform_thread_lock_mutex(&globalLock);
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001647 PIPELINE_NODE* pPipeNode = new PIPELINE_NODE;
1648 memset((void*)pPipeNode, 0, sizeof(PIPELINE_NODE));
1649 pPipeNode->pipeline = *pPipeline;
1650 initPipeline(pPipeNode, pCreateInfo);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001651 loader_platform_thread_unlock_mutex(&globalLock);
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001652}
1653
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001654VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001655{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001656 VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001657 // Create LL HEAD for this Pipeline
1658 char str[1024];
1659 sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001660 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, *pPipeline, 0, DRAWSTATE_NONE, "DS", str);
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001661
1662 track_pipeline(pCreateInfo, pPipeline);
1663
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001664 return result;
1665}
1666
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001667VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(
1668 VkDevice device,
1669 const VkGraphicsPipelineCreateInfo* pCreateInfo,
1670 VkPipeline basePipeline,
1671 VkPipeline* pPipeline)
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001672{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001673 VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001674 // Create LL HEAD for this Pipeline
1675 char str[1024];
1676 sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001677 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, *pPipeline, 0, DRAWSTATE_NONE, "DS", str);
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001678
1679 track_pipeline(pCreateInfo, pPipeline);
1680
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001681 loader_platform_thread_unlock_mutex(&globalLock);
Jon Ashburnbdcd7562015-04-14 14:12:59 -06001682
1683 return result;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001684}
1685
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001686VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001687{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001688 VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001689 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001690 loader_platform_thread_lock_mutex(&globalLock);
1691 SAMPLER_NODE* pNewNode = new SAMPLER_NODE;
1692 pNewNode->sampler = *pSampler;
1693 pNewNode->createInfo = *pCreateInfo;
1694 sampleMap[*pSampler] = pNewNode;
1695 loader_platform_thread_unlock_mutex(&globalLock);
1696 }
1697 return result;
1698}
1699
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001700VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001701{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001702 VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001703 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001704 LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
1705 if (NULL == pNewNode) {
1706 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001707 sprintf(str, "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()");
1708 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001709 }
1710 memset(pNewNode, 0, sizeof(LAYOUT_NODE));
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001711 memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo));
1712 pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->count];
1713 memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->count);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001714 uint32_t totalCount = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001715 for (uint32_t i=0; i<pCreateInfo->count; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +08001716 totalCount += pCreateInfo->pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001717 if (pCreateInfo->pBinding[i].pImmutableSamplers) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001718 VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers;
Chia-I Wud3114a22015-05-25 16:22:52 +08001719 *ppIS = new VkSampler[pCreateInfo->pBinding[i].arraySize];
1720 memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].arraySize*sizeof(VkSampler));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001721 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001722 }
1723 if (totalCount > 0) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001724 pNewNode->pTypes = new VkDescriptorType[totalCount];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001725 uint32_t offset = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001726 uint32_t j = 0;
1727 for (uint32_t i=0; i<pCreateInfo->count; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +08001728 for (j = 0; j < pCreateInfo->pBinding[i].arraySize; j++) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001729 pNewNode->pTypes[offset + j] = pCreateInfo->pBinding[i].descriptorType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001730 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001731 offset += j;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001732 }
1733 }
1734 pNewNode->layout = *pSetLayout;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001735 pNewNode->startIndex = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001736 pNewNode->endIndex = pNewNode->startIndex + totalCount - 1;
1737 assert(pNewNode->endIndex >= pNewNode->startIndex);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001738 // Put new node at Head of global Layer list
1739 loader_platform_thread_lock_mutex(&globalLock);
1740 layoutMap[*pSetLayout] = pNewNode;
1741 loader_platform_thread_unlock_mutex(&globalLock);
1742 }
1743 return result;
1744}
1745
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001746VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001747{
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001748 VkResult result = nextTable.CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001749 if (VK_SUCCESS == result) {
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001750 // TODO : Need to capture the pipeline layout
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001751 }
1752 return result;
1753}
1754
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001755VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001756{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001757 VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001758 if (VK_SUCCESS == result) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001759 // Insert this pool into Global Pool LL at head
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001760 char str[1024];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001761 sprintf(str, "Created Descriptor Pool %p", (void*)*pDescriptorPool);
Mike Stroyan230e6252015-04-17 12:36:38 -06001762 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001763 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001764 POOL_NODE* pNewNode = new POOL_NODE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001765 if (NULL == pNewNode) {
1766 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001767 sprintf(str, "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()");
Mike Stroyan230e6252015-04-17 12:36:38 -06001768 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VkObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001769 }
1770 else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001771 memset(pNewNode, 0, sizeof(POOL_NODE));
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001772 VkDescriptorPoolCreateInfo* pCI = (VkDescriptorPoolCreateInfo*)&pNewNode->createInfo;
1773 memcpy((void*)pCI, pCreateInfo, sizeof(VkDescriptorPoolCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001774 if (pNewNode->createInfo.count) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001775 size_t typeCountSize = pNewNode->createInfo.count * sizeof(VkDescriptorTypeCount);
1776 pNewNode->createInfo.pTypeCount = new VkDescriptorTypeCount[typeCountSize];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001777 memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize);
1778 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001779 pNewNode->poolUsage = poolUsage;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001780 pNewNode->maxSets = maxSets;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001781 pNewNode->pool = *pDescriptorPool;
1782 poolMap[*pDescriptorPool] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001783 }
1784 loader_platform_thread_unlock_mutex(&globalLock);
1785 }
1786 else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001787 // Need to do anything if pool create fails?
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001788 }
1789 return result;
1790}
1791
Mike Stroyan230e6252015-04-17 12:36:38 -06001792VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001793{
Mike Stroyan230e6252015-04-17 12:36:38 -06001794 VkResult result = nextTable.ResetDescriptorPool(device, descriptorPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001795 if (VK_SUCCESS == result) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001796 clearDescriptorPool(descriptorPool);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001797 }
1798 return result;
1799}
1800
Mike Stroyan230e6252015-04-17 12:36:38 -06001801VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001802{
Mike Stroyan230e6252015-04-17 12:36:38 -06001803 VkResult result = nextTable.AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001804 if ((VK_SUCCESS == result) || (*pCount > 0)) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001805 POOL_NODE *pPoolNode = getPoolNode(descriptorPool);
1806 if (!pPoolNode) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001807 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001808 sprintf(str, "Unable to find pool node for pool %p specified in vkAllocDescriptorSets() call", (void*)descriptorPool);
1809 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001810 }
1811 else {
1812 for (uint32_t i = 0; i < *pCount; i++) {
1813 char str[1024];
1814 sprintf(str, "Created Descriptor Set %p", (void*)pDescriptorSets[i]);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001815 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001816 // Create new set node and add to head of pool nodes
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001817 SET_NODE* pNewNode = new SET_NODE;
1818 if (NULL == pNewNode) {
1819 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001820 sprintf(str, "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()");
1821 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001822 }
1823 else {
1824 memset(pNewNode, 0, sizeof(SET_NODE));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001825 // Insert set at head of Set LL for this pool
1826 pNewNode->pNext = pPoolNode->pSets;
1827 pPoolNode->pSets = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001828 LAYOUT_NODE* pLayout = getLayoutNode(pSetLayouts[i]);
1829 if (NULL == pLayout) {
1830 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001831 sprintf(str, "Unable to find set layout node for layout %p specified in vkAllocDescriptorSets() call", (void*)pSetLayouts[i]);
1832 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001833 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001834 pNewNode->pLayout = pLayout;
1835 pNewNode->pool = descriptorPool;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001836 pNewNode->set = pDescriptorSets[i];
1837 pNewNode->setUsage = setUsage;
1838 pNewNode->descriptorCount = pLayout->endIndex + 1;
1839 if (pNewNode->descriptorCount) {
1840 size_t descriptorArraySize = sizeof(GENERIC_HEADER*)*pNewNode->descriptorCount;
1841 pNewNode->ppDescriptors = new GENERIC_HEADER*[descriptorArraySize];
1842 memset(pNewNode->ppDescriptors, 0, descriptorArraySize);
1843 }
1844 setMap[pDescriptorSets[i]] = pNewNode;
1845 }
1846 }
1847 }
1848 }
1849 return result;
1850}
1851
Mike Stroyan230e6252015-04-17 12:36:38 -06001852VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001853{
1854 for (uint32_t i = 0; i < count; i++) {
1855 clearDescriptorSet(pDescriptorSets[i]);
1856 }
Mike Stroyan230e6252015-04-17 12:36:38 -06001857 nextTable.ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001858}
1859
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001860VK_LAYER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001861{
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001862 if (dsUpdate(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, writeCount, pDescriptorWrites) &&
1863 dsUpdate(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, copyCount, pDescriptorCopies))
1864 return nextTable.UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
1865 else
1866 return VK_ERROR_UNKNOWN;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001867}
1868
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001869VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001870{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001871 VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001872 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_VIEWPORT);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001873 return result;
1874}
1875
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001876VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001877{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001878 VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001879 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001880 return result;
1881}
1882
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001883VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001884{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001885 VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001886 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_COLOR_BLEND);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001887 return result;
1888}
1889
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001890VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001891{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001892 VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001893 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_STENCIL);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001894 return result;
1895}
1896
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001897VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001898{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001899 VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001900 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001901 loader_platform_thread_lock_mutex(&globalLock);
1902 GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
1903 memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
1904 pCB->cmdBuffer = *pCmdBuffer;
1905 pCB->flags = pCreateInfo->flags;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -07001906 pCB->queueNodeIndex = pCreateInfo->queueNodeIndex;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001907 pCB->lastVtxBinding = MAX_BINDING;
1908 cmdBufferMap[*pCmdBuffer] = pCB;
1909 loader_platform_thread_unlock_mutex(&globalLock);
1910 updateCBTracking(*pCmdBuffer);
1911 }
1912 return result;
1913}
1914
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001915VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001916{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001917 VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001918 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001919 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1920 if (pCB) {
1921 if (CB_NEW != pCB->state)
1922 resetCB(cmdBuffer);
1923 pCB->state = CB_UPDATE_ACTIVE;
Tobin Ehlis2464b882015-04-01 08:40:34 -06001924 if (pBeginInfo->pNext) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001925 VkCmdBufferGraphicsBeginInfo* pCbGfxBI = (VkCmdBufferGraphicsBeginInfo*)pBeginInfo->pNext;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001926 if (VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) {
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -06001927 pCB->activeRenderPass = pCbGfxBI->renderPassContinue.renderPass;
Tobin Ehlis2464b882015-04-01 08:40:34 -06001928 }
1929 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001930 }
1931 else {
1932 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001933 sprintf(str, "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
1934 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001935 }
1936 updateCBTracking(cmdBuffer);
1937 }
1938 return result;
1939}
1940
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001941VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001942{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001943 VkResult result = nextTable.EndCommandBuffer(cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001944 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001945 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1946 if (pCB) {
1947 pCB->state = CB_UPDATE_COMPLETE;
Tobin Ehlis97866202015-06-10 12:57:07 -06001948 // Reset CB status flags
1949 pCB->status = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001950 printCB(cmdBuffer);
1951 }
1952 else {
1953 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001954 sprintf(str, "In vkEndCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
1955 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001956 }
1957 updateCBTracking(cmdBuffer);
1958 //cbDumpDotFile("cb_dump.dot");
1959 }
1960 return result;
1961}
1962
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001963VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001964{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001965 VkResult result = nextTable.ResetCommandBuffer(cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001966 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001967 resetCB(cmdBuffer);
1968 updateCBTracking(cmdBuffer);
1969 }
1970 return result;
1971}
1972
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001973VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001974{
1975 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1976 if (pCB) {
1977 updateCBTracking(cmdBuffer);
1978 addCmd(pCB, CMD_BINDPIPELINE);
1979 PIPELINE_NODE* pPN = getPipeline(pipeline);
1980 if (pPN) {
1981 pCB->lastBoundPipeline = pipeline;
1982 loader_platform_thread_lock_mutex(&globalLock);
1983 g_lastBoundPipeline = pPN;
1984 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis2464b882015-04-01 08:40:34 -06001985 validatePipelineState(pCB, pipelineBindPoint, pipeline);
Tobin Ehlise9b700e2015-05-26 16:06:50 -06001986 nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001987 }
1988 else {
1989 char str[1024];
1990 sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001991 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001992 }
1993 }
1994 else {
1995 char str[1024];
1996 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001997 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001998 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001999}
2000
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002001VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002002{
2003 setLastBoundDynamicState(cmdBuffer, state, stateBindPoint);
2004 nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
2005}
2006
Cody Northrop1a01b1d2015-04-16 13:41:56 -06002007VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002008{
2009 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2010 if (pCB) {
2011 updateCBTracking(cmdBuffer);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06002012 addCmd(pCB, CMD_BINDDESCRIPTORSETS);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002013 if (validateBoundPipeline(cmdBuffer)) {
2014 for (uint32_t i=0; i<setCount; i++) {
2015 if (getSetNode(pDescriptorSets[i])) {
2016 loader_platform_thread_lock_mutex(&globalLock);
2017 pCB->lastBoundDescriptorSet = pDescriptorSets[i];
2018 pCB->boundDescriptorSets.push_back(pDescriptorSets[i]);
2019 g_lastBoundDescriptorSet = pDescriptorSets[i];
2020 loader_platform_thread_unlock_mutex(&globalLock);
2021 char str[1024];
2022 sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint));
2023 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002024 }
2025 else {
2026 char str[1024];
2027 sprintf(str, "Attempt to bind DS %p that doesn't exist!", (void*)pDescriptorSets[i]);
2028 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", str);
2029 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002030 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002031 nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002032 }
2033 }
2034 else {
2035 char str[1024];
2036 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002037 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002038 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002039}
2040
Tony Barbour8205d902015-04-16 15:59:00 -06002041VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002042{
2043 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2044 if (pCB) {
2045 updateCBTracking(cmdBuffer);
2046 addCmd(pCB, CMD_BINDINDEXBUFFER);
2047 // TODO : Track idxBuffer binding
2048 }
2049 else {
2050 char str[1024];
2051 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002052 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002053 }
2054 nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
2055}
2056
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002057VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
2058 VkCmdBuffer cmdBuffer,
2059 uint32_t startBinding,
2060 uint32_t bindingCount,
2061 const VkBuffer* pBuffers,
Tony Barbour8205d902015-04-16 15:59:00 -06002062 const VkDeviceSize* pOffsets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002063{
2064 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2065 if (pCB) {
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002066 /* TODO: Need to track all the vertex buffers, not just last one */
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002067 updateCBTracking(cmdBuffer);
2068 addCmd(pCB, CMD_BINDVERTEXBUFFER);
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002069 pCB->lastVtxBinding = startBinding + bindingCount -1;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002070 if (validateBoundPipeline(cmdBuffer)) {
2071 nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
2072 }
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002073 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002074 char str[1024];
2075 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002076 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002077 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002078}
2079
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002080VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002081{
2082 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002083 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002084 if (pCB) {
2085 updateCBTracking(cmdBuffer);
2086 addCmd(pCB, CMD_DRAW);
2087 pCB->drawCount[DRAW]++;
Tobin Ehlis97866202015-06-10 12:57:07 -06002088 loader_platform_thread_lock_mutex(&globalLock);
2089 valid = validate_draw_state_flags(cmdBuffer);
2090 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002091 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002092 sprintf(str, "vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
2093 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002094 synchAndPrintDSConfig(cmdBuffer);
2095 }
2096 else {
2097 char str[1024];
2098 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002099 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002100 }
Tobin Ehlis97866202015-06-10 12:57:07 -06002101 if (valid)
2102 nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002103}
2104
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002105VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002106{
2107 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002108 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002109 if (pCB) {
2110 updateCBTracking(cmdBuffer);
2111 addCmd(pCB, CMD_DRAWINDEXED);
2112 pCB->drawCount[DRAW_INDEXED]++;
Tobin Ehlis97866202015-06-10 12:57:07 -06002113 loader_platform_thread_lock_mutex(&globalLock);
2114 valid = validate_draw_state_flags(cmdBuffer);
2115 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002116 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002117 sprintf(str, "vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
2118 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002119 synchAndPrintDSConfig(cmdBuffer);
2120 }
2121 else {
2122 char str[1024];
2123 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002124 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002125 }
Tobin Ehlis97866202015-06-10 12:57:07 -06002126 if (valid)
2127 nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002128}
2129
Tony Barbour8205d902015-04-16 15:59:00 -06002130VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002131{
2132 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002133 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002134 if (pCB) {
2135 updateCBTracking(cmdBuffer);
2136 addCmd(pCB, CMD_DRAWINDIRECT);
2137 pCB->drawCount[DRAW_INDIRECT]++;
Tobin Ehlis97866202015-06-10 12:57:07 -06002138 loader_platform_thread_lock_mutex(&globalLock);
2139 valid = validate_draw_state_flags(cmdBuffer);
2140 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002141 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002142 sprintf(str, "vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
2143 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002144 synchAndPrintDSConfig(cmdBuffer);
2145 }
2146 else {
2147 char str[1024];
2148 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002149 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002150 }
Tobin Ehlis97866202015-06-10 12:57:07 -06002151 if (valid)
2152 nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002153}
2154
Tony Barbour8205d902015-04-16 15:59:00 -06002155VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002156{
2157 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002158 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002159 if (pCB) {
2160 updateCBTracking(cmdBuffer);
2161 addCmd(pCB, CMD_DRAWINDEXEDINDIRECT);
2162 pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
Tobin Ehlis97866202015-06-10 12:57:07 -06002163 loader_platform_thread_lock_mutex(&globalLock);
2164 valid = validate_draw_state_flags(cmdBuffer);
2165 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002166 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002167 sprintf(str, "vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
2168 layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_NONE, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002169 synchAndPrintDSConfig(cmdBuffer);
2170 }
2171 else {
2172 char str[1024];
2173 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002174 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002175 }
Tobin Ehlis97866202015-06-10 12:57:07 -06002176 if (valid)
2177 nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002178}
2179
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002180VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002181{
2182 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2183 if (pCB) {
2184 updateCBTracking(cmdBuffer);
2185 addCmd(pCB, CMD_DISPATCH);
2186 }
2187 else {
2188 char str[1024];
2189 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002190 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002191 }
2192 nextTable.CmdDispatch(cmdBuffer, x, y, z);
2193}
2194
Tony Barbour8205d902015-04-16 15:59:00 -06002195VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002196{
2197 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2198 if (pCB) {
2199 updateCBTracking(cmdBuffer);
2200 addCmd(pCB, CMD_DISPATCHINDIRECT);
2201 }
2202 else {
2203 char str[1024];
2204 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002205 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002206 }
2207 nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
2208}
2209
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002210VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002211{
2212 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2213 if (pCB) {
2214 updateCBTracking(cmdBuffer);
2215 addCmd(pCB, CMD_COPYBUFFER);
2216 }
2217 else {
2218 char str[1024];
2219 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002220 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002221 }
2222 nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
2223}
2224
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002225VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
2226 VkImage srcImage,
2227 VkImageLayout srcImageLayout,
2228 VkImage destImage,
2229 VkImageLayout destImageLayout,
2230 uint32_t regionCount, const VkImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002231{
2232 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2233 if (pCB) {
2234 updateCBTracking(cmdBuffer);
2235 addCmd(pCB, CMD_COPYIMAGE);
2236 }
2237 else {
2238 char str[1024];
2239 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002240 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002241 }
Courtney Goeltzenleuchter45334842015-04-13 16:16:56 -06002242 nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002243}
2244
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002245VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
2246 VkImage srcImage, VkImageLayout srcImageLayout,
2247 VkImage destImage, VkImageLayout destImageLayout,
Mark Lobodzinski20f68592015-05-22 14:43:25 -05002248 uint32_t regionCount, const VkImageBlit* pRegions,
2249 VkTexFilter filter)
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002250{
2251 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2252 if (pCB) {
2253 updateCBTracking(cmdBuffer);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06002254 addCmd(pCB, CMD_BLITIMAGE);
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002255 }
2256 else {
2257 char str[1024];
2258 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002259 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002260 }
Mark Lobodzinski20f68592015-05-22 14:43:25 -05002261 nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002262}
2263
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002264VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
2265 VkBuffer srcBuffer,
2266 VkImage destImage, VkImageLayout destImageLayout,
2267 uint32_t regionCount, const VkBufferImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002268{
2269 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2270 if (pCB) {
2271 updateCBTracking(cmdBuffer);
2272 addCmd(pCB, CMD_COPYBUFFERTOIMAGE);
2273 }
2274 else {
2275 char str[1024];
2276 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002277 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002278 }
Courtney Goeltzenleuchter45334842015-04-13 16:16:56 -06002279 nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002280}
2281
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002282VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
2283 VkImage srcImage, VkImageLayout srcImageLayout,
2284 VkBuffer destBuffer,
2285 uint32_t regionCount, const VkBufferImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002286{
2287 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2288 if (pCB) {
2289 updateCBTracking(cmdBuffer);
2290 addCmd(pCB, CMD_COPYIMAGETOBUFFER);
2291 }
2292 else {
2293 char str[1024];
2294 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002295 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002296 }
Courtney Goeltzenleuchter45334842015-04-13 16:16:56 -06002297 nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002298}
2299
Tony Barbour8205d902015-04-16 15:59:00 -06002300VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002301{
2302 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2303 if (pCB) {
2304 updateCBTracking(cmdBuffer);
2305 addCmd(pCB, CMD_UPDATEBUFFER);
2306 }
2307 else {
2308 char str[1024];
2309 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002310 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002311 }
2312 nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
2313}
2314
Tony Barbour8205d902015-04-16 15:59:00 -06002315VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002316{
2317 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2318 if (pCB) {
2319 updateCBTracking(cmdBuffer);
2320 addCmd(pCB, CMD_FILLBUFFER);
2321 }
2322 else {
2323 char str[1024];
2324 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002325 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002326 }
2327 nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
2328}
2329
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06002330VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
2331 VkCmdBuffer cmdBuffer,
2332 VkImage image, VkImageLayout imageLayout,
2333 const VkClearColor *pColor,
2334 uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002335{
2336 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2337 if (pCB) {
2338 updateCBTracking(cmdBuffer);
2339 addCmd(pCB, CMD_CLEARCOLORIMAGE);
2340 }
2341 else {
2342 char str[1024];
2343 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002344 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002345 }
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06002346 nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002347}
2348
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002349VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer,
2350 VkImage image, VkImageLayout imageLayout,
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002351 float depth, uint32_t stencil,
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002352 uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002353{
2354 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2355 if (pCB) {
2356 updateCBTracking(cmdBuffer);
2357 addCmd(pCB, CMD_CLEARDEPTHSTENCIL);
2358 }
2359 else {
2360 char str[1024];
2361 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002362 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002363 }
Courtney Goeltzenleuchter45334842015-04-13 16:16:56 -06002364 nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002365}
2366
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002367VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
2368 VkImage srcImage, VkImageLayout srcImageLayout,
2369 VkImage destImage, VkImageLayout destImageLayout,
Tony Barbour11f74372015-04-13 15:02:52 -06002370 uint32_t regionCount, const VkImageResolve* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002371{
2372 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2373 if (pCB) {
2374 updateCBTracking(cmdBuffer);
2375 addCmd(pCB, CMD_RESOLVEIMAGE);
2376 }
2377 else {
2378 char str[1024];
2379 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002380 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002381 }
Tony Barbour11f74372015-04-13 15:02:52 -06002382 nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002383}
2384
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002385VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002386{
2387 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2388 if (pCB) {
2389 updateCBTracking(cmdBuffer);
2390 addCmd(pCB, CMD_SETEVENT);
2391 }
2392 else {
2393 char str[1024];
2394 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002395 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002396 }
2397 nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
2398}
2399
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002400VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002401{
2402 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2403 if (pCB) {
2404 updateCBTracking(cmdBuffer);
2405 addCmd(pCB, CMD_RESETEVENT);
2406 }
2407 else {
2408 char str[1024];
2409 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002410 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002411 }
Courtney Goeltzenleuchteraa86e0e2015-03-24 18:02:34 -06002412 nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002413}
2414
Tony Barbour8205d902015-04-16 15:59:00 -06002415VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002416{
2417 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2418 if (pCB) {
2419 updateCBTracking(cmdBuffer);
2420 addCmd(pCB, CMD_WAITEVENTS);
2421 }
2422 else {
2423 char str[1024];
2424 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002425 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002426 }
Tony Barbour8205d902015-04-16 15:59:00 -06002427 nextTable.CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002428}
2429
Tony Barbour8205d902015-04-16 15:59:00 -06002430VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002431{
2432 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2433 if (pCB) {
2434 updateCBTracking(cmdBuffer);
2435 addCmd(pCB, CMD_PIPELINEBARRIER);
2436 }
2437 else {
2438 char str[1024];
2439 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002440 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002441 }
Tony Barbour8205d902015-04-16 15:59:00 -06002442 nextTable.CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002443}
2444
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002445VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002446{
2447 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2448 if (pCB) {
2449 updateCBTracking(cmdBuffer);
2450 addCmd(pCB, CMD_BEGINQUERY);
2451 }
2452 else {
2453 char str[1024];
2454 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002455 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002456 }
2457 nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
2458}
2459
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002460VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002461{
2462 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2463 if (pCB) {
2464 updateCBTracking(cmdBuffer);
2465 addCmd(pCB, CMD_ENDQUERY);
2466 }
2467 else {
2468 char str[1024];
2469 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002470 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002471 }
2472 nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
2473}
2474
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002475VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002476{
2477 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2478 if (pCB) {
2479 updateCBTracking(cmdBuffer);
2480 addCmd(pCB, CMD_RESETQUERYPOOL);
2481 }
2482 else {
2483 char str[1024];
2484 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002485 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002486 }
2487 nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
2488}
2489
Tony Barbour8205d902015-04-16 15:59:00 -06002490VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002491{
2492 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2493 if (pCB) {
2494 updateCBTracking(cmdBuffer);
2495 addCmd(pCB, CMD_WRITETIMESTAMP);
2496 }
2497 else {
2498 char str[1024];
2499 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002500 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002501 }
2502 nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
2503}
2504
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002505VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002506{
2507 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2508 if (pCB) {
2509 updateCBTracking(cmdBuffer);
2510 addCmd(pCB, CMD_INITATOMICCOUNTERS);
2511 }
2512 else {
2513 char str[1024];
2514 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002515 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002516 }
2517 nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
2518}
2519
Tony Barbour8205d902015-04-16 15:59:00 -06002520VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002521{
2522 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2523 if (pCB) {
2524 updateCBTracking(cmdBuffer);
2525 addCmd(pCB, CMD_LOADATOMICCOUNTERS);
2526 }
2527 else {
2528 char str[1024];
2529 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002530 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002531 }
2532 nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
2533}
2534
Tony Barbour8205d902015-04-16 15:59:00 -06002535VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkDeviceSize destOffset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002536{
2537 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2538 if (pCB) {
2539 updateCBTracking(cmdBuffer);
2540 addCmd(pCB, CMD_SAVEATOMICCOUNTERS);
2541 }
2542 else {
2543 char str[1024];
2544 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002545 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002546 }
2547 nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
2548}
2549
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002550VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
Tobin Ehlis2464b882015-04-01 08:40:34 -06002551{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002552 VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002553 if (VK_SUCCESS == result) {
Tobin Ehlis2464b882015-04-01 08:40:34 -06002554 // Shadow create info and store in map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002555 VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
Tobin Ehlis2464b882015-04-01 08:40:34 -06002556 if (pCreateInfo->pColorAttachments) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002557 localFBCI->pColorAttachments = new VkColorAttachmentBindInfo[localFBCI->colorAttachmentCount];
2558 memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VkColorAttachmentBindInfo));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002559 }
2560 if (pCreateInfo->pDepthStencilAttachment) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002561 localFBCI->pDepthStencilAttachment = new VkDepthStencilBindInfo[localFBCI->colorAttachmentCount];
2562 memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VkDepthStencilBindInfo));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002563 }
2564 frameBufferMap[*pFramebuffer] = localFBCI;
2565 }
2566 return result;
2567}
2568
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002569VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
Tobin Ehlis2464b882015-04-01 08:40:34 -06002570{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002571 VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002572 if (VK_SUCCESS == result) {
Tobin Ehlis2464b882015-04-01 08:40:34 -06002573 // Shadow create info and store in map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002574 VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
Tobin Ehlis2464b882015-04-01 08:40:34 -06002575 if (pCreateInfo->pColorLoadOps) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002576 localRPCI->pColorLoadOps = new VkAttachmentLoadOp[localRPCI->colorAttachmentCount];
2577 memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentLoadOp));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002578 }
2579 if (pCreateInfo->pColorStoreOps) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002580 localRPCI->pColorStoreOps = new VkAttachmentStoreOp[localRPCI->colorAttachmentCount];
2581 memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentStoreOp));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002582 }
2583 if (pCreateInfo->pColorLoadClearValues) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002584 localRPCI->pColorLoadClearValues = new VkClearColor[localRPCI->colorAttachmentCount];
2585 memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VkClearColor));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002586 }
2587 renderPassMap[*pRenderPass] = localRPCI;
2588 }
2589 return result;
2590}
2591
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002592VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002593{
2594 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2595 if (pCB) {
2596 updateCBTracking(cmdBuffer);
2597 addCmd(pCB, CMD_BEGINRENDERPASS);
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -06002598 pCB->activeRenderPass = pRenderPassBegin->renderPass;
2599 pCB->framebuffer = pRenderPassBegin->framebuffer;
Tony Barbourb9f82ba2015-04-06 11:09:26 -06002600 if (pCB->lastBoundPipeline) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002601 validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
Tony Barbourb9f82ba2015-04-06 11:09:26 -06002602 }
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -06002603 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002604 char str[1024];
2605 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002606 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002607 }
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -06002608 nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002609}
2610
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002611VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002612{
2613 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2614 if (pCB) {
2615 updateCBTracking(cmdBuffer);
2616 addCmd(pCB, CMD_ENDRENDERPASS);
Tobin Ehlis2464b882015-04-01 08:40:34 -06002617 pCB->activeRenderPass = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002618 }
2619 else {
2620 char str[1024];
2621 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002622 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002623 }
2624 nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
2625}
2626
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002627VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002628{
2629 // This layer intercepts callbacks
Tobin Ehliseaf28662015-04-08 10:58:37 -06002630 VK_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = new VK_LAYER_DBG_FUNCTION_NODE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002631 if (!pNewDbgFuncNode)
Tony Barbour8205d902015-04-16 15:59:00 -06002632 return VK_ERROR_OUT_OF_HOST_MEMORY;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002633 pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
2634 pNewDbgFuncNode->pUserData = pUserData;
2635 pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
2636 g_pDbgFunctionHead = pNewDbgFuncNode;
2637 // force callbacks if DebugAction hasn't been set already other than initial value
2638 if (g_actionIsDefault) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002639 g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002640 }
Jon Ashburn52c1d732015-05-12 17:23:55 -06002641 VkResult result = nextInstanceTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002642 return result;
2643}
2644
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002645VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002646{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002647 VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
2648 VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002649 while (pTrav) {
2650 if (pTrav->pfnMsgCallback == pfnMsgCallback) {
2651 pPrev->pNext = pTrav->pNext;
2652 if (g_pDbgFunctionHead == pTrav)
2653 g_pDbgFunctionHead = pTrav->pNext;
Tobin Ehliseaf28662015-04-08 10:58:37 -06002654 delete pTrav;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002655 break;
2656 }
2657 pPrev = pTrav;
2658 pTrav = pTrav->pNext;
2659 }
2660 if (g_pDbgFunctionHead == NULL)
2661 {
2662 if (g_actionIsDefault)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002663 g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002664 else
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002665 g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002666 }
Jon Ashburn52c1d732015-05-12 17:23:55 -06002667 VkResult result = nextInstanceTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002668 return result;
2669}
2670
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002671VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002672{
2673 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2674 if (pCB) {
2675 updateCBTracking(cmdBuffer);
2676 addCmd(pCB, CMD_DBGMARKERBEGIN);
2677 }
2678 else {
2679 char str[1024];
2680 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002681 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002682 }
2683 nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
2684}
2685
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002686VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002687{
2688 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2689 if (pCB) {
2690 updateCBTracking(cmdBuffer);
2691 addCmd(pCB, CMD_DBGMARKEREND);
2692 }
2693 else {
2694 char str[1024];
2695 sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002696 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002697 }
2698 nextTable.CmdDbgMarkerEnd(cmdBuffer);
2699}
2700
2701// TODO : Want to pass in a cmdBuffer here based on which state to display
2702void drawStateDumpDotFile(char* outFileName)
2703{
2704 // TODO : Currently just setting cmdBuffer based on global var
2705 //dumpDotFile(g_lastDrawStateCmdBuffer, outFileName);
2706 dumpGlobalDotFile(outFileName);
2707}
2708
2709void drawStateDumpCommandBufferDotFile(char* outFileName)
2710{
2711 cbDumpDotFile(outFileName);
2712}
2713
2714void drawStateDumpPngFile(char* outFileName)
2715{
2716#if defined(_WIN32)
2717// FIXME: NEED WINDOWS EQUIVALENT
2718 char str[1024];
2719 sprintf(str, "Cannot execute dot program yet on Windows.");
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002720 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002721#else // WIN32
2722 char dotExe[32] = "/usr/bin/dot";
2723 if( access(dotExe, X_OK) != -1) {
2724 dumpDotFile(g_lastCmdBuffer[getTIDIndex()], "/tmp/tmp.dot");
2725 char dotCmd[1024];
2726 sprintf(dotCmd, "%s /tmp/tmp.dot -Tpng -o %s", dotExe, outFileName);
Tony Barbour22a30862015-04-22 09:02:32 -06002727 int retval = system(dotCmd);
2728 assert(retval != -1);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002729 remove("/tmp/tmp.dot");
2730 }
2731 else {
2732 char str[1024];
2733 sprintf(str, "Cannot execute dot program at (%s) to dump requested %s file.", dotExe, outFileName);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002734 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_MISSING_DOT_PROGRAM, "DS", str);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002735 }
2736#endif // WIN32
2737}
2738
Tony Barbour8205d902015-04-16 15:59:00 -06002739VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002740{
Jon Ashburn301c5f02015-04-06 10:58:22 -06002741 VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002742
2743 if (gpu == NULL)
2744 return NULL;
2745 pCurObj = gpuw;
2746 loader_platform_thread_once(&g_initOnce, initDrawState);
Jon Ashburnd9564002015-05-07 10:27:37 -06002747 loader_platform_thread_once(&g_tabDeviceOnce, initDeviceTable);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002748
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002749 if (!strcmp(funcName, "vkGetProcAddr"))
2750 return (void *) vkGetProcAddr;
2751 if (!strcmp(funcName, "vkCreateDevice"))
2752 return (void*) vkCreateDevice;
2753 if (!strcmp(funcName, "vkDestroyDevice"))
2754 return (void*) vkDestroyDevice;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002755 if (!strcmp(funcName, "vkEnumerateLayers"))
2756 return (void*) vkEnumerateLayers;
2757 if (!strcmp(funcName, "vkQueueSubmit"))
2758 return (void*) vkQueueSubmit;
2759 if (!strcmp(funcName, "vkDestroyObject"))
2760 return (void*) vkDestroyObject;
2761 if (!strcmp(funcName, "vkCreateBufferView"))
2762 return (void*) vkCreateBufferView;
2763 if (!strcmp(funcName, "vkCreateImageView"))
2764 return (void*) vkCreateImageView;
2765 if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
2766 return (void*) vkCreateGraphicsPipeline;
2767 if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
2768 return (void*) vkCreateGraphicsPipelineDerivative;
2769 if (!strcmp(funcName, "vkCreateSampler"))
2770 return (void*) vkCreateSampler;
2771 if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
2772 return (void*) vkCreateDescriptorSetLayout;
Mark Lobodzinski556f7212015-04-17 14:11:39 -05002773 if (!strcmp(funcName, "vkCreatePipelineLayout"))
2774 return (void*) vkCreatePipelineLayout;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002775 if (!strcmp(funcName, "vkCreateDescriptorPool"))
2776 return (void*) vkCreateDescriptorPool;
2777 if (!strcmp(funcName, "vkResetDescriptorPool"))
2778 return (void*) vkResetDescriptorPool;
2779 if (!strcmp(funcName, "vkAllocDescriptorSets"))
2780 return (void*) vkAllocDescriptorSets;
2781 if (!strcmp(funcName, "vkClearDescriptorSets"))
2782 return (void*) vkClearDescriptorSets;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08002783 if (!strcmp(funcName, "vkUpdateDescriptorSets"))
2784 return (void*) vkUpdateDescriptorSets;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002785 if (!strcmp(funcName, "vkCreateDynamicViewportState"))
2786 return (void*) vkCreateDynamicViewportState;
2787 if (!strcmp(funcName, "vkCreateDynamicRasterState"))
2788 return (void*) vkCreateDynamicRasterState;
2789 if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
2790 return (void*) vkCreateDynamicColorBlendState;
2791 if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
2792 return (void*) vkCreateDynamicDepthStencilState;
2793 if (!strcmp(funcName, "vkCreateCommandBuffer"))
2794 return (void*) vkCreateCommandBuffer;
2795 if (!strcmp(funcName, "vkBeginCommandBuffer"))
2796 return (void*) vkBeginCommandBuffer;
2797 if (!strcmp(funcName, "vkEndCommandBuffer"))
2798 return (void*) vkEndCommandBuffer;
2799 if (!strcmp(funcName, "vkResetCommandBuffer"))
2800 return (void*) vkResetCommandBuffer;
2801 if (!strcmp(funcName, "vkCmdBindPipeline"))
2802 return (void*) vkCmdBindPipeline;
2803 if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
2804 return (void*) vkCmdBindDynamicStateObject;
2805 if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
2806 return (void*) vkCmdBindDescriptorSets;
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002807 if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
2808 return (void*) vkCmdBindVertexBuffers;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002809 if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
2810 return (void*) vkCmdBindIndexBuffer;
2811 if (!strcmp(funcName, "vkCmdDraw"))
2812 return (void*) vkCmdDraw;
2813 if (!strcmp(funcName, "vkCmdDrawIndexed"))
2814 return (void*) vkCmdDrawIndexed;
2815 if (!strcmp(funcName, "vkCmdDrawIndirect"))
2816 return (void*) vkCmdDrawIndirect;
2817 if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
2818 return (void*) vkCmdDrawIndexedIndirect;
2819 if (!strcmp(funcName, "vkCmdDispatch"))
2820 return (void*) vkCmdDispatch;
2821 if (!strcmp(funcName, "vkCmdDispatchIndirect"))
2822 return (void*) vkCmdDispatchIndirect;
2823 if (!strcmp(funcName, "vkCmdCopyBuffer"))
2824 return (void*) vkCmdCopyBuffer;
2825 if (!strcmp(funcName, "vkCmdCopyImage"))
2826 return (void*) vkCmdCopyImage;
2827 if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
2828 return (void*) vkCmdCopyBufferToImage;
2829 if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
2830 return (void*) vkCmdCopyImageToBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002831 if (!strcmp(funcName, "vkCmdUpdateBuffer"))
2832 return (void*) vkCmdUpdateBuffer;
2833 if (!strcmp(funcName, "vkCmdFillBuffer"))
2834 return (void*) vkCmdFillBuffer;
2835 if (!strcmp(funcName, "vkCmdClearColorImage"))
2836 return (void*) vkCmdClearColorImage;
2837 if (!strcmp(funcName, "vkCmdClearDepthStencil"))
2838 return (void*) vkCmdClearDepthStencil;
2839 if (!strcmp(funcName, "vkCmdResolveImage"))
2840 return (void*) vkCmdResolveImage;
2841 if (!strcmp(funcName, "vkCmdSetEvent"))
2842 return (void*) vkCmdSetEvent;
2843 if (!strcmp(funcName, "vkCmdResetEvent"))
2844 return (void*) vkCmdResetEvent;
2845 if (!strcmp(funcName, "vkCmdWaitEvents"))
2846 return (void*) vkCmdWaitEvents;
2847 if (!strcmp(funcName, "vkCmdPipelineBarrier"))
2848 return (void*) vkCmdPipelineBarrier;
2849 if (!strcmp(funcName, "vkCmdBeginQuery"))
2850 return (void*) vkCmdBeginQuery;
2851 if (!strcmp(funcName, "vkCmdEndQuery"))
2852 return (void*) vkCmdEndQuery;
2853 if (!strcmp(funcName, "vkCmdResetQueryPool"))
2854 return (void*) vkCmdResetQueryPool;
2855 if (!strcmp(funcName, "vkCmdWriteTimestamp"))
2856 return (void*) vkCmdWriteTimestamp;
2857 if (!strcmp(funcName, "vkCmdInitAtomicCounters"))
2858 return (void*) vkCmdInitAtomicCounters;
2859 if (!strcmp(funcName, "vkCmdLoadAtomicCounters"))
2860 return (void*) vkCmdLoadAtomicCounters;
2861 if (!strcmp(funcName, "vkCmdSaveAtomicCounters"))
2862 return (void*) vkCmdSaveAtomicCounters;
2863 if (!strcmp(funcName, "vkCreateFramebuffer"))
2864 return (void*) vkCreateFramebuffer;
2865 if (!strcmp(funcName, "vkCreateRenderPass"))
2866 return (void*) vkCreateRenderPass;
2867 if (!strcmp(funcName, "vkCmdBeginRenderPass"))
2868 return (void*) vkCmdBeginRenderPass;
2869 if (!strcmp(funcName, "vkCmdEndRenderPass"))
2870 return (void*) vkCmdEndRenderPass;
2871 if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
2872 return (void*) vkDbgRegisterMsgCallback;
2873 if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
2874 return (void*) vkDbgUnregisterMsgCallback;
2875 if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
2876 return (void*) vkCmdDbgMarkerBegin;
2877 if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
2878 return (void*) vkCmdDbgMarkerEnd;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002879 if (!strcmp("drawStateDumpDotFile", funcName))
2880 return (void*) drawStateDumpDotFile;
2881 if (!strcmp("drawStateDumpCommandBufferDotFile", funcName))
2882 return (void*) drawStateDumpCommandBufferDotFile;
2883 if (!strcmp("drawStateDumpPngFile", funcName))
2884 return (void*) drawStateDumpPngFile;
2885 else {
2886 if (gpuw->pGPA == NULL)
2887 return NULL;
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002888 return gpuw->pGPA((VkObject)gpuw->nextObject, funcName);
2889 }
2890}
2891
2892VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
2893{
2894 VkBaseLayerObject* instw = (VkBaseLayerObject *) instance;
2895 if (instance == NULL)
2896 return NULL;
2897
Jon Ashburnd9564002015-05-07 10:27:37 -06002898 pCurObj = instw;
2899 loader_platform_thread_once(&g_initOnce, initDrawState);
2900 loader_platform_thread_once(&g_tabInstanceOnce, initInstanceTable);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002901
2902 if (!strcmp(funcName, "vkGetInstanceProcAddr"))
2903 return (void *) vkGetInstanceProcAddr;
2904 if (!strcmp(funcName, "vkGetProcAddr"))
2905 return (void *) vkGetProcAddr;
2906 if (!strcmp(funcName, "vkCreateDevice"))
2907 return (void*) vkCreateDevice;
2908 if (!strcmp(funcName, "vkEnumerateLayers"))
2909 return (void*) vkEnumerateLayers;
2910 if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
2911 return (void*) vkDbgRegisterMsgCallback;
2912 if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
2913 return (void*) vkDbgUnregisterMsgCallback;
2914 else {
2915 if (instw->pGPA == NULL)
2916 return NULL;
2917 return instw->pGPA((VkObject) instw->nextObject, funcName);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002918 }
2919}