blob: c1ad7fbebc333cb563d416897e659f0a05c7ba56 [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
Tobin Ehlis7a51d902015-07-03 10:34:49 -060030#include "vk_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"
Tobin Ehlis56d204a2015-07-03 10:15:26 -060042#include "vk_layer_config.h"
Jon Ashburnf0615e22015-05-25 14:11:37 -060043#include "vk_debug_marker_layer.h"
Tobin Ehlis63bb9482015-03-17 16:24:32 -060044// The following is #included again to catch certain OS-specific functions
45// being used:
Tobin Ehlis7a51d902015-07-03 10:34:49 -060046#include "vk_loader_platform.h"
Tobin Ehlis56d204a2015-07-03 10:15:26 -060047#include "vk_layer_msg.h"
48#include "vk_layer_table.h"
49#include "vk_layer_debug_marker_table.h"
50#include "vk_layer_data.h"
51#include "vk_layer_logging.h"
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -060052#include "vk_layer_extension_utils.h"
Tobin Ehlis63bb9482015-03-17 16:24:32 -060053
Tobin Ehlisc91330b2015-06-16 09:04:30 -060054typedef struct _layer_data {
55 debug_report_data *report_data;
56 // TODO: put instance data here
57 VkDbgMsgCallback logging_callback;
58} layer_data;
59
60static std::unordered_map<void *, layer_data *> layer_data_map;
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -060061static device_table_map draw_state_device_table_map;
62static instance_table_map draw_state_instance_table_map;
63
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060064unordered_map<VkSampler, SAMPLER_NODE*> sampleMap;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -060065unordered_map<VkNonDispatchable, IMAGE_NODE*> viewCreateInfoMap;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060066unordered_map<VkBufferView, BUFFER_NODE*> bufferMap;
67unordered_map<VkDynamicStateObject, DYNAMIC_STATE_NODE*> dynamicStateMap;
68unordered_map<VkPipeline, PIPELINE_NODE*> pipelineMap;
69unordered_map<VkDescriptorPool, POOL_NODE*> poolMap;
70unordered_map<VkDescriptorSet, SET_NODE*> setMap;
71unordered_map<VkDescriptorSetLayout, LAYOUT_NODE*> layoutMap;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -060072// Map for layout chains
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060073unordered_map<VkCmdBuffer, GLOBAL_CB_NODE*> cmdBufferMap;
74unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
75unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060076
Jon Ashburn6f8cd632015-06-01 09:37:38 -060077struct devExts {
78 bool debug_marker_enabled;
79};
80
Jon Ashburn6f8cd632015-06-01 09:37:38 -060081static std::unordered_map<void *, struct devExts> deviceExtMap;
Jon Ashburne0fa2282015-05-20 09:00:28 -060082
Tobin Ehlis63bb9482015-03-17 16:24:32 -060083static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
Jon Ashburnd9564002015-05-07 10:27:37 -060084
Tobin Ehlis63bb9482015-03-17 16:24:32 -060085// TODO : This can be much smarter, using separate locks for separate global data
86static int globalLockInitialized = 0;
87static loader_platform_thread_mutex globalLock;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060088#define MAX_TID 513
89static loader_platform_thread_id g_tidMapping[MAX_TID] = {0};
90static uint32_t g_maxTID = 0;
Tobin Ehlisfde4dce2015-06-16 15:50:44 -060091
92template layer_data *get_my_data_ptr<layer_data>(
93 void *data_key,
94 std::unordered_map<void *, layer_data *> &data_map);
95
96debug_report_data *mdd(VkObject object)
97{
98 dispatch_key key = get_dispatch_key(object);
99 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
100#if DISPATCH_MAP_DEBUG
101 fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, my_data);
102#endif
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600103 return my_data->report_data;
104}
105
106debug_report_data *mid(VkInstance object)
107{
108 dispatch_key key = get_dispatch_key(object);
109 layer_data *my_data = get_my_data_ptr(get_dispatch_key(object), layer_data_map);
110#if DISPATCH_MAP_DEBUG
111 fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, my_data);
112#endif
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600113 return my_data->report_data;
114}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600115// Map actual TID to an index value and return that index
116// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs
117static uint32_t getTIDIndex() {
118 loader_platform_thread_id tid = loader_platform_get_thread_id();
119 for (uint32_t i = 0; i < g_maxTID; i++) {
120 if (tid == g_tidMapping[i])
121 return i;
122 }
123 // Don't yet have mapping, set it and return newly set index
124 uint32_t retVal = (uint32_t) g_maxTID;
125 g_tidMapping[g_maxTID++] = tid;
126 assert(g_maxTID < MAX_TID);
127 return retVal;
128}
129// Return a string representation of CMD_TYPE enum
130static string cmdTypeToString(CMD_TYPE cmd)
131{
132 switch (cmd)
133 {
134 case CMD_BINDPIPELINE:
135 return "CMD_BINDPIPELINE";
136 case CMD_BINDPIPELINEDELTA:
137 return "CMD_BINDPIPELINEDELTA";
138 case CMD_BINDDYNAMICSTATEOBJECT:
139 return "CMD_BINDDYNAMICSTATEOBJECT";
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600140 case CMD_BINDDESCRIPTORSETS:
141 return "CMD_BINDDESCRIPTORSETS";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600142 case CMD_BINDINDEXBUFFER:
143 return "CMD_BINDINDEXBUFFER";
144 case CMD_BINDVERTEXBUFFER:
145 return "CMD_BINDVERTEXBUFFER";
146 case CMD_DRAW:
147 return "CMD_DRAW";
148 case CMD_DRAWINDEXED:
149 return "CMD_DRAWINDEXED";
150 case CMD_DRAWINDIRECT:
151 return "CMD_DRAWINDIRECT";
152 case CMD_DRAWINDEXEDINDIRECT:
153 return "CMD_DRAWINDEXEDINDIRECT";
154 case CMD_DISPATCH:
155 return "CMD_DISPATCH";
156 case CMD_DISPATCHINDIRECT:
157 return "CMD_DISPATCHINDIRECT";
158 case CMD_COPYBUFFER:
159 return "CMD_COPYBUFFER";
160 case CMD_COPYIMAGE:
161 return "CMD_COPYIMAGE";
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600162 case CMD_BLITIMAGE:
163 return "CMD_BLITIMAGE";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600164 case CMD_COPYBUFFERTOIMAGE:
165 return "CMD_COPYBUFFERTOIMAGE";
166 case CMD_COPYIMAGETOBUFFER:
167 return "CMD_COPYIMAGETOBUFFER";
168 case CMD_CLONEIMAGEDATA:
169 return "CMD_CLONEIMAGEDATA";
170 case CMD_UPDATEBUFFER:
171 return "CMD_UPDATEBUFFER";
172 case CMD_FILLBUFFER:
173 return "CMD_FILLBUFFER";
174 case CMD_CLEARCOLORIMAGE:
175 return "CMD_CLEARCOLORIMAGE";
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600176 case CMD_CLEARCOLORATTACHMENT:
177 return "CMD_CLEARCOLORATTACHMENT";
178 case CMD_CLEARDEPTHSTENCILIMAGE:
179 return "CMD_CLEARDEPTHSTENCILIMAGE";
180 case CMD_CLEARDEPTHSTENCILATTACHMENT:
181 return "CMD_CLEARDEPTHSTENCILATTACHMENT";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600182 case CMD_RESOLVEIMAGE:
183 return "CMD_RESOLVEIMAGE";
184 case CMD_SETEVENT:
185 return "CMD_SETEVENT";
186 case CMD_RESETEVENT:
187 return "CMD_RESETEVENT";
188 case CMD_WAITEVENTS:
189 return "CMD_WAITEVENTS";
190 case CMD_PIPELINEBARRIER:
191 return "CMD_PIPELINEBARRIER";
192 case CMD_BEGINQUERY:
193 return "CMD_BEGINQUERY";
194 case CMD_ENDQUERY:
195 return "CMD_ENDQUERY";
196 case CMD_RESETQUERYPOOL:
197 return "CMD_RESETQUERYPOOL";
198 case CMD_WRITETIMESTAMP:
199 return "CMD_WRITETIMESTAMP";
200 case CMD_INITATOMICCOUNTERS:
201 return "CMD_INITATOMICCOUNTERS";
202 case CMD_LOADATOMICCOUNTERS:
203 return "CMD_LOADATOMICCOUNTERS";
204 case CMD_SAVEATOMICCOUNTERS:
205 return "CMD_SAVEATOMICCOUNTERS";
206 case CMD_BEGINRENDERPASS:
207 return "CMD_BEGINRENDERPASS";
208 case CMD_ENDRENDERPASS:
209 return "CMD_ENDRENDERPASS";
210 case CMD_DBGMARKERBEGIN:
211 return "CMD_DBGMARKERBEGIN";
212 case CMD_DBGMARKEREND:
213 return "CMD_DBGMARKEREND";
214 default:
215 return "UNKNOWN";
216 }
217}
218// Block of code at start here for managing/tracking Pipeline state that this layer cares about
219// Just track 2 shaders for now
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600220#define VK_NUM_GRAPHICS_SHADERS VK_SHADER_STAGE_COMPUTE
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600221#define MAX_SLOTS 2048
222#define NUM_COMMAND_BUFFERS_TO_DISPLAY 10
223
224static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0};
225
226// TODO : Should be tracking lastBound per cmdBuffer and when draws occur, report based on that cmd buffer lastBound
227// Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
228// to that same cmd buffer by separate thread are not changing state from underneath us
229// Track the last cmd buffer touched by this thread
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600230static VkCmdBuffer g_lastCmdBuffer[MAX_TID] = {NULL};
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600231// Track the last group of CBs touched for displaying to dot file
232static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
233static uint32_t g_lastTouchedCBIndex = 0;
234// Track the last global DrawState of interest touched by any thread
235static GLOBAL_CB_NODE* g_lastGlobalCB = NULL;
236static PIPELINE_NODE* g_lastBoundPipeline = NULL;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600237static DYNAMIC_STATE_NODE* g_lastBoundDynamicState[VK_NUM_STATE_BIND_POINT] = {NULL};
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600238static VkDescriptorSet g_lastBoundDescriptorSet = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600239#define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
240
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600241//static DYNAMIC_STATE_NODE* g_pDynamicStateHead[VK_NUM_STATE_BIND_POINT] = {0};
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600242
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600243static void insertDynamicState(const VkDynamicStateObject state, const GENERIC_HEADER* pCreateInfo, VkStateBindPoint bindPoint)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600244{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600245 VkDynamicVpStateCreateInfo* pVPCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600246 size_t scSize = 0;
247 size_t vpSize = 0;
248 loader_platform_thread_lock_mutex(&globalLock);
249 DYNAMIC_STATE_NODE* pStateNode = new DYNAMIC_STATE_NODE;
250 pStateNode->stateObj = state;
251 switch (pCreateInfo->sType) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600252 case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600253 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo));
254 pVPCI = (VkDynamicVpStateCreateInfo*)pCreateInfo;
Chris Forbes2951d7d2015-06-22 17:21:59 +1200255 pStateNode->create_info.vpci.pScissors = new VkRect2D[pStateNode->create_info.vpci.viewportAndScissorCount];
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600256 pStateNode->create_info.vpci.pViewports = new VkViewport[pStateNode->create_info.vpci.viewportAndScissorCount];
Chris Forbes2951d7d2015-06-22 17:21:59 +1200257 scSize = pVPCI->viewportAndScissorCount * sizeof(VkRect2D);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600258 vpSize = pVPCI->viewportAndScissorCount * sizeof(VkViewport);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600259 memcpy((void*)pStateNode->create_info.vpci.pScissors, pVPCI->pScissors, scSize);
260 memcpy((void*)pStateNode->create_info.vpci.pViewports, pVPCI->pViewports, vpSize);
261 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600262 case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600263 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600264 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600265 case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600266 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600267 break;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600268 case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600269 memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600270 break;
271 default:
272 assert(0);
273 break;
274 }
275 pStateNode->pCreateInfo = (GENERIC_HEADER*)&pStateNode->create_info.cbci;
276 dynamicStateMap[state] = pStateNode;
277 loader_platform_thread_unlock_mutex(&globalLock);
278}
279// Free all allocated nodes for Dynamic State objs
Tobin Ehliseaf28662015-04-08 10:58:37 -0600280static void deleteDynamicState()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600281{
David Pinedof5997ab2015-04-27 16:36:17 -0600282 if (dynamicStateMap.size() <= 0)
283 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600284 for (unordered_map<VkDynamicStateObject, DYNAMIC_STATE_NODE*>::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600285 if (VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600286 delete[] (*ii).second->create_info.vpci.pScissors;
287 delete[] (*ii).second->create_info.vpci.pViewports;
288 }
289 delete (*ii).second;
290 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600291 dynamicStateMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600292}
293// Free all sampler nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600294static void deleteSamplers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600295{
David Pinedof5997ab2015-04-27 16:36:17 -0600296 if (sampleMap.size() <= 0)
297 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600298 for (unordered_map<VkSampler, SAMPLER_NODE*>::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600299 delete (*ii).second;
300 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600301 sampleMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600302}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600303static VkImageViewCreateInfo* getImageViewCreateInfo(VkImageView view)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600304{
305 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600306 if (viewCreateInfoMap.find(view) == viewCreateInfoMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600307 loader_platform_thread_unlock_mutex(&globalLock);
308 return NULL;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600309 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600310 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600311 return &viewCreateInfoMap[view]->createInfo.ivci;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600312 }
313}
314// Free all image nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600315static void deleteImages()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600316{
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600317 if (viewCreateInfoMap.size() <= 0)
David Pinedof5997ab2015-04-27 16:36:17 -0600318 return;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600319 for (auto ii=viewCreateInfoMap.begin(); ii!=viewCreateInfoMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600320 delete (*ii).second;
321 }
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600322 viewCreateInfoMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600323}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600324static VkBufferViewCreateInfo* getBufferViewCreateInfo(VkBufferView view)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600325{
326 loader_platform_thread_lock_mutex(&globalLock);
327 if (bufferMap.find(view) == bufferMap.end()) {
328 loader_platform_thread_unlock_mutex(&globalLock);
329 return NULL;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600330 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600331 loader_platform_thread_unlock_mutex(&globalLock);
332 return &bufferMap[view]->createInfo;
333 }
334}
335// Free all buffer nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600336static void deleteBuffers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600337{
David Pinedof5997ab2015-04-27 16:36:17 -0600338 if (bufferMap.size() <= 0)
339 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600340 for (unordered_map<VkBufferView, BUFFER_NODE*>::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600341 delete (*ii).second;
342 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600343 bufferMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600344}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600345static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600346// Update global ptrs to reflect that specified cmdBuffer has been used
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600347static void updateCBTracking(VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600348{
349 g_lastCmdBuffer[getTIDIndex()] = cb;
350 GLOBAL_CB_NODE* pCB = getCBNode(cb);
351 loader_platform_thread_lock_mutex(&globalLock);
352 g_lastGlobalCB = pCB;
353 // TODO : This is a dumb algorithm. Need smart LRU that drops off oldest
354 for (uint32_t i = 0; i < NUM_COMMAND_BUFFERS_TO_DISPLAY; i++) {
355 if (g_pLastTouchedCB[i] == pCB) {
356 loader_platform_thread_unlock_mutex(&globalLock);
357 return;
358 }
359 }
360 g_pLastTouchedCB[g_lastTouchedCBIndex++] = pCB;
361 g_lastTouchedCBIndex = g_lastTouchedCBIndex % NUM_COMMAND_BUFFERS_TO_DISPLAY;
362 loader_platform_thread_unlock_mutex(&globalLock);
363}
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600364static bool32_t hasDrawCmd(GLOBAL_CB_NODE* pCB)
365{
366 for (uint32_t i=0; i<NUM_DRAW_TYPES; i++) {
367 if (pCB->drawCount[i])
368 return VK_TRUE;
369 }
370 return VK_FALSE;
371}
Tobin Ehlis97866202015-06-10 12:57:07 -0600372// Check object status for selected flag state
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600373static bool32_t validate_status(GLOBAL_CB_NODE* pNode, CBStatusFlags enable_mask, CBStatusFlags status_mask, CBStatusFlags status_flag, VkFlags msg_flags, DRAW_STATE_ERROR error_code, const char* fail_msg)
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600374{
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600375 // If non-zero enable mask is present, check it against status but if enable_mask
376 // is 0 then no enable required so we should always just check status
377 if ((!enable_mask) || (enable_mask & pNode->status)) {
378 if ((pNode->status & status_mask) != status_flag) {
379 log_msg(mdd(pNode->cmdBuffer), msg_flags, VK_OBJECT_TYPE_COMMAND_BUFFER, pNode->cmdBuffer, 0, error_code, "DS",
380 "CB object 0x%" PRIxLEAST64 ": %s", reinterpret_cast<VkUintPtrLeast64>(pNode->cmdBuffer), fail_msg);
381 return VK_FALSE;
Tobin Ehlis97866202015-06-10 12:57:07 -0600382 }
Tobin Ehlis97866202015-06-10 12:57:07 -0600383 }
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600384 return VK_TRUE;
Tobin Ehlis97866202015-06-10 12:57:07 -0600385}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600386// Print the last bound dynamic state
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600387static void printDynamicState(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600388{
389 GLOBAL_CB_NODE* pCB = getCBNode(cb);
390 if (pCB) {
391 loader_platform_thread_lock_mutex(&globalLock);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600392 for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600393 if (pCB->lastBoundDynamicState[i]) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600394 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, pCB->lastBoundDynamicState[i]->objType, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS",
395 "Reporting CreateInfo for currently bound %s object %p", string_VkStateBindPoint((VkStateBindPoint)i), pCB->lastBoundDynamicState[i]->stateObj);
396 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, pCB->lastBoundDynamicState[i]->objType, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS",
397 dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, " ").c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600398 break;
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600399 } else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600400 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
401 "No dynamic state of type %s bound", string_VkStateBindPoint((VkStateBindPoint)i));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600402 }
403 }
404 loader_platform_thread_unlock_mutex(&globalLock);
405 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600406}
407// Retrieve pipeline node ptr for given pipeline object
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600408static PIPELINE_NODE* getPipeline(VkPipeline pipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600409{
410 loader_platform_thread_lock_mutex(&globalLock);
411 if (pipelineMap.find(pipeline) == pipelineMap.end()) {
412 loader_platform_thread_unlock_mutex(&globalLock);
413 return NULL;
414 }
415 loader_platform_thread_unlock_mutex(&globalLock);
416 return pipelineMap[pipeline];
417}
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600418// Validate state stored as flags at time of draw call
419static bool32_t validate_draw_state_flags(GLOBAL_CB_NODE* pCB, bool32_t indexedDraw) {
420 bool32_t result;
421 result = validate_status(pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_BOUND, CBSTATUS_VIEWPORT_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer");
422 result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_BOUND, CBSTATUS_RASTER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_NOT_BOUND, "Raster object not bound to this command buffer");
423 result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_COLOR_BLEND_BOUND, CBSTATUS_COLOR_BLEND_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_COLOR_BLEND_NOT_BOUND, "Color-blend object not bound to this command buffer");
424 result &= validate_status(pCB, CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE, CBSTATUS_DEPTH_STENCIL_BOUND, CBSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");
425 if (indexedDraw)
426 result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_INDEX_BUFFER_BOUND, CBSTATUS_INDEX_BUFFER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_INDEX_BUFFER_NOT_BOUND, "Index buffer object not bound to this command buffer when Index Draw attempted");
427 return result;
428}
429// Validate overall state at the time of a draw call
430static bool32_t validate_draw_state(GLOBAL_CB_NODE* pCB, bool32_t indexedDraw) {
431 // First check flag states
432 bool32_t result = validate_draw_state_flags(pCB, indexedDraw);
433 PIPELINE_NODE* pPipe = getPipeline(pCB->lastBoundPipeline);
434 // Now complete other state checks
Tobin Ehlise4076782015-06-24 15:53:07 -0600435 if (pPipe && (pCB->lastBoundPipelineLayout != pPipe->graphicsPipelineCI.layout)) {
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600436 result = VK_FALSE;
437 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE_LAYOUT, pCB->lastBoundPipelineLayout, 0, DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, "DS",
438 "Pipeline layout from last vkCmdBindDescriptorSets() (%s) does not match PSO Pipeline layout (%s)", pCB->lastBoundPipelineLayout, pPipe->graphicsPipelineCI.layout);
439 }
Tobin Ehlis451efca2015-06-23 11:22:55 -0600440 if (!pCB->activeRenderPass) {
441 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
442 "Draw cmd issued without an active RenderPass. vkCmdDraw*() must only be called within a RenderPass.");
443 }
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600444 return result;
445}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600446// For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600447static VkSamplerCreateInfo* getSamplerCreateInfo(const VkSampler sampler)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600448{
449 loader_platform_thread_lock_mutex(&globalLock);
450 if (sampleMap.find(sampler) == sampleMap.end()) {
451 loader_platform_thread_unlock_mutex(&globalLock);
452 return NULL;
453 }
454 loader_platform_thread_unlock_mutex(&globalLock);
455 return &sampleMap[sampler]->createInfo;
456}
Tobin Ehlisde63c532015-06-18 15:59:33 -0600457// Verify that create state for a pipeline is valid
458static bool32_t verifyPipelineCreateState(const VkDevice device, const PIPELINE_NODE* pPipeline)
459{
460 // VS is required
461 if (!(pPipeline->active_shaders & VK_SHADER_STAGE_VERTEX_BIT)) {
462 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
463 "Invalid Pipeline CreateInfo State: Vtx Shader required");
464 return VK_FALSE;
465 }
466 // Either both or neither TC/TE shaders should be defined
467 if (((pPipeline->active_shaders & VK_SHADER_STAGE_TESS_CONTROL_BIT) == 0) !=
468 ((pPipeline->active_shaders & VK_SHADER_STAGE_TESS_EVALUATION_BIT) == 0) ) {
469 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
470 "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair");
471 return VK_FALSE;
472 }
473 // Compute shaders should be specified independent of Gfx shaders
474 if ((pPipeline->active_shaders & VK_SHADER_STAGE_COMPUTE_BIT) &&
475 (pPipeline->active_shaders & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESS_CONTROL_BIT |
476 VK_SHADER_STAGE_TESS_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT |
477 VK_SHADER_STAGE_FRAGMENT_BIT))) {
478 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
479 "Invalid Pipeline CreateInfo State: Do not specify Compute Shader for Gfx Pipeline");
480 return VK_FALSE;
481 }
482 // VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only valid for tessellation pipelines.
483 // Mismatching primitive topology and tessellation fails graphics pipeline creation.
484 if (pPipeline->active_shaders & (VK_SHADER_STAGE_TESS_CONTROL_BIT | VK_SHADER_STAGE_TESS_EVALUATION_BIT) &&
485 (pPipeline->iaStateCI.topology != VK_PRIMITIVE_TOPOLOGY_PATCH)) {
486 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
487 "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH must be set as IA topology for tessellation pipelines");
488 return VK_FALSE;
489 }
490 if ((pPipeline->iaStateCI.topology == VK_PRIMITIVE_TOPOLOGY_PATCH) &&
491 (~pPipeline->active_shaders & VK_SHADER_STAGE_TESS_CONTROL_BIT)) {
492 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
493 "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only valid for tessellation pipelines");
494 return VK_FALSE;
495 }
496 return VK_TRUE;
497}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600498// Init the pipeline mapping info based on pipeline create info LL tree
499// Threading note : Calls to this function should wrapped in mutex
Tobin Ehlisde63c532015-06-18 15:59:33 -0600500static PIPELINE_NODE* initPipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, PIPELINE_NODE* pBasePipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600501{
Tobin Ehlisde63c532015-06-18 15:59:33 -0600502 PIPELINE_NODE* pPipeline = new PIPELINE_NODE;
503 if (pBasePipeline) {
504 memcpy((void*)pPipeline, (void*)pBasePipeline, sizeof(PIPELINE_NODE));
Tobin Ehlise42007c2015-06-19 13:00:59 -0600505 } else {
Tobin Ehlisde63c532015-06-18 15:59:33 -0600506 memset((void*)pPipeline, 0, sizeof(PIPELINE_NODE));
507 }
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600508 // First init create info
Tobin Ehlis2464b882015-04-01 08:40:34 -0600509 // TODO : Validate that no create info is incorrectly replicated
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600510 memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo));
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600511
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600512 size_t bufferSize = 0;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600513 const VkPipelineVertexInputStateCreateInfo* pVICI = NULL;
514 const VkPipelineCbStateCreateInfo* pCBCI = NULL;
515
516 for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
517 const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
518
519 switch (pPSSCI->stage) {
520 case VK_SHADER_STAGE_VERTEX:
521 memcpy(&pPipeline->vsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
522 pPipeline->active_shaders |= VK_SHADER_STAGE_VERTEX_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600523 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600524 case VK_SHADER_STAGE_TESS_CONTROL:
525 memcpy(&pPipeline->tcsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
526 pPipeline->active_shaders |= VK_SHADER_STAGE_TESS_CONTROL_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600527 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600528 case VK_SHADER_STAGE_TESS_EVALUATION:
529 memcpy(&pPipeline->tesCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
530 pPipeline->active_shaders |= VK_SHADER_STAGE_TESS_EVALUATION_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600531 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600532 case VK_SHADER_STAGE_GEOMETRY:
533 memcpy(&pPipeline->gsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
534 pPipeline->active_shaders |= VK_SHADER_STAGE_GEOMETRY_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600535 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600536 case VK_SHADER_STAGE_FRAGMENT:
537 memcpy(&pPipeline->fsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
538 pPipeline->active_shaders |= VK_SHADER_STAGE_FRAGMENT_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600539 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600540 case VK_SHADER_STAGE_COMPUTE:
541 // TODO : Flag error, CS is specified through VkComputePipelineCreateInfo
542 pPipeline->active_shaders |= VK_SHADER_STAGE_COMPUTE_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600543 break;
544 default:
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600545 // TODO : Flag error
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600546 break;
547 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600548 }
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600549
550 if (pCreateInfo->pVertexInputState != NULL) {
551 memcpy((void*)&pPipeline->vertexInputCI, pCreateInfo->pVertexInputState , sizeof(VkPipelineVertexInputStateCreateInfo));
552 // Copy embedded ptrs
553 pVICI = pCreateInfo->pVertexInputState;
554 pPipeline->vtxBindingCount = pVICI->bindingCount;
555 if (pPipeline->vtxBindingCount) {
556 pPipeline->pVertexBindingDescriptions = new VkVertexInputBindingDescription[pPipeline->vtxBindingCount];
557 bufferSize = pPipeline->vtxBindingCount * sizeof(VkVertexInputBindingDescription);
558 memcpy((void*)pPipeline->pVertexBindingDescriptions, pVICI->pVertexBindingDescriptions, bufferSize);
559 }
560 pPipeline->vtxAttributeCount = pVICI->attributeCount;
561 if (pPipeline->vtxAttributeCount) {
562 pPipeline->pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[pPipeline->vtxAttributeCount];
563 bufferSize = pPipeline->vtxAttributeCount * sizeof(VkVertexInputAttributeDescription);
564 memcpy((void*)pPipeline->pVertexAttributeDescriptions, pVICI->pVertexAttributeDescriptions, bufferSize);
565 }
566 pPipeline->graphicsPipelineCI.pVertexInputState = &pPipeline->vertexInputCI;
567 }
568 if (pCreateInfo->pIaState != NULL) {
569 memcpy((void*)&pPipeline->iaStateCI, pCreateInfo->pIaState, sizeof(VkPipelineIaStateCreateInfo));
570 pPipeline->graphicsPipelineCI.pIaState = &pPipeline->iaStateCI;
571 }
572 if (pCreateInfo->pTessState != NULL) {
573 memcpy((void*)&pPipeline->tessStateCI, pCreateInfo->pTessState, sizeof(VkPipelineTessStateCreateInfo));
574 pPipeline->graphicsPipelineCI.pTessState = &pPipeline->tessStateCI;
575 }
576 if (pCreateInfo->pVpState != NULL) {
577 memcpy((void*)&pPipeline->vpStateCI, pCreateInfo->pVpState, sizeof(VkPipelineVpStateCreateInfo));
578 pPipeline->graphicsPipelineCI.pVpState = &pPipeline->vpStateCI;
579 }
580 if (pCreateInfo->pRsState != NULL) {
581 memcpy((void*)&pPipeline->rsStateCI, pCreateInfo->pRsState, sizeof(VkPipelineRsStateCreateInfo));
582 pPipeline->graphicsPipelineCI.pRsState = &pPipeline->rsStateCI;
583 }
584 if (pCreateInfo->pMsState != NULL) {
585 memcpy((void*)&pPipeline->msStateCI, pCreateInfo->pMsState, sizeof(VkPipelineMsStateCreateInfo));
586 pPipeline->graphicsPipelineCI.pMsState = &pPipeline->msStateCI;
587 }
588 if (pCreateInfo->pCbState != NULL) {
589 memcpy((void*)&pPipeline->cbStateCI, pCreateInfo->pCbState, sizeof(VkPipelineCbStateCreateInfo));
590 // Copy embedded ptrs
591 pCBCI = pCreateInfo->pCbState;
592 pPipeline->attachmentCount = pCBCI->attachmentCount;
593 if (pPipeline->attachmentCount) {
594 pPipeline->pAttachments = new VkPipelineCbAttachmentState[pPipeline->attachmentCount];
595 bufferSize = pPipeline->attachmentCount * sizeof(VkPipelineCbAttachmentState);
596 memcpy((void*)pPipeline->pAttachments, pCBCI->pAttachments, bufferSize);
597 }
598 pPipeline->graphicsPipelineCI.pCbState = &pPipeline->cbStateCI;
599 }
600 if (pCreateInfo->pDsState != NULL) {
601 memcpy((void*)&pPipeline->dsStateCI, pCreateInfo->pDsState, sizeof(VkPipelineDsStateCreateInfo));
602 pPipeline->graphicsPipelineCI.pDsState = &pPipeline->dsStateCI;
603 }
604
605 // Copy over GraphicsPipelineCreateInfo structure embedded pointers
606 if (pCreateInfo->stageCount != 0) {
607 pPipeline->graphicsPipelineCI.pStages = new VkPipelineShaderStageCreateInfo[pCreateInfo->stageCount];
608 bufferSize = pCreateInfo->stageCount * sizeof(VkPipelineShaderStageCreateInfo);
609 memcpy((void*)pPipeline->graphicsPipelineCI.pStages, pCreateInfo->pStages, bufferSize);
610 }
611
Tobin Ehlisde63c532015-06-18 15:59:33 -0600612 return pPipeline;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600613}
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600614
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600615// Free the Pipeline nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600616static void deletePipelines()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600617{
David Pinedof5997ab2015-04-27 16:36:17 -0600618 if (pipelineMap.size() <= 0)
619 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600620 for (unordered_map<VkPipeline, PIPELINE_NODE*>::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600621 if ((*ii).second->graphicsPipelineCI.stageCount != 0) {
622 delete[] (*ii).second->graphicsPipelineCI.pStages;
623 }
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600624 if ((*ii).second->pVertexBindingDescriptions) {
625 delete[] (*ii).second->pVertexBindingDescriptions;
626 }
627 if ((*ii).second->pVertexAttributeDescriptions) {
628 delete[] (*ii).second->pVertexAttributeDescriptions;
629 }
630 if ((*ii).second->pAttachments) {
631 delete[] (*ii).second->pAttachments;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600632 }
633 delete (*ii).second;
634 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600635 pipelineMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600636}
Tobin Ehlis2464b882015-04-01 08:40:34 -0600637// For given pipeline, return number of MSAA samples, or one if MSAA disabled
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600638static uint32_t getNumSamples(const VkPipeline pipeline)
Tobin Ehlis2464b882015-04-01 08:40:34 -0600639{
640 PIPELINE_NODE* pPipe = pipelineMap[pipeline];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600641 if (VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600642 if (pPipe->msStateCI.multisampleEnable)
Tony Barboure094edf2015-06-26 10:18:34 -0600643 return pPipe->msStateCI.rasterSamples;
Tobin Ehlis2464b882015-04-01 08:40:34 -0600644 }
645 return 1;
646}
647// Validate state related to the PSO
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600648static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VkPipelineBindPoint pipelineBindPoint, const VkPipeline pipeline)
Tobin Ehlis2464b882015-04-01 08:40:34 -0600649{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600650 if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
Tobin Ehlis2464b882015-04-01 08:40:34 -0600651 // Verify that any MSAA request in PSO matches sample# in bound FB
652 uint32_t psoNumSamples = getNumSamples(pipeline);
653 if (pCB->activeRenderPass) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600654 VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass];
655 VkFramebufferCreateInfo* pFBCI = frameBufferMap[pCB->framebuffer];
Tobin Ehlis63826ec2015-05-21 09:06:56 -0600656 if ((psoNumSamples != pFBCI->sampleCount) || (psoNumSamples != pRPCI->sampleCount)) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600657 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
658 "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);
Tobin Ehlis2464b882015-04-01 08:40:34 -0600659 }
660 } else {
661 // TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
662 // Verify and flag error as appropriate
663 }
664 // TODO : Add more checks here
665 } else {
666 // TODO : Validate non-gfx pipeline updates
667 }
668}
669
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600670// Block of code at start here specifically for managing/tracking DSs
671
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600672// Return Pool node ptr for specified pool or else NULL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600673static POOL_NODE* getPoolNode(VkDescriptorPool pool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600674{
675 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600676 if (poolMap.find(pool) == poolMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600677 loader_platform_thread_unlock_mutex(&globalLock);
678 return NULL;
679 }
680 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600681 return poolMap[pool];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600682}
683// Return Set node ptr for specified set or else NULL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600684static SET_NODE* getSetNode(VkDescriptorSet set)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600685{
686 loader_platform_thread_lock_mutex(&globalLock);
687 if (setMap.find(set) == setMap.end()) {
688 loader_platform_thread_unlock_mutex(&globalLock);
689 return NULL;
690 }
691 loader_platform_thread_unlock_mutex(&globalLock);
692 return setMap[set];
693}
694
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600695static LAYOUT_NODE* getLayoutNode(const VkDescriptorSetLayout layout) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600696 loader_platform_thread_lock_mutex(&globalLock);
697 if (layoutMap.find(layout) == layoutMap.end()) {
698 loader_platform_thread_unlock_mutex(&globalLock);
699 return NULL;
700 }
701 loader_platform_thread_unlock_mutex(&globalLock);
702 return layoutMap[layout];
703}
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600704// Return 1 if update struct is of valid type, 0 otherwise
Tobin Ehlisde63c532015-06-18 15:59:33 -0600705static bool32_t validUpdateStruct(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600706{
707 char str[1024];
708 switch (pUpdateStruct->sType)
709 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800710 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
711 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600712 return 1;
713 default:
Tobin Ehlisde63c532015-06-18 15:59:33 -0600714 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600715 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600716 return 0;
717 }
718}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600719// For given update struct, return binding
Tobin Ehlisde63c532015-06-18 15:59:33 -0600720static uint32_t getUpdateBinding(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600721{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600722 char str[1024];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600723 switch (pUpdateStruct->sType)
724 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800725 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
726 return ((VkWriteDescriptorSet*)pUpdateStruct)->destBinding;
727 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
728 return ((VkCopyDescriptorSet*)pUpdateStruct)->destBinding;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600729 default:
Tobin Ehlisde63c532015-06-18 15:59:33 -0600730 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600731 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600732 return 0xFFFFFFFF;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600733 }
734}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600735// Return count for given update struct
Tobin Ehlisde63c532015-06-18 15:59:33 -0600736static uint32_t getUpdateArrayIndex(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600737{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600738 char str[1024];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600739 switch (pUpdateStruct->sType)
740 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800741 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
742 return ((VkWriteDescriptorSet*)pUpdateStruct)->destArrayElement;
743 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600744 // TODO : Need to understand this case better and make sure code is correct
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800745 return ((VkCopyDescriptorSet*)pUpdateStruct)->destArrayElement;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600746 default:
Tobin Ehlisde63c532015-06-18 15:59:33 -0600747 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600748 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600749 return 0;
750 }
751}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600752// Return count for given update struct
Tobin Ehlisde63c532015-06-18 15:59:33 -0600753static uint32_t getUpdateCount(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600754{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600755 char str[1024];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600756 switch (pUpdateStruct->sType)
757 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800758 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
759 return ((VkWriteDescriptorSet*)pUpdateStruct)->count;
760 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600761 // TODO : Need to understand this case better and make sure code is correct
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800762 return ((VkCopyDescriptorSet*)pUpdateStruct)->count;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600763 default:
Tobin Ehlisde63c532015-06-18 15:59:33 -0600764 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600765 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600766 return 0;
767 }
768}
769// For given Layout Node and binding, return index where that binding begins
770static uint32_t getBindingStartIndex(const LAYOUT_NODE* pLayout, const uint32_t binding)
771{
772 uint32_t offsetIndex = 0;
773 for (uint32_t i = 0; i<binding; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +0800774 offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600775 }
776 return offsetIndex;
777}
778// For given layout node and binding, return last index that is updated
779static uint32_t getBindingEndIndex(const LAYOUT_NODE* pLayout, const uint32_t binding)
780{
781 uint32_t offsetIndex = 0;
782 for (uint32_t i = 0; i<=binding; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +0800783 offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600784 }
785 return offsetIndex-1;
786}
787// For given layout and update, return the first overall index of the layout that is update
Tobin Ehlisde63c532015-06-18 15:59:33 -0600788static uint32_t getUpdateStartIndex(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600789{
Tobin Ehlisde63c532015-06-18 15:59:33 -0600790 return (getBindingStartIndex(pLayout, getUpdateBinding(device, pUpdateStruct))+getUpdateArrayIndex(device, pUpdateStruct));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600791}
792// For given layout and update, return the last overall index of the layout that is update
Tobin Ehlisde63c532015-06-18 15:59:33 -0600793static uint32_t getUpdateEndIndex(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600794{
Tobin Ehlisde63c532015-06-18 15:59:33 -0600795 return (getBindingStartIndex(pLayout, getUpdateBinding(device, pUpdateStruct))+getUpdateArrayIndex(device, pUpdateStruct)+getUpdateCount(device, pUpdateStruct)-1);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600796}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600797// Verify that the descriptor type in the update struct matches what's expected by the layout
Tobin Ehlisde63c532015-06-18 15:59:33 -0600798static bool32_t validateUpdateType(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600799{
800 // First get actual type of update
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600801 VkDescriptorType actualType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600802 uint32_t i = 0;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600803 char str[1024];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600804 switch (pUpdateStruct->sType)
805 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800806 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
807 actualType = ((VkWriteDescriptorSet*)pUpdateStruct)->descriptorType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600808 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800809 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
810 /* no need to validate */
811 return 1;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600812 break;
813 default:
Tobin Ehlisde63c532015-06-18 15:59:33 -0600814 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, VK_NULL_HANDLE, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600815 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600816 return 0;
817 }
Tobin Ehlisde63c532015-06-18 15:59:33 -0600818 for (i = getUpdateStartIndex(device, pLayout, pUpdateStruct); i <= getUpdateEndIndex(device, pLayout, pUpdateStruct); i++) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600819 if (pLayout->pTypes[i] != actualType)
820 return 0;
821 }
822 return 1;
823}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600824// Determine the update type, allocate a new struct of that type, shadow the given pUpdate
825// struct into the new struct and return ptr to shadow struct cast as GENERIC_HEADER
826// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehlisde63c532015-06-18 15:59:33 -0600827static GENERIC_HEADER* shadowUpdateNode(const VkDevice device, GENERIC_HEADER* pUpdate)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600828{
829 GENERIC_HEADER* pNewNode = NULL;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800830 VkWriteDescriptorSet* pWDS = NULL;
831 VkCopyDescriptorSet* pCDS = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600832 size_t array_size = 0;
833 size_t base_array_size = 0;
834 size_t total_array_size = 0;
835 size_t baseBuffAddr = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600836 char str[1024];
837 switch (pUpdate->sType)
838 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800839 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
840 pWDS = new VkWriteDescriptorSet;
841 pNewNode = (GENERIC_HEADER*)pWDS;
842 memcpy(pWDS, pUpdate, sizeof(VkWriteDescriptorSet));
843 pWDS->pDescriptors = new VkDescriptorInfo[pWDS->count];
844 array_size = sizeof(VkDescriptorInfo) * pWDS->count;
845 memcpy((void*)pWDS->pDescriptors, ((VkWriteDescriptorSet*)pUpdate)->pDescriptors, array_size);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600846 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800847 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
848 pCDS = new VkCopyDescriptorSet;
849 pUpdate = (GENERIC_HEADER*)pCDS;
850 memcpy(pCDS, pUpdate, sizeof(VkCopyDescriptorSet));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600851 break;
852 default:
Tobin Ehlisde63c532015-06-18 15:59:33 -0600853 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600854 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdate->sType), pUpdate->sType);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600855 return NULL;
856 }
857 // Make sure that pNext for the end of shadow copy is NULL
858 pNewNode->pNext = NULL;
859 return pNewNode;
860}
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800861// update DS mappings based on ppUpdateArray
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600862static bool32_t dsUpdate(VkDevice device, VkStructureType type, uint32_t updateCount, const void* pUpdateArray)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600863{
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800864 const VkWriteDescriptorSet *pWDS = NULL;
865 const VkCopyDescriptorSet *pCDS = NULL;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600866 bool32_t result = 1;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800867
868 if (type == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET)
869 pWDS = (const VkWriteDescriptorSet *) pUpdateArray;
870 else
871 pCDS = (const VkCopyDescriptorSet *) pUpdateArray;
872
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600873 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600874 LAYOUT_NODE* pLayout = NULL;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600875 VkDescriptorSetLayoutCreateInfo* pLayoutCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600876 // TODO : If pCIList is NULL, flag error
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600877 // Perform all updates
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600878 for (uint32_t i = 0; i < updateCount; i++) {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800879 VkDescriptorSet ds = (pWDS) ? pWDS->destSet : pCDS->destSet;
880 SET_NODE* pSet = setMap[ds]; // getSetNode() without locking
881 g_lastBoundDescriptorSet = pSet->set;
882 GENERIC_HEADER* pUpdate = (pWDS) ? (GENERIC_HEADER*) &pWDS[i] : (GENERIC_HEADER*) &pCDS[i];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600883 pLayout = pSet->pLayout;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600884 // First verify valid update struct
Tobin Ehlisde63c532015-06-18 15:59:33 -0600885 if (!validUpdateStruct(device, pUpdate)) {
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600886 result = 0;
887 break;
888 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600889 // Make sure that binding is within bounds
Tobin Ehlisde63c532015-06-18 15:59:33 -0600890 if (pLayout->createInfo.count < getUpdateBinding(device, pUpdate)) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600891 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600892 "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(device, pUpdate), string_VkStructureType(pUpdate->sType));
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600893 result = 0;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600894 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600895 // Next verify that update falls within size of given binding
Tobin Ehlisde63c532015-06-18 15:59:33 -0600896 if (getBindingEndIndex(pLayout, getUpdateBinding(device, pUpdate)) < getUpdateEndIndex(device, pLayout, pUpdate)) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600897 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 -0600898 pLayoutCI = &pLayout->createInfo;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600899 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600900 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600901 "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), getUpdateBinding(device, pUpdate), DSstr.c_str());
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600902 result = 0;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600903 } else { // TODO : should we skip update on a type mismatch or force it?
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600904 // Layout bindings match w/ update ok, now verify that update is of the right type
Tobin Ehlisde63c532015-06-18 15:59:33 -0600905 if (!validateUpdateType(device, pLayout, pUpdate)) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600906 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS",
907 "Descriptor update type of %s does not match overlapping binding type!", string_VkStructureType(pUpdate->sType));
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600908 result = 0;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600909 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600910 // Save the update info
911 // TODO : Info message that update successful
912 // Create new update struct for this set's shadow copy
Tobin Ehlisde63c532015-06-18 15:59:33 -0600913 GENERIC_HEADER* pNewNode = shadowUpdateNode(device, pUpdate);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600914 if (NULL == pNewNode) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600915 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
916 "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600917 result = 0;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600918 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600919 // Insert shadow node into LL of updates for this set
920 pNewNode->pNext = pSet->pUpdateStructs;
921 pSet->pUpdateStructs = pNewNode;
922 // Now update appropriate descriptor(s) to point to new Update node
Tobin Ehlisde63c532015-06-18 15:59:33 -0600923 for (uint32_t j = getUpdateStartIndex(device, pLayout, pUpdate); j <= getUpdateEndIndex(device, pLayout, pUpdate); j++) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600924 assert(j<pSet->descriptorCount);
925 pSet->ppDescriptors[j] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600926 }
927 }
928 }
929 }
930 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600931 }
932 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600933 return result;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600934}
935// Free the shadowed update node for this Set
936// NOTE : Calls to this function should be wrapped in mutex
937static void freeShadowUpdateTree(SET_NODE* pSet)
938{
939 GENERIC_HEADER* pShadowUpdate = pSet->pUpdateStructs;
940 pSet->pUpdateStructs = NULL;
941 GENERIC_HEADER* pFreeUpdate = pShadowUpdate;
942 // Clear the descriptor mappings as they will now be invalid
943 memset(pSet->ppDescriptors, 0, pSet->descriptorCount*sizeof(GENERIC_HEADER*));
944 while(pShadowUpdate) {
945 pFreeUpdate = pShadowUpdate;
946 pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext;
947 uint32_t index = 0;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800948 VkWriteDescriptorSet * pWDS = NULL;
949 VkCopyDescriptorSet * pCDS = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600950 void** ppToFree = NULL;
951 switch (pFreeUpdate->sType)
952 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800953 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
954 pWDS = (VkWriteDescriptorSet*)pFreeUpdate;
955 if (pWDS->pDescriptors)
956 delete[] pWDS->pDescriptors;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600957 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800958 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600959 break;
960 default:
961 assert(0);
962 break;
963 }
Tobin Ehliseaf28662015-04-08 10:58:37 -0600964 delete pFreeUpdate;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600965 }
966}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600967// Free all DS Pools including their Sets & related sub-structs
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600968// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -0600969static void deletePools()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600970{
David Pinedof5997ab2015-04-27 16:36:17 -0600971 if (poolMap.size() <= 0)
972 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600973 for (unordered_map<VkDescriptorPool, POOL_NODE*>::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600974 SET_NODE* pSet = (*ii).second->pSets;
975 SET_NODE* pFreeSet = pSet;
976 while (pSet) {
977 pFreeSet = pSet;
978 pSet = pSet->pNext;
Tobin Ehliseaf28662015-04-08 10:58:37 -0600979 // Freeing layouts handled in deleteLayouts() function
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600980 // Free Update shadow struct tree
981 freeShadowUpdateTree(pFreeSet);
982 if (pFreeSet->ppDescriptors) {
Chris Forbes4506d3f2015-06-04 10:49:27 +1200983 delete[] pFreeSet->ppDescriptors;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600984 }
985 delete pFreeSet;
986 }
987 if ((*ii).second->createInfo.pTypeCount) {
Chris Forbes4506d3f2015-06-04 10:49:27 +1200988 delete[] (*ii).second->createInfo.pTypeCount;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600989 }
990 delete (*ii).second;
991 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600992 poolMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600993}
Tobin Ehliseaf28662015-04-08 10:58:37 -0600994// WARN : Once deleteLayouts() called, any layout ptrs in Pool/Set data structure will be invalid
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600995// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -0600996static void deleteLayouts()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600997{
David Pinedof5997ab2015-04-27 16:36:17 -0600998 if (layoutMap.size() <= 0)
999 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001000 for (unordered_map<VkDescriptorSetLayout, LAYOUT_NODE*>::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001001 LAYOUT_NODE* pLayout = (*ii).second;
Tobin Ehliseaf28662015-04-08 10:58:37 -06001002 if (pLayout->createInfo.pBinding) {
1003 for (uint32_t i=0; i<pLayout->createInfo.count; i++) {
1004 if (pLayout->createInfo.pBinding[i].pImmutableSamplers)
1005 delete[] pLayout->createInfo.pBinding[i].pImmutableSamplers;
1006 }
1007 delete[] pLayout->createInfo.pBinding;
1008 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001009 if (pLayout->pTypes) {
Chris Forbes4506d3f2015-06-04 10:49:27 +12001010 delete[] pLayout->pTypes;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001011 }
1012 delete pLayout;
1013 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -06001014 layoutMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001015}
1016// Currently clearing a set is removing all previous updates to that set
1017// TODO : Validate if this is correct clearing behavior
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001018static void clearDescriptorSet(VkDescriptorSet set)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001019{
1020 SET_NODE* pSet = getSetNode(set);
1021 if (!pSet) {
1022 // TODO : Return error
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001023 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001024 loader_platform_thread_lock_mutex(&globalLock);
1025 freeShadowUpdateTree(pSet);
1026 loader_platform_thread_unlock_mutex(&globalLock);
1027 }
1028}
1029
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001030static void clearDescriptorPool(VkDevice device, VkDescriptorPool pool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001031{
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001032 POOL_NODE* pPool = getPoolNode(pool);
1033 if (!pPool) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001034 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pool, 0, DRAWSTATE_INVALID_POOL, "DS",
1035 "Unable to find pool node for pool %p specified in vkResetDescriptorPool() call", (void*)pool);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001036 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001037 // For every set off of this pool, clear it
1038 SET_NODE* pSet = pPool->pSets;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001039 while (pSet) {
1040 clearDescriptorSet(pSet->set);
1041 }
1042 }
1043}
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001044// For given CB object, fetch associated CB Node from map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001045static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001046{
1047 loader_platform_thread_lock_mutex(&globalLock);
1048 if (cmdBufferMap.find(cb) == cmdBufferMap.end()) {
1049 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001050 log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
1051 "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cb);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001052 return NULL;
1053 }
1054 loader_platform_thread_unlock_mutex(&globalLock);
1055 return cmdBufferMap[cb];
1056}
1057// Free all CB Nodes
1058// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -06001059static void deleteCmdBuffers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001060{
David Pinedof5997ab2015-04-27 16:36:17 -06001061 if (cmdBufferMap.size() <= 0)
1062 return;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001063 for (unordered_map<VkCmdBuffer, GLOBAL_CB_NODE*>::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
Courtney Goeltzenleuchter09098a72015-04-27 15:04:43 -06001064 vector<CMD_NODE*> cmd_node_list = (*ii).second->pCmds;
1065 while (!cmd_node_list.empty()) {
1066 CMD_NODE* cmd_node = cmd_node_list.back();
1067 delete cmd_node;
1068 cmd_node_list.pop_back();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001069 }
1070 delete (*ii).second;
1071 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -06001072 cmdBufferMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001073}
Tobin Ehlise42007c2015-06-19 13:00:59 -06001074static void report_error_no_cb_begin(const VkCmdBuffer cb, const char* caller_name)
1075{
1076 log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, DRAWSTATE_NO_BEGIN_CMD_BUFFER, "DS",
1077 "You must call vkBeginCommandBuffer() before this call to %s", (void*)caller_name);
1078}
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001079static void addCmd(GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd)
1080{
1081 CMD_NODE* pCmd = new CMD_NODE;
1082 if (pCmd) {
1083 // init cmd node and append to end of cmd LL
1084 memset(pCmd, 0, sizeof(CMD_NODE));
1085 pCmd->cmdNumber = ++pCB->numCmds;
1086 pCmd->type = cmd;
1087 pCB->pCmds.push_back(pCmd);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001088 } else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001089 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1090 "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %p", (void*)pCB->cmdBuffer);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001091 }
1092}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001093static void resetCB(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001094{
1095 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1096 if (pCB) {
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001097 vector<CMD_NODE*> cmd_list = pCB->pCmds;
1098 while (!cmd_list.empty()) {
1099 delete cmd_list.back();
1100 cmd_list.pop_back();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001101 }
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001102 pCB->pCmds.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001103 // Reset CB state
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001104 VkFlags saveFlags = pCB->flags;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -07001105 uint32_t saveQueueNodeIndex = pCB->queueNodeIndex;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001106 memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
1107 pCB->cmdBuffer = cb;
1108 pCB->flags = saveFlags;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -07001109 pCB->queueNodeIndex = saveQueueNodeIndex;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001110 pCB->lastVtxBinding = MAX_BINDING;
1111 }
1112}
Tobin Ehlis97866202015-06-10 12:57:07 -06001113// Set PSO-related status bits for CB
1114static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe)
1115{
1116 for (uint32_t i = 0; i < pPipe->cbStateCI.attachmentCount; i++) {
1117 if (0 != pPipe->pAttachments[i].channelWriteMask) {
1118 pCB->status |= CBSTATUS_COLOR_BLEND_WRITE_ENABLE;
1119 }
1120 }
1121 if (pPipe->dsStateCI.depthWriteEnable) {
1122 pCB->status |= CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE;
1123 }
1124}
1125// Set dyn-state related status bits for an object node
1126static void set_cb_dyn_status(GLOBAL_CB_NODE* pNode, VkStateBindPoint stateBindPoint) {
1127 if (stateBindPoint == VK_STATE_BIND_POINT_VIEWPORT) {
1128 pNode->status |= CBSTATUS_VIEWPORT_BOUND;
1129 } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER) {
1130 pNode->status |= CBSTATUS_RASTER_BOUND;
1131 } else if (stateBindPoint == VK_STATE_BIND_POINT_COLOR_BLEND) {
1132 pNode->status |= CBSTATUS_COLOR_BLEND_BOUND;
1133 } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_STENCIL) {
1134 pNode->status |= CBSTATUS_DEPTH_STENCIL_BOUND;
1135 }
1136}
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001137// Print the last bound Gfx Pipeline
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001138static void printPipeline(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001139{
1140 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1141 if (pCB) {
1142 PIPELINE_NODE *pPipeTrav = getPipeline(pCB->lastBoundPipeline);
1143 if (!pPipeTrav) {
1144 // nothing to print
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001145 } else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001146 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1147 vk_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001148 }
1149 }
1150}
Jon Ashburne1390f22015-07-06 14:17:01 -06001151
Tobin Ehlise90b1712015-05-27 14:30:06 -06001152// Verify bound Pipeline State Object
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001153static bool validateBoundPipeline(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001154{
1155 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1156 if (pCB && pCB->lastBoundPipeline) {
1157 // First verify that we have a Node for bound pipeline
1158 PIPELINE_NODE *pPipeTrav = getPipeline(pCB->lastBoundPipeline);
1159 char str[1024];
1160 if (!pPipeTrav) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001161 log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_PIPELINE_BOUND, "DS",
1162 "Can't find last bound Pipeline %p!", (void*)pCB->lastBoundPipeline);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001163 return false;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001164 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001165 // Verify Vtx binding
1166 if (MAX_BINDING != pCB->lastVtxBinding) {
1167 if (pCB->lastVtxBinding >= pPipeTrav->vtxBindingCount) {
1168 if (0 == pPipeTrav->vtxBindingCount) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001169 log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS",
1170 "Vtx Buffer Index %u was bound, but no vtx buffers are attached to PSO.", pCB->lastVtxBinding);
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001171 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001172 }
1173 else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001174 log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS",
1175 "Vtx binding Index of %u exceeds PSO pVertexBindingDescriptions max array index of %u.", pCB->lastVtxBinding, (pPipeTrav->vtxBindingCount - 1));
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001176 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001177 }
1178 }
1179 else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001180 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1181 vk_print_vkvertexinputbindingdescription(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001182 }
1183 }
1184 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001185 return true;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001186 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001187 return false;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001188}
1189// Print details of DS config to stdout
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001190static void printDSConfig(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001191{
1192 char tmp_str[1024];
1193 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.
1194 GLOBAL_CB_NODE* pCB = getCBNode(cb);
Tobin Ehlis7297f192015-06-09 08:39:32 -06001195 if (pCB && pCB->lastBoundDescriptorSet) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001196 SET_NODE* pSet = getSetNode(pCB->lastBoundDescriptorSet);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001197 POOL_NODE* pPool = getPoolNode(pSet->pool);
1198 // Print out pool details
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001199 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1200 "Details for pool %p.", (void*)pPool->pool);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001201 string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " ");
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001202 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1203 "%s", poolStr.c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001204 // Print out set details
1205 char prefix[10];
1206 uint32_t index = 0;
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001207 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1208 "Details for descriptor set %p.", (void*)pSet->set);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001209 LAYOUT_NODE* pLayout = pSet->pLayout;
1210 // Print layout details
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001211 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1212 "Layout #%u, (object %p) for DS %p.", index+1, (void*)pLayout->layout, (void*)pSet->set);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001213 sprintf(prefix, " [L%u] ", index);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001214 string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str();
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001215 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1216 "%s", DSLstr.c_str());
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001217 index++;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001218 GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
1219 if (pUpdate) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001220 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1221 "Update Chain [UC] for descriptor set %p:", (void*)pSet->set);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001222 sprintf(prefix, " [UC] ");
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001223 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1224 dynamic_display(pUpdate, prefix).c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001225 // TODO : If there is a "view" associated with this update, print CI for that view
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001226 } else {
Tobin Ehlis2bca8b02015-06-15 08:41:17 -06001227 if (0 != pSet->descriptorCount) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001228 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1229 "No Update Chain for descriptor set %p which has %u descriptors (vkUpdateDescriptors has not been called)", (void*)pSet->set, pSet->descriptorCount);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001230 } else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001231 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1232 "FYI: No descriptors in descriptor set %p.", (void*)pSet->set);
Tobin Ehlis2bca8b02015-06-15 08:41:17 -06001233 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001234 }
1235 }
1236}
1237
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001238static void printCB(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001239{
1240 GLOBAL_CB_NODE* pCB = getCBNode(cb);
David Pinedof5997ab2015-04-27 16:36:17 -06001241 if (pCB && pCB->pCmds.size() > 0) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001242 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NONE, "DS",
1243 "Cmds in CB %p", (void*)cb);
Courtney Goeltzenleuchtercf2a5362015-04-27 11:16:35 -06001244 vector<CMD_NODE*> pCmds = pCB->pCmds;
1245 for (vector<CMD_NODE*>::iterator ii=pCmds.begin(); ii!=pCmds.end(); ++ii) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001246 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, DRAWSTATE_NONE, "DS",
1247 " CMD#%lu: %s", (*ii)->cmdNumber, cmdTypeToString((*ii)->type).c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001248 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001249 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001250 // Nothing to print
1251 }
1252}
1253
1254
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001255static void synchAndPrintDSConfig(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001256{
1257 printDSConfig(cb);
1258 printPipeline(cb);
1259 printDynamicState(cb);
Jon Ashburne1390f22015-07-06 14:17:01 -06001260
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001261}
1262
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001263static void init_draw_state(layer_data *my_data)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001264{
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001265 uint32_t report_flags = 0;
1266 uint32_t debug_action = 0;
1267 FILE *log_output = NULL;
1268 const char *option_str;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001269 // initialize DrawState options
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001270 report_flags = getLayerOptionFlags("DrawStateReportFlags", 0);
1271 getLayerOptionEnum("DrawStateDebugAction", (uint32_t *) &debug_action);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001272
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001273 if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001274 {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001275 option_str = getLayerOption("DrawStateLogFilename");
1276 if (option_str)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001277 {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001278 log_output = fopen(option_str, "w");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001279 }
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001280 if (log_output == NULL)
1281 log_output = stdout;
1282
1283 layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &my_data->logging_callback);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001284 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001285
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001286 if (!globalLockInitialized)
1287 {
1288 // TODO/TBD: Need to delete this mutex sometime. How??? One
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001289 // suggestion is to call this during vkCreateInstance(), and then we
1290 // can clean it up during vkDestroyInstance(). However, that requires
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001291 // that the layer have per-instance locks. We need to come back and
1292 // address this soon.
1293 loader_platform_thread_create_mutex(&globalLock);
1294 globalLockInitialized = 1;
1295 }
1296}
1297
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06001298VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
1299{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001300 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map,*pInstance);
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06001301 VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
1302
1303 if (result == VK_SUCCESS) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001304 layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
1305 my_data->report_data = debug_report_create_instance(
1306 pTable,
1307 *pInstance,
1308 pCreateInfo->extensionCount,
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001309 pCreateInfo->ppEnabledExtensionNames);
Courtney Goeltzenleuchterf4a2eba2015-06-08 14:58:39 -06001310
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001311 init_draw_state(my_data);
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06001312 }
1313 return result;
1314}
1315
Jon Ashburne0fa2282015-05-20 09:00:28 -06001316/* hook DestroyInstance to remove tableInstanceMap entry */
1317VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
1318{
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001319 dispatch_key key = get_dispatch_key(instance);
1320 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
1321 VkResult res = pTable->DestroyInstance(instance);
1322
1323 // Clean up logging callback, if any
1324 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
1325 if (my_data->logging_callback) {
1326 layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);
1327 }
1328
Courtney Goeltzenleuchter2d034fd2015-06-28 13:01:17 -06001329 layer_debug_report_destroy_instance(my_data->report_data);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001330 layer_data_map.erase(pTable);
1331
1332 draw_state_instance_table_map.erase(key);
Jon Ashburne0fa2282015-05-20 09:00:28 -06001333 return res;
1334}
1335
Jon Ashburnf0615e22015-05-25 14:11:37 -06001336static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
1337{
1338 uint32_t i, ext_idx;
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001339 VkLayerDispatchTable *pDisp = get_dispatch_table(draw_state_device_table_map, device);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06001340 deviceExtMap[pDisp].debug_marker_enabled = false;
Jon Ashburnf0615e22015-05-25 14:11:37 -06001341
1342 for (i = 0; i < pCreateInfo->extensionCount; i++) {
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001343 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], DEBUG_MARKER_EXTENSION_NAME) == 0) {
Jon Ashburn6f8cd632015-06-01 09:37:38 -06001344 /* Found a matching extension name, mark it enabled and init dispatch table*/
1345 initDebugMarkerTable(device);
1346 deviceExtMap[pDisp].debug_marker_enabled = true;
Jon Ashburnf0615e22015-05-25 14:11:37 -06001347 }
1348
1349 }
1350}
1351
Tony Barbour8205d902015-04-16 15:59:00 -06001352VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001353{
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -06001354 VkLayerDispatchTable *pDeviceTable = get_dispatch_table(draw_state_device_table_map, *pDevice);
1355 VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001356 if (result == VK_SUCCESS) {
1357 layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
1358 VkLayerDispatchTable *pTable = get_dispatch_table(draw_state_device_table_map, *pDevice);
1359 layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
1360 my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001361 createDeviceRegisterExtensions(pCreateInfo, *pDevice);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001362 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001363 return result;
1364}
1365
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001366VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001367{
1368 // Free all the memory
1369 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehliseaf28662015-04-08 10:58:37 -06001370 deletePipelines();
1371 deleteSamplers();
1372 deleteImages();
1373 deleteBuffers();
1374 deleteCmdBuffers();
1375 deleteDynamicState();
1376 deletePools();
1377 deleteLayouts();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001378 loader_platform_thread_unlock_mutex(&globalLock);
Jon Ashburne0fa2282015-05-20 09:00:28 -06001379
Jeremy Hayesea1fef52015-06-19 11:37:38 -06001380 dispatch_key key = get_dispatch_key(device);
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001381 VkLayerDispatchTable *pDisp = get_dispatch_table(draw_state_device_table_map, device);
1382 VkResult result = pDisp->DestroyDevice(device);
1383 deviceExtMap.erase(pDisp);
Jeremy Hayesea1fef52015-06-19 11:37:38 -06001384 draw_state_device_table_map.erase(key);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06001385 tableDebugMarkerMap.erase(pDisp);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001386 return result;
1387}
1388
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001389static const VkLayerProperties ds_global_layers[] = {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001390 {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001391 "DrawState",
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001392 VK_API_VERSION,
1393 VK_MAKE_VERSION(0, 1, 0),
1394 "Validation layer: DrawState",
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001395 }
Jon Ashburneb2728b2015-04-10 14:33:07 -06001396};
1397
Tony Barbour426b9052015-06-24 16:06:58 -06001398VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionProperties(
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001399 const char *pLayerName,
1400 uint32_t *pCount,
1401 VkExtensionProperties* pProperties)
Jon Ashburneb2728b2015-04-10 14:33:07 -06001402{
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001403 /* DrawState does not have any global extensions */
1404 return util_GetExtensionProperties(0, NULL, pCount, pProperties);
1405}
Jon Ashburneb2728b2015-04-10 14:33:07 -06001406
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001407VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalLayerProperties(
1408 uint32_t *pCount,
1409 VkLayerProperties* pProperties)
1410{
1411 return util_GetLayerProperties(ARRAY_SIZE(ds_global_layers),
1412 ds_global_layers,
1413 pCount, pProperties);
1414}
Jon Ashburneb2728b2015-04-10 14:33:07 -06001415
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001416static const VkExtensionProperties ds_device_extensions[] = {
1417 {
1418 DEBUG_MARKER_EXTENSION_NAME,
1419 VK_MAKE_VERSION(0, 1, 0),
1420 VK_API_VERSION
1421 }
1422};
1423
1424static const VkLayerProperties ds_device_layers[] = {
1425 {
1426 "DrawState",
1427 VK_API_VERSION,
1428 VK_MAKE_VERSION(0, 1, 0),
1429 "Validation layer: DrawState",
1430 }
1431};
1432
1433VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
1434 VkPhysicalDevice physicalDevice,
1435 const char* pLayerName,
1436 uint32_t* pCount,
1437 VkExtensionProperties* pProperties)
1438{
1439 /* Mem tracker does not have any physical device extensions */
1440 return util_GetExtensionProperties(ARRAY_SIZE(ds_device_extensions), ds_device_extensions,
1441 pCount, pProperties);
1442}
1443
1444VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLayerProperties(
1445 VkPhysicalDevice physicalDevice,
1446 uint32_t* pCount,
1447 VkLayerProperties* pProperties)
1448{
1449 /* Mem tracker's physical device layers are the same as global */
1450 return util_GetLayerProperties(ARRAY_SIZE(ds_device_layers), ds_device_layers,
1451 pCount, pProperties);
Jon Ashburneb2728b2015-04-10 14:33:07 -06001452}
1453
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001454VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001455{
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001456 GLOBAL_CB_NODE* pCB = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001457 for (uint32_t i=0; i < cmdBufferCount; i++) {
1458 // Validate that cmd buffers have been updated
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001459 pCB = getCBNode(pCmdBuffers[i]);
1460 loader_platform_thread_lock_mutex(&globalLock);
1461 if (CB_UPDATE_COMPLETE != pCB->state) {
1462 // Flag error for using CB w/o vkEndCommandBuffer() called
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001463 log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, pCB->cmdBuffer, 0, DRAWSTATE_NO_END_CMD_BUFFER, "DS",
1464 "You must call vkEndCommandBuffer() on CB %p before this call to vkQueueSubmit()!", pCB->cmdBuffer);
Tobin Ehlise90b1712015-05-27 14:30:06 -06001465 loader_platform_thread_unlock_mutex(&globalLock);
1466 return VK_ERROR_UNKNOWN;
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001467 }
Tobin Ehlise9b700e2015-05-26 16:06:50 -06001468 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001469 }
Jon Ashburne0fa2282015-05-20 09:00:28 -06001470
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001471 VkResult result = get_dispatch_table(draw_state_device_table_map, queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001472 return result;
1473}
1474
Mike Stroyan230e6252015-04-17 12:36:38 -06001475VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001476{
1477 // TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001478 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyObject(device, objType, object);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001479 return result;
1480}
1481
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001482VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001483{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001484 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001485 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001486 loader_platform_thread_lock_mutex(&globalLock);
1487 BUFFER_NODE* pNewNode = new BUFFER_NODE;
1488 pNewNode->buffer = *pView;
1489 pNewNode->createInfo = *pCreateInfo;
1490 bufferMap[*pView] = pNewNode;
1491 loader_platform_thread_unlock_mutex(&globalLock);
1492 }
1493 return result;
1494}
1495
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001496VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001497{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001498 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001499 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001500 loader_platform_thread_lock_mutex(&globalLock);
1501 IMAGE_NODE *pNewNode = new IMAGE_NODE;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06001502 pNewNode->createInfo.ivci = *pCreateInfo;
1503 viewCreateInfoMap[*pView] = pNewNode;
1504 loader_platform_thread_unlock_mutex(&globalLock);
1505 }
1506 return result;
1507}
1508
1509VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView)
1510{
1511 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateColorAttachmentView(device, pCreateInfo, pView);
1512 if (VK_SUCCESS == result) {
1513 loader_platform_thread_lock_mutex(&globalLock);
1514 IMAGE_NODE *pNewNode = new IMAGE_NODE;
1515 pNewNode->createInfo.cvci = *pCreateInfo;
1516 viewCreateInfoMap[*pView] = pNewNode;
1517 loader_platform_thread_unlock_mutex(&globalLock);
1518 }
1519 return result;
1520}
1521
1522VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView)
1523{
1524 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDepthStencilView(device, pCreateInfo, pView);
1525 if (VK_SUCCESS == result) {
1526 loader_platform_thread_lock_mutex(&globalLock);
1527 IMAGE_NODE *pNewNode = new IMAGE_NODE;
1528 pNewNode->createInfo.dsvci = *pCreateInfo;
1529 viewCreateInfoMap[*pView] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001530 loader_platform_thread_unlock_mutex(&globalLock);
1531 }
1532 return result;
1533}
1534
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001535VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001536{
Tobin Ehlisde63c532015-06-18 15:59:33 -06001537 VkResult result = VK_ERROR_BAD_PIPELINE_DATA;
1538 // The order of operations here is a little convoluted but gets the job done
1539 // 1. Pipeline create state is first shadowed into PIPELINE_NODE struct
1540 // 2. Create state is then validated (which uses flags setup during shadowing)
1541 // 3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap
1542 loader_platform_thread_lock_mutex(&globalLock);
1543 PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfo, NULL);
1544 bool32_t valid = verifyPipelineCreateState(device, pPipeNode);
1545 loader_platform_thread_unlock_mutex(&globalLock);
1546 if (VK_TRUE == valid) {
1547 result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
1548 log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PIPELINE, *pPipeline, 0, DRAWSTATE_NONE, "DS",
1549 "Created Gfx Pipeline %p", (void*)*pPipeline);
1550 loader_platform_thread_lock_mutex(&globalLock);
1551 pPipeNode->pipeline = *pPipeline;
1552 pipelineMap[pPipeNode->pipeline] = pPipeNode;
1553 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001554 } else {
Tobin Ehlisde63c532015-06-18 15:59:33 -06001555 if (pPipeNode) {
1556 // If we allocated a pipeNode, need to clean it up here
1557 delete[] pPipeNode->pVertexBindingDescriptions;
1558 delete[] pPipeNode->pVertexAttributeDescriptions;
1559 delete[] pPipeNode->pAttachments;
1560 delete pPipeNode;
1561 }
1562 }
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001563 return result;
1564}
1565
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001566VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(
1567 VkDevice device,
1568 const VkGraphicsPipelineCreateInfo* pCreateInfo,
1569 VkPipeline basePipeline,
1570 VkPipeline* pPipeline)
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001571{
Tobin Ehlisde63c532015-06-18 15:59:33 -06001572 VkResult result = VK_ERROR_BAD_PIPELINE_DATA;
1573 loader_platform_thread_lock_mutex(&globalLock);
1574 PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfo, NULL);
1575 bool32_t valid = verifyPipelineCreateState(device, pipelineMap[basePipeline]);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001576 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisde63c532015-06-18 15:59:33 -06001577 if (VK_TRUE == valid) {
1578 result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
1579 log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PIPELINE, *pPipeline, 0, DRAWSTATE_NONE, "DS",
1580 "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
1581 loader_platform_thread_lock_mutex(&globalLock);
1582 pPipeNode->pipeline = *pPipeline;
1583 pipelineMap[pPipeNode->pipeline] = pPipeNode;
1584 loader_platform_thread_unlock_mutex(&globalLock);
1585 }
1586 else { // Skipped pipeline creation due to bad CreateInfo data
1587 if (pPipeNode) {
1588 // If we allocated a pipeNode, need to clean it up here
1589 delete[] pPipeNode->pVertexBindingDescriptions;
1590 delete[] pPipeNode->pVertexAttributeDescriptions;
1591 delete[] pPipeNode->pAttachments;
1592 delete pPipeNode;
1593 }
1594 }
Jon Ashburnbdcd7562015-04-14 14:12:59 -06001595 return result;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001596}
1597
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001598VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001599{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001600 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001601 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001602 loader_platform_thread_lock_mutex(&globalLock);
1603 SAMPLER_NODE* pNewNode = new SAMPLER_NODE;
1604 pNewNode->sampler = *pSampler;
1605 pNewNode->createInfo = *pCreateInfo;
1606 sampleMap[*pSampler] = pNewNode;
1607 loader_platform_thread_unlock_mutex(&globalLock);
1608 }
1609 return result;
1610}
1611
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001612VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001613{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001614 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001615 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001616 LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
1617 if (NULL == pNewNode) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001618 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1619 "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001620 }
1621 memset(pNewNode, 0, sizeof(LAYOUT_NODE));
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001622 memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo));
1623 pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->count];
1624 memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->count);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001625 uint32_t totalCount = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001626 for (uint32_t i=0; i<pCreateInfo->count; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +08001627 totalCount += pCreateInfo->pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001628 if (pCreateInfo->pBinding[i].pImmutableSamplers) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001629 VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers;
Chia-I Wud3114a22015-05-25 16:22:52 +08001630 *ppIS = new VkSampler[pCreateInfo->pBinding[i].arraySize];
1631 memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].arraySize*sizeof(VkSampler));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001632 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001633 }
1634 if (totalCount > 0) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001635 pNewNode->pTypes = new VkDescriptorType[totalCount];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001636 uint32_t offset = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001637 uint32_t j = 0;
1638 for (uint32_t i=0; i<pCreateInfo->count; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +08001639 for (j = 0; j < pCreateInfo->pBinding[i].arraySize; j++) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001640 pNewNode->pTypes[offset + j] = pCreateInfo->pBinding[i].descriptorType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001641 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001642 offset += j;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001643 }
1644 }
1645 pNewNode->layout = *pSetLayout;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001646 pNewNode->startIndex = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001647 pNewNode->endIndex = pNewNode->startIndex + totalCount - 1;
1648 assert(pNewNode->endIndex >= pNewNode->startIndex);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001649 // Put new node at Head of global Layer list
1650 loader_platform_thread_lock_mutex(&globalLock);
1651 layoutMap[*pSetLayout] = pNewNode;
1652 loader_platform_thread_unlock_mutex(&globalLock);
1653 }
1654 return result;
1655}
1656
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001657VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001658{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001659 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001660 if (VK_SUCCESS == result) {
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001661 // TODO : Need to capture the pipeline layout
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001662 }
1663 return result;
1664}
1665
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001666VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001667{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001668 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001669 if (VK_SUCCESS == result) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001670 // Insert this pool into Global Pool LL at head
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001671 log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (VkObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1672 "Created Descriptor Pool %p", (void*)*pDescriptorPool);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001673 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001674 POOL_NODE* pNewNode = new POOL_NODE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001675 if (NULL == pNewNode) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001676 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (VkObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1677 "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()");
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001678 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001679 memset(pNewNode, 0, sizeof(POOL_NODE));
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001680 VkDescriptorPoolCreateInfo* pCI = (VkDescriptorPoolCreateInfo*)&pNewNode->createInfo;
1681 memcpy((void*)pCI, pCreateInfo, sizeof(VkDescriptorPoolCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001682 if (pNewNode->createInfo.count) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001683 size_t typeCountSize = pNewNode->createInfo.count * sizeof(VkDescriptorTypeCount);
1684 pNewNode->createInfo.pTypeCount = new VkDescriptorTypeCount[typeCountSize];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001685 memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize);
1686 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001687 pNewNode->poolUsage = poolUsage;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001688 pNewNode->maxSets = maxSets;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001689 pNewNode->pool = *pDescriptorPool;
1690 poolMap[*pDescriptorPool] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001691 }
1692 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001693 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001694 // Need to do anything if pool create fails?
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001695 }
1696 return result;
1697}
1698
Mike Stroyan230e6252015-04-17 12:36:38 -06001699VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001700{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001701 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->ResetDescriptorPool(device, descriptorPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001702 if (VK_SUCCESS == result) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001703 clearDescriptorPool(device, descriptorPool);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001704 }
1705 return result;
1706}
1707
Mike Stroyan230e6252015-04-17 12:36:38 -06001708VK_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 -06001709{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001710 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001711 if ((VK_SUCCESS == result) || (*pCount > 0)) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001712 POOL_NODE *pPoolNode = getPoolNode(descriptorPool);
1713 if (!pPoolNode) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001714 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
1715 "Unable to find pool node for pool %p specified in vkAllocDescriptorSets() call", (void*)descriptorPool);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001716 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001717 for (uint32_t i = 0; i < *pCount; i++) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001718 log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
1719 "Created Descriptor Set %p", (void*)pDescriptorSets[i]);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001720 // Create new set node and add to head of pool nodes
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001721 SET_NODE* pNewNode = new SET_NODE;
1722 if (NULL == pNewNode) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001723 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1724 "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()");
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001725 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001726 memset(pNewNode, 0, sizeof(SET_NODE));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001727 // Insert set at head of Set LL for this pool
1728 pNewNode->pNext = pPoolNode->pSets;
1729 pPoolNode->pSets = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001730 LAYOUT_NODE* pLayout = getLayoutNode(pSetLayouts[i]);
1731 if (NULL == pLayout) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001732 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
1733 "Unable to find set layout node for layout %p specified in vkAllocDescriptorSets() call", (void*)pSetLayouts[i]);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001734 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001735 pNewNode->pLayout = pLayout;
1736 pNewNode->pool = descriptorPool;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001737 pNewNode->set = pDescriptorSets[i];
1738 pNewNode->setUsage = setUsage;
1739 pNewNode->descriptorCount = pLayout->endIndex + 1;
1740 if (pNewNode->descriptorCount) {
1741 size_t descriptorArraySize = sizeof(GENERIC_HEADER*)*pNewNode->descriptorCount;
1742 pNewNode->ppDescriptors = new GENERIC_HEADER*[descriptorArraySize];
1743 memset(pNewNode->ppDescriptors, 0, descriptorArraySize);
1744 }
1745 setMap[pDescriptorSets[i]] = pNewNode;
1746 }
1747 }
1748 }
1749 }
1750 return result;
1751}
1752
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001753VK_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 -06001754{
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001755 if (dsUpdate(device, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, writeCount, pDescriptorWrites) &&
1756 dsUpdate(device, VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, copyCount, pDescriptorCopies)) {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001757 return get_dispatch_table(draw_state_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
Jon Ashburne0fa2282015-05-20 09:00:28 -06001758 }
1759 return VK_ERROR_UNKNOWN;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001760}
1761
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001762VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001763{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001764 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicViewportState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001765 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_VIEWPORT);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001766 return result;
1767}
1768
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001769VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001770{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001771 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001772 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001773 return result;
1774}
1775
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001776VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001777{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001778 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001779 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_COLOR_BLEND);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001780 return result;
1781}
1782
Courtney Goeltzenleuchterfcf855f2015-04-10 16:24:50 -06001783VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001784{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001785 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
Tony Barbour8205d902015-04-16 15:59:00 -06001786 insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_STENCIL);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001787 return result;
1788}
1789
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001790VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001791{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001792 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001793 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001794 loader_platform_thread_lock_mutex(&globalLock);
1795 GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
1796 memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
1797 pCB->cmdBuffer = *pCmdBuffer;
1798 pCB->flags = pCreateInfo->flags;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -07001799 pCB->queueNodeIndex = pCreateInfo->queueNodeIndex;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001800 pCB->lastVtxBinding = MAX_BINDING;
1801 cmdBufferMap[*pCmdBuffer] = pCB;
1802 loader_platform_thread_unlock_mutex(&globalLock);
1803 updateCBTracking(*pCmdBuffer);
1804 }
1805 return result;
1806}
1807
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001808VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001809{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001810 VkResult result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001811 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001812 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1813 if (pCB) {
1814 if (CB_NEW != pCB->state)
1815 resetCB(cmdBuffer);
1816 pCB->state = CB_UPDATE_ACTIVE;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001817 } else {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001818 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
1819 "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001820 }
1821 updateCBTracking(cmdBuffer);
1822 }
1823 return result;
1824}
1825
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001826VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001827{
Tobin Ehlise42007c2015-06-19 13:00:59 -06001828 VkResult result = VK_ERROR_BUILDING_COMMAND_BUFFER;
1829 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1830 if (pCB) {
1831 if (pCB->state == CB_UPDATE_ACTIVE) {
1832 result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
1833 if (VK_SUCCESS == result) {
1834 updateCBTracking(cmdBuffer);
1835 pCB->state = CB_UPDATE_COMPLETE;
1836 // Reset CB status flags
1837 pCB->status = 0;
1838 printCB(cmdBuffer);
1839 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001840 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001841 report_error_no_cb_begin(cmdBuffer, "vkEndCommandBuffer()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001842 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001843 }
1844 return result;
1845}
1846
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001847VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001848{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001849 VkResult result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001850 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001851 resetCB(cmdBuffer);
1852 updateCBTracking(cmdBuffer);
1853 }
1854 return result;
1855}
1856
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001857VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001858{
1859 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1860 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001861 if (pCB->state == CB_UPDATE_ACTIVE) {
1862 updateCBTracking(cmdBuffer);
1863 addCmd(pCB, CMD_BINDPIPELINE);
Tobin Ehlis642d5a52015-06-23 08:46:18 -06001864 if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
1865 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
1866 "Incorrectly binding compute pipeline (%p) during active RenderPass (%p)", (void*)pipeline, (void*)pCB->activeRenderPass);
Tobin Ehlise4076782015-06-24 15:53:07 -06001867 } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
1868 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
1869 "Incorrectly binding graphics pipeline (%p) without an active RenderPass", (void*)pipeline);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001870 } else {
Tobin Ehlise4076782015-06-24 15:53:07 -06001871 PIPELINE_NODE* pPN = getPipeline(pipeline);
1872 if (pPN) {
1873 pCB->lastBoundPipeline = pipeline;
1874 loader_platform_thread_lock_mutex(&globalLock);
1875 set_cb_pso_status(pCB, pPN);
1876 g_lastBoundPipeline = pPN;
1877 loader_platform_thread_unlock_mutex(&globalLock);
1878 validatePipelineState(pCB, pipelineBindPoint, pipeline);
1879 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
1880 } else {
1881 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS",
1882 "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
1883 }
Tobin Ehlise42007c2015-06-19 13:00:59 -06001884 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001885 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001886 report_error_no_cb_begin(cmdBuffer, "vkCmdBindPipeline()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001887 }
1888 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001889}
1890
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001891VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001892{
Tobin Ehlise42007c2015-06-19 13:00:59 -06001893 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1894 if (pCB) {
1895 if (pCB->state == CB_UPDATE_ACTIVE) {
1896 updateCBTracking(cmdBuffer);
Tobin Ehlise4076782015-06-24 15:53:07 -06001897 addCmd(pCB, CMD_BINDDYNAMICSTATEOBJECT);
1898 if (!pCB->activeRenderPass) {
1899 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
1900 "Incorrect call to vkCmdBindDynamicStateObject() without an active RenderPass.");
1901 }
Tobin Ehlise42007c2015-06-19 13:00:59 -06001902 loader_platform_thread_lock_mutex(&globalLock);
1903 set_cb_dyn_status(pCB, stateBindPoint);
Tobin Ehlise42007c2015-06-19 13:00:59 -06001904 if (dynamicStateMap.find(state) == dynamicStateMap.end()) {
Tobin Ehlis01630b82015-06-23 10:52:08 -06001905 VkObjectType stateType;
1906 switch (stateBindPoint) {
1907 case VK_STATE_BIND_POINT_VIEWPORT:
1908 stateType = VK_OBJECT_TYPE_DYNAMIC_VP_STATE;
1909 break;
1910 case VK_STATE_BIND_POINT_RASTER:
1911 stateType = VK_OBJECT_TYPE_DYNAMIC_RS_STATE;
1912 break;
1913 case VK_STATE_BIND_POINT_COLOR_BLEND:
1914 stateType = VK_OBJECT_TYPE_DYNAMIC_CB_STATE;
1915 break;
1916 case VK_STATE_BIND_POINT_DEPTH_STENCIL:
1917 stateType = VK_OBJECT_TYPE_DYNAMIC_DS_STATE;
1918 break;
1919 default:
1920 stateType = (VkObjectType) 0;
1921 }
1922 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, stateType, state, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
Tobin Ehlise42007c2015-06-19 13:00:59 -06001923 "Unable to find dynamic state object %p, was it ever created?", (void*)state);
1924 } else {
1925 pCB->lastBoundDynamicState[stateBindPoint] = dynamicStateMap[state];
1926 g_lastBoundDynamicState[stateBindPoint] = dynamicStateMap[state];
1927 }
1928 loader_platform_thread_unlock_mutex(&globalLock);
1929 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
1930 } else {
1931 report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicStateObject()");
1932 }
1933 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001934}
1935
Mark Lobodzinskia65c4632015-06-15 13:21:21 -06001936VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001937{
1938 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1939 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001940 if (pCB->state == CB_UPDATE_ACTIVE) {
1941 updateCBTracking(cmdBuffer);
1942 addCmd(pCB, CMD_BINDDESCRIPTORSETS);
Tobin Ehlise4076782015-06-24 15:53:07 -06001943 if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
1944 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
1945 "Incorrectly binding compute DescriptorSets during active RenderPass (%p)", (void*)pCB->activeRenderPass);
1946 } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
1947 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
1948 "Incorrectly binding graphics DescriptorSets without an active RenderPass");
1949 } else if (validateBoundPipeline(cmdBuffer)) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001950 for (uint32_t i=0; i<setCount; i++) {
Tobin Ehlis55c1c602015-06-24 17:27:33 -06001951 SET_NODE* pSet = getSetNode(pDescriptorSets[i]);
1952 if (pSet) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001953 loader_platform_thread_lock_mutex(&globalLock);
1954 pCB->lastBoundDescriptorSet = pDescriptorSets[i];
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -06001955 pCB->lastBoundPipelineLayout = layout;
Tobin Ehlise42007c2015-06-19 13:00:59 -06001956 pCB->boundDescriptorSets.push_back(pDescriptorSets[i]);
1957 g_lastBoundDescriptorSet = pDescriptorSets[i];
1958 loader_platform_thread_unlock_mutex(&globalLock);
1959 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
1960 "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint));
Tobin Ehlis55c1c602015-06-24 17:27:33 -06001961 if (!pSet->pUpdateStructs)
1962 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i], 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS",
1963 "DS %p bound but it was never updated. You may want to either update it or not bind it.", (void*)pDescriptorSets[i]);
Tobin Ehlise42007c2015-06-19 13:00:59 -06001964 } else {
1965 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS",
1966 "Attempt to bind DS %p that doesn't exist!", (void*)pDescriptorSets[i]);
1967 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06001968 }
Tobin Ehlis9bde5922015-06-22 18:00:14 -06001969 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001970 }
Tobin Ehlise42007c2015-06-19 13:00:59 -06001971 } else {
1972 report_error_no_cb_begin(cmdBuffer, "vkCmdBindDescriptorSets()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001973 }
1974 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001975}
1976
Tony Barbour8205d902015-04-16 15:59:00 -06001977VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001978{
1979 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1980 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001981 if (pCB->state == CB_UPDATE_ACTIVE) {
1982 updateCBTracking(cmdBuffer);
1983 addCmd(pCB, CMD_BINDINDEXBUFFER);
Tobin Ehlise4076782015-06-24 15:53:07 -06001984 if (!pCB->activeRenderPass) {
1985 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
1986 "Incorrect call to vkCmdBindIndexBuffer() without an active RenderPass.");
1987 } else {
1988 // TODO : Can be more exact in tracking/validating details for Idx buffer, for now just make sure *something* was bound
1989 pCB->status |= CBSTATUS_INDEX_BUFFER_BOUND;
1990 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
1991 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001992 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06001993 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
1994 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001995 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001996}
1997
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06001998VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
1999 VkCmdBuffer cmdBuffer,
2000 uint32_t startBinding,
2001 uint32_t bindingCount,
2002 const VkBuffer* pBuffers,
Tony Barbour8205d902015-04-16 15:59:00 -06002003 const VkDeviceSize* pOffsets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002004{
2005 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2006 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002007 if (pCB->state == CB_UPDATE_ACTIVE) {
2008 /* TODO: Need to track all the vertex buffers, not just last one */
2009 updateCBTracking(cmdBuffer);
2010 addCmd(pCB, CMD_BINDVERTEXBUFFER);
Tobin Ehlise4076782015-06-24 15:53:07 -06002011 if (!pCB->activeRenderPass) {
2012 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
2013 "Incorrect call to vkCmdBindVertexBuffers() without an active RenderPass.");
2014 } else {
2015 pCB->lastVtxBinding = startBinding + bindingCount -1;
2016 if (validateBoundPipeline(cmdBuffer)) {
2017 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
2018 }
Tobin Ehlise42007c2015-06-19 13:00:59 -06002019 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002020 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002021 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002022 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002023 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002024}
2025
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002026VK_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 -06002027{
2028 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002029 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002030 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002031 if (pCB->state == CB_UPDATE_ACTIVE) {
2032 updateCBTracking(cmdBuffer);
2033 addCmd(pCB, CMD_DRAW);
2034 pCB->drawCount[DRAW]++;
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -06002035 valid = validate_draw_state(pCB, VK_FALSE);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002036 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_NONE, "DS",
2037 "vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
2038 synchAndPrintDSConfig(cmdBuffer);
2039 if (valid) {
2040 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
2041 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002042 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002043 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2044 }
Jon Ashburne0fa2282015-05-20 09:00:28 -06002045 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002046}
2047
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002048VK_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 -06002049{
2050 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002051 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002052 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002053 if (pCB->state == CB_UPDATE_ACTIVE) {
2054 updateCBTracking(cmdBuffer);
2055 addCmd(pCB, CMD_DRAWINDEXED);
2056 pCB->drawCount[DRAW_INDEXED]++;
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -06002057 valid = validate_draw_state(pCB, VK_TRUE);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002058 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_NONE, "DS",
2059 "vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
2060 synchAndPrintDSConfig(cmdBuffer);
2061 if (valid) {
2062 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
2063 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002064 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002065 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2066 }
Jon Ashburne0fa2282015-05-20 09:00:28 -06002067 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002068}
2069
Tony Barbour8205d902015-04-16 15:59:00 -06002070VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002071{
2072 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002073 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002074 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002075 if (pCB->state == CB_UPDATE_ACTIVE) {
2076 updateCBTracking(cmdBuffer);
2077 addCmd(pCB, CMD_DRAWINDIRECT);
2078 pCB->drawCount[DRAW_INDIRECT]++;
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -06002079 valid = validate_draw_state(pCB, VK_FALSE);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002080 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_NONE, "DS",
2081 "vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
2082 synchAndPrintDSConfig(cmdBuffer);
2083 if (valid) {
2084 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
2085 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002086 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002087 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2088 }
Jon Ashburne0fa2282015-05-20 09:00:28 -06002089 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002090}
2091
Tony Barbour8205d902015-04-16 15:59:00 -06002092VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002093{
2094 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis97866202015-06-10 12:57:07 -06002095 bool32_t valid = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002096 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002097 if (pCB->state == CB_UPDATE_ACTIVE) {
2098 updateCBTracking(cmdBuffer);
2099 addCmd(pCB, CMD_DRAWINDEXEDINDIRECT);
2100 pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -06002101 valid = validate_draw_state(pCB, VK_TRUE);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002102 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_NONE, "DS",
2103 "vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
2104 synchAndPrintDSConfig(cmdBuffer);
2105 if (valid) {
2106 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
2107 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002108 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002109 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2110 }
Jon Ashburne0fa2282015-05-20 09:00:28 -06002111 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002112}
2113
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002114VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002115{
2116 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2117 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002118 if (pCB->state == CB_UPDATE_ACTIVE) {
2119 updateCBTracking(cmdBuffer);
2120 addCmd(pCB, CMD_DISPATCH);
2121 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002122 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002123 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2124 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002125 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002126}
2127
Tony Barbour8205d902015-04-16 15:59:00 -06002128VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002129{
2130 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2131 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002132 if (pCB->state == CB_UPDATE_ACTIVE) {
2133 updateCBTracking(cmdBuffer);
2134 addCmd(pCB, CMD_DISPATCHINDIRECT);
2135 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002136 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002137 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2138 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002139 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002140}
2141
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002142VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002143{
2144 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2145 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002146 if (pCB->state == CB_UPDATE_ACTIVE) {
2147 updateCBTracking(cmdBuffer);
2148 addCmd(pCB, CMD_COPYBUFFER);
2149 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002150 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002151 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2152 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002153 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002154}
2155
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002156VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
2157 VkImage srcImage,
2158 VkImageLayout srcImageLayout,
2159 VkImage destImage,
2160 VkImageLayout destImageLayout,
2161 uint32_t regionCount, const VkImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002162{
2163 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2164 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002165 if (pCB->state == CB_UPDATE_ACTIVE) {
2166 updateCBTracking(cmdBuffer);
2167 addCmd(pCB, CMD_COPYIMAGE);
2168 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002169 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002170 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2171 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002172 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002173}
2174
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002175VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
2176 VkImage srcImage, VkImageLayout srcImageLayout,
2177 VkImage destImage, VkImageLayout destImageLayout,
Mark Lobodzinski20f68592015-05-22 14:43:25 -05002178 uint32_t regionCount, const VkImageBlit* pRegions,
2179 VkTexFilter filter)
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002180{
2181 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2182 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002183 if (pCB->state == CB_UPDATE_ACTIVE) {
2184 updateCBTracking(cmdBuffer);
2185 addCmd(pCB, CMD_BLITIMAGE);
Tobin Ehlis054bd872015-06-23 10:41:13 -06002186 if (pCB->activeRenderPass) {
2187 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
2188 "Incorrectly issuing CmdBlitImage during active RenderPass (%p)", (void*)pCB->activeRenderPass);
2189 }
Tobin Ehlise4076782015-06-24 15:53:07 -06002190 else
2191 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002192 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002193 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2194 }
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002195 }
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002196}
2197
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002198VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
2199 VkBuffer srcBuffer,
2200 VkImage destImage, VkImageLayout destImageLayout,
2201 uint32_t regionCount, const VkBufferImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002202{
2203 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2204 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002205 if (pCB->state == CB_UPDATE_ACTIVE) {
2206 updateCBTracking(cmdBuffer);
2207 addCmd(pCB, CMD_COPYBUFFERTOIMAGE);
2208 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002209 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002210 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2211 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002212 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002213}
2214
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002215VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
2216 VkImage srcImage, VkImageLayout srcImageLayout,
2217 VkBuffer destBuffer,
2218 uint32_t regionCount, const VkBufferImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002219{
2220 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2221 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002222 if (pCB->state == CB_UPDATE_ACTIVE) {
2223 updateCBTracking(cmdBuffer);
2224 addCmd(pCB, CMD_COPYIMAGETOBUFFER);
2225 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002226 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002227 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2228 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002229 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002230}
2231
Tony Barbour8205d902015-04-16 15:59:00 -06002232VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002233{
2234 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2235 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002236 if (pCB->state == CB_UPDATE_ACTIVE) {
2237 updateCBTracking(cmdBuffer);
2238 addCmd(pCB, CMD_UPDATEBUFFER);
2239 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002240 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002241 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2242 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002243 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002244}
2245
Tony Barbour8205d902015-04-16 15:59:00 -06002246VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002247{
2248 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2249 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002250 if (pCB->state == CB_UPDATE_ACTIVE) {
2251 updateCBTracking(cmdBuffer);
2252 addCmd(pCB, CMD_FILLBUFFER);
2253 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002254 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002255 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2256 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002257 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002258}
2259
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002260VK_LAYER_EXPORT void VKAPI vkCmdClearColorAttachment(
2261 VkCmdBuffer cmdBuffer,
2262 uint32_t colorAttachment,
2263 VkImageLayout imageLayout,
2264 const VkClearColorValue* pColor,
2265 uint32_t rectCount,
2266 const VkRect3D* pRects)
2267{
2268 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2269 if (pCB) {
2270 if (pCB->state == CB_UPDATE_ACTIVE) {
2271 // Warn if this is issued prior to Draw Cmd
2272 if (!hasDrawCmd(pCB)) {
2273 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS",
2274 "vkCmdClearColorAttachment() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds."
2275 " It is recommended you use RenderPass LOAD_OP_CLEAR on Color Attachments prior to any Draw.", reinterpret_cast<VkUintPtrLeast64>(cmdBuffer));
2276 }
Tobin Ehlis92a89912015-06-23 11:34:28 -06002277 if (!pCB->activeRenderPass) {
2278 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
2279 "Clear*Attachment cmd issued without an active RenderPass. vkCmdClearColorAttachment() must only be called inside of a RenderPass."
2280 " vkCmdClearColorImage() should be used outside of a RenderPass.");
2281 } else {
2282 updateCBTracking(cmdBuffer);
2283 addCmd(pCB, CMD_CLEARCOLORATTACHMENT);
2284 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
2285 }
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002286 } else {
2287 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2288 }
2289 }
2290}
2291
2292VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilAttachment(
2293 VkCmdBuffer cmdBuffer,
2294 VkImageAspectFlags imageAspectMask,
2295 VkImageLayout imageLayout,
2296 float depth,
2297 uint32_t stencil,
2298 uint32_t rectCount,
2299 const VkRect3D* pRects)
2300{
2301 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2302 if (pCB) {
2303 if (pCB->state == CB_UPDATE_ACTIVE) {
2304 // Warn if this is issued prior to Draw Cmd
2305 if (!hasDrawCmd(pCB)) {
2306 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS",
2307 "vkCmdClearDepthStencilAttachment() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds."
2308 " It is recommended you use RenderPass LOAD_OP_CLEAR on DS Attachment prior to any Draw.", reinterpret_cast<VkUintPtrLeast64>(cmdBuffer));
2309 }
Tobin Ehlis92a89912015-06-23 11:34:28 -06002310 if (!pCB->activeRenderPass) {
2311 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
2312 "Clear*Attachment cmd issued without an active RenderPass. vkCmdClearDepthStencilAttachment() must only be called inside of a RenderPass."
2313 " vkCmdClearDepthStencilImage() should be used outside of a RenderPass.");
2314 } else {
2315 updateCBTracking(cmdBuffer);
2316 addCmd(pCB, CMD_CLEARDEPTHSTENCILATTACHMENT);
2317 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects);
2318 }
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002319 } else {
2320 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2321 }
2322 }
2323}
2324
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06002325VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
2326 VkCmdBuffer cmdBuffer,
2327 VkImage image, VkImageLayout imageLayout,
Chris Forbese3105972015-06-24 14:34:53 +12002328 const VkClearColorValue *pColor,
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06002329 uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002330{
2331 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2332 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002333 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlis92a89912015-06-23 11:34:28 -06002334 if (pCB->activeRenderPass) {
2335 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
2336 "Clear*Image cmd issued with an active RenderPass. vkCmdClearColorImage() must only be called outside of a RenderPass."
2337 " vkCmdClearColorAttachment() should be used within a RenderPass.");
2338 } else {
2339 updateCBTracking(cmdBuffer);
2340 addCmd(pCB, CMD_CLEARCOLORIMAGE);
2341 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
2342 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002343 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002344 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2345 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002346 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002347}
2348
Chris Forbes2951d7d2015-06-22 17:21:59 +12002349VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer,
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002350 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) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002356 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlis92a89912015-06-23 11:34:28 -06002357 if (pCB->activeRenderPass) {
2358 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
2359 "Clear*Image cmd issued with an active RenderPass. vkCmdClearDepthStencilImage() must only be called outside of a RenderPass."
2360 " vkCmdClearDepthStencilAttachment() should be used within a RenderPass.");
2361 } else {
2362 updateCBTracking(cmdBuffer);
2363 addCmd(pCB, CMD_CLEARDEPTHSTENCILIMAGE);
2364 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
2365 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002366 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002367 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2368 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002369 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002370}
2371
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002372VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
2373 VkImage srcImage, VkImageLayout srcImageLayout,
2374 VkImage destImage, VkImageLayout destImageLayout,
Tony Barbour11f74372015-04-13 15:02:52 -06002375 uint32_t regionCount, const VkImageResolve* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002376{
2377 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2378 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002379 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlise4076782015-06-24 15:53:07 -06002380 if (pCB->activeRenderPass) {
2381 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
2382 "Cannot call vkCmdResolveImage() during an active RenderPass (%p).", (void*)pCB->activeRenderPass);
Tobin Ehlis92a89912015-06-23 11:34:28 -06002383 } else {
2384 updateCBTracking(cmdBuffer);
2385 addCmd(pCB, CMD_RESOLVEIMAGE);
Tobin Ehlise4076782015-06-24 15:53:07 -06002386 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis92a89912015-06-23 11:34:28 -06002387 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002388 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002389 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2390 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002391 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002392}
2393
Tony Barbourc2e987e2015-06-29 16:20:35 -06002394VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002395{
2396 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2397 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002398 if (pCB->state == CB_UPDATE_ACTIVE) {
2399 updateCBTracking(cmdBuffer);
2400 addCmd(pCB, CMD_SETEVENT);
Tony Barbourc2e987e2015-06-29 16:20:35 -06002401 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002402 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002403 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2404 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002405 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002406}
2407
Tony Barbourc2e987e2015-06-29 16:20:35 -06002408VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002409{
2410 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2411 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002412 if (pCB->state == CB_UPDATE_ACTIVE) {
2413 updateCBTracking(cmdBuffer);
2414 addCmd(pCB, CMD_RESETEVENT);
Tony Barbourc2e987e2015-06-29 16:20:35 -06002415 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002416 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002417 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2418 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002419 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002420}
2421
Tony Barbourc2e987e2015-06-29 16:20:35 -06002422VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void** ppMemBarriers)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002423{
2424 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2425 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002426 if (pCB->state == CB_UPDATE_ACTIVE) {
2427 updateCBTracking(cmdBuffer);
2428 addCmd(pCB, CMD_WAITEVENTS);
Tony Barbourc2e987e2015-06-29 16:20:35 -06002429 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002430 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002431 report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
2432 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002433 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002434}
2435
Tony Barbourc2e987e2015-06-29 16:20:35 -06002436VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002437{
2438 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2439 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002440 if (pCB->state == CB_UPDATE_ACTIVE) {
2441 updateCBTracking(cmdBuffer);
2442 addCmd(pCB, CMD_PIPELINEBARRIER);
Tony Barbourc2e987e2015-06-29 16:20:35 -06002443 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002444 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002445 report_error_no_cb_begin(cmdBuffer, "vkCmdPipelineBarrier()");
2446 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002447 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002448}
2449
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002450VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002451{
2452 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2453 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002454 if (pCB->state == CB_UPDATE_ACTIVE) {
2455 updateCBTracking(cmdBuffer);
2456 addCmd(pCB, CMD_BEGINQUERY);
2457 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002458 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002459 report_error_no_cb_begin(cmdBuffer, "vkCmdBeginQuery()");
2460 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002461 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002462}
2463
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002464VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002465{
2466 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2467 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002468 if (pCB->state == CB_UPDATE_ACTIVE) {
2469 updateCBTracking(cmdBuffer);
2470 addCmd(pCB, CMD_ENDQUERY);
2471 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002472 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002473 report_error_no_cb_begin(cmdBuffer, "vkCmdEndQuery()");
2474 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002475 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002476}
2477
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002478VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002479{
2480 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2481 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002482 if (pCB->state == CB_UPDATE_ACTIVE) {
2483 updateCBTracking(cmdBuffer);
2484 addCmd(pCB, CMD_RESETQUERYPOOL);
2485 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002486 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002487 report_error_no_cb_begin(cmdBuffer, "vkCmdResetQueryPool()");
2488 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002489 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002490}
2491
Tony Barbour8205d902015-04-16 15:59:00 -06002492VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002493{
2494 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2495 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002496 if (pCB->state == CB_UPDATE_ACTIVE) {
2497 updateCBTracking(cmdBuffer);
2498 addCmd(pCB, CMD_WRITETIMESTAMP);
2499 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002500 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002501 report_error_no_cb_begin(cmdBuffer, "vkCmdWriteTimestamp()");
2502 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002503 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002504}
2505
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002506VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
Tobin Ehlis2464b882015-04-01 08:40:34 -06002507{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002508 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002509 if (VK_SUCCESS == result) {
Tobin Ehlis2464b882015-04-01 08:40:34 -06002510 // Shadow create info and store in map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002511 VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
Tobin Ehlis2464b882015-04-01 08:40:34 -06002512 if (pCreateInfo->pColorAttachments) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002513 localFBCI->pColorAttachments = new VkColorAttachmentBindInfo[localFBCI->colorAttachmentCount];
2514 memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VkColorAttachmentBindInfo));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002515 }
2516 if (pCreateInfo->pDepthStencilAttachment) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002517 localFBCI->pDepthStencilAttachment = new VkDepthStencilBindInfo[localFBCI->colorAttachmentCount];
2518 memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VkDepthStencilBindInfo));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002519 }
2520 frameBufferMap[*pFramebuffer] = localFBCI;
2521 }
2522 return result;
2523}
2524
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002525VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
Tobin Ehlis2464b882015-04-01 08:40:34 -06002526{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002527 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002528 if (VK_SUCCESS == result) {
Tobin Ehlis2464b882015-04-01 08:40:34 -06002529 // Shadow create info and store in map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002530 VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
Tobin Ehlis2464b882015-04-01 08:40:34 -06002531 if (pCreateInfo->pColorLoadOps) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002532 localRPCI->pColorLoadOps = new VkAttachmentLoadOp[localRPCI->colorAttachmentCount];
2533 memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentLoadOp));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002534 }
2535 if (pCreateInfo->pColorStoreOps) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002536 localRPCI->pColorStoreOps = new VkAttachmentStoreOp[localRPCI->colorAttachmentCount];
2537 memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentStoreOp));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002538 }
2539 if (pCreateInfo->pColorLoadClearValues) {
Chris Forbese3105972015-06-24 14:34:53 +12002540 localRPCI->pColorLoadClearValues = new VkClearColorValue[localRPCI->colorAttachmentCount];
2541 memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VkClearColorValue));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002542 }
2543 renderPassMap[*pRenderPass] = localRPCI;
2544 }
2545 return result;
2546}
2547
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002548VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002549{
2550 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2551 if (pCB) {
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06002552 if (pRenderPassBegin && pRenderPassBegin->renderPass) {
Tobin Ehlise4076782015-06-24 15:53:07 -06002553 if (pCB->activeRenderPass) {
2554 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
2555 "Cannot call vkCmdBeginRenderPass() during an active RenderPass (%p). You must first call vkCmdEndRenderPass().", (void*)pCB->activeRenderPass);
2556 } else {
2557 updateCBTracking(cmdBuffer);
2558 addCmd(pCB, CMD_BEGINRENDERPASS);
2559 pCB->activeRenderPass = pRenderPassBegin->renderPass;
2560 pCB->framebuffer = pRenderPassBegin->framebuffer;
2561 if (pCB->lastBoundPipeline) {
2562 validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
2563 }
2564 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06002565 }
Tobin Ehlise4076782015-06-24 15:53:07 -06002566 } else {
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06002567 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS, "DS",
2568 "You cannot use a NULL RenderPass object in vkCmdBeginRenderPass()");
Tony Barbourb9f82ba2015-04-06 11:09:26 -06002569 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002570 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002571}
2572
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08002573VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002574{
2575 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2576 if (pCB) {
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08002577 if (!pCB->activeRenderPass) {
2578 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
2579 "Incorrect call to vkCmdEndRenderPass() without an active RenderPass.");
Tobin Ehlis536cfe42015-06-23 16:13:03 -06002580 } else {
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08002581 updateCBTracking(cmdBuffer);
2582 addCmd(pCB, CMD_ENDRENDERPASS);
2583 pCB->activeRenderPass = 0;
2584 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer);
2585 }
2586 }
2587}
2588
2589VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
2590{
2591 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2592 if (pCB) {
2593 if (!pCB->activeRenderPass) {
2594 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
2595 "Incorrect call to vkCmdExecuteCommands() without an active RenderPass.");
2596 } else {
2597 updateCBTracking(cmdBuffer);
2598 addCmd(pCB, CMD_EXECUTECOMMANDS);
2599 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06002600 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002601 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002602}
2603
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002604VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
2605 VkInstance instance,
2606 VkFlags msgFlags,
2607 const PFN_vkDbgMsgCallback pfnMsgCallback,
2608 void* pUserData,
2609 VkDbgMsgCallback* pMsgCallback)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002610{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002611 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Tobin Ehlisc91330b2015-06-16 09:04:30 -06002612 VkResult res = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
2613 if (VK_SUCCESS == res) {
2614 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
2615 res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
2616 }
2617 return res;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002618}
2619
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002620VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
2621 VkInstance instance,
2622 VkDbgMsgCallback msgCallback)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002623{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002624 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Tobin Ehlisc91330b2015-06-16 09:04:30 -06002625 VkResult res = pTable->DbgDestroyMsgCallback(instance, msgCallback);
2626 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
2627 layer_destroy_msg_callback(my_data->report_data, msgCallback);
2628 return res;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002629}
2630
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002631VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002632{
2633 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002634 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
2635 if (!deviceExtMap[pDisp].debug_marker_enabled) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06002636 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
2637 "Attempt to use CmdDbgMarkerBegin but extension disabled!");
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002638 return;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002639 } else if (pCB) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002640 updateCBTracking(cmdBuffer);
2641 addCmd(pCB, CMD_DBGMARKERBEGIN);
2642 }
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002643 debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerBegin(cmdBuffer, pMarker);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002644}
2645
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002646VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002647{
2648 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002649 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
2650 if (!deviceExtMap[pDisp].debug_marker_enabled) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06002651 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
2652 "Attempt to use CmdDbgMarkerEnd but extension disabled!");
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002653 return;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002654 } else if (pCB) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002655 updateCBTracking(cmdBuffer);
2656 addCmd(pCB, CMD_DBGMARKEREND);
2657 }
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002658 debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerEnd(cmdBuffer);
2659}
2660
2661VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkDevice device, VkObjectType objType, VkObject object, size_t tagSize, const void* pTag)
2662{
2663 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
2664 if (!deviceExtMap[pDisp].debug_marker_enabled) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06002665 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, objType, object, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
2666 "Attempt to use DbgSetObjectTag but extension disabled!");
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002667 return VK_ERROR_UNAVAILABLE;
2668 }
2669 debug_marker_dispatch_table(device)->DbgSetObjectTag(device, objType, object, tagSize, pTag);
2670}
2671
2672VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectName(VkDevice device, VkObjectType objType, VkObject object, size_t nameSize, const char* pName)
2673{
2674 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
2675 if (!deviceExtMap[pDisp].debug_marker_enabled) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06002676 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, objType, object, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
2677 "Attempt to use DbgSetObjectName but extension disabled!");
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002678 return VK_ERROR_UNAVAILABLE;
2679 }
2680 debug_marker_dispatch_table(device)->DbgSetObjectName(device, objType, object, nameSize, pName);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002681}
2682
Jon Ashburn1245cec2015-05-18 13:20:15 -06002683VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002684{
Jon Ashburn1245cec2015-05-18 13:20:15 -06002685 if (dev == NULL)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002686 return NULL;
Jon Ashburne0fa2282015-05-20 09:00:28 -06002687
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002688 /* loader uses this to force layer initialization; device object is wrapped */
2689 if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002690 initDeviceTable(draw_state_device_table_map, (const VkBaseLayerObject *) dev);
Jon Ashburn1245cec2015-05-18 13:20:15 -06002691 return (void *) vkGetDeviceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002692 }
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -06002693 if (!strcmp(funcName, "vkCreateDevice"))
2694 return (void*) vkCreateDevice;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002695 if (!strcmp(funcName, "vkDestroyDevice"))
2696 return (void*) vkDestroyDevice;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002697 if (!strcmp(funcName, "vkQueueSubmit"))
2698 return (void*) vkQueueSubmit;
2699 if (!strcmp(funcName, "vkDestroyObject"))
2700 return (void*) vkDestroyObject;
2701 if (!strcmp(funcName, "vkCreateBufferView"))
2702 return (void*) vkCreateBufferView;
2703 if (!strcmp(funcName, "vkCreateImageView"))
2704 return (void*) vkCreateImageView;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002705 if (!strcmp(funcName, "vkCreateColorAttachmentView"))
2706 return (void*) vkCreateColorAttachmentView;
2707 if (!strcmp(funcName, "vkCreateDepthStencilView"))
2708 return (void*) vkCreateDepthStencilView;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002709 if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
2710 return (void*) vkCreateGraphicsPipeline;
2711 if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
2712 return (void*) vkCreateGraphicsPipelineDerivative;
2713 if (!strcmp(funcName, "vkCreateSampler"))
2714 return (void*) vkCreateSampler;
2715 if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
2716 return (void*) vkCreateDescriptorSetLayout;
Mark Lobodzinski556f7212015-04-17 14:11:39 -05002717 if (!strcmp(funcName, "vkCreatePipelineLayout"))
2718 return (void*) vkCreatePipelineLayout;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002719 if (!strcmp(funcName, "vkCreateDescriptorPool"))
2720 return (void*) vkCreateDescriptorPool;
2721 if (!strcmp(funcName, "vkResetDescriptorPool"))
2722 return (void*) vkResetDescriptorPool;
2723 if (!strcmp(funcName, "vkAllocDescriptorSets"))
2724 return (void*) vkAllocDescriptorSets;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08002725 if (!strcmp(funcName, "vkUpdateDescriptorSets"))
2726 return (void*) vkUpdateDescriptorSets;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002727 if (!strcmp(funcName, "vkCreateDynamicViewportState"))
2728 return (void*) vkCreateDynamicViewportState;
2729 if (!strcmp(funcName, "vkCreateDynamicRasterState"))
2730 return (void*) vkCreateDynamicRasterState;
2731 if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
2732 return (void*) vkCreateDynamicColorBlendState;
2733 if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
2734 return (void*) vkCreateDynamicDepthStencilState;
2735 if (!strcmp(funcName, "vkCreateCommandBuffer"))
2736 return (void*) vkCreateCommandBuffer;
2737 if (!strcmp(funcName, "vkBeginCommandBuffer"))
2738 return (void*) vkBeginCommandBuffer;
2739 if (!strcmp(funcName, "vkEndCommandBuffer"))
2740 return (void*) vkEndCommandBuffer;
2741 if (!strcmp(funcName, "vkResetCommandBuffer"))
2742 return (void*) vkResetCommandBuffer;
2743 if (!strcmp(funcName, "vkCmdBindPipeline"))
2744 return (void*) vkCmdBindPipeline;
2745 if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
2746 return (void*) vkCmdBindDynamicStateObject;
2747 if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
2748 return (void*) vkCmdBindDescriptorSets;
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002749 if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
2750 return (void*) vkCmdBindVertexBuffers;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002751 if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
2752 return (void*) vkCmdBindIndexBuffer;
2753 if (!strcmp(funcName, "vkCmdDraw"))
2754 return (void*) vkCmdDraw;
2755 if (!strcmp(funcName, "vkCmdDrawIndexed"))
2756 return (void*) vkCmdDrawIndexed;
2757 if (!strcmp(funcName, "vkCmdDrawIndirect"))
2758 return (void*) vkCmdDrawIndirect;
2759 if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
2760 return (void*) vkCmdDrawIndexedIndirect;
2761 if (!strcmp(funcName, "vkCmdDispatch"))
2762 return (void*) vkCmdDispatch;
2763 if (!strcmp(funcName, "vkCmdDispatchIndirect"))
2764 return (void*) vkCmdDispatchIndirect;
2765 if (!strcmp(funcName, "vkCmdCopyBuffer"))
2766 return (void*) vkCmdCopyBuffer;
2767 if (!strcmp(funcName, "vkCmdCopyImage"))
2768 return (void*) vkCmdCopyImage;
2769 if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
2770 return (void*) vkCmdCopyBufferToImage;
2771 if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
2772 return (void*) vkCmdCopyImageToBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002773 if (!strcmp(funcName, "vkCmdUpdateBuffer"))
2774 return (void*) vkCmdUpdateBuffer;
2775 if (!strcmp(funcName, "vkCmdFillBuffer"))
2776 return (void*) vkCmdFillBuffer;
2777 if (!strcmp(funcName, "vkCmdClearColorImage"))
2778 return (void*) vkCmdClearColorImage;
Chris Forbes2951d7d2015-06-22 17:21:59 +12002779 if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
2780 return (void*) vkCmdClearDepthStencilImage;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002781 if (!strcmp(funcName, "vkCmdClearColorAttachment"))
2782 return (void*) vkCmdClearColorAttachment;
2783 if (!strcmp(funcName, "vkCmdClearDepthStencilAttachment"))
2784 return (void*) vkCmdClearDepthStencilAttachment;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002785 if (!strcmp(funcName, "vkCmdResolveImage"))
2786 return (void*) vkCmdResolveImage;
2787 if (!strcmp(funcName, "vkCmdSetEvent"))
2788 return (void*) vkCmdSetEvent;
2789 if (!strcmp(funcName, "vkCmdResetEvent"))
2790 return (void*) vkCmdResetEvent;
2791 if (!strcmp(funcName, "vkCmdWaitEvents"))
2792 return (void*) vkCmdWaitEvents;
2793 if (!strcmp(funcName, "vkCmdPipelineBarrier"))
2794 return (void*) vkCmdPipelineBarrier;
2795 if (!strcmp(funcName, "vkCmdBeginQuery"))
2796 return (void*) vkCmdBeginQuery;
2797 if (!strcmp(funcName, "vkCmdEndQuery"))
2798 return (void*) vkCmdEndQuery;
2799 if (!strcmp(funcName, "vkCmdResetQueryPool"))
2800 return (void*) vkCmdResetQueryPool;
2801 if (!strcmp(funcName, "vkCmdWriteTimestamp"))
2802 return (void*) vkCmdWriteTimestamp;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002803 if (!strcmp(funcName, "vkCreateFramebuffer"))
2804 return (void*) vkCreateFramebuffer;
2805 if (!strcmp(funcName, "vkCreateRenderPass"))
2806 return (void*) vkCreateRenderPass;
2807 if (!strcmp(funcName, "vkCmdBeginRenderPass"))
2808 return (void*) vkCmdBeginRenderPass;
2809 if (!strcmp(funcName, "vkCmdEndRenderPass"))
2810 return (void*) vkCmdEndRenderPass;
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002811
Jon Ashburn7e07faf2015-06-18 15:02:58 -06002812 VkLayerDispatchTable* pTable = get_dispatch_table(draw_state_device_table_map, dev);
2813 if (deviceExtMap.size() == 0 || deviceExtMap[pTable].debug_marker_enabled)
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002814 {
Jon Ashburn7e07faf2015-06-18 15:02:58 -06002815 if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002816 return (void*) vkCmdDbgMarkerBegin;
Jon Ashburn7e07faf2015-06-18 15:02:58 -06002817 if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002818 return (void*) vkCmdDbgMarkerEnd;
Jon Ashburn7e07faf2015-06-18 15:02:58 -06002819 if (!strcmp(funcName, "vkDbgSetObjectTag"))
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002820 return (void*) vkDbgSetObjectTag;
Jon Ashburn7e07faf2015-06-18 15:02:58 -06002821 if (!strcmp(funcName, "vkDbgSetObjectName"))
Jon Ashburn6f8cd632015-06-01 09:37:38 -06002822 return (void*) vkDbgSetObjectName;
2823 }
2824 {
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002825 if (pTable->GetDeviceProcAddr == NULL)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002826 return NULL;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002827 return pTable->GetDeviceProcAddr(dev, funcName);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002828 }
2829}
2830
2831VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
2832{
Courtney Goeltzenleuchtercc899fe2015-06-01 14:33:14 -06002833 void *fptr;
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002834 if (instance == NULL)
2835 return NULL;
2836
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002837 /* loader uses this to force layer initialization; instance object is wrapped */
2838 if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002839 initInstanceTable(draw_state_instance_table_map, (const VkBaseLayerObject *) instance);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002840 return (void *) vkGetInstanceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002841 }
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06002842 if (!strcmp(funcName, "vkCreateInstance"))
2843 return (void *) vkCreateInstance;
Jon Ashburne0fa2282015-05-20 09:00:28 -06002844 if (!strcmp(funcName, "vkDestroyInstance"))
2845 return (void *) vkDestroyInstance;
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06002846 if (!strcmp(funcName, "vkGetGlobalLayerProperties"))
2847 return (void*) vkGetGlobalLayerProperties;
2848 if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
2849 return (void*) vkGetGlobalExtensionProperties;
2850 if (!strcmp(funcName, "vkGetPhysicalDeviceLayerProperties"))
2851 return (void*) vkGetPhysicalDeviceLayerProperties;
Tony Barbour426b9052015-06-24 16:06:58 -06002852 if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
2853 return (void*) vkGetPhysicalDeviceExtensionProperties;
Courtney Goeltzenleuchtercc899fe2015-06-01 14:33:14 -06002854
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06002855 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
2856 fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
Courtney Goeltzenleuchtercc899fe2015-06-01 14:33:14 -06002857 if (fptr)
2858 return fptr;
2859
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002860 {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002861 VkLayerInstanceDispatchTable* pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002862 if (pTable->GetInstanceProcAddr == NULL)
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002863 return NULL;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002864 return pTable->GetInstanceProcAddr(instance, funcName);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002865 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002866}