blob: 67268e4b333b4639c61aacad97f0b4b8492a9d58 [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
Tony Barboura938abb2015-04-22 11:36:22 -060036#if defined(__GNUC__)
Tobin Ehlis63bb9482015-03-17 16:24:32 -060037#pragma GCC diagnostic warning "-Wwrite-strings"
Tony Barboura938abb2015-04-22 11:36:22 -060038#endif
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060039#include "vk_struct_size_helper.h"
Tobin Ehlis63bb9482015-03-17 16:24:32 -060040#include "draw_state.h"
Tobin Ehlis56d204a2015-07-03 10:15:26 -060041#include "vk_layer_config.h"
Jon Ashburnf0615e22015-05-25 14:11:37 -060042#include "vk_debug_marker_layer.h"
Tobin Ehlis63bb9482015-03-17 16:24:32 -060043// The following is #included again to catch certain OS-specific functions
44// being used:
Tobin Ehlis7a51d902015-07-03 10:34:49 -060045#include "vk_loader_platform.h"
Tobin Ehlis56d204a2015-07-03 10:15:26 -060046#include "vk_layer_table.h"
47#include "vk_layer_debug_marker_table.h"
48#include "vk_layer_data.h"
49#include "vk_layer_logging.h"
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -060050#include "vk_layer_extension_utils.h"
Tobin Ehlis63bb9482015-03-17 16:24:32 -060051
Cody Northrop73bb6572015-09-28 15:09:32 -060052struct layer_data {
Tobin Ehlisc91330b2015-06-16 09:04:30 -060053 debug_report_data *report_data;
54 // TODO: put instance data here
55 VkDbgMsgCallback logging_callback;
Cody Northrop73bb6572015-09-28 15:09:32 -060056
57 layer_data() :
58 report_data(nullptr),
59 logging_callback(nullptr)
60 {};
61};
Tobin Ehlisc91330b2015-06-16 09:04:30 -060062
63static std::unordered_map<void *, layer_data *> layer_data_map;
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -060064static device_table_map draw_state_device_table_map;
65static instance_table_map draw_state_instance_table_map;
66
Mike Stroyan74b430c2015-09-11 13:29:21 -060067static unordered_map<uint64_t, SAMPLER_NODE*> sampleMap;
68static unordered_map<uint64_t, VkImageViewCreateInfo> imageMap;
69static unordered_map<uint64_t, VkImageViewCreateInfo> viewMap;
70static unordered_map<uint64_t, BUFFER_NODE*> bufferMap;
Mike Stroyan74b430c2015-09-11 13:29:21 -060071static unordered_map<uint64_t, PIPELINE_NODE*> pipelineMap;
72static unordered_map<uint64_t, POOL_NODE*> poolMap;
73static unordered_map<uint64_t, SET_NODE*> setMap;
74static unordered_map<uint64_t, LAYOUT_NODE*> layoutMap;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -060075// Map for layout chains
Mike Stroyan74b430c2015-09-11 13:29:21 -060076static unordered_map<void*, GLOBAL_CB_NODE*> cmdBufferMap;
77static unordered_map<uint64_t, VkRenderPassCreateInfo*> renderPassMap;
78static unordered_map<uint64_t, VkFramebufferCreateInfo*> frameBufferMap;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060079
Jon Ashburn6f8cd632015-06-01 09:37:38 -060080struct devExts {
81 bool debug_marker_enabled;
82};
83
Jon Ashburn6f8cd632015-06-01 09:37:38 -060084static std::unordered_map<void *, struct devExts> deviceExtMap;
Jon Ashburne0fa2282015-05-20 09:00:28 -060085
Tobin Ehlis63bb9482015-03-17 16:24:32 -060086static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
Jon Ashburnd9564002015-05-07 10:27:37 -060087
Tobin Ehlis63bb9482015-03-17 16:24:32 -060088// TODO : This can be much smarter, using separate locks for separate global data
89static int globalLockInitialized = 0;
90static loader_platform_thread_mutex globalLock;
Tobin Ehlis63bb9482015-03-17 16:24:32 -060091#define MAX_TID 513
92static loader_platform_thread_id g_tidMapping[MAX_TID] = {0};
93static uint32_t g_maxTID = 0;
Tobin Ehlisfde4dce2015-06-16 15:50:44 -060094
95template layer_data *get_my_data_ptr<layer_data>(
96 void *data_key,
97 std::unordered_map<void *, layer_data *> &data_map);
98
Tobin Ehlis1dce5f12015-07-07 10:42:20 -060099debug_report_data *mdd(void* object)
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600100{
101 dispatch_key key = get_dispatch_key(object);
102 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
103#if DISPATCH_MAP_DEBUG
104 fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, my_data);
105#endif
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600106 return my_data->report_data;
107}
108
109debug_report_data *mid(VkInstance object)
110{
111 dispatch_key key = get_dispatch_key(object);
Tobin Ehlis8354e022015-09-01 11:46:36 -0600112 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600113#if DISPATCH_MAP_DEBUG
114 fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, my_data);
115#endif
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600116 return my_data->report_data;
117}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600118// Map actual TID to an index value and return that index
119// This keeps TIDs in range from 0-MAX_TID and simplifies compares between runs
120static uint32_t getTIDIndex() {
121 loader_platform_thread_id tid = loader_platform_get_thread_id();
122 for (uint32_t i = 0; i < g_maxTID; i++) {
123 if (tid == g_tidMapping[i])
124 return i;
125 }
126 // Don't yet have mapping, set it and return newly set index
127 uint32_t retVal = (uint32_t) g_maxTID;
128 g_tidMapping[g_maxTID++] = tid;
129 assert(g_maxTID < MAX_TID);
130 return retVal;
131}
132// Return a string representation of CMD_TYPE enum
133static string cmdTypeToString(CMD_TYPE cmd)
134{
135 switch (cmd)
136 {
137 case CMD_BINDPIPELINE:
138 return "CMD_BINDPIPELINE";
139 case CMD_BINDPIPELINEDELTA:
140 return "CMD_BINDPIPELINEDELTA";
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -0600141 case CMD_SETVIEWPORTSTATE:
142 return "CMD_SETVIEWPORTSTATE";
143 case CMD_SETLINEWIDTHSTATE:
144 return "CMD_SETLINEWIDTHSTATE";
145 case CMD_SETDEPTHBIASSTATE:
146 return "CMD_SETDEPTHBIASSTATE";
147 case CMD_SETBLENDSTATE:
148 return "CMD_SETBLENDSTATE";
149 case CMD_SETDEPTHBOUNDSSTATE:
150 return "CMD_SETDEPTHBOUNDSSTATE";
151 case CMD_SETSTENCILREADMASKSTATE:
152 return "CMD_SETSTENCILREADMASKSTATE";
153 case CMD_SETSTENCILWRITEMASKSTATE:
154 return "CMD_SETSTENCILWRITEMASKSTATE";
155 case CMD_SETSTENCILREFERENCESTATE:
156 return "CMD_SETSTENCILREFERENCESTATE";
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600157 case CMD_BINDDESCRIPTORSETS:
158 return "CMD_BINDDESCRIPTORSETS";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600159 case CMD_BINDINDEXBUFFER:
160 return "CMD_BINDINDEXBUFFER";
161 case CMD_BINDVERTEXBUFFER:
162 return "CMD_BINDVERTEXBUFFER";
163 case CMD_DRAW:
164 return "CMD_DRAW";
165 case CMD_DRAWINDEXED:
166 return "CMD_DRAWINDEXED";
167 case CMD_DRAWINDIRECT:
168 return "CMD_DRAWINDIRECT";
169 case CMD_DRAWINDEXEDINDIRECT:
170 return "CMD_DRAWINDEXEDINDIRECT";
171 case CMD_DISPATCH:
172 return "CMD_DISPATCH";
173 case CMD_DISPATCHINDIRECT:
174 return "CMD_DISPATCHINDIRECT";
175 case CMD_COPYBUFFER:
176 return "CMD_COPYBUFFER";
177 case CMD_COPYIMAGE:
178 return "CMD_COPYIMAGE";
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600179 case CMD_BLITIMAGE:
180 return "CMD_BLITIMAGE";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600181 case CMD_COPYBUFFERTOIMAGE:
182 return "CMD_COPYBUFFERTOIMAGE";
183 case CMD_COPYIMAGETOBUFFER:
184 return "CMD_COPYIMAGETOBUFFER";
185 case CMD_CLONEIMAGEDATA:
186 return "CMD_CLONEIMAGEDATA";
187 case CMD_UPDATEBUFFER:
188 return "CMD_UPDATEBUFFER";
189 case CMD_FILLBUFFER:
190 return "CMD_FILLBUFFER";
191 case CMD_CLEARCOLORIMAGE:
192 return "CMD_CLEARCOLORIMAGE";
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600193 case CMD_CLEARCOLORATTACHMENT:
194 return "CMD_CLEARCOLORATTACHMENT";
195 case CMD_CLEARDEPTHSTENCILIMAGE:
196 return "CMD_CLEARDEPTHSTENCILIMAGE";
197 case CMD_CLEARDEPTHSTENCILATTACHMENT:
198 return "CMD_CLEARDEPTHSTENCILATTACHMENT";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600199 case CMD_RESOLVEIMAGE:
200 return "CMD_RESOLVEIMAGE";
201 case CMD_SETEVENT:
202 return "CMD_SETEVENT";
203 case CMD_RESETEVENT:
204 return "CMD_RESETEVENT";
205 case CMD_WAITEVENTS:
206 return "CMD_WAITEVENTS";
207 case CMD_PIPELINEBARRIER:
208 return "CMD_PIPELINEBARRIER";
209 case CMD_BEGINQUERY:
210 return "CMD_BEGINQUERY";
211 case CMD_ENDQUERY:
212 return "CMD_ENDQUERY";
213 case CMD_RESETQUERYPOOL:
214 return "CMD_RESETQUERYPOOL";
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -0600215 case CMD_COPYQUERYPOOLRESULTS:
216 return "CMD_COPYQUERYPOOLRESULTS";
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600217 case CMD_WRITETIMESTAMP:
218 return "CMD_WRITETIMESTAMP";
219 case CMD_INITATOMICCOUNTERS:
220 return "CMD_INITATOMICCOUNTERS";
221 case CMD_LOADATOMICCOUNTERS:
222 return "CMD_LOADATOMICCOUNTERS";
223 case CMD_SAVEATOMICCOUNTERS:
224 return "CMD_SAVEATOMICCOUNTERS";
225 case CMD_BEGINRENDERPASS:
226 return "CMD_BEGINRENDERPASS";
227 case CMD_ENDRENDERPASS:
228 return "CMD_ENDRENDERPASS";
229 case CMD_DBGMARKERBEGIN:
230 return "CMD_DBGMARKERBEGIN";
231 case CMD_DBGMARKEREND:
232 return "CMD_DBGMARKEREND";
233 default:
234 return "UNKNOWN";
235 }
236}
237// Block of code at start here for managing/tracking Pipeline state that this layer cares about
238// Just track 2 shaders for now
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600239#define VK_NUM_GRAPHICS_SHADERS VK_SHADER_STAGE_COMPUTE
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600240#define MAX_SLOTS 2048
241#define NUM_COMMAND_BUFFERS_TO_DISPLAY 10
242
243static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0};
244
245// TODO : Should be tracking lastBound per cmdBuffer and when draws occur, report based on that cmd buffer lastBound
246// Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
247// to that same cmd buffer by separate thread are not changing state from underneath us
248// Track the last cmd buffer touched by this thread
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600249static VkCmdBuffer g_lastCmdBuffer[MAX_TID] = {NULL};
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600250// Track the last group of CBs touched for displaying to dot file
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600251static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
252static uint32_t g_lastTouchedCBIndex = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600253// Track the last global DrawState of interest touched by any thread
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600254static GLOBAL_CB_NODE* g_lastGlobalCB = NULL;
255static PIPELINE_NODE* g_lastBoundPipeline = NULL;
Dana Jansens4a3e0862015-07-30 13:22:15 -0700256static VkDescriptorSet g_lastBoundDescriptorSet = VK_NULL_HANDLE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600257#define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
258
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600259// Free all sampler nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600260static void deleteSamplers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600261{
David Pinedof5997ab2015-04-27 16:36:17 -0600262 if (sampleMap.size() <= 0)
263 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600264 for (auto ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600265 delete (*ii).second;
266 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600267 sampleMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600268}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600269static VkImageViewCreateInfo* getImageViewCreateInfo(VkImageView view)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600270{
271 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600272 if (imageMap.find(view.handle) == imageMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600273 loader_platform_thread_unlock_mutex(&globalLock);
274 return NULL;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600275 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600276 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600277 return &imageMap[view.handle];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600278 }
279}
280// Free all image nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600281static void deleteImages()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600282{
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600283 if (imageMap.size() <= 0)
David Pinedof5997ab2015-04-27 16:36:17 -0600284 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600285 imageMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600286}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600287static VkBufferViewCreateInfo* getBufferViewCreateInfo(VkBufferView view)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600288{
289 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600290 if (bufferMap.find(view.handle) == bufferMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600291 loader_platform_thread_unlock_mutex(&globalLock);
292 return NULL;
Tobin Ehlise42007c2015-06-19 13:00:59 -0600293 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600294 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600295 return &bufferMap[view.handle]->createInfo;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600296 }
297}
298// Free all buffer nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600299static void deleteBuffers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600300{
David Pinedof5997ab2015-04-27 16:36:17 -0600301 if (bufferMap.size() <= 0)
302 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600303 for (auto ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600304 delete (*ii).second;
305 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600306 bufferMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600307}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600308static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600309// Update global ptrs to reflect that specified cmdBuffer has been used
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600310static void updateCBTracking(VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600311{
312 g_lastCmdBuffer[getTIDIndex()] = cb;
313 GLOBAL_CB_NODE* pCB = getCBNode(cb);
314 loader_platform_thread_lock_mutex(&globalLock);
315 g_lastGlobalCB = pCB;
316 // TODO : This is a dumb algorithm. Need smart LRU that drops off oldest
317 for (uint32_t i = 0; i < NUM_COMMAND_BUFFERS_TO_DISPLAY; i++) {
318 if (g_pLastTouchedCB[i] == pCB) {
319 loader_platform_thread_unlock_mutex(&globalLock);
320 return;
321 }
322 }
323 g_pLastTouchedCB[g_lastTouchedCBIndex++] = pCB;
324 g_lastTouchedCBIndex = g_lastTouchedCBIndex % NUM_COMMAND_BUFFERS_TO_DISPLAY;
325 loader_platform_thread_unlock_mutex(&globalLock);
326}
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600327static VkBool32 hasDrawCmd(GLOBAL_CB_NODE* pCB)
Tobin Ehlis8cd650e2015-07-01 16:46:13 -0600328{
329 for (uint32_t i=0; i<NUM_DRAW_TYPES; i++) {
330 if (pCB->drawCount[i])
331 return VK_TRUE;
332 }
333 return VK_FALSE;
334}
Tobin Ehlis97866202015-06-10 12:57:07 -0600335// Check object status for selected flag state
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600336static VkBool32 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 -0600337{
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600338 // If non-zero enable mask is present, check it against status but if enable_mask
339 // is 0 then no enable required so we should always just check status
340 if ((!enable_mask) || (enable_mask & pNode->status)) {
341 if ((pNode->status & status_mask) != status_flag) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600342 // TODO : How to pass dispatchable objects as srcObject? Here src obj should be cmd buffer
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600343 return log_msg(mdd(pNode->cmdBuffer), msg_flags, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, error_code, "DS",
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600344 "CB object %#" PRIxLEAST64 ": %s", reinterpret_cast<uint64_t>(pNode->cmdBuffer), fail_msg);
Tobin Ehlis97866202015-06-10 12:57:07 -0600345 }
Tobin Ehlis97866202015-06-10 12:57:07 -0600346 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600347 return VK_FALSE;
Tobin Ehlis97866202015-06-10 12:57:07 -0600348}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600349// Retrieve pipeline node ptr for given pipeline object
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600350static PIPELINE_NODE* getPipeline(VkPipeline pipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600351{
352 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600353 if (pipelineMap.find(pipeline.handle) == pipelineMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600354 loader_platform_thread_unlock_mutex(&globalLock);
355 return NULL;
356 }
357 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600358 return pipelineMap[pipeline.handle];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600359}
Tobin Ehlisa88e2f52015-10-02 11:00:56 -0600360// Return VK_TRUE if for a given PSO, the given state enum is dynamic, else return VK_FALSE
361static VkBool32 isDynamic(const PIPELINE_NODE* pPipeline, const VkDynamicState state)
362{
363 if (pPipeline && pPipeline->graphicsPipelineCI.pDynamicState) {
364 for (uint32_t i=0; i<pPipeline->graphicsPipelineCI.pDynamicState->dynamicStateCount; i++) {
365 if (state == pPipeline->graphicsPipelineCI.pDynamicState->pDynamicStates[i])
366 return VK_TRUE;
367 }
368 }
369 return VK_FALSE;
370}
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600371// Validate state stored as flags at time of draw call
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600372static VkBool32 validate_draw_state_flags(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) {
373 VkBool32 result;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -0600374 result = validate_status(pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_SET, CBSTATUS_VIEWPORT_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Dynamic viewport state not set for this command buffer");
375 result |= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_SCISSOR_SET, CBSTATUS_SCISSOR_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic scissor state not set for this command buffer");
376 result |= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_LINE_WIDTH_SET, CBSTATUS_LINE_WIDTH_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_LINE_WIDTH_NOT_BOUND, "Dynamic line width state not set for this command buffer");
377 result |= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_DEPTH_BIAS_SET, CBSTATUS_DEPTH_BIAS_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BIAS_NOT_BOUND, "Dynamic depth bias state not set for this command buffer");
378 result |= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_BLEND_SET, CBSTATUS_BLEND_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_BLEND_NOT_BOUND, "Dynamic blend object state not set for this command buffer");
379 result |= validate_status(pCB, CBSTATUS_DEPTH_WRITE_ENABLE, CBSTATUS_DEPTH_BOUNDS_SET, CBSTATUS_DEPTH_BOUNDS_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, "Dynamic depth bounds state not set for this command buffer");
380 result |= validate_status(pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_READ_MASK_SET, CBSTATUS_STENCIL_READ_MASK_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil read mask state not set for this command buffer");
381 result |= validate_status(pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_WRITE_MASK_SET, CBSTATUS_STENCIL_WRITE_MASK_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil write mask state not set for this command buffer");
382 result |= validate_status(pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_REFERENCE_SET, CBSTATUS_STENCIL_REFERENCE_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil reference state not set for this command buffer");
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600383 if (indexedDraw)
Tobin Ehlisf6cb4672015-09-29 08:18:34 -0600384 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 Indexed Draw attempted");
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600385 return result;
386}
387// Validate overall state at the time of a draw call
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600388static VkBool32 validate_draw_state(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) {
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600389 // First check flag states
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600390 VkBool32 result = validate_draw_state_flags(pCB, indexedDraw);
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600391 PIPELINE_NODE* pPipe = getPipeline(pCB->lastBoundPipeline);
392 // Now complete other state checks
Tobin Ehlis12ab7dc2015-09-09 13:31:01 -0600393 // TODO : Currently only performing next check if *something* was bound (non-zero last bound)
394 // There is probably a better way to gate when this check happens, and to know if something *should* have been bound
395 // We should have that check separately and then gate this check based on that check
396 if (pPipe && (pCB->lastBoundPipelineLayout) && (pCB->lastBoundPipelineLayout != pPipe->graphicsPipelineCI.layout)) {
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600397 result = VK_FALSE;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600398 result |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE_LAYOUT, pCB->lastBoundPipelineLayout.handle, 0, DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, "DS",
Mark Lobodzinskia98cf9b2015-08-04 10:54:43 -0600399 "Pipeline layout from last vkCmdBindDescriptorSets() (%#" PRIxLEAST64 ") does not match PSO Pipeline layout (%#" PRIxLEAST64 ") ", pCB->lastBoundPipelineLayout.handle, pPipe->graphicsPipelineCI.layout.handle);
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600400 }
Tobin Ehlisd28acef2015-09-09 15:12:35 -0600401 // Verify Vtx binding
402 if (MAX_BINDING != pCB->lastVtxBinding) {
403 if (pCB->lastVtxBinding >= pPipe->vtxBindingCount) {
404 if (0 == pPipe->vtxBindingCount) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600405 result |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS",
Tobin Ehlisd28acef2015-09-09 15:12:35 -0600406 "Vtx Buffer Index %u was bound, but no vtx buffers are attached to PSO.", pCB->lastVtxBinding);
Tobin Ehlisd28acef2015-09-09 15:12:35 -0600407 }
408 else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600409 result |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS",
Tobin Ehlisd28acef2015-09-09 15:12:35 -0600410 "Vtx binding Index of %u exceeds PSO pVertexBindingDescriptions max array index of %u.", pCB->lastVtxBinding, (pPipe->vtxBindingCount - 1));
Tobin Ehlisd28acef2015-09-09 15:12:35 -0600411 }
412 }
413 }
Tobin Ehlisa88e2f52015-10-02 11:00:56 -0600414 // If Viewport or scissors are dynamic, verify that dynamic count matches PSO count
415 VkBool32 dynViewport = isDynamic(pPipe, VK_DYNAMIC_STATE_VIEWPORT);
416 VkBool32 dynScissor = isDynamic(pPipe, VK_DYNAMIC_STATE_SCISSOR);
417 if (dynViewport) {
418 if (pCB->viewports.size() != pPipe->graphicsPipelineCI.pViewportState->viewportCount) {
419 result |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
420 "Dynamic viewportCount from vkCmdSetViewport() is %u, but PSO viewportCount is %u. These counts must match.", pCB->viewports.size(), pPipe->graphicsPipelineCI.pViewportState->viewportCount);
421 }
422 }
423 if (dynScissor) {
424 if (pCB->scissors.size() != pPipe->graphicsPipelineCI.pViewportState->scissorCount) {
425 result |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
426 "Dynamic scissorCount from vkCmdSetScissor() is %u, but PSO scissorCount is %u. These counts must match.", pCB->scissors.size(), pPipe->graphicsPipelineCI.pViewportState->scissorCount);
427 }
428 }
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -0600429 return result;
430}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600431// For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600432static VkSamplerCreateInfo* getSamplerCreateInfo(const VkSampler sampler)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600433{
434 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600435 if (sampleMap.find(sampler.handle) == sampleMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600436 loader_platform_thread_unlock_mutex(&globalLock);
437 return NULL;
438 }
439 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600440 return &sampleMap[sampler.handle]->createInfo;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600441}
Tobin Ehlisde63c532015-06-18 15:59:33 -0600442// Verify that create state for a pipeline is valid
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600443static VkBool32 verifyPipelineCreateState(const VkDevice device, const PIPELINE_NODE* pPipeline)
Tobin Ehlisde63c532015-06-18 15:59:33 -0600444{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600445 VkBool32 skipCall = VK_FALSE;
Tobin Ehlisde63c532015-06-18 15:59:33 -0600446 // VS is required
447 if (!(pPipeline->active_shaders & VK_SHADER_STAGE_VERTEX_BIT)) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600448 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600449 "Invalid Pipeline CreateInfo State: Vtx Shader required");
Tobin Ehlisde63c532015-06-18 15:59:33 -0600450 }
451 // Either both or neither TC/TE shaders should be defined
452 if (((pPipeline->active_shaders & VK_SHADER_STAGE_TESS_CONTROL_BIT) == 0) !=
453 ((pPipeline->active_shaders & VK_SHADER_STAGE_TESS_EVALUATION_BIT) == 0) ) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600454 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600455 "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair");
Tobin Ehlisde63c532015-06-18 15:59:33 -0600456 }
457 // Compute shaders should be specified independent of Gfx shaders
458 if ((pPipeline->active_shaders & VK_SHADER_STAGE_COMPUTE_BIT) &&
459 (pPipeline->active_shaders & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESS_CONTROL_BIT |
460 VK_SHADER_STAGE_TESS_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT |
461 VK_SHADER_STAGE_FRAGMENT_BIT))) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600462 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600463 "Invalid Pipeline CreateInfo State: Do not specify Compute Shader for Gfx Pipeline");
Tobin Ehlisde63c532015-06-18 15:59:33 -0600464 }
465 // VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only valid for tessellation pipelines.
466 // Mismatching primitive topology and tessellation fails graphics pipeline creation.
467 if (pPipeline->active_shaders & (VK_SHADER_STAGE_TESS_CONTROL_BIT | VK_SHADER_STAGE_TESS_EVALUATION_BIT) &&
468 (pPipeline->iaStateCI.topology != VK_PRIMITIVE_TOPOLOGY_PATCH)) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600469 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600470 "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH must be set as IA topology for tessellation pipelines");
Tobin Ehlisde63c532015-06-18 15:59:33 -0600471 }
Tobin Ehlis20693172015-09-17 08:46:18 -0600472 if (pPipeline->iaStateCI.topology == VK_PRIMITIVE_TOPOLOGY_PATCH) {
473 if (~pPipeline->active_shaders & VK_SHADER_STAGE_TESS_CONTROL_BIT) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600474 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
Tobin Ehlisde63c532015-06-18 15:59:33 -0600475 "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only valid for tessellation pipelines");
Tobin Ehlis20693172015-09-17 08:46:18 -0600476 }
477 if (!pPipeline->tessStateCI.patchControlPoints || (pPipeline->tessStateCI.patchControlPoints > 32)) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600478 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS",
Tobin Ehlis20693172015-09-17 08:46:18 -0600479 "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology used with patchControlPoints value %u."
480 " patchControlPoints should be >0 and <=32.", pPipeline->tessStateCI.patchControlPoints);
481 }
Tobin Ehlisde63c532015-06-18 15:59:33 -0600482 }
Tobin Ehlisa88e2f52015-10-02 11:00:56 -0600483 // Viewport state must be included and viewport and scissor counts should always match
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600484 // NOTE : Even if these are flagged as dynamic, counts need to be set correctly for shader compiler
Tobin Ehlisa88e2f52015-10-02 11:00:56 -0600485 if (!pPipeline->graphicsPipelineCI.pViewportState) {
486 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
487 "Gfx Pipeline pViewportState is null. Even if viewport and scissors are dynamic PSO must include viewportCount and scissorCount in pViewportState.");
488 } else if (pPipeline->graphicsPipelineCI.pViewportState->scissorCount != pPipeline->graphicsPipelineCI.pViewportState->viewportCount) {
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600489 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
490 "Gfx Pipeline viewport count (%u) must match scissor count (%u).", pPipeline->vpStateCI.viewportCount, pPipeline->vpStateCI.scissorCount);
Tobin Ehlisa88e2f52015-10-02 11:00:56 -0600491 } else {
492 // If viewport or scissor are not dynamic, then verify that data is appropriate for count
493 VkBool32 dynViewport = isDynamic(pPipeline, VK_DYNAMIC_STATE_VIEWPORT);
494 VkBool32 dynScissor = isDynamic(pPipeline, VK_DYNAMIC_STATE_SCISSOR);
495 if (!dynViewport) {
496 if (pPipeline->graphicsPipelineCI.pViewportState->viewportCount && !pPipeline->graphicsPipelineCI.pViewportState->pViewports) {
497 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
498 "Gfx Pipeline viewportCount is %u, but pViewports is NULL. For non-zero viewportCount, you must either include pViewports data, or include viewport in pDynamicState and set it with vkCmdSetViewport().", pPipeline->graphicsPipelineCI.pViewportState->viewportCount);
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600499 }
500 }
Tobin Ehlisa88e2f52015-10-02 11:00:56 -0600501 if (!dynScissor) {
502 if (pPipeline->graphicsPipelineCI.pViewportState->scissorCount && !pPipeline->graphicsPipelineCI.pViewportState->pScissors) {
503 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
504 "Gfx Pipeline scissorCount is %u, but pScissors is NULL. For non-zero scissorCount, you must either include pScissors data, or include scissor in pDynamicState and set it with vkCmdSetScissor().", pPipeline->graphicsPipelineCI.pViewportState->scissorCount);
505 }
Tobin Ehlis9e839e52015-10-01 11:15:13 -0600506 }
507 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600508 return skipCall;
Tobin Ehlisde63c532015-06-18 15:59:33 -0600509}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600510// Init the pipeline mapping info based on pipeline create info LL tree
511// Threading note : Calls to this function should wrapped in mutex
Tobin Ehlisde63c532015-06-18 15:59:33 -0600512static PIPELINE_NODE* initPipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, PIPELINE_NODE* pBasePipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600513{
Tobin Ehlisde63c532015-06-18 15:59:33 -0600514 PIPELINE_NODE* pPipeline = new PIPELINE_NODE;
515 if (pBasePipeline) {
516 memcpy((void*)pPipeline, (void*)pBasePipeline, sizeof(PIPELINE_NODE));
Tobin Ehlise42007c2015-06-19 13:00:59 -0600517 } else {
Tobin Ehlisde63c532015-06-18 15:59:33 -0600518 memset((void*)pPipeline, 0, sizeof(PIPELINE_NODE));
519 }
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600520 // First init create info
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600521 memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo));
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600522
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600523 size_t bufferSize = 0;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600524 const VkPipelineVertexInputStateCreateInfo* pVICI = NULL;
Tobin Ehlis59db5712015-07-13 13:14:24 -0600525 const VkPipelineColorBlendStateCreateInfo* pCBCI = NULL;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600526
527 for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
528 const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
529
530 switch (pPSSCI->stage) {
531 case VK_SHADER_STAGE_VERTEX:
532 memcpy(&pPipeline->vsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
533 pPipeline->active_shaders |= VK_SHADER_STAGE_VERTEX_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600534 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600535 case VK_SHADER_STAGE_TESS_CONTROL:
536 memcpy(&pPipeline->tcsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
537 pPipeline->active_shaders |= VK_SHADER_STAGE_TESS_CONTROL_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600538 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600539 case VK_SHADER_STAGE_TESS_EVALUATION:
540 memcpy(&pPipeline->tesCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
541 pPipeline->active_shaders |= VK_SHADER_STAGE_TESS_EVALUATION_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600542 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600543 case VK_SHADER_STAGE_GEOMETRY:
544 memcpy(&pPipeline->gsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
545 pPipeline->active_shaders |= VK_SHADER_STAGE_GEOMETRY_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600546 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600547 case VK_SHADER_STAGE_FRAGMENT:
548 memcpy(&pPipeline->fsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
549 pPipeline->active_shaders |= VK_SHADER_STAGE_FRAGMENT_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600550 break;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600551 case VK_SHADER_STAGE_COMPUTE:
552 // TODO : Flag error, CS is specified through VkComputePipelineCreateInfo
553 pPipeline->active_shaders |= VK_SHADER_STAGE_COMPUTE_BIT;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600554 break;
555 default:
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600556 // TODO : Flag error
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600557 break;
558 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600559 }
Tobin Ehlisf6cb4672015-09-29 08:18:34 -0600560 // Copy over GraphicsPipelineCreateInfo structure embedded pointers
561 if (pCreateInfo->stageCount != 0) {
562 pPipeline->graphicsPipelineCI.pStages = new VkPipelineShaderStageCreateInfo[pCreateInfo->stageCount];
563 bufferSize = pCreateInfo->stageCount * sizeof(VkPipelineShaderStageCreateInfo);
564 memcpy((void*)pPipeline->graphicsPipelineCI.pStages, pCreateInfo->pStages, bufferSize);
565 }
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600566 if (pCreateInfo->pVertexInputState != NULL) {
567 memcpy((void*)&pPipeline->vertexInputCI, pCreateInfo->pVertexInputState , sizeof(VkPipelineVertexInputStateCreateInfo));
568 // Copy embedded ptrs
569 pVICI = pCreateInfo->pVertexInputState;
570 pPipeline->vtxBindingCount = pVICI->bindingCount;
571 if (pPipeline->vtxBindingCount) {
572 pPipeline->pVertexBindingDescriptions = new VkVertexInputBindingDescription[pPipeline->vtxBindingCount];
573 bufferSize = pPipeline->vtxBindingCount * sizeof(VkVertexInputBindingDescription);
574 memcpy((void*)pPipeline->pVertexBindingDescriptions, pVICI->pVertexBindingDescriptions, bufferSize);
575 }
576 pPipeline->vtxAttributeCount = pVICI->attributeCount;
577 if (pPipeline->vtxAttributeCount) {
578 pPipeline->pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[pPipeline->vtxAttributeCount];
579 bufferSize = pPipeline->vtxAttributeCount * sizeof(VkVertexInputAttributeDescription);
580 memcpy((void*)pPipeline->pVertexAttributeDescriptions, pVICI->pVertexAttributeDescriptions, bufferSize);
581 }
582 pPipeline->graphicsPipelineCI.pVertexInputState = &pPipeline->vertexInputCI;
583 }
Tony Barboure307f582015-07-10 15:29:03 -0600584 if (pCreateInfo->pInputAssemblyState != NULL) {
585 memcpy((void*)&pPipeline->iaStateCI, pCreateInfo->pInputAssemblyState, sizeof(VkPipelineInputAssemblyStateCreateInfo));
586 pPipeline->graphicsPipelineCI.pInputAssemblyState = &pPipeline->iaStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600587 }
Tony Barboure307f582015-07-10 15:29:03 -0600588 if (pCreateInfo->pTessellationState != NULL) {
589 memcpy((void*)&pPipeline->tessStateCI, pCreateInfo->pTessellationState, sizeof(VkPipelineTessellationStateCreateInfo));
590 pPipeline->graphicsPipelineCI.pTessellationState = &pPipeline->tessStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600591 }
Tony Barboure307f582015-07-10 15:29:03 -0600592 if (pCreateInfo->pViewportState != NULL) {
593 memcpy((void*)&pPipeline->vpStateCI, pCreateInfo->pViewportState, sizeof(VkPipelineViewportStateCreateInfo));
594 pPipeline->graphicsPipelineCI.pViewportState = &pPipeline->vpStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600595 }
Tony Barboure307f582015-07-10 15:29:03 -0600596 if (pCreateInfo->pRasterState != NULL) {
597 memcpy((void*)&pPipeline->rsStateCI, pCreateInfo->pRasterState, sizeof(VkPipelineRasterStateCreateInfo));
598 pPipeline->graphicsPipelineCI.pRasterState = &pPipeline->rsStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600599 }
Tony Barboure307f582015-07-10 15:29:03 -0600600 if (pCreateInfo->pMultisampleState != NULL) {
601 memcpy((void*)&pPipeline->msStateCI, pCreateInfo->pMultisampleState, sizeof(VkPipelineMultisampleStateCreateInfo));
602 pPipeline->graphicsPipelineCI.pMultisampleState = &pPipeline->msStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600603 }
Tobin Ehlisf6cb4672015-09-29 08:18:34 -0600604 if (pCreateInfo->pDepthStencilState != NULL) {
605 memcpy((void*)&pPipeline->dsStateCI, pCreateInfo->pDepthStencilState, sizeof(VkPipelineDepthStencilStateCreateInfo));
606 pPipeline->graphicsPipelineCI.pDepthStencilState = &pPipeline->dsStateCI;
607 }
Tony Barboure307f582015-07-10 15:29:03 -0600608 if (pCreateInfo->pColorBlendState != NULL) {
609 memcpy((void*)&pPipeline->cbStateCI, pCreateInfo->pColorBlendState, sizeof(VkPipelineColorBlendStateCreateInfo));
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600610 // Copy embedded ptrs
Tony Barboure307f582015-07-10 15:29:03 -0600611 pCBCI = pCreateInfo->pColorBlendState;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600612 pPipeline->attachmentCount = pCBCI->attachmentCount;
613 if (pPipeline->attachmentCount) {
Tony Barboure307f582015-07-10 15:29:03 -0600614 pPipeline->pAttachments = new VkPipelineColorBlendAttachmentState[pPipeline->attachmentCount];
615 bufferSize = pPipeline->attachmentCount * sizeof(VkPipelineColorBlendAttachmentState);
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600616 memcpy((void*)pPipeline->pAttachments, pCBCI->pAttachments, bufferSize);
617 }
Tony Barboure307f582015-07-10 15:29:03 -0600618 pPipeline->graphicsPipelineCI.pColorBlendState = &pPipeline->cbStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600619 }
Tobin Ehlisf6cb4672015-09-29 08:18:34 -0600620 if (pCreateInfo->pDynamicState != NULL) {
621 memcpy((void*)&pPipeline->dynStateCI, pCreateInfo->pDynamicState, sizeof(VkPipelineDynamicStateCreateInfo));
622 if (pPipeline->dynStateCI.dynamicStateCount) {
623 pPipeline->dynStateCI.pDynamicStates = new VkDynamicState[pPipeline->dynStateCI.dynamicStateCount];
624 bufferSize = pPipeline->dynStateCI.dynamicStateCount * sizeof(VkDynamicState);
625 memcpy((void*)pPipeline->dynStateCI.pDynamicStates, pCreateInfo->pDynamicState->pDynamicStates, bufferSize);
626 }
627 pPipeline->graphicsPipelineCI.pDynamicState = &pPipeline->dynStateCI;
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600628 }
629
Tobin Ehlisde63c532015-06-18 15:59:33 -0600630 return pPipeline;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600631}
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600632
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600633// Free the Pipeline nodes
Tobin Ehliseaf28662015-04-08 10:58:37 -0600634static void deletePipelines()
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600635{
David Pinedof5997ab2015-04-27 16:36:17 -0600636 if (pipelineMap.size() <= 0)
637 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600638 for (auto ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) {
Mark Lobodzinski0e0fb5c2015-06-23 15:11:57 -0600639 if ((*ii).second->graphicsPipelineCI.stageCount != 0) {
640 delete[] (*ii).second->graphicsPipelineCI.pStages;
641 }
Tobin Ehliscd3109e2015-04-01 11:59:08 -0600642 if ((*ii).second->pVertexBindingDescriptions) {
643 delete[] (*ii).second->pVertexBindingDescriptions;
644 }
645 if ((*ii).second->pVertexAttributeDescriptions) {
646 delete[] (*ii).second->pVertexAttributeDescriptions;
647 }
648 if ((*ii).second->pAttachments) {
649 delete[] (*ii).second->pAttachments;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600650 }
Tobin Ehlisf6cb4672015-09-29 08:18:34 -0600651 if ((*ii).second->dynStateCI.dynamicStateCount != 0) {
652 delete[] (*ii).second->dynStateCI.pDynamicStates;
653 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600654 delete (*ii).second;
655 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -0600656 pipelineMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600657}
Tobin Ehlis2464b882015-04-01 08:40:34 -0600658// For given pipeline, return number of MSAA samples, or one if MSAA disabled
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600659static uint32_t getNumSamples(const VkPipeline pipeline)
Tobin Ehlis2464b882015-04-01 08:40:34 -0600660{
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600661 PIPELINE_NODE* pPipe = pipelineMap[pipeline.handle];
Tobin Ehlisb3a506f2015-07-13 14:51:15 -0600662 if (VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
663 return pPipe->msStateCI.rasterSamples;
664 }
Tobin Ehlis2464b882015-04-01 08:40:34 -0600665 return 1;
666}
667// Validate state related to the PSO
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600668static VkBool32 validatePipelineState(const GLOBAL_CB_NODE* pCB, const VkPipelineBindPoint pipelineBindPoint, const VkPipeline pipeline)
Tobin Ehlis2464b882015-04-01 08:40:34 -0600669{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600670 if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) {
Tobin Ehlis2464b882015-04-01 08:40:34 -0600671 // Verify that any MSAA request in PSO matches sample# in bound FB
672 uint32_t psoNumSamples = getNumSamples(pipeline);
673 if (pCB->activeRenderPass) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600674 const VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass.handle];
Chia-I Wuc278df82015-07-07 11:50:03 +0800675 const VkSubpassDescription* pSD = &pRPCI->pSubpasses[pCB->activeSubpass];
676 int subpassNumSamples = 0;
677 uint32_t i;
678
679 for (i = 0; i < pSD->colorCount; i++) {
680 uint32_t samples;
681
Cody Northrop6de6b0b2015-08-04 11:16:41 -0600682 if (pSD->pColorAttachments[i].attachment == VK_ATTACHMENT_UNUSED)
Chia-I Wuc278df82015-07-07 11:50:03 +0800683 continue;
684
Cody Northrop6de6b0b2015-08-04 11:16:41 -0600685 samples = pRPCI->pAttachments[pSD->pColorAttachments[i].attachment].samples;
Chia-I Wuc278df82015-07-07 11:50:03 +0800686 if (subpassNumSamples == 0) {
687 subpassNumSamples = samples;
688 } else if (subpassNumSamples != samples) {
689 subpassNumSamples = -1;
690 break;
691 }
692 }
693 if (pSD->depthStencilAttachment.attachment != VK_ATTACHMENT_UNUSED) {
694 const uint32_t samples = pRPCI->pAttachments[pSD->depthStencilAttachment.attachment].samples;
695 if (subpassNumSamples == 0)
696 subpassNumSamples = samples;
697 else if (subpassNumSamples != samples)
698 subpassNumSamples = -1;
699 }
700
701 if (psoNumSamples != subpassNumSamples) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600702 return log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -0600703 "Num samples mismatch! Binding PSO (%#" PRIxLEAST64 ") with %u samples while current RenderPass (%#" PRIxLEAST64 ") w/ %u samples!",
704 pipeline.handle, psoNumSamples, pCB->activeRenderPass.handle, subpassNumSamples);
Tobin Ehlis2464b882015-04-01 08:40:34 -0600705 }
706 } else {
707 // TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
708 // Verify and flag error as appropriate
709 }
710 // TODO : Add more checks here
711 } else {
712 // TODO : Validate non-gfx pipeline updates
713 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600714 return VK_FALSE;
Tobin Ehlis2464b882015-04-01 08:40:34 -0600715}
716
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600717// Block of code at start here specifically for managing/tracking DSs
718
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600719// Return Pool node ptr for specified pool or else NULL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600720static POOL_NODE* getPoolNode(VkDescriptorPool pool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600721{
722 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600723 if (poolMap.find(pool.handle) == poolMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600724 loader_platform_thread_unlock_mutex(&globalLock);
725 return NULL;
726 }
727 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600728 return poolMap[pool.handle];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600729}
730// Return Set node ptr for specified set or else NULL
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600731static SET_NODE* getSetNode(VkDescriptorSet set)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600732{
733 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600734 if (setMap.find(set.handle) == setMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600735 loader_platform_thread_unlock_mutex(&globalLock);
736 return NULL;
737 }
738 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600739 return setMap[set.handle];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600740}
741
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600742static LAYOUT_NODE* getLayoutNode(const VkDescriptorSetLayout layout) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600743 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600744 if (layoutMap.find(layout.handle) == layoutMap.end()) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600745 loader_platform_thread_unlock_mutex(&globalLock);
746 return NULL;
747 }
748 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600749 return layoutMap[layout.handle];
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600750}
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600751// Return VK_FALSE if update struct is of valid type, otherwise flag error and return code from callback
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600752static VkBool32 validUpdateStruct(const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600753{
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600754 switch (pUpdateStruct->sType)
755 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800756 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
757 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600758 return VK_FALSE;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600759 default:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600760 return log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600761 "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 -0600762 }
763}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600764// For given update struct, return binding
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600765static VkBool32 getUpdateBinding(const VkDevice device, const GENERIC_HEADER* pUpdateStruct, uint32_t* binding)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600766{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600767 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600768 switch (pUpdateStruct->sType)
769 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800770 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600771 *binding = ((VkWriteDescriptorSet*)pUpdateStruct)->destBinding;
772 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800773 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600774 *binding = ((VkCopyDescriptorSet*)pUpdateStruct)->destBinding;
775 break;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600776 default:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600777 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600778 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600779 *binding = 0xFFFFFFFF;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600780 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600781 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600782}
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600783// Set arrayIndex for given update struct in the last parameter
784// Return value of skipCall, which is only VK_TRUE is error occurs and callback signals execution to cease
785static uint32_t getUpdateArrayIndex(const VkDevice device, const GENERIC_HEADER* pUpdateStruct, uint32_t* arrayIndex)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600786{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600787 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600788 switch (pUpdateStruct->sType)
789 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800790 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600791 *arrayIndex = ((VkWriteDescriptorSet*)pUpdateStruct)->destArrayElement;
792 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800793 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600794 // TODO : Need to understand this case better and make sure code is correct
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600795 *arrayIndex = ((VkCopyDescriptorSet*)pUpdateStruct)->destArrayElement;
796 break;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600797 default:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600798 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600799 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600800 *arrayIndex = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600801 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600802 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600803}
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600804// Set count for given update struct in the last parameter
805// Return value of skipCall, which is only VK_TRUE is error occurs and callback signals execution to cease
806static uint32_t getUpdateCount(const VkDevice device, const GENERIC_HEADER* pUpdateStruct, uint32_t* count)
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600807{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600808 VkBool32 skipCall = VK_FALSE;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600809 switch (pUpdateStruct->sType)
810 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800811 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600812 *count = ((VkWriteDescriptorSet*)pUpdateStruct)->count;
813 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800814 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600815 // TODO : Need to understand this case better and make sure code is correct
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600816 *count = ((VkCopyDescriptorSet*)pUpdateStruct)->count;
817 break;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600818 default:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600819 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600820 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600821 *count = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600822 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600823 return skipCall;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600824}
825// For given Layout Node and binding, return index where that binding begins
826static uint32_t getBindingStartIndex(const LAYOUT_NODE* pLayout, const uint32_t binding)
827{
828 uint32_t offsetIndex = 0;
829 for (uint32_t i = 0; i<binding; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +0800830 offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600831 }
832 return offsetIndex;
833}
834// For given layout node and binding, return last index that is updated
835static uint32_t getBindingEndIndex(const LAYOUT_NODE* pLayout, const uint32_t binding)
836{
837 uint32_t offsetIndex = 0;
838 for (uint32_t i = 0; i<=binding; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +0800839 offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600840 }
841 return offsetIndex-1;
842}
843// For given layout and update, return the first overall index of the layout that is update
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600844static VkBool32 getUpdateStartIndex(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct, uint32_t* startIndex)
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600845{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600846 uint32_t binding = 0, arrayIndex = 0;
847 VkBool32 skipCall = getUpdateBinding(device, pUpdateStruct, &binding);
848 skipCall |= getUpdateArrayIndex(device, pUpdateStruct, &arrayIndex);
849 if (VK_FALSE == skipCall)
850 *startIndex = getBindingStartIndex(pLayout, binding)+arrayIndex;
851 return skipCall;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600852}
853// For given layout and update, return the last overall index of the layout that is update
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600854static VkBool32 getUpdateEndIndex(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct, uint32_t* endIndex)
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600855{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600856 uint32_t binding = 0, arrayIndex = 0, count = 0;
857 VkBool32 skipCall = getUpdateBinding(device, pUpdateStruct, &binding);
858 skipCall |= getUpdateArrayIndex(device, pUpdateStruct, &arrayIndex);
859 skipCall |= getUpdateCount(device, pUpdateStruct, &count);
860 if (VK_FALSE == skipCall)
861 *endIndex = getBindingStartIndex(pLayout, binding)+arrayIndex+count-1;
862 return skipCall;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600863}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600864// Verify that the descriptor type in the update struct matches what's expected by the layout
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600865static VkBool32 validateUpdateType(const VkDevice device, const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600866{
867 // First get actual type of update
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600868 VkBool32 skipCall = VK_FALSE;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600869 VkDescriptorType actualType;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600870 uint32_t i = 0, startIndex = 0, endIndex = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600871 switch (pUpdateStruct->sType)
872 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800873 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
874 actualType = ((VkWriteDescriptorSet*)pUpdateStruct)->descriptorType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600875 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800876 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
877 /* no need to validate */
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600878 return VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600879 break;
880 default:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600881 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600882 "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 -0600883 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600884 skipCall |= getUpdateStartIndex(device, pLayout, pUpdateStruct, &startIndex);
885 skipCall |= getUpdateEndIndex(device, pLayout, pUpdateStruct, &endIndex);
886 if (VK_FALSE == skipCall) {
887 for (i = startIndex; i <= endIndex; i++) {
Tobin Ehlis3b341092015-09-30 08:30:20 -0600888 if (pLayout->pTypes[i] != actualType) {
889 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS",
890 "Descriptor update type of %s has descriptor type %s that does not match overlapping binding descriptor type of %s!",
891 string_VkStructureType(pUpdateStruct->sType), string_VkDescriptorType(actualType), string_VkDescriptorType(pLayout->pTypes[i]));
892 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600893 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600894 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600895 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600896}
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600897// Determine the update type, allocate a new struct of that type, shadow the given pUpdate
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600898// struct into the pNewNode param. Return VK_TRUE if error condition encountered and callback signals early exit.
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600899// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600900static VkBool32 shadowUpdateNode(const VkDevice device, GENERIC_HEADER* pUpdate, GENERIC_HEADER** pNewNode)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600901{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600902 VkBool32 skipCall = VK_FALSE;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800903 VkWriteDescriptorSet* pWDS = NULL;
904 VkCopyDescriptorSet* pCDS = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600905 size_t array_size = 0;
906 size_t base_array_size = 0;
907 size_t total_array_size = 0;
908 size_t baseBuffAddr = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600909 switch (pUpdate->sType)
910 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800911 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
912 pWDS = new VkWriteDescriptorSet;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600913 *pNewNode = (GENERIC_HEADER*)pWDS;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800914 memcpy(pWDS, pUpdate, sizeof(VkWriteDescriptorSet));
915 pWDS->pDescriptors = new VkDescriptorInfo[pWDS->count];
916 array_size = sizeof(VkDescriptorInfo) * pWDS->count;
917 memcpy((void*)pWDS->pDescriptors, ((VkWriteDescriptorSet*)pUpdate)->pDescriptors, array_size);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600918 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800919 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
920 pCDS = new VkCopyDescriptorSet;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600921 *pNewNode = (GENERIC_HEADER*)pCDS;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800922 memcpy(pCDS, pUpdate, sizeof(VkCopyDescriptorSet));
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600923 break;
924 default:
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600925 if (log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS",
926 "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdate->sType), pUpdate->sType))
927 return VK_TRUE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600928 }
929 // Make sure that pNext for the end of shadow copy is NULL
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600930 (*pNewNode)->pNext = NULL;
931 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600932}
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800933// update DS mappings based on ppUpdateArray
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600934static VkBool32 dsUpdate(VkDevice device, VkStructureType type, uint32_t updateCount, const void* pUpdateArray)
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600935{
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800936 const VkWriteDescriptorSet *pWDS = NULL;
937 const VkCopyDescriptorSet *pCDS = NULL;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600938 VkBool32 skipCall = VK_FALSE;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800939
940 if (type == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET)
941 pWDS = (const VkWriteDescriptorSet *) pUpdateArray;
942 else
943 pCDS = (const VkCopyDescriptorSet *) pUpdateArray;
944
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600945 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600946 LAYOUT_NODE* pLayout = NULL;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600947 VkDescriptorSetLayoutCreateInfo* pLayoutCI = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600948 // TODO : If pCIList is NULL, flag error
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600949 // Perform all updates
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600950 for (uint32_t i = 0; i < updateCount; i++) {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800951 VkDescriptorSet ds = (pWDS) ? pWDS->destSet : pCDS->destSet;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -0600952 SET_NODE* pSet = setMap[ds.handle]; // getSetNode() without locking
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800953 g_lastBoundDescriptorSet = pSet->set;
954 GENERIC_HEADER* pUpdate = (pWDS) ? (GENERIC_HEADER*) &pWDS[i] : (GENERIC_HEADER*) &pCDS[i];
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600955 pLayout = pSet->pLayout;
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600956 // First verify valid update struct
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600957 if ((skipCall = validUpdateStruct(device, pUpdate)) == VK_TRUE) {
Tobin Ehlis0b551cd2015-05-28 12:10:17 -0600958 break;
959 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600960 // Make sure that binding is within bounds
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600961 uint32_t binding = 0, endIndex = 0;
962 skipCall |= getUpdateBinding(device, pUpdate, &binding);
963 if (pLayout->createInfo.count < binding) {
964 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
965 "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, binding, string_VkStructureType(pUpdate->sType));
Tobin Ehlise42007c2015-06-19 13:00:59 -0600966 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600967 // Next verify that update falls within size of given binding
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600968 skipCall |= getUpdateBinding(device, pUpdate, &binding);
969 skipCall |= getUpdateEndIndex(device, pLayout, pUpdate, &endIndex);
970 if (getBindingEndIndex(pLayout, binding) < endIndex) {
Tony Barbour29b12062015-07-13 13:37:24 -0600971 // TODO : Keep count of layout CI structs and size this string dynamically based on that count
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600972 pLayoutCI = &pLayout->createInfo;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600973 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600974 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
975 "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str());
Tobin Ehlise42007c2015-06-19 13:00:59 -0600976 } else { // TODO : should we skip update on a type mismatch or force it?
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600977 // Layout bindings match w/ update ok, now verify that update is of the right type
Tobin Ehlis3b341092015-09-30 08:30:20 -0600978 if ((skipCall = validateUpdateType(device, pLayout, pUpdate)) == VK_FALSE) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600979 // Save the update info
980 // TODO : Info message that update successful
981 // Create new update struct for this set's shadow copy
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600982 GENERIC_HEADER* pNewNode = NULL;
983 skipCall |= shadowUpdateNode(device, pUpdate, &pNewNode);
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600984 if (NULL == pNewNode) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600985 skipCall |= log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -0600986 "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
Tobin Ehlise42007c2015-06-19 13:00:59 -0600987 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600988 // Insert shadow node into LL of updates for this set
989 pNewNode->pNext = pSet->pUpdateStructs;
990 pSet->pUpdateStructs = pNewNode;
991 // Now update appropriate descriptor(s) to point to new Update node
Tobin Ehlis48ddcb82015-09-09 11:31:10 -0600992 skipCall |= getUpdateEndIndex(device, pLayout, pUpdate, &endIndex);
993 uint32_t startIndex;
994 skipCall |= getUpdateStartIndex(device, pLayout, pUpdate, &startIndex);
995 for (uint32_t j = startIndex; j <= endIndex; j++) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -0600996 assert(j<pSet->descriptorCount);
997 pSet->ppDescriptors[j] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -0600998 }
999 }
1000 }
1001 }
1002 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001003 }
1004 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001005 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001006}
1007// Free the shadowed update node for this Set
1008// NOTE : Calls to this function should be wrapped in mutex
1009static void freeShadowUpdateTree(SET_NODE* pSet)
1010{
1011 GENERIC_HEADER* pShadowUpdate = pSet->pUpdateStructs;
1012 pSet->pUpdateStructs = NULL;
1013 GENERIC_HEADER* pFreeUpdate = pShadowUpdate;
1014 // Clear the descriptor mappings as they will now be invalid
1015 memset(pSet->ppDescriptors, 0, pSet->descriptorCount*sizeof(GENERIC_HEADER*));
1016 while(pShadowUpdate) {
1017 pFreeUpdate = pShadowUpdate;
1018 pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext;
1019 uint32_t index = 0;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001020 VkWriteDescriptorSet * pWDS = NULL;
1021 VkCopyDescriptorSet * pCDS = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001022 void** ppToFree = NULL;
1023 switch (pFreeUpdate->sType)
1024 {
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001025 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
1026 pWDS = (VkWriteDescriptorSet*)pFreeUpdate;
1027 if (pWDS->pDescriptors)
1028 delete[] pWDS->pDescriptors;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001029 break;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08001030 case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001031 break;
1032 default:
1033 assert(0);
1034 break;
1035 }
Tobin Ehliseaf28662015-04-08 10:58:37 -06001036 delete pFreeUpdate;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001037 }
1038}
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001039// Free all DS Pools including their Sets & related sub-structs
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001040// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -06001041static void deletePools()
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001042{
David Pinedof5997ab2015-04-27 16:36:17 -06001043 if (poolMap.size() <= 0)
1044 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001045 for (auto ii=poolMap.begin(); ii!=poolMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001046 SET_NODE* pSet = (*ii).second->pSets;
1047 SET_NODE* pFreeSet = pSet;
1048 while (pSet) {
1049 pFreeSet = pSet;
1050 pSet = pSet->pNext;
Tobin Ehliseaf28662015-04-08 10:58:37 -06001051 // Freeing layouts handled in deleteLayouts() function
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001052 // Free Update shadow struct tree
1053 freeShadowUpdateTree(pFreeSet);
1054 if (pFreeSet->ppDescriptors) {
Chris Forbes4506d3f2015-06-04 10:49:27 +12001055 delete[] pFreeSet->ppDescriptors;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001056 }
1057 delete pFreeSet;
1058 }
1059 if ((*ii).second->createInfo.pTypeCount) {
Chris Forbes4506d3f2015-06-04 10:49:27 +12001060 delete[] (*ii).second->createInfo.pTypeCount;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001061 }
1062 delete (*ii).second;
1063 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -06001064 poolMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001065}
Tobin Ehliseaf28662015-04-08 10:58:37 -06001066// WARN : Once deleteLayouts() called, any layout ptrs in Pool/Set data structure will be invalid
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001067// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -06001068static void deleteLayouts()
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001069{
David Pinedof5997ab2015-04-27 16:36:17 -06001070 if (layoutMap.size() <= 0)
1071 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001072 for (auto ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001073 LAYOUT_NODE* pLayout = (*ii).second;
Tobin Ehliseaf28662015-04-08 10:58:37 -06001074 if (pLayout->createInfo.pBinding) {
1075 for (uint32_t i=0; i<pLayout->createInfo.count; i++) {
1076 if (pLayout->createInfo.pBinding[i].pImmutableSamplers)
1077 delete[] pLayout->createInfo.pBinding[i].pImmutableSamplers;
1078 }
1079 delete[] pLayout->createInfo.pBinding;
1080 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001081 if (pLayout->pTypes) {
Chris Forbes4506d3f2015-06-04 10:49:27 +12001082 delete[] pLayout->pTypes;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001083 }
1084 delete pLayout;
1085 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -06001086 layoutMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001087}
1088// Currently clearing a set is removing all previous updates to that set
1089// TODO : Validate if this is correct clearing behavior
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001090static void clearDescriptorSet(VkDescriptorSet set)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001091{
1092 SET_NODE* pSet = getSetNode(set);
1093 if (!pSet) {
1094 // TODO : Return error
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001095 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001096 loader_platform_thread_lock_mutex(&globalLock);
1097 freeShadowUpdateTree(pSet);
1098 loader_platform_thread_unlock_mutex(&globalLock);
1099 }
1100}
1101
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001102static void clearDescriptorPool(VkDevice device, VkDescriptorPool pool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001103{
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001104 POOL_NODE* pPool = getPoolNode(pool);
1105 if (!pPool) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001106 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
1107 "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", pool.handle);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001108 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001109 // For every set off of this pool, clear it
1110 SET_NODE* pSet = pPool->pSets;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001111 while (pSet) {
1112 clearDescriptorSet(pSet->set);
1113 }
1114 }
1115}
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001116// For given CB object, fetch associated CB Node from map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001117static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001118{
1119 loader_platform_thread_lock_mutex(&globalLock);
1120 if (cmdBufferMap.find(cb) == cmdBufferMap.end()) {
1121 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001122 // TODO : How to pass cb as srcObj here?
1123 log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -06001124 "Attempt to use CmdBuffer %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast<uint64_t>(cb));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001125 return NULL;
1126 }
1127 loader_platform_thread_unlock_mutex(&globalLock);
1128 return cmdBufferMap[cb];
1129}
1130// Free all CB Nodes
1131// NOTE : Calls to this function should be wrapped in mutex
Tobin Ehliseaf28662015-04-08 10:58:37 -06001132static void deleteCmdBuffers()
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001133{
David Pinedof5997ab2015-04-27 16:36:17 -06001134 if (cmdBufferMap.size() <= 0)
1135 return;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001136 for (auto ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) {
Courtney Goeltzenleuchter09098a72015-04-27 15:04:43 -06001137 vector<CMD_NODE*> cmd_node_list = (*ii).second->pCmds;
1138 while (!cmd_node_list.empty()) {
1139 CMD_NODE* cmd_node = cmd_node_list.back();
1140 delete cmd_node;
1141 cmd_node_list.pop_back();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001142 }
1143 delete (*ii).second;
1144 }
Jon Ashburnd0cb7cd2015-06-15 10:58:28 -06001145 cmdBufferMap.clear();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001146}
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001147static VkBool32 report_error_no_cb_begin(const VkCmdBuffer cb, const char* caller_name)
Tobin Ehlise42007c2015-06-19 13:00:59 -06001148{
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001149 // TODO : How to pass cb as srcObj here?
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001150 return log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_CMD_BUFFER, "DS",
Tobin Ehlise42007c2015-06-19 13:00:59 -06001151 "You must call vkBeginCommandBuffer() before this call to %s", (void*)caller_name);
1152}
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001153static VkBool32 addCmd(GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001154{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001155 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001156 CMD_NODE* pCmd = new CMD_NODE;
1157 if (pCmd) {
1158 // init cmd node and append to end of cmd LL
1159 memset(pCmd, 0, sizeof(CMD_NODE));
1160 pCmd->cmdNumber = ++pCB->numCmds;
1161 pCmd->type = cmd;
1162 pCB->pCmds.push_back(pCmd);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001163 } else {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001164 // TODO : How to pass cb as srcObj here?
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001165 skipCall |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -06001166 "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %#" PRIxLEAST64, reinterpret_cast<uint64_t>(pCB->cmdBuffer));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001167 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001168 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001169}
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001170static void resetCB(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001171{
1172 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1173 if (pCB) {
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001174 vector<CMD_NODE*> cmd_list = pCB->pCmds;
1175 while (!cmd_list.empty()) {
1176 delete cmd_list.back();
1177 cmd_list.pop_back();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001178 }
Courtney Goeltzenleuchterf03711e2015-04-27 17:16:56 -06001179 pCB->pCmds.clear();
Tobin Ehlis0cea4082015-08-18 07:10:58 -06001180 // Reset CB state (need to save createInfo)
1181 VkCmdBufferCreateInfo saveCBCI = pCB->createInfo;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001182 memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
1183 pCB->cmdBuffer = cb;
Tobin Ehlis0cea4082015-08-18 07:10:58 -06001184 pCB->createInfo = saveCBCI;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001185 pCB->lastVtxBinding = MAX_BINDING;
1186 }
1187}
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001188// Set PSO-related status bits for CB, including dynamic state set via PSO
Tobin Ehlis97866202015-06-10 12:57:07 -06001189static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe)
1190{
1191 for (uint32_t i = 0; i < pPipe->cbStateCI.attachmentCount; i++) {
1192 if (0 != pPipe->pAttachments[i].channelWriteMask) {
1193 pCB->status |= CBSTATUS_COLOR_BLEND_WRITE_ENABLE;
1194 }
1195 }
1196 if (pPipe->dsStateCI.depthWriteEnable) {
Cody Northrop2605cb02015-08-18 15:21:16 -06001197 pCB->status |= CBSTATUS_DEPTH_WRITE_ENABLE;
1198 }
Cody Northrop2605cb02015-08-18 15:21:16 -06001199 if (pPipe->dsStateCI.stencilTestEnable) {
1200 pCB->status |= CBSTATUS_STENCIL_TEST_ENABLE;
Tobin Ehlis97866202015-06-10 12:57:07 -06001201 }
Tobin Ehlisa88e2f52015-10-02 11:00:56 -06001202 // Account for any dynamic state not set via this PSO
1203 if (!pPipe->dynStateCI.dynamicStateCount) { // All state is static
1204 pCB->status = CBSTATUS_ALL;
1205 } else {
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001206 // First consider all state on
1207 // Then unset any state that's noted as dynamic in PSO
1208 // Finally OR that into CB statemask
1209 CBStatusFlags psoDynStateMask = CBSTATUS_ALL;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001210 for (uint32_t i=0; i < pPipe->dynStateCI.dynamicStateCount; i++) {
1211 switch (pPipe->dynStateCI.pDynamicStates[i]) {
1212 case VK_DYNAMIC_STATE_VIEWPORT:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001213 psoDynStateMask &= ~CBSTATUS_VIEWPORT_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001214 break;
1215 case VK_DYNAMIC_STATE_SCISSOR:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001216 psoDynStateMask &= ~CBSTATUS_SCISSOR_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001217 break;
1218 case VK_DYNAMIC_STATE_LINE_WIDTH:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001219 psoDynStateMask &= ~CBSTATUS_LINE_WIDTH_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001220 break;
1221 case VK_DYNAMIC_STATE_DEPTH_BIAS:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001222 psoDynStateMask &= ~CBSTATUS_DEPTH_BIAS_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001223 break;
1224 case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001225 psoDynStateMask &= ~CBSTATUS_BLEND_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001226 break;
1227 case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001228 psoDynStateMask &= ~CBSTATUS_DEPTH_BOUNDS_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001229 break;
1230 case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001231 psoDynStateMask &= ~CBSTATUS_STENCIL_READ_MASK_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001232 break;
1233 case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001234 psoDynStateMask &= ~CBSTATUS_STENCIL_WRITE_MASK_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001235 break;
1236 case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001237 psoDynStateMask &= ~CBSTATUS_STENCIL_REFERENCE_SET;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001238 break;
1239 default:
1240 // TODO : Flag error here
1241 break;
1242 }
1243 }
Tobin Ehlis3dec46c2015-10-01 09:24:40 -06001244 pCB->status |= psoDynStateMask;
Tobin Ehlisf6cb4672015-09-29 08:18:34 -06001245 }
Tobin Ehlis97866202015-06-10 12:57:07 -06001246}
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001247// Print the last bound Gfx Pipeline
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001248static VkBool32 printPipeline(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001249{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001250 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001251 GLOBAL_CB_NODE* pCB = getCBNode(cb);
1252 if (pCB) {
1253 PIPELINE_NODE *pPipeTrav = getPipeline(pCB->lastBoundPipeline);
1254 if (!pPipeTrav) {
1255 // nothing to print
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001256 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001257 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001258 vk_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001259 }
1260 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001261 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001262}
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001263// Print details of DS config to stdout
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001264static VkBool32 printDSConfig(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001265{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001266 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001267 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.
1268 GLOBAL_CB_NODE* pCB = getCBNode(cb);
Tobin Ehlis7297f192015-06-09 08:39:32 -06001269 if (pCB && pCB->lastBoundDescriptorSet) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001270 SET_NODE* pSet = getSetNode(pCB->lastBoundDescriptorSet);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001271 POOL_NODE* pPool = getPoolNode(pSet->pool);
1272 // Print out pool details
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001273 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001274 "Details for pool %#" PRIxLEAST64 ".", pPool->pool.handle);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001275 string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " ");
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001276 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001277 "%s", poolStr.c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001278 // Print out set details
1279 char prefix[10];
1280 uint32_t index = 0;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001281 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001282 "Details for descriptor set %#" PRIxLEAST64 ".", pSet->set.handle);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001283 LAYOUT_NODE* pLayout = pSet->pLayout;
1284 // Print layout details
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001285 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001286 "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (void*)pLayout->layout.handle, (void*)pSet->set.handle);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001287 sprintf(prefix, " [L%u] ", index);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001288 string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str();
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001289 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001290 "%s", DSLstr.c_str());
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001291 index++;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001292 GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
1293 if (pUpdate) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001294 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001295 "Update Chain [UC] for descriptor set %#" PRIxLEAST64 ":", pSet->set.handle);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001296 sprintf(prefix, " [UC] ");
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001297 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001298 dynamic_display(pUpdate, prefix).c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001299 // TODO : If there is a "view" associated with this update, print CI for that view
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001300 } else {
Tobin Ehlis2bca8b02015-06-15 08:41:17 -06001301 if (0 != pSet->descriptorCount) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001302 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001303 "No Update Chain for descriptor set %#" PRIxLEAST64 " which has %u descriptors (vkUpdateDescriptors has not been called)", pSet->set.handle, pSet->descriptorCount);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001304 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001305 skipCall |= log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001306 "FYI: No descriptors in descriptor set %#" PRIxLEAST64 ".", pSet->set.handle);
Tobin Ehlis2bca8b02015-06-15 08:41:17 -06001307 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001308 }
1309 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001310 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001311}
1312
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001313static void printCB(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001314{
1315 GLOBAL_CB_NODE* pCB = getCBNode(cb);
David Pinedof5997ab2015-04-27 16:36:17 -06001316 if (pCB && pCB->pCmds.size() > 0) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001317 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001318 "Cmds in CB %p", (void*)cb);
Courtney Goeltzenleuchtercf2a5362015-04-27 11:16:35 -06001319 vector<CMD_NODE*> pCmds = pCB->pCmds;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001320 for (auto ii=pCmds.begin(); ii!=pCmds.end(); ++ii) {
1321 // TODO : Need to pass cb as srcObj here
1322 log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001323 " CMD#%lu: %s", (*ii)->cmdNumber, cmdTypeToString((*ii)->type).c_str());
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001324 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001325 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001326 // Nothing to print
1327 }
1328}
1329
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001330static VkBool32 synchAndPrintDSConfig(const VkCmdBuffer cb)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001331{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001332 VkBool32 skipCall = VK_FALSE;
Mike Stroyanfa2f2222015-08-12 17:11:28 -06001333 if (!(mdd(cb)->active_flags & VK_DBG_REPORT_INFO_BIT)) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001334 return skipCall;
Mike Stroyanfa2f2222015-08-12 17:11:28 -06001335 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001336 skipCall |= printDSConfig(cb);
1337 skipCall |= printPipeline(cb);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001338 return skipCall;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001339}
1340
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06001341// Flags validation error if the associated call is made inside a render pass. The apiName
1342// routine should ONLY be called outside a render pass.
1343static VkBool32 insideRenderPass(GLOBAL_CB_NODE *pCB, const char *apiName)
1344{
1345 VkBool32 inside = VK_FALSE;
1346 if (pCB->activeRenderPass) {
1347 inside = log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
1348 (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
1349 "%s: It is invalid to issue this call inside an active render pass (%#" PRIxLEAST64 ")",
1350 apiName, pCB->activeRenderPass.handle);
1351 }
1352 return inside;
1353}
1354
1355// Flags validation error if the associated call is made outside a render pass. The apiName
1356// routine should ONLY be called inside a render pass.
1357static VkBool32 outsideRenderPass(GLOBAL_CB_NODE *pCB, const char *apiName)
1358{
1359 VkBool32 outside = VK_FALSE;
1360 if (!pCB->activeRenderPass) {
1361 outside = log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
Mark Lobodzinski70244842015-10-01 17:00:47 -06001362 (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06001363 "%s: This call must be issued inside an active render pass.", apiName);
1364 }
1365 return outside;
1366}
1367
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001368static void init_draw_state(layer_data *my_data)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001369{
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001370 uint32_t report_flags = 0;
1371 uint32_t debug_action = 0;
1372 FILE *log_output = NULL;
1373 const char *option_str;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001374 // initialize DrawState options
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001375 report_flags = getLayerOptionFlags("DrawStateReportFlags", 0);
1376 getLayerOptionEnum("DrawStateDebugAction", (uint32_t *) &debug_action);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001377
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001378 if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001379 {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001380 option_str = getLayerOption("DrawStateLogFilename");
Tobin Ehlisb4b6e7c2015-09-15 09:55:54 -06001381 log_output = getLayerLogOutput(option_str, "DrawState");
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001382 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 -06001383 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001384
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001385 if (!globalLockInitialized)
1386 {
Mike Stroyand9dd0072015-08-18 15:56:18 -06001387 // This mutex may be deleted by vkDestroyInstance of last instance.
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001388 loader_platform_thread_create_mutex(&globalLock);
1389 globalLockInitialized = 1;
1390 }
1391}
1392
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06001393VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
1394{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001395 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map,*pInstance);
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06001396 VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
1397
1398 if (result == VK_SUCCESS) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001399 layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
1400 my_data->report_data = debug_report_create_instance(
1401 pTable,
1402 *pInstance,
1403 pCreateInfo->extensionCount,
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001404 pCreateInfo->ppEnabledExtensionNames);
Courtney Goeltzenleuchterf4a2eba2015-06-08 14:58:39 -06001405
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001406 init_draw_state(my_data);
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06001407 }
1408 return result;
1409}
1410
Jon Ashburne0fa2282015-05-20 09:00:28 -06001411/* hook DestroyInstance to remove tableInstanceMap entry */
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001412VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
Jon Ashburne0fa2282015-05-20 09:00:28 -06001413{
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001414 dispatch_key key = get_dispatch_key(instance);
1415 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001416 pTable->DestroyInstance(instance);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001417
1418 // Clean up logging callback, if any
1419 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
1420 if (my_data->logging_callback) {
1421 layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);
1422 }
1423
Courtney Goeltzenleuchter2d034fd2015-06-28 13:01:17 -06001424 layer_debug_report_destroy_instance(my_data->report_data);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001425 layer_data_map.erase(pTable);
1426
1427 draw_state_instance_table_map.erase(key);
Mike Stroyand9dd0072015-08-18 15:56:18 -06001428 if (draw_state_instance_table_map.empty()) {
1429 // Release mutex when destroying last instance.
1430 loader_platform_thread_delete_mutex(&globalLock);
1431 globalLockInitialized = 0;
1432 }
Jon Ashburne0fa2282015-05-20 09:00:28 -06001433}
1434
Jon Ashburnf0615e22015-05-25 14:11:37 -06001435static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
1436{
Tony Barbour29b12062015-07-13 13:37:24 -06001437 uint32_t i;
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001438 VkLayerDispatchTable *pDisp = get_dispatch_table(draw_state_device_table_map, device);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06001439 deviceExtMap[pDisp].debug_marker_enabled = false;
Jon Ashburnf0615e22015-05-25 14:11:37 -06001440
1441 for (i = 0; i < pCreateInfo->extensionCount; i++) {
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001442 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], DEBUG_MARKER_EXTENSION_NAME) == 0) {
Jon Ashburn6f8cd632015-06-01 09:37:38 -06001443 /* Found a matching extension name, mark it enabled and init dispatch table*/
1444 initDebugMarkerTable(device);
1445 deviceExtMap[pDisp].debug_marker_enabled = true;
Jon Ashburnf0615e22015-05-25 14:11:37 -06001446 }
1447
1448 }
1449}
1450
Tony Barbour8205d902015-04-16 15:59:00 -06001451VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001452{
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -06001453 VkLayerDispatchTable *pDeviceTable = get_dispatch_table(draw_state_device_table_map, *pDevice);
1454 VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001455 if (result == VK_SUCCESS) {
1456 layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
1457 VkLayerDispatchTable *pTable = get_dispatch_table(draw_state_device_table_map, *pDevice);
1458 layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
1459 my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001460 createDeviceRegisterExtensions(pCreateInfo, *pDevice);
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001461 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001462 return result;
1463}
1464
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001465VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001466{
1467 // Free all the memory
1468 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehliseaf28662015-04-08 10:58:37 -06001469 deletePipelines();
1470 deleteSamplers();
1471 deleteImages();
1472 deleteBuffers();
1473 deleteCmdBuffers();
Tobin Ehliseaf28662015-04-08 10:58:37 -06001474 deletePools();
1475 deleteLayouts();
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001476 loader_platform_thread_unlock_mutex(&globalLock);
Jon Ashburne0fa2282015-05-20 09:00:28 -06001477
Jeremy Hayesea1fef52015-06-19 11:37:38 -06001478 dispatch_key key = get_dispatch_key(device);
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001479 VkLayerDispatchTable *pDisp = get_dispatch_table(draw_state_device_table_map, device);
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001480 pDisp->DestroyDevice(device);
Jon Ashburn7e07faf2015-06-18 15:02:58 -06001481 deviceExtMap.erase(pDisp);
Jeremy Hayesea1fef52015-06-19 11:37:38 -06001482 draw_state_device_table_map.erase(key);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06001483 tableDebugMarkerMap.erase(pDisp);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001484}
1485
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001486static const VkLayerProperties ds_global_layers[] = {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001487 {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001488 "DrawState",
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001489 VK_API_VERSION,
1490 VK_MAKE_VERSION(0, 1, 0),
1491 "Validation layer: DrawState",
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001492 }
Jon Ashburneb2728b2015-04-10 14:33:07 -06001493};
1494
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -06001495VK_LAYER_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001496 const char *pLayerName,
1497 uint32_t *pCount,
1498 VkExtensionProperties* pProperties)
Jon Ashburneb2728b2015-04-10 14:33:07 -06001499{
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001500 /* DrawState does not have any global extensions */
1501 return util_GetExtensionProperties(0, NULL, pCount, pProperties);
1502}
Jon Ashburneb2728b2015-04-10 14:33:07 -06001503
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -06001504VK_LAYER_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001505 uint32_t *pCount,
1506 VkLayerProperties* pProperties)
1507{
1508 return util_GetLayerProperties(ARRAY_SIZE(ds_global_layers),
1509 ds_global_layers,
1510 pCount, pProperties);
1511}
Jon Ashburneb2728b2015-04-10 14:33:07 -06001512
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001513static const VkExtensionProperties ds_device_extensions[] = {
1514 {
1515 DEBUG_MARKER_EXTENSION_NAME,
1516 VK_MAKE_VERSION(0, 1, 0),
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001517 }
1518};
1519
1520static const VkLayerProperties ds_device_layers[] = {
1521 {
1522 "DrawState",
1523 VK_API_VERSION,
1524 VK_MAKE_VERSION(0, 1, 0),
1525 "Validation layer: DrawState",
1526 }
1527};
1528
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -06001529VK_LAYER_EXPORT VkResult VKAPI vkEnumerateDeviceExtensionProperties(
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001530 VkPhysicalDevice physicalDevice,
1531 const char* pLayerName,
1532 uint32_t* pCount,
1533 VkExtensionProperties* pProperties)
1534{
1535 /* Mem tracker does not have any physical device extensions */
1536 return util_GetExtensionProperties(ARRAY_SIZE(ds_device_extensions), ds_device_extensions,
1537 pCount, pProperties);
1538}
1539
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -06001540VK_LAYER_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
Courtney Goeltzenleuchter73e8bd42015-07-06 22:31:52 -06001541 VkPhysicalDevice physicalDevice,
1542 uint32_t* pCount,
1543 VkLayerProperties* pProperties)
1544{
1545 /* Mem tracker's physical device layers are the same as global */
1546 return util_GetLayerProperties(ARRAY_SIZE(ds_device_layers), ds_device_layers,
1547 pCount, pProperties);
Jon Ashburneb2728b2015-04-10 14:33:07 -06001548}
1549
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001550VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001551{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001552 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001553 GLOBAL_CB_NODE* pCB = NULL;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001554 for (uint32_t i=0; i < cmdBufferCount; i++) {
1555 // Validate that cmd buffers have been updated
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001556 pCB = getCBNode(pCmdBuffers[i]);
1557 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis0cea4082015-08-18 07:10:58 -06001558 pCB->submitCount++; // increment submit count
1559 if ((pCB->beginInfo.flags & VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001560 skipCall |= log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS",
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -06001561 "CB %#" PRIxLEAST64 " was begun w/ VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT set, but has been submitted %#" PRIxLEAST64 " times.", reinterpret_cast<uint64_t>(pCB->cmdBuffer), pCB->submitCount);
Tobin Ehlis0cea4082015-08-18 07:10:58 -06001562 }
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001563 if (CB_UPDATE_COMPLETE != pCB->state) {
1564 // Flag error for using CB w/o vkEndCommandBuffer() called
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001565 // TODO : How to pass cb as srcObj?
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001566 skipCall |= log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_CMD_BUFFER, "DS",
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -06001567 "You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast<uint64_t>(pCB->cmdBuffer));
Tobin Ehlise90b1712015-05-27 14:30:06 -06001568 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001569 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlis28be0be2015-05-22 12:38:16 -06001570 }
Tobin Ehlise9b700e2015-05-26 16:06:50 -06001571 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001572 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001573 if (VK_FALSE == skipCall)
1574 return get_dispatch_table(draw_state_device_table_map, queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
1575 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001576}
1577
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001578VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001579{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001580 get_dispatch_table(draw_state_device_table_map, device)->DestroyFence(device, fence);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001581 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001582}
1583
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001584VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001585{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001586 get_dispatch_table(draw_state_device_table_map, device)->DestroySemaphore(device, semaphore);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001587 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001588}
1589
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001590VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001591{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001592 get_dispatch_table(draw_state_device_table_map, device)->DestroyEvent(device, event);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001593 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001594}
1595
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001596VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001597{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001598 get_dispatch_table(draw_state_device_table_map, device)->DestroyQueryPool(device, queryPool);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001599 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001600}
1601
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001602VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001603{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001604 get_dispatch_table(draw_state_device_table_map, device)->DestroyBuffer(device, buffer);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001605 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001606}
1607
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001608VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001609{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001610 get_dispatch_table(draw_state_device_table_map, device)->DestroyBufferView(device, bufferView);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001611 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001612}
1613
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001614VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001615{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001616 get_dispatch_table(draw_state_device_table_map, device)->DestroyImage(device, image);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001617 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001618}
1619
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001620VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001621{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001622 get_dispatch_table(draw_state_device_table_map, device)->DestroyImageView(device, imageView);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001623 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001624}
1625
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001626VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001627{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001628 get_dispatch_table(draw_state_device_table_map, device)->DestroyShaderModule(device, shaderModule);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001629 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001630}
1631
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001632VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001633{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001634 get_dispatch_table(draw_state_device_table_map, device)->DestroyShader(device, shader);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001635 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001636}
1637
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001638VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001639{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001640 get_dispatch_table(draw_state_device_table_map, device)->DestroyPipeline(device, pipeline);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001641 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001642}
1643
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001644VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001645{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001646 get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001647 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001648}
1649
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001650VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001651{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001652 get_dispatch_table(draw_state_device_table_map, device)->DestroySampler(device, sampler);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001653 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001654}
1655
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001656VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001657{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001658 get_dispatch_table(draw_state_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001659 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001660}
1661
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001662VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001663{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001664 get_dispatch_table(draw_state_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001665 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001666}
1667
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001668VK_LAYER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001669{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001670 get_dispatch_table(draw_state_device_table_map, device)->DestroyCommandBuffer(device, commandBuffer);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001671 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001672}
1673
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001674VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001675{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001676 get_dispatch_table(draw_state_device_table_map, device)->DestroyFramebuffer(device, framebuffer);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001677 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001678}
1679
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001680VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001681{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001682 get_dispatch_table(draw_state_device_table_map, device)->DestroyRenderPass(device, renderPass);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001683 // TODO : Clean up any internal data structures using this obj.
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001684}
1685
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001686VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001687{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001688 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001689 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001690 loader_platform_thread_lock_mutex(&globalLock);
1691 BUFFER_NODE* pNewNode = new BUFFER_NODE;
1692 pNewNode->buffer = *pView;
1693 pNewNode->createInfo = *pCreateInfo;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001694 bufferMap[pView->handle] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001695 loader_platform_thread_unlock_mutex(&globalLock);
1696 }
1697 return result;
1698}
1699
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001700VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001701{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001702 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001703 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001704 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001705 imageMap[pView->handle] = *pCreateInfo;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06001706 loader_platform_thread_unlock_mutex(&globalLock);
1707 }
1708 return result;
1709}
1710
Jon Ashburn0d60d272015-07-09 15:02:25 -06001711//TODO handle pipeline caches
1712VkResult VKAPI vkCreatePipelineCache(
1713 VkDevice device,
1714 const VkPipelineCacheCreateInfo* pCreateInfo,
1715 VkPipelineCache* pPipelineCache)
1716{
1717 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
1718 return result;
1719}
1720
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001721void VKAPI vkDestroyPipelineCache(
Jon Ashburn0d60d272015-07-09 15:02:25 -06001722 VkDevice device,
1723 VkPipelineCache pipelineCache)
1724{
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001725 get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineCache(device, pipelineCache);
Jon Ashburn0d60d272015-07-09 15:02:25 -06001726}
1727
1728size_t VKAPI vkGetPipelineCacheSize(
1729 VkDevice device,
1730 VkPipelineCache pipelineCache)
1731{
1732 size_t size = get_dispatch_table(draw_state_device_table_map, device)->GetPipelineCacheSize(device, pipelineCache);
1733 return size;
1734}
1735
1736VkResult VKAPI vkGetPipelineCacheData(
1737 VkDevice device,
1738 VkPipelineCache pipelineCache,
1739 void* pData)
1740{
1741 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pData);
1742 return result;
1743}
1744
1745VkResult VKAPI vkMergePipelineCaches(
1746 VkDevice device,
1747 VkPipelineCache destCache,
1748 uint32_t srcCacheCount,
1749 const VkPipelineCache* pSrcCaches)
1750{
1751 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
1752 return result;
1753}
1754
1755VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001756{
Courtney Goeltzenleuchtera54b76a2015-09-04 13:39:59 -06001757 VkResult result = VK_SUCCESS;
Tobin Ehlise48be202015-09-16 10:33:53 -06001758 //TODO What to do with pipelineCache?
Tobin Ehlisde63c532015-06-18 15:59:33 -06001759 // The order of operations here is a little convoluted but gets the job done
1760 // 1. Pipeline create state is first shadowed into PIPELINE_NODE struct
1761 // 2. Create state is then validated (which uses flags setup during shadowing)
1762 // 3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap
Tobin Ehlise48be202015-09-16 10:33:53 -06001763 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis76c18852015-09-17 16:33:58 -06001764 // TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic
1765 vector<PIPELINE_NODE*> pPipeNode(count);
Tobin Ehlise48be202015-09-16 10:33:53 -06001766 uint32_t i=0;
Tobin Ehlisde63c532015-06-18 15:59:33 -06001767 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlise48be202015-09-16 10:33:53 -06001768 for (i=0; i<count; i++) {
1769 pPipeNode[i] = initPipeline(&pCreateInfos[i], NULL);
1770 skipCall |= verifyPipelineCreateState(device, pPipeNode[i]);
1771 }
Tobin Ehlisde63c532015-06-18 15:59:33 -06001772 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001773 if (VK_FALSE == skipCall) {
Jon Ashburn0d60d272015-07-09 15:02:25 -06001774 result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
Tobin Ehlisde63c532015-06-18 15:59:33 -06001775 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlise48be202015-09-16 10:33:53 -06001776 for (i=0; i<count; i++) {
1777 pPipeNode[i]->pipeline = pPipelines[i];
1778 pipelineMap[pPipeNode[i]->pipeline.handle] = pPipeNode[i];
1779 }
Tobin Ehlisde63c532015-06-18 15:59:33 -06001780 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001781 } else {
Tobin Ehlise48be202015-09-16 10:33:53 -06001782 for (i=0; i<count; i++) {
1783 if (pPipeNode[i]) {
1784 // If we allocated a pipeNode, need to clean it up here
1785 delete[] pPipeNode[i]->pVertexBindingDescriptions;
1786 delete[] pPipeNode[i]->pVertexAttributeDescriptions;
1787 delete[] pPipeNode[i]->pAttachments;
1788 delete pPipeNode[i];
1789 }
Tobin Ehlisde63c532015-06-18 15:59:33 -06001790 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001791 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlisde63c532015-06-18 15:59:33 -06001792 }
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -06001793 return result;
1794}
1795
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001796VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001797{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001798 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001799 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001800 loader_platform_thread_lock_mutex(&globalLock);
1801 SAMPLER_NODE* pNewNode = new SAMPLER_NODE;
1802 pNewNode->sampler = *pSampler;
1803 pNewNode->createInfo = *pCreateInfo;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001804 sampleMap[pSampler->handle] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001805 loader_platform_thread_unlock_mutex(&globalLock);
1806 }
1807 return result;
1808}
1809
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001810VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001811{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001812 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001813 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001814 LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
1815 if (NULL == pNewNode) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001816 if (log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (*pSetLayout).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1817 "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()"))
1818 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001819 }
1820 memset(pNewNode, 0, sizeof(LAYOUT_NODE));
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001821 memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo));
1822 pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->count];
1823 memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->count);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001824 uint32_t totalCount = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001825 for (uint32_t i=0; i<pCreateInfo->count; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +08001826 totalCount += pCreateInfo->pBinding[i].arraySize;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001827 if (pCreateInfo->pBinding[i].pImmutableSamplers) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001828 VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers;
Chia-I Wud3114a22015-05-25 16:22:52 +08001829 *ppIS = new VkSampler[pCreateInfo->pBinding[i].arraySize];
1830 memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].arraySize*sizeof(VkSampler));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001831 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001832 }
1833 if (totalCount > 0) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001834 pNewNode->pTypes = new VkDescriptorType[totalCount];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001835 uint32_t offset = 0;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001836 uint32_t j = 0;
1837 for (uint32_t i=0; i<pCreateInfo->count; i++) {
Chia-I Wud3114a22015-05-25 16:22:52 +08001838 for (j = 0; j < pCreateInfo->pBinding[i].arraySize; j++) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001839 pNewNode->pTypes[offset + j] = pCreateInfo->pBinding[i].descriptorType;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001840 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001841 offset += j;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001842 }
1843 }
1844 pNewNode->layout = *pSetLayout;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001845 pNewNode->startIndex = 0;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001846 pNewNode->endIndex = pNewNode->startIndex + totalCount - 1;
1847 assert(pNewNode->endIndex >= pNewNode->startIndex);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001848 // Put new node at Head of global Layer list
1849 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001850 layoutMap[pSetLayout->handle] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001851 loader_platform_thread_unlock_mutex(&globalLock);
1852 }
1853 return result;
1854}
1855
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001856VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001857{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001858 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001859 if (VK_SUCCESS == result) {
Mark Lobodzinski556f7212015-04-17 14:11:39 -05001860 // TODO : Need to capture the pipeline layout
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001861 }
1862 return result;
1863}
1864
Courtney Goeltzenleuchterd9e966a2015-09-16 16:12:45 -06001865VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001866{
Courtney Goeltzenleuchterd9e966a2015-09-16 16:12:45 -06001867 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001868 if (VK_SUCCESS == result) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001869 // Insert this pool into Global Pool LL at head
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001870 if (log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (*pDescriptorPool).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1871 "Created Descriptor Pool %#" PRIxLEAST64, (*pDescriptorPool).handle))
1872 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001873 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001874 POOL_NODE* pNewNode = new POOL_NODE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001875 if (NULL == pNewNode) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001876 if (log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (*pDescriptorPool).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1877 "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()"))
1878 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001879 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001880 memset(pNewNode, 0, sizeof(POOL_NODE));
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001881 VkDescriptorPoolCreateInfo* pCI = (VkDescriptorPoolCreateInfo*)&pNewNode->createInfo;
1882 memcpy((void*)pCI, pCreateInfo, sizeof(VkDescriptorPoolCreateInfo));
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001883 if (pNewNode->createInfo.count) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001884 size_t typeCountSize = pNewNode->createInfo.count * sizeof(VkDescriptorTypeCount);
1885 pNewNode->createInfo.pTypeCount = new VkDescriptorTypeCount[typeCountSize];
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001886 memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize);
1887 }
Courtney Goeltzenleuchterd9e966a2015-09-16 16:12:45 -06001888 pNewNode->poolUsage = pCreateInfo->poolUsage;
1889 pNewNode->maxSets = pCreateInfo->maxSets;
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001890 pNewNode->pool = *pDescriptorPool;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001891 poolMap[pDescriptorPool->handle] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001892 }
1893 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001894 } else {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001895 // Need to do anything if pool create fails?
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001896 }
1897 return result;
1898}
1899
Mike Stroyan230e6252015-04-17 12:36:38 -06001900VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001901{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001902 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->ResetDescriptorPool(device, descriptorPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001903 if (VK_SUCCESS == result) {
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06001904 clearDescriptorPool(device, descriptorPool);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001905 }
1906 return result;
1907}
1908
Cody Northropc8aa4a52015-08-03 12:47:29 -06001909VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001910{
Cody Northropc8aa4a52015-08-03 12:47:29 -06001911 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
1912 if (VK_SUCCESS == result) {
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001913 POOL_NODE *pPoolNode = getPoolNode(descriptorPool);
1914 if (!pPoolNode) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001915 log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, descriptorPool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
1916 "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", descriptorPool.handle);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001917 } else {
Cody Northropc8aa4a52015-08-03 12:47:29 -06001918 if (count == 0) {
1919 log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, count, 0, DRAWSTATE_NONE, "DS",
1920 "AllocDescriptorSets called with 0 count");
1921 }
1922 for (uint32_t i = 0; i < count; i++) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001923 log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
1924 "Created Descriptor Set %#" PRIxLEAST64, pDescriptorSets[i].handle);
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001925 // Create new set node and add to head of pool nodes
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001926 SET_NODE* pNewNode = new SET_NODE;
1927 if (NULL == pNewNode) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001928 if (log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
1929 "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()"))
1930 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06001931 } else {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001932 memset(pNewNode, 0, sizeof(SET_NODE));
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001933 // Insert set at head of Set LL for this pool
1934 pNewNode->pNext = pPoolNode->pSets;
1935 pPoolNode->pSets = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001936 LAYOUT_NODE* pLayout = getLayoutNode(pSetLayouts[i]);
1937 if (NULL == pLayout) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001938 if (log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
1939 "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pSetLayouts[i].handle))
1940 return VK_ERROR_VALIDATION_FAILED;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001941 }
Tobin Ehlisdd82f6b2015-04-03 12:01:11 -06001942 pNewNode->pLayout = pLayout;
1943 pNewNode->pool = descriptorPool;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001944 pNewNode->set = pDescriptorSets[i];
1945 pNewNode->setUsage = setUsage;
1946 pNewNode->descriptorCount = pLayout->endIndex + 1;
1947 if (pNewNode->descriptorCount) {
1948 size_t descriptorArraySize = sizeof(GENERIC_HEADER*)*pNewNode->descriptorCount;
1949 pNewNode->ppDescriptors = new GENERIC_HEADER*[descriptorArraySize];
1950 memset(pNewNode->ppDescriptors, 0, descriptorArraySize);
1951 }
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06001952 setMap[pDescriptorSets[i].handle] = pNewNode;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001953 }
1954 }
1955 }
1956 }
1957 return result;
1958}
1959
Tony Barbourb857d312015-07-10 10:50:45 -06001960VK_LAYER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
1961{
1962 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
1963 // TODO : Clean up any internal data structures using this obj.
1964 return result;
1965}
1966
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001967VK_LAYER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001968{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001969 // dsUpdate will return VK_TRUE only if a bailout error occurs, so we want to call down tree when both updates return VK_FALSE
1970 if (!dsUpdate(device, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, writeCount, pDescriptorWrites) &&
1971 !dsUpdate(device, VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, copyCount, pDescriptorCopies)) {
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001972 get_dispatch_table(draw_state_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
Jon Ashburne0fa2282015-05-20 09:00:28 -06001973 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001974}
1975
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001976VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001977{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06001978 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001979 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001980 loader_platform_thread_lock_mutex(&globalLock);
1981 GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
1982 memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
1983 pCB->cmdBuffer = *pCmdBuffer;
Tobin Ehlis0cea4082015-08-18 07:10:58 -06001984 pCB->createInfo = *pCreateInfo;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001985 pCB->lastVtxBinding = MAX_BINDING;
Mark Lobodzinski90bf5b02015-08-04 16:24:20 -06001986 pCB->level = pCreateInfo->level;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001987 cmdBufferMap[*pCmdBuffer] = pCB;
1988 loader_platform_thread_unlock_mutex(&globalLock);
1989 updateCBTracking(*pCmdBuffer);
1990 }
1991 return result;
1992}
1993
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001994VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06001995{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06001996 VkBool32 skipCall = false;
Mark Lobodzinski90bf5b02015-08-04 16:24:20 -06001997 // Validate command buffer level
1998 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
1999 if (pCB) {
2000 if (pCB->level == VK_CMD_BUFFER_LEVEL_PRIMARY) {
2001 if (pBeginInfo->renderPass.handle || pBeginInfo->framebuffer.handle) {
2002 // These should be NULL for a Primary CB
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002003 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
Mark Lobodzinski90bf5b02015-08-04 16:24:20 -06002004 "vkCreateCommandBuffer(): Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
2005 }
2006 } else {
2007 if (!pBeginInfo->renderPass.handle || !pBeginInfo->framebuffer.handle) {
2008 // These should NOT be null for an Secondary CB
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002009 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
Mark Lobodzinski90bf5b02015-08-04 16:24:20 -06002010 "vkCreateCommandBuffer(): Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
2011 }
2012 }
Tobin Ehlis0cea4082015-08-18 07:10:58 -06002013 pCB->beginInfo = *pBeginInfo;
2014 } else {
2015 // TODO : Need to pass cmdBuffer as objType here
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002016 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
Tobin Ehlis0cea4082015-08-18 07:10:58 -06002017 "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
Mark Lobodzinski90bf5b02015-08-04 16:24:20 -06002018 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002019 if (skipCall) {
2020 return VK_ERROR_VALIDATION_FAILED;
Courtney Goeltzenleuchter3abd86e2015-09-04 15:03:52 -06002021 }
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002022 VkResult result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002023 if (VK_SUCCESS == result) {
Tobin Ehlis0cea4082015-08-18 07:10:58 -06002024 if (CB_NEW != pCB->state)
2025 resetCB(cmdBuffer);
2026 pCB->state = CB_UPDATE_ACTIVE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002027 updateCBTracking(cmdBuffer);
2028 }
2029 return result;
2030}
2031
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002032VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002033{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002034 VkBool32 skipCall = VK_FALSE;
Courtney Goeltzenleuchtera54b76a2015-09-04 13:39:59 -06002035 VkResult result = VK_SUCCESS;
Tobin Ehlise42007c2015-06-19 13:00:59 -06002036 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Courtney Goeltzenleuchtera54b76a2015-09-04 13:39:59 -06002037 /* TODO: preference is to always call API function after reporting any validation errors */
Tobin Ehlise42007c2015-06-19 13:00:59 -06002038 if (pCB) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002039 if (pCB->state != CB_UPDATE_ACTIVE) {
2040 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkEndCommandBuffer()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002041 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002042 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002043 if (VK_FALSE == skipCall) {
2044 result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
2045 if (VK_SUCCESS == result) {
2046 updateCBTracking(cmdBuffer);
2047 pCB->state = CB_UPDATE_COMPLETE;
2048 // Reset CB status flags
2049 pCB->status = 0;
2050 printCB(cmdBuffer);
2051 }
2052 } else {
2053 result = VK_ERROR_VALIDATION_FAILED;
2054 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002055 return result;
2056}
2057
Cody Northropf02f9f82015-07-09 18:08:05 -06002058VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002059{
Cody Northropf02f9f82015-07-09 18:08:05 -06002060 VkResult result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer, flags);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002061 if (VK_SUCCESS == result) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002062 resetCB(cmdBuffer);
2063 updateCBTracking(cmdBuffer);
2064 }
2065 return result;
2066}
2067
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002068VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002069{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002070 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002071 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2072 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002073 if (pCB->state == CB_UPDATE_ACTIVE) {
2074 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002075 skipCall |= addCmd(pCB, CMD_BINDPIPELINE);
Tobin Ehlis642d5a52015-06-23 08:46:18 -06002076 if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002077 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
2078 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
2079 "Incorrectly binding compute pipeline (%#" PRIxLEAST64 ") during active RenderPass (%#" PRIxLEAST64 ")",
2080 pipeline.handle, pCB->activeRenderPass.handle);
Tobin Ehlise4076782015-06-24 15:53:07 -06002081 } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002082 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
2083 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", "Incorrectly binding graphics pipeline "
2084 " (%#" PRIxLEAST64 ") without an active RenderPass", pipeline.handle);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002085 } else {
Tobin Ehlise4076782015-06-24 15:53:07 -06002086 PIPELINE_NODE* pPN = getPipeline(pipeline);
2087 if (pPN) {
2088 pCB->lastBoundPipeline = pipeline;
2089 loader_platform_thread_lock_mutex(&globalLock);
2090 set_cb_pso_status(pCB, pPN);
2091 g_lastBoundPipeline = pPN;
2092 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002093 skipCall |= validatePipelineState(pCB, pipelineBindPoint, pipeline);
Tobin Ehlise4076782015-06-24 15:53:07 -06002094 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002095 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
2096 0, DRAWSTATE_INVALID_PIPELINE, "DS",
2097 "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (void*)pipeline.handle);
Tobin Ehlise4076782015-06-24 15:53:07 -06002098 }
Tobin Ehlise42007c2015-06-19 13:00:59 -06002099 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002100 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002101 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBindPipeline()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002102 }
2103 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002104 if (VK_FALSE == skipCall)
2105 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002106}
2107
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002108VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
2109 VkCmdBuffer cmdBuffer,
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06002110 uint32_t viewportCount,
2111 const VkViewport* pViewports)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002112{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002113 VkBool32 skipCall = VK_FALSE;
Tobin Ehlise42007c2015-06-19 13:00:59 -06002114 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2115 if (pCB) {
2116 if (pCB->state == CB_UPDATE_ACTIVE) {
2117 updateCBTracking(cmdBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002118 skipCall |= addCmd(pCB, CMD_SETVIEWPORTSTATE);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002119 loader_platform_thread_lock_mutex(&globalLock);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002120 pCB->status |= CBSTATUS_VIEWPORT_SET;
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06002121 pCB->viewports.resize(viewportCount);
Tobin Ehlis9e839e52015-10-01 11:15:13 -06002122 memcpy(pCB->viewports.data(), pViewports, viewportCount * sizeof(VkViewport));
Tobin Ehlise42007c2015-06-19 13:00:59 -06002123 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002124 } else {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002125 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetViewport()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002126 }
2127 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002128 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06002129 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
2130}
2131
2132VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
2133 VkCmdBuffer cmdBuffer,
2134 uint32_t scissorCount,
2135 const VkRect2D* pScissors)
2136{
2137 VkBool32 skipCall = VK_FALSE;
2138 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2139 if (pCB) {
2140 if (pCB->state == CB_UPDATE_ACTIVE) {
2141 updateCBTracking(cmdBuffer);
2142 skipCall |= addCmd(pCB, CMD_SETSCISSORSTATE);
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06002143 loader_platform_thread_lock_mutex(&globalLock);
2144 pCB->status |= CBSTATUS_SCISSOR_SET;
2145 pCB->scissors.resize(scissorCount);
Tobin Ehlis9e839e52015-10-01 11:15:13 -06002146 memcpy(pCB->scissors.data(), pScissors, scissorCount * sizeof(VkRect2D));
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06002147 loader_platform_thread_unlock_mutex(&globalLock);
2148 } else {
2149 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetScissor()");
2150 }
2151 }
2152 if (VK_FALSE == skipCall)
2153 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002154}
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002155
2156VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002157{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002158 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002159 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2160 if (pCB) {
2161 if (pCB->state == CB_UPDATE_ACTIVE) {
2162 updateCBTracking(cmdBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002163 skipCall |= addCmd(pCB, CMD_SETLINEWIDTHSTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002164 /* TODO: Do we still need this lock? */
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002165 loader_platform_thread_lock_mutex(&globalLock);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002166 pCB->status |= CBSTATUS_LINE_WIDTH_SET;
2167 pCB->lineWidth = lineWidth;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002168 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002169 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002170 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicLineWidthState()");
Cody Northropf5bd2252015-08-17 11:10:49 -06002171 }
2172 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002173 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002174 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetLineWidth(cmdBuffer, lineWidth);
Cody Northropf5bd2252015-08-17 11:10:49 -06002175}
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002176
2177VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(
2178 VkCmdBuffer cmdBuffer,
2179 float depthBias,
2180 float depthBiasClamp,
2181 float slopeScaledDepthBias)
Cody Northropf5bd2252015-08-17 11:10:49 -06002182{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002183 VkBool32 skipCall = VK_FALSE;
Cody Northropf5bd2252015-08-17 11:10:49 -06002184 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2185 if (pCB) {
2186 if (pCB->state == CB_UPDATE_ACTIVE) {
2187 updateCBTracking(cmdBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002188 skipCall |= addCmd(pCB, CMD_SETDEPTHBIASSTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002189 pCB->status |= CBSTATUS_DEPTH_BIAS_SET;
2190 pCB->depthBias = depthBias;
2191 pCB->depthBiasClamp = depthBiasClamp;
2192 pCB->slopeScaledDepthBias = slopeScaledDepthBias;
Cody Northropf5bd2252015-08-17 11:10:49 -06002193 } else {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002194 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetDepthBias()");
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002195 }
2196 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002197 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002198 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetDepthBias(cmdBuffer, depthBias, depthBiasClamp, slopeScaledDepthBias);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002199}
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002200
2201VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4])
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002202{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002203 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002204 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2205 if (pCB) {
2206 if (pCB->state == CB_UPDATE_ACTIVE) {
2207 updateCBTracking(cmdBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002208 skipCall |= addCmd(pCB, CMD_SETBLENDSTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002209 pCB->status |= CBSTATUS_BLEND_SET;
2210 memcpy(pCB->blendConst, blendConst, 4 * sizeof(float));
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002211 } else {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002212 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetBlendConstants()");
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002213 }
2214 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002215 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002216 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetBlendConstants(cmdBuffer, blendConst);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002217}
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002218
2219VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(
2220 VkCmdBuffer cmdBuffer,
2221 float minDepthBounds,
2222 float maxDepthBounds)
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002223{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002224 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002225 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2226 if (pCB) {
2227 if (pCB->state == CB_UPDATE_ACTIVE) {
2228 updateCBTracking(cmdBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002229 skipCall |= addCmd(pCB, CMD_SETDEPTHBOUNDSSTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002230 pCB->status |= CBSTATUS_DEPTH_BOUNDS_SET;
2231 pCB->minDepthBounds = minDepthBounds;
2232 pCB->maxDepthBounds = maxDepthBounds;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002233 } else {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002234 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetDepthBounds()");
Cody Northrop2605cb02015-08-18 15:21:16 -06002235 }
2236 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002237 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002238 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
Cody Northrop2605cb02015-08-18 15:21:16 -06002239}
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002240
2241VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
2242 VkCmdBuffer cmdBuffer,
2243 VkStencilFaceFlags faceMask,
2244 uint32_t stencilCompareMask)
Cody Northrop2605cb02015-08-18 15:21:16 -06002245{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002246 VkBool32 skipCall = VK_FALSE;
Cody Northrop2605cb02015-08-18 15:21:16 -06002247 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2248 if (pCB) {
2249 if (pCB->state == CB_UPDATE_ACTIVE) {
2250 updateCBTracking(cmdBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002251 skipCall |= addCmd(pCB, CMD_SETSTENCILREADMASKSTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002252 if (faceMask & VK_STENCIL_FACE_FRONT_BIT) {
2253 pCB->front.stencilCompareMask = stencilCompareMask;
Cody Northrop2605cb02015-08-18 15:21:16 -06002254 }
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002255 if (faceMask & VK_STENCIL_FACE_BACK_BIT) {
2256 pCB->back.stencilCompareMask = stencilCompareMask;
2257 }
2258 /* TODO: Do we need to track front and back separately? */
2259 /* TODO: We aren't capturing the faceMask, do we need to? */
2260 pCB->status |= CBSTATUS_STENCIL_READ_MASK_SET;
Cody Northrop2605cb02015-08-18 15:21:16 -06002261 } else {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002262 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetStencilCompareMask()");
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002263 }
2264 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002265 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002266 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002267}
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002268
2269VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
2270 VkCmdBuffer cmdBuffer,
2271 VkStencilFaceFlags faceMask,
2272 uint32_t stencilWriteMask)
2273{
2274 VkBool32 skipCall = VK_FALSE;
2275 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2276 if (pCB) {
2277 if (pCB->state == CB_UPDATE_ACTIVE) {
2278 updateCBTracking(cmdBuffer);
2279 skipCall |= addCmd(pCB, CMD_SETSTENCILWRITEMASKSTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002280 if (faceMask & VK_STENCIL_FACE_FRONT_BIT) {
2281 pCB->front.stencilWriteMask = stencilWriteMask;
2282 }
2283 if (faceMask & VK_STENCIL_FACE_BACK_BIT) {
2284 pCB->back.stencilWriteMask = stencilWriteMask;
2285 }
2286 pCB->status |= CBSTATUS_STENCIL_WRITE_MASK_SET;
2287 } else {
2288 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetStencilWriteMask()");
2289 }
2290 }
2291 if (VK_FALSE == skipCall)
2292 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
2293}
2294
2295VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
2296 VkCmdBuffer cmdBuffer,
2297 VkStencilFaceFlags faceMask,
2298 uint32_t stencilReference)
2299{
2300 VkBool32 skipCall = VK_FALSE;
2301 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2302 if (pCB) {
2303 if (pCB->state == CB_UPDATE_ACTIVE) {
2304 updateCBTracking(cmdBuffer);
2305 skipCall |= addCmd(pCB, CMD_SETSTENCILREFERENCESTATE);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06002306 if (faceMask & VK_STENCIL_FACE_FRONT_BIT) {
2307 pCB->front.stencilReference = stencilReference;
2308 }
2309 if (faceMask & VK_STENCIL_FACE_BACK_BIT) {
2310 pCB->back.stencilReference = stencilReference;
2311 }
2312 pCB->status |= CBSTATUS_STENCIL_REFERENCE_SET;
2313 } else {
2314 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetStencilReference()");
2315 }
2316 }
2317 if (VK_FALSE == skipCall)
2318 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
2319}
2320
Mark Lobodzinskia65c4632015-06-15 13:21:21 -06002321VK_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 -06002322{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002323 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002324 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2325 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002326 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlise4076782015-06-24 15:53:07 -06002327 if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002328 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002329 "Incorrectly binding compute DescriptorSets during active RenderPass (%#" PRIxLEAST64 ")", pCB->activeRenderPass.handle);
Tobin Ehlise4076782015-06-24 15:53:07 -06002330 } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002331 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
Tobin Ehlise4076782015-06-24 15:53:07 -06002332 "Incorrectly binding graphics DescriptorSets without an active RenderPass");
Tobin Ehlisd28acef2015-09-09 15:12:35 -06002333 } else {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002334 for (uint32_t i=0; i<setCount; i++) {
Tobin Ehlis55c1c602015-06-24 17:27:33 -06002335 SET_NODE* pSet = getSetNode(pDescriptorSets[i]);
2336 if (pSet) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002337 loader_platform_thread_lock_mutex(&globalLock);
2338 pCB->lastBoundDescriptorSet = pDescriptorSets[i];
Tobin Ehlisc6c3d6d2015-06-22 17:20:50 -06002339 pCB->lastBoundPipelineLayout = layout;
Tobin Ehlise42007c2015-06-19 13:00:59 -06002340 pCB->boundDescriptorSets.push_back(pDescriptorSets[i]);
2341 g_lastBoundDescriptorSet = pDescriptorSets[i];
2342 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002343 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002344 "DS %#" PRIxLEAST64 " bound on pipeline %s", pDescriptorSets[i].handle, string_VkPipelineBindPoint(pipelineBindPoint));
Tobin Ehlis55c1c602015-06-24 17:27:33 -06002345 if (!pSet->pUpdateStructs)
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002346 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002347 "DS %#" PRIxLEAST64 " bound but it was never updated. You may want to either update it or not bind it.", pDescriptorSets[i].handle);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002348 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002349 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_INVALID_SET, "DS",
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002350 "Attempt to bind DS %#" PRIxLEAST64 " that doesn't exist!", pDescriptorSets[i].handle);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002351 }
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002352 }
Tobin Ehlis59db5712015-07-13 13:14:24 -06002353 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002354 skipCall |= addCmd(pCB, CMD_BINDDESCRIPTORSETS);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002355 }
Tobin Ehlise42007c2015-06-19 13:00:59 -06002356 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002357 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBindDescriptorSets()");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002358 }
2359 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002360 if (VK_FALSE == skipCall)
2361 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 -06002362}
2363
Tony Barbour8205d902015-04-16 15:59:00 -06002364VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002365{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002366 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002367 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2368 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002369 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlis8d199e52015-09-17 12:24:13 -06002370 VkDeviceSize offset_align = 0;
2371 switch (indexType) {
2372 case VK_INDEX_TYPE_UINT16:
2373 offset_align = 2;
2374 break;
2375 case VK_INDEX_TYPE_UINT32:
2376 offset_align = 4;
2377 break;
2378 default:
2379 // ParamChecker should catch bad enum, we'll also throw alignment error below if offset_align stays 0
2380 break;
2381 }
2382 if (!offset_align || (offset % offset_align)) {
2383 skipCall |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, "DS",
2384 "vkCmdBindIndexBuffer() offset (%#" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", offset, string_VkIndexType(indexType));
Tobin Ehlise4076782015-06-24 15:53:07 -06002385 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002386 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002387 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBindIndexBuffer()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002388 }
Tobin Ehlis8d199e52015-09-17 12:24:13 -06002389 pCB->status |= CBSTATUS_INDEX_BUFFER_BOUND;
2390 updateCBTracking(cmdBuffer);
2391 skipCall |= addCmd(pCB, CMD_BINDINDEXBUFFER);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002392 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002393 if (VK_FALSE == skipCall)
2394 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002395}
2396
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002397VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
2398 VkCmdBuffer cmdBuffer,
2399 uint32_t startBinding,
2400 uint32_t bindingCount,
2401 const VkBuffer* pBuffers,
Tony Barbour8205d902015-04-16 15:59:00 -06002402 const VkDeviceSize* pOffsets)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002403{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002404 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002405 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2406 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002407 if (pCB->state == CB_UPDATE_ACTIVE) {
2408 /* TODO: Need to track all the vertex buffers, not just last one */
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002409 pCB->lastVtxBinding = startBinding + bindingCount -1;
2410 updateCBTracking(cmdBuffer);
2411 addCmd(pCB, CMD_BINDVERTEXBUFFER);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002412 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002413 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBindVertexBuffer()");
Tobin Ehlis0b551cd2015-05-28 12:10:17 -06002414 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002415 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002416 if (VK_FALSE == skipCall)
2417 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002418}
2419
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -06002420VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002421{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002422 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002423 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2424 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002425 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002426 pCB->drawCount[DRAW]++;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002427 skipCall |= validate_draw_state(pCB, VK_FALSE);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002428 // TODO : Need to pass cmdBuffer as srcObj here
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002429 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlise42007c2015-06-19 13:00:59 -06002430 "vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002431 skipCall |= synchAndPrintDSConfig(cmdBuffer);
2432 if (VK_FALSE == skipCall) {
Tobin Ehlis59db5712015-07-13 13:14:24 -06002433 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002434 skipCall |= addCmd(pCB, CMD_DRAW);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002435 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002436 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002437 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdDraw()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002438 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002439 skipCall |= outsideRenderPass(pCB, "vkCmdDraw");
Jon Ashburne0fa2282015-05-20 09:00:28 -06002440 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002441 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -06002442 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002443}
2444
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -06002445VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002446{
2447 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002448 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002449 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002450 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002451 pCB->drawCount[DRAW_INDEXED]++;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002452 skipCall |= validate_draw_state(pCB, VK_TRUE);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002453 // TODO : Need to pass cmdBuffer as srcObj here
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002454 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlise42007c2015-06-19 13:00:59 -06002455 "vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002456 skipCall |= synchAndPrintDSConfig(cmdBuffer);
2457 if (VK_FALSE == skipCall) {
Tobin Ehlis59db5712015-07-13 13:14:24 -06002458 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002459 skipCall |= addCmd(pCB, CMD_DRAWINDEXED);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002460 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002461 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002462 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdDrawIndexed()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002463 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002464 skipCall |= outsideRenderPass(pCB, "vkCmdDrawIndexed");
Jon Ashburne0fa2282015-05-20 09:00:28 -06002465 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002466 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -06002467 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002468}
2469
Tony Barbour8205d902015-04-16 15:59:00 -06002470VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002471{
2472 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002473 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002474 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002475 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002476 pCB->drawCount[DRAW_INDIRECT]++;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002477 skipCall |= validate_draw_state(pCB, VK_FALSE);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002478 // TODO : Need to pass cmdBuffer as srcObj here
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002479 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlise42007c2015-06-19 13:00:59 -06002480 "vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002481 skipCall |= synchAndPrintDSConfig(cmdBuffer);
2482 if (VK_FALSE == skipCall) {
Tobin Ehlis59db5712015-07-13 13:14:24 -06002483 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002484 skipCall |= addCmd(pCB, CMD_DRAWINDIRECT);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002485 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002486 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002487 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdDrawIndirect()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002488 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002489 skipCall |= outsideRenderPass(pCB, "vkCmdDrawIndirect");
Jon Ashburne0fa2282015-05-20 09:00:28 -06002490 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002491 if (VK_FALSE == skipCall)
2492 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002493}
2494
Tony Barbour8205d902015-04-16 15:59:00 -06002495VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002496{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002497 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002498 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2499 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002500 if (pCB->state == CB_UPDATE_ACTIVE) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002501 pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002502 skipCall |= validate_draw_state(pCB, VK_TRUE);
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002503 // TODO : Need to pass cmdBuffer as srcObj here
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002504 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
Tobin Ehlise42007c2015-06-19 13:00:59 -06002505 "vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002506 skipCall |= synchAndPrintDSConfig(cmdBuffer);
2507 if (VK_FALSE == skipCall) {
Tobin Ehlis59db5712015-07-13 13:14:24 -06002508 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002509 skipCall |= addCmd(pCB, CMD_DRAWINDEXEDINDIRECT);
Tobin Ehlise42007c2015-06-19 13:00:59 -06002510 }
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002511 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002512 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdDrawIndexedIndirect()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002513 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002514 skipCall |= outsideRenderPass(pCB, "vkCmdDrawIndexedIndirect");
Jon Ashburne0fa2282015-05-20 09:00:28 -06002515 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002516 if (VK_FALSE == skipCall)
2517 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002518}
2519
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002520VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002521{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002522 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002523 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2524 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002525 if (pCB->state == CB_UPDATE_ACTIVE) {
2526 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002527 skipCall |= addCmd(pCB, CMD_DISPATCH);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002528 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002529 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdDispatch()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002530 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002531 skipCall |= insideRenderPass(pCB, "vkCmdDispatch");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002532 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002533 if (VK_FALSE == skipCall)
2534 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002535}
2536
Tony Barbour8205d902015-04-16 15:59:00 -06002537VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002538{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002539 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002540 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2541 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002542 if (pCB->state == CB_UPDATE_ACTIVE) {
2543 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002544 skipCall |= addCmd(pCB, CMD_DISPATCHINDIRECT);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002545 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002546 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdDispatchIndirect()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002547 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002548 skipCall |= insideRenderPass(pCB, "vkCmdDispatchIndirect");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002549 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002550 if (VK_FALSE == skipCall)
2551 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002552}
2553
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002554VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002555{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002556 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002557 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2558 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002559 if (pCB->state == CB_UPDATE_ACTIVE) {
2560 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002561 skipCall |= addCmd(pCB, CMD_COPYBUFFER);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002562 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002563 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdCopyBuffer()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002564 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002565 skipCall |= insideRenderPass(pCB, "vkCmdCopyBuffer");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002566 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002567 if (VK_FALSE == skipCall)
2568 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002569}
2570
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002571VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
2572 VkImage srcImage,
2573 VkImageLayout srcImageLayout,
2574 VkImage destImage,
2575 VkImageLayout destImageLayout,
2576 uint32_t regionCount, const VkImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002577{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002578 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002579 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2580 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002581 if (pCB->state == CB_UPDATE_ACTIVE) {
2582 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002583 skipCall |= addCmd(pCB, CMD_COPYIMAGE);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002584 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002585 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdCopyImage()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002586 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002587 skipCall |= insideRenderPass(pCB, "vkCmdCopyImage");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002588 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002589 if (VK_FALSE == skipCall)
2590 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002591}
2592
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002593VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
2594 VkImage srcImage, VkImageLayout srcImageLayout,
2595 VkImage destImage, VkImageLayout destImageLayout,
Mark Lobodzinski20f68592015-05-22 14:43:25 -05002596 uint32_t regionCount, const VkImageBlit* pRegions,
2597 VkTexFilter filter)
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002598{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002599 VkBool32 skipCall = VK_FALSE;
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002600 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2601 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002602 if (pCB->state == CB_UPDATE_ACTIVE) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002603 updateCBTracking(cmdBuffer);
2604 skipCall |= addCmd(pCB, CMD_BLITIMAGE);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002605 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002606 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBlitImage()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002607 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002608 skipCall |= insideRenderPass(pCB, "vkCmdBlitImage");
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002609 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002610 if (VK_FALSE == skipCall)
2611 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
Courtney Goeltzenleuchter6ff8ebc2015-04-03 14:42:51 -06002612}
2613
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002614VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
2615 VkBuffer srcBuffer,
2616 VkImage destImage, VkImageLayout destImageLayout,
2617 uint32_t regionCount, const VkBufferImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002618{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002619 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002620 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2621 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002622 if (pCB->state == CB_UPDATE_ACTIVE) {
2623 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002624 skipCall |= addCmd(pCB, CMD_COPYBUFFERTOIMAGE);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002625 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002626 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdCopyBufferToImage()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002627 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002628 skipCall |= insideRenderPass(pCB, "vkCmdCopyBufferToImage");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002629 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002630 if (VK_FALSE == skipCall)
2631 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002632}
2633
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002634VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
2635 VkImage srcImage, VkImageLayout srcImageLayout,
2636 VkBuffer destBuffer,
2637 uint32_t regionCount, const VkBufferImageCopy* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002638{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002639 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002640 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2641 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002642 if (pCB->state == CB_UPDATE_ACTIVE) {
2643 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002644 skipCall |= addCmd(pCB, CMD_COPYIMAGETOBUFFER);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002645 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002646 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdCopyImageToBuffer()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002647 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002648 skipCall |= insideRenderPass(pCB, "vkCmdCopyImageToBuffer");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002649 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002650 if (VK_FALSE == skipCall)
2651 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002652}
2653
Tony Barbour8205d902015-04-16 15:59:00 -06002654VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002655{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002656 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002657 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2658 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002659 if (pCB->state == CB_UPDATE_ACTIVE) {
2660 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002661 skipCall |= addCmd(pCB, CMD_UPDATEBUFFER);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002662 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002663 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdUpdateBuffer()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002664 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002665 skipCall |= insideRenderPass(pCB, "vkCmdCopyUpdateBuffer");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002666 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002667 if (VK_FALSE == skipCall)
2668 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002669}
2670
Tony Barbour8205d902015-04-16 15:59:00 -06002671VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002672{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002673 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002674 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2675 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002676 if (pCB->state == CB_UPDATE_ACTIVE) {
2677 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002678 skipCall |= addCmd(pCB, CMD_FILLBUFFER);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002679 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002680 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdFillBuffer()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002681 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002682 skipCall |= insideRenderPass(pCB, "vkCmdCopyFillBuffer");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002683 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002684 if (VK_FALSE == skipCall)
2685 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002686}
2687
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002688VK_LAYER_EXPORT void VKAPI vkCmdClearColorAttachment(
2689 VkCmdBuffer cmdBuffer,
2690 uint32_t colorAttachment,
2691 VkImageLayout imageLayout,
2692 const VkClearColorValue* pColor,
2693 uint32_t rectCount,
2694 const VkRect3D* pRects)
2695{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002696 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002697 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2698 if (pCB) {
2699 if (pCB->state == CB_UPDATE_ACTIVE) {
2700 // Warn if this is issued prior to Draw Cmd
2701 if (!hasDrawCmd(pCB)) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002702 // TODO : cmdBuffer should be srcObj
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002703 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS",
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002704 "vkCmdClearColorAttachment() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds."
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -06002705 " It is recommended you use RenderPass LOAD_OP_CLEAR on Color Attachments prior to any Draw.", reinterpret_cast<uint64_t>(cmdBuffer));
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002706 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002707 updateCBTracking(cmdBuffer);
2708 skipCall |= addCmd(pCB, CMD_CLEARCOLORATTACHMENT);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002709 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002710 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdClearColorAttachment()");
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002711 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002712 skipCall |= outsideRenderPass(pCB, "vkCmdClearColorAttachment");
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002713 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002714 if (VK_FALSE == skipCall)
2715 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002716}
2717
2718VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilAttachment(
2719 VkCmdBuffer cmdBuffer,
2720 VkImageAspectFlags imageAspectMask,
2721 VkImageLayout imageLayout,
Courtney Goeltzenleuchter315ad992015-09-15 18:03:22 -06002722 const VkClearDepthStencilValue* pDepthStencil,
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002723 uint32_t rectCount,
2724 const VkRect3D* pRects)
2725{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002726 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002727 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2728 if (pCB) {
2729 if (pCB->state == CB_UPDATE_ACTIVE) {
2730 // Warn if this is issued prior to Draw Cmd
2731 if (!hasDrawCmd(pCB)) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002732 // TODO : cmdBuffer should be srcObj
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002733 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS",
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002734 "vkCmdClearDepthStencilAttachment() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds."
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -06002735 " It is recommended you use RenderPass LOAD_OP_CLEAR on DS Attachment prior to any Draw.", reinterpret_cast<uint64_t>(cmdBuffer));
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002736 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002737 updateCBTracking(cmdBuffer);
2738 skipCall |= addCmd(pCB, CMD_CLEARDEPTHSTENCILATTACHMENT);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002739 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002740 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdClearDepthStencilAttachment()");
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002741 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002742 skipCall |= outsideRenderPass(pCB, "vkCmdClearDepthStencilAttachment");
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002743 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002744 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter315ad992015-09-15 18:03:22 -06002745 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, pDepthStencil, rectCount, pRects);
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06002746}
2747
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06002748VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
2749 VkCmdBuffer cmdBuffer,
2750 VkImage image, VkImageLayout imageLayout,
Chris Forbese3105972015-06-24 14:34:53 +12002751 const VkClearColorValue *pColor,
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06002752 uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002753{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002754 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002755 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2756 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002757 if (pCB->state == CB_UPDATE_ACTIVE) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002758 updateCBTracking(cmdBuffer);
2759 skipCall |= addCmd(pCB, CMD_CLEARCOLORIMAGE);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002760 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002761 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdClearColorImage()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002762 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002763 skipCall |= insideRenderPass(pCB, "vkCmdClearColorImage");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002764 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002765 if (VK_FALSE == skipCall)
2766 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002767}
2768
Courtney Goeltzenleuchter315ad992015-09-15 18:03:22 -06002769VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
2770 VkCmdBuffer cmdBuffer,
2771 VkImage image, VkImageLayout imageLayout,
2772 const VkClearDepthStencilValue *pDepthStencil,
2773 uint32_t rangeCount,
2774 const VkImageSubresourceRange* pRanges)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002775{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002776 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002777 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2778 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002779 if (pCB->state == CB_UPDATE_ACTIVE) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002780 updateCBTracking(cmdBuffer);
2781 skipCall |= addCmd(pCB, CMD_CLEARDEPTHSTENCILIMAGE);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002782 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002783 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdClearDepthStencilImage()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002784 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002785 skipCall |= insideRenderPass(pCB, "vkCmdClearDepthStencilImage");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002786 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002787 if (VK_FALSE == skipCall)
Courtney Goeltzenleuchter315ad992015-09-15 18:03:22 -06002788 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002789}
2790
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002791VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
2792 VkImage srcImage, VkImageLayout srcImageLayout,
2793 VkImage destImage, VkImageLayout destImageLayout,
Tony Barbour11f74372015-04-13 15:02:52 -06002794 uint32_t regionCount, const VkImageResolve* pRegions)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002795{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002796 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002797 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2798 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002799 if (pCB->state == CB_UPDATE_ACTIVE) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002800 updateCBTracking(cmdBuffer);
2801 skipCall |= addCmd(pCB, CMD_RESOLVEIMAGE);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002802 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002803 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdResolveImage()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002804 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002805 skipCall |= insideRenderPass(pCB, "vkCmdResolveImage");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002806 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002807 if (VK_FALSE == skipCall)
2808 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002809}
2810
Tony Barbourc2e987e2015-06-29 16:20:35 -06002811VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002812{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002813 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002814 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2815 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002816 if (pCB->state == CB_UPDATE_ACTIVE) {
2817 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002818 skipCall |= addCmd(pCB, CMD_SETEVENT);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002819 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002820 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdSetEvent()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002821 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002822 skipCall |= insideRenderPass(pCB, "vkCmdSetEvent");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002823 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002824 if (VK_FALSE == skipCall)
2825 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002826}
2827
Tony Barbourc2e987e2015-06-29 16:20:35 -06002828VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002829{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002830 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002831 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2832 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002833 if (pCB->state == CB_UPDATE_ACTIVE) {
2834 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002835 skipCall |= addCmd(pCB, CMD_RESETEVENT);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002836 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002837 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdResetEvent()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002838 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002839 skipCall |= insideRenderPass(pCB, "vkCmdResetEvent");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002840 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002841 if (VK_FALSE == skipCall)
2842 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002843}
2844
Courtney Goeltzenleuchterd9ba3422015-07-12 12:58:58 -06002845VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002846{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002847 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002848 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2849 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002850 if (pCB->state == CB_UPDATE_ACTIVE) {
2851 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002852 skipCall |= addCmd(pCB, CMD_WAITEVENTS);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002853 } else {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002854 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdWaitEvents()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002855 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002856 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002857 if (VK_FALSE == skipCall)
2858 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002859}
2860
Courtney Goeltzenleuchter82b348f2015-07-12 13:07:46 -06002861VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002862{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002863 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002864 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2865 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002866 if (pCB->state == CB_UPDATE_ACTIVE) {
2867 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002868 skipCall |= addCmd(pCB, CMD_PIPELINEBARRIER);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002869 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002870 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdPipelineBarrier()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002871 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002872 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002873 if (VK_FALSE == skipCall)
2874 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002875}
2876
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002877VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002878{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002879 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002880 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2881 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002882 if (pCB->state == CB_UPDATE_ACTIVE) {
2883 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002884 skipCall |= addCmd(pCB, CMD_BEGINQUERY);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002885 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002886 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdBeginQuery()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002887 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002888 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002889 if (VK_FALSE == skipCall)
2890 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002891}
2892
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002893VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002894{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002895 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002896 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2897 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002898 if (pCB->state == CB_UPDATE_ACTIVE) {
2899 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002900 skipCall |= addCmd(pCB, CMD_ENDQUERY);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002901 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002902 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdEndQuery()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002903 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002904 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002905 if (VK_FALSE == skipCall)
2906 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002907}
2908
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002909VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002910{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002911 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002912 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2913 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002914 if (pCB->state == CB_UPDATE_ACTIVE) {
2915 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002916 skipCall |= addCmd(pCB, CMD_RESETQUERYPOOL);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002917 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002918 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdResetQueryPool()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002919 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002920 skipCall |= insideRenderPass(pCB, "vkCmdQueryPool");
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002921 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002922 if (VK_FALSE == skipCall)
2923 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002924}
2925
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06002926VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery,
2927 uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset,
2928 VkDeviceSize destStride, VkQueryResultFlags flags)
2929{
2930 VkBool32 skipCall = VK_FALSE;
2931 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2932 if (pCB) {
2933 if (pCB->state == CB_UPDATE_ACTIVE) {
2934 updateCBTracking(cmdBuffer);
2935 skipCall |= addCmd(pCB, CMD_COPYQUERYPOOLRESULTS);
2936 } else {
2937 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdCopyQueryPoolResults()");
2938 }
2939 skipCall |= insideRenderPass(pCB, "vkCmdCopyQueryPoolResults");
2940 }
2941 if (VK_FALSE == skipCall)
2942 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdCopyQueryPoolResults(cmdBuffer, queryPool,
2943 startQuery, queryCount, destBuffer, destOffset, destStride, flags);
2944}
2945
Tony Barbour8205d902015-04-16 15:59:00 -06002946VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002947{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002948 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002949 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
2950 if (pCB) {
Tobin Ehlise42007c2015-06-19 13:00:59 -06002951 if (pCB->state == CB_UPDATE_ACTIVE) {
2952 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002953 skipCall |= addCmd(pCB, CMD_WRITETIMESTAMP);
Tobin Ehlisa366ca22015-06-19 15:07:05 -06002954 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002955 skipCall |= report_error_no_cb_begin(cmdBuffer, "vkCmdWriteTimestamp()");
Tobin Ehlise42007c2015-06-19 13:00:59 -06002956 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002957 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06002958 if (VK_FALSE == skipCall)
2959 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06002960}
2961
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002962VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
Tobin Ehlis2464b882015-04-01 08:40:34 -06002963{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002964 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002965 if (VK_SUCCESS == result) {
Tobin Ehlis2464b882015-04-01 08:40:34 -06002966 // Shadow create info and store in map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002967 VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
Chia-I Wuc278df82015-07-07 11:50:03 +08002968 if (pCreateInfo->pAttachments) {
Courtney Goeltzenleuchter1856d6f2015-09-01 17:30:39 -06002969 localFBCI->pAttachments = new VkImageView[localFBCI->attachmentCount];
2970 memcpy((void*)localFBCI->pAttachments, pCreateInfo->pAttachments, localFBCI->attachmentCount*sizeof(VkImageView));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002971 }
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06002972 frameBufferMap[pFramebuffer->handle] = localFBCI;
Tobin Ehlis2464b882015-04-01 08:40:34 -06002973 }
2974 return result;
2975}
2976
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002977VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
Tobin Ehlis2464b882015-04-01 08:40:34 -06002978{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06002979 VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002980 if (VK_SUCCESS == result) {
Tobin Ehlis2464b882015-04-01 08:40:34 -06002981 // Shadow create info and store in map
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06002982 VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
Chia-I Wuc278df82015-07-07 11:50:03 +08002983 if (pCreateInfo->pAttachments) {
2984 localRPCI->pAttachments = new VkAttachmentDescription[localRPCI->attachmentCount];
2985 memcpy((void*)localRPCI->pAttachments, pCreateInfo->pAttachments, localRPCI->attachmentCount*sizeof(VkAttachmentDescription));
Tobin Ehlis2464b882015-04-01 08:40:34 -06002986 }
Chia-I Wuc278df82015-07-07 11:50:03 +08002987 if (pCreateInfo->pSubpasses) {
2988 localRPCI->pSubpasses = new VkSubpassDescription[localRPCI->subpassCount];
2989 memcpy((void*)localRPCI->pSubpasses, pCreateInfo->pSubpasses, localRPCI->subpassCount*sizeof(VkSubpassDescription));
2990
2991 for (uint32_t i = 0; i < localRPCI->subpassCount; i++) {
2992 VkSubpassDescription *subpass = (VkSubpassDescription *) &localRPCI->pSubpasses[i];
2993 const uint32_t attachmentCount = subpass->inputCount +
Cody Northrop6de6b0b2015-08-04 11:16:41 -06002994 subpass->colorCount * (1 + (subpass->pResolveAttachments?1:0)) +
Chia-I Wuc278df82015-07-07 11:50:03 +08002995 subpass->preserveCount;
2996 VkAttachmentReference *attachments = new VkAttachmentReference[attachmentCount];
2997
Cody Northrop6de6b0b2015-08-04 11:16:41 -06002998 memcpy(attachments, subpass->pInputAttachments,
Chia-I Wuc278df82015-07-07 11:50:03 +08002999 sizeof(attachments[0]) * subpass->inputCount);
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003000 subpass->pInputAttachments = attachments;
Chia-I Wuc278df82015-07-07 11:50:03 +08003001 attachments += subpass->inputCount;
3002
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003003 memcpy(attachments, subpass->pColorAttachments,
Chia-I Wuc278df82015-07-07 11:50:03 +08003004 sizeof(attachments[0]) * subpass->colorCount);
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003005 subpass->pColorAttachments = attachments;
Chia-I Wuc278df82015-07-07 11:50:03 +08003006 attachments += subpass->colorCount;
3007
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003008 if (subpass->pResolveAttachments) {
3009 memcpy(attachments, subpass->pResolveAttachments,
Chia-I Wuc278df82015-07-07 11:50:03 +08003010 sizeof(attachments[0]) * subpass->colorCount);
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003011 subpass->pResolveAttachments = attachments;
Chia-I Wuc278df82015-07-07 11:50:03 +08003012 attachments += subpass->colorCount;
3013 }
3014
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003015 memcpy(attachments, subpass->pPreserveAttachments,
Chia-I Wuc278df82015-07-07 11:50:03 +08003016 sizeof(attachments[0]) * subpass->preserveCount);
Cody Northrop6de6b0b2015-08-04 11:16:41 -06003017 subpass->pPreserveAttachments = attachments;
Chia-I Wuc278df82015-07-07 11:50:03 +08003018 }
Tobin Ehlis2464b882015-04-01 08:40:34 -06003019 }
Chia-I Wuc278df82015-07-07 11:50:03 +08003020 if (pCreateInfo->pDependencies) {
3021 localRPCI->pDependencies = new VkSubpassDependency[localRPCI->dependencyCount];
3022 memcpy((void*)localRPCI->pDependencies, pCreateInfo->pDependencies, localRPCI->dependencyCount*sizeof(VkSubpassDependency));
Tobin Ehlis2464b882015-04-01 08:40:34 -06003023 }
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003024 renderPassMap[pRenderPass->handle] = localRPCI;
Tobin Ehlis2464b882015-04-01 08:40:34 -06003025 }
3026 return result;
3027}
3028
Chia-I Wuc278df82015-07-07 11:50:03 +08003029VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003030{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003031 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003032 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
3033 if (pCB) {
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06003034 if (pRenderPassBegin && pRenderPassBegin->renderPass) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06003035 skipCall |= insideRenderPass(pCB, "vkCmdBeginRenderPass");
3036 updateCBTracking(cmdBuffer);
3037 skipCall |= addCmd(pCB, CMD_BEGINRENDERPASS);
3038 pCB->activeRenderPass = pRenderPassBegin->renderPass;
3039 pCB->activeSubpass = 0;
3040 pCB->framebuffer = pRenderPassBegin->framebuffer;
3041 if (pCB->lastBoundPipeline) {
3042 skipCall |= validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06003043 }
Tobin Ehlise4076782015-06-24 15:53:07 -06003044 } else {
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003045 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS",
Tobin Ehlis8b6c2352015-06-23 16:13:03 -06003046 "You cannot use a NULL RenderPass object in vkCmdBeginRenderPass()");
Tony Barbourb9f82ba2015-04-06 11:09:26 -06003047 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003048 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003049 if (VK_FALSE == skipCall)
3050 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003051}
3052
Chia-I Wuc278df82015-07-07 11:50:03 +08003053VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
3054{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003055 VkBool32 skipCall = VK_FALSE;
Chia-I Wuc278df82015-07-07 11:50:03 +08003056 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
3057 if (pCB) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06003058 updateCBTracking(cmdBuffer);
3059 skipCall |= addCmd(pCB, CMD_NEXTSUBPASS);
3060 pCB->activeSubpass++;
3061 if (pCB->lastBoundPipeline) {
3062 skipCall |= validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
Chia-I Wuc278df82015-07-07 11:50:03 +08003063 }
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06003064 skipCall |= outsideRenderPass(pCB, "vkCmdNextSubpass");
Chia-I Wuc278df82015-07-07 11:50:03 +08003065 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003066 if (VK_FALSE == skipCall)
3067 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdNextSubpass(cmdBuffer, contents);
Chia-I Wuc278df82015-07-07 11:50:03 +08003068}
3069
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08003070VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003071{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003072 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003073 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
3074 if (pCB) {
Mark Lobodzinskia0f061c2015-09-30 16:19:16 -06003075 skipCall |= outsideRenderPass(pCB, "vkEndRenderpass");
3076 updateCBTracking(cmdBuffer);
3077 skipCall |= addCmd(pCB, CMD_ENDRENDERPASS);
3078 pCB->activeRenderPass = 0;
3079 pCB->activeSubpass = 0;
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08003080 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003081 if (VK_FALSE == skipCall)
3082 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer);
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08003083}
3084
3085VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
3086{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003087 VkBool32 skipCall = VK_FALSE;
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08003088 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
3089 if (pCB) {
Tobin Ehlis5f728d32015-09-17 14:18:16 -06003090 GLOBAL_CB_NODE* pSubCB = NULL;
3091 for (uint32_t i=0; i<cmdBuffersCount; i++) {
3092 pSubCB = getCBNode(pCmdBuffers[i]);
3093 if (!pSubCB) {
3094 skipCall |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, "DS",
3095 "vkCmdExecuteCommands() called w/ invalid Cmd Buffer %p in element %u of pCmdBuffers array.", (void*)pCmdBuffers[i], i);
3096 } else if (VK_CMD_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) {
3097 skipCall |= log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, "DS",
3098 "vkCmdExecuteCommands() called w/ Primary Cmd Buffer %p in element %u of pCmdBuffers array. All cmd buffers in pCmdBuffers array must be secondary.", (void*)pCmdBuffers[i], i);
3099 }
3100 }
3101 updateCBTracking(cmdBuffer);
3102 skipCall |= addCmd(pCB, CMD_EXECUTECOMMANDS);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003103 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003104 if (VK_FALSE == skipCall)
3105 get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003106}
3107
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06003108VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
3109 VkInstance instance,
3110 VkFlags msgFlags,
3111 const PFN_vkDbgMsgCallback pfnMsgCallback,
3112 void* pUserData,
3113 VkDbgMsgCallback* pMsgCallback)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003114{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06003115 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Tobin Ehlisc91330b2015-06-16 09:04:30 -06003116 VkResult res = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
3117 if (VK_SUCCESS == res) {
3118 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
3119 res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
3120 }
3121 return res;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003122}
3123
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06003124VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
3125 VkInstance instance,
3126 VkDbgMsgCallback msgCallback)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003127{
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06003128 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Tobin Ehlisc91330b2015-06-16 09:04:30 -06003129 VkResult res = pTable->DbgDestroyMsgCallback(instance, msgCallback);
3130 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
3131 layer_destroy_msg_callback(my_data->report_data, msgCallback);
3132 return res;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003133}
3134
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06003135VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003136{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003137 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003138 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003139 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
3140 if (!deviceExtMap[pDisp].debug_marker_enabled) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003141 // TODO : cmdBuffer should be srcObj
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003142 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06003143 "Attempt to use CmdDbgMarkerBegin but extension disabled!");
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003144 return;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06003145 } else if (pCB) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003146 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003147 skipCall |= addCmd(pCB, CMD_DBGMARKERBEGIN);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003148 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003149 if (VK_FALSE == skipCall)
3150 debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerBegin(cmdBuffer, pMarker);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003151}
3152
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06003153VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003154{
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003155 VkBool32 skipCall = VK_FALSE;
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003156 GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003157 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) cmdBuffer;
3158 if (!deviceExtMap[pDisp].debug_marker_enabled) {
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003159 // TODO : cmdBuffer should be srcObj
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003160 skipCall |= log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06003161 "Attempt to use CmdDbgMarkerEnd but extension disabled!");
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003162 return;
Tobin Ehlisa366ca22015-06-19 15:07:05 -06003163 } else if (pCB) {
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003164 updateCBTracking(cmdBuffer);
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003165 skipCall |= addCmd(pCB, CMD_DBGMARKEREND);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003166 }
Tobin Ehlis48ddcb82015-09-09 11:31:10 -06003167 if (VK_FALSE == skipCall)
3168 debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerEnd(cmdBuffer);
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003169}
3170
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003171//VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkDevice device, VkObjectType objType, VkObject object, size_t tagSize, const void* pTag)
3172//{
3173// VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
3174// if (!deviceExtMap[pDisp].debug_marker_enabled) {
3175// log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, objType, object, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
3176// "Attempt to use DbgSetObjectTag but extension disabled!");
3177// return VK_ERROR_UNAVAILABLE;
3178// }
3179// debug_marker_dispatch_table(device)->DbgSetObjectTag(device, objType, object, tagSize, pTag);
3180//}
3181//
3182//VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectName(VkDevice device, VkObjectType objType, VkObject object, size_t nameSize, const char* pName)
3183//{
3184// VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
3185// if (!deviceExtMap[pDisp].debug_marker_enabled) {
3186// log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, objType, object, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
3187// "Attempt to use DbgSetObjectName but extension disabled!");
3188// return VK_ERROR_UNAVAILABLE;
3189// }
3190// debug_marker_dispatch_table(device)->DbgSetObjectName(device, objType, object, nameSize, pName);
3191//}
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003192
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003193VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003194{
Jon Ashburn1245cec2015-05-18 13:20:15 -06003195 if (dev == NULL)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003196 return NULL;
Jon Ashburne0fa2282015-05-20 09:00:28 -06003197
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003198 /* loader uses this to force layer initialization; device object is wrapped */
3199 if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06003200 initDeviceTable(draw_state_device_table_map, (const VkBaseLayerObject *) dev);
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003201 return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003202 }
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -06003203 if (!strcmp(funcName, "vkCreateDevice"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003204 return (PFN_vkVoidFunction) vkCreateDevice;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003205 if (!strcmp(funcName, "vkDestroyDevice"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003206 return (PFN_vkVoidFunction) vkDestroyDevice;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003207 if (!strcmp(funcName, "vkQueueSubmit"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003208 return (PFN_vkVoidFunction) vkQueueSubmit;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003209 if (!strcmp(funcName, "vkDestroyInstance"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003210 return (PFN_vkVoidFunction) vkDestroyInstance;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003211 if (!strcmp(funcName, "vkDestroyDevice"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003212 return (PFN_vkVoidFunction) vkDestroyDevice;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003213 if (!strcmp(funcName, "vkDestroyFence"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003214 return (PFN_vkVoidFunction) vkDestroyFence;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003215 if (!strcmp(funcName, "vkDestroySemaphore"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003216 return (PFN_vkVoidFunction) vkDestroySemaphore;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003217 if (!strcmp(funcName, "vkDestroyEvent"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003218 return (PFN_vkVoidFunction) vkDestroyEvent;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003219 if (!strcmp(funcName, "vkDestroyQueryPool"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003220 return (PFN_vkVoidFunction) vkDestroyQueryPool;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003221 if (!strcmp(funcName, "vkDestroyBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003222 return (PFN_vkVoidFunction) vkDestroyBuffer;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003223 if (!strcmp(funcName, "vkDestroyBufferView"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003224 return (PFN_vkVoidFunction) vkDestroyBufferView;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003225 if (!strcmp(funcName, "vkDestroyImage"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003226 return (PFN_vkVoidFunction) vkDestroyImage;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003227 if (!strcmp(funcName, "vkDestroyImageView"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003228 return (PFN_vkVoidFunction) vkDestroyImageView;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003229 if (!strcmp(funcName, "vkDestroyShaderModule"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003230 return (PFN_vkVoidFunction) vkDestroyShaderModule;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003231 if (!strcmp(funcName, "vkDestroyShader"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003232 return (PFN_vkVoidFunction) vkDestroyShader;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003233 if (!strcmp(funcName, "vkDestroyPipeline"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003234 return (PFN_vkVoidFunction) vkDestroyPipeline;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003235 if (!strcmp(funcName, "vkDestroyPipelineLayout"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003236 return (PFN_vkVoidFunction) vkDestroyPipelineLayout;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003237 if (!strcmp(funcName, "vkDestroySampler"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003238 return (PFN_vkVoidFunction) vkDestroySampler;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003239 if (!strcmp(funcName, "vkDestroyDescriptorSetLayout"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003240 return (PFN_vkVoidFunction) vkDestroyDescriptorSetLayout;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003241 if (!strcmp(funcName, "vkDestroyDescriptorPool"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003242 return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003243 if (!strcmp(funcName, "vkDestroyCommandBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003244 return (PFN_vkVoidFunction) vkDestroyCommandBuffer;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003245 if (!strcmp(funcName, "vkDestroyFramebuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003246 return (PFN_vkVoidFunction) vkDestroyFramebuffer;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003247 if (!strcmp(funcName, "vkDestroyRenderPass"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003248 return (PFN_vkVoidFunction) vkDestroyRenderPass;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003249 if (!strcmp(funcName, "vkCreateBufferView"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003250 return (PFN_vkVoidFunction) vkCreateBufferView;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003251 if (!strcmp(funcName, "vkCreateImageView"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003252 return (PFN_vkVoidFunction) vkCreateImageView;
Jon Ashburn0d60d272015-07-09 15:02:25 -06003253 if (!strcmp(funcName, "CreatePipelineCache"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003254 return (PFN_vkVoidFunction) vkCreatePipelineCache;
Jon Ashburn0d60d272015-07-09 15:02:25 -06003255 if (!strcmp(funcName, "DestroyPipelineCache"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003256 return (PFN_vkVoidFunction) vkDestroyPipelineCache;
Jon Ashburn0d60d272015-07-09 15:02:25 -06003257 if (!strcmp(funcName, "GetPipelineCacheSize"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003258 return (PFN_vkVoidFunction) vkGetPipelineCacheSize;
Jon Ashburn0d60d272015-07-09 15:02:25 -06003259 if (!strcmp(funcName, "GetPipelineCacheData"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003260 return (PFN_vkVoidFunction) vkGetPipelineCacheData;
Jon Ashburn0d60d272015-07-09 15:02:25 -06003261 if (!strcmp(funcName, "MergePipelineCaches"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003262 return (PFN_vkVoidFunction) vkMergePipelineCaches;
Jon Ashburn0d60d272015-07-09 15:02:25 -06003263 if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003264 return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003265 if (!strcmp(funcName, "vkCreateSampler"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003266 return (PFN_vkVoidFunction) vkCreateSampler;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003267 if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003268 return (PFN_vkVoidFunction) vkCreateDescriptorSetLayout;
Mark Lobodzinski556f7212015-04-17 14:11:39 -05003269 if (!strcmp(funcName, "vkCreatePipelineLayout"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003270 return (PFN_vkVoidFunction) vkCreatePipelineLayout;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003271 if (!strcmp(funcName, "vkCreateDescriptorPool"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003272 return (PFN_vkVoidFunction) vkCreateDescriptorPool;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003273 if (!strcmp(funcName, "vkResetDescriptorPool"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003274 return (PFN_vkVoidFunction) vkResetDescriptorPool;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003275 if (!strcmp(funcName, "vkAllocDescriptorSets"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003276 return (PFN_vkVoidFunction) vkAllocDescriptorSets;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +08003277 if (!strcmp(funcName, "vkUpdateDescriptorSets"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003278 return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003279 if (!strcmp(funcName, "vkCreateCommandBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003280 return (PFN_vkVoidFunction) vkCreateCommandBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003281 if (!strcmp(funcName, "vkBeginCommandBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003282 return (PFN_vkVoidFunction) vkBeginCommandBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003283 if (!strcmp(funcName, "vkEndCommandBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003284 return (PFN_vkVoidFunction) vkEndCommandBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003285 if (!strcmp(funcName, "vkResetCommandBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003286 return (PFN_vkVoidFunction) vkResetCommandBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003287 if (!strcmp(funcName, "vkCmdBindPipeline"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003288 return (PFN_vkVoidFunction) vkCmdBindPipeline;
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06003289 if (!strcmp(funcName, "vkCmdSetViewport"))
3290 return (PFN_vkVoidFunction) vkCmdSetViewport;
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06003291 if (!strcmp(funcName, "vkCmdSetScissor"))
3292 return (PFN_vkVoidFunction) vkCmdSetScissor;
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06003293 if (!strcmp(funcName, "vkCmdSetLineWidth"))
3294 return (PFN_vkVoidFunction) vkCmdSetLineWidth;
3295 if (!strcmp(funcName, "vkCmdSetDepthBias"))
3296 return (PFN_vkVoidFunction) vkCmdSetDepthBias;
3297 if (!strcmp(funcName, "vkCmdSetBlendConstants"))
3298 return (PFN_vkVoidFunction) vkCmdSetBlendConstants;
3299 if (!strcmp(funcName, "vkCmdSetDepthBounds"))
3300 return (PFN_vkVoidFunction) vkCmdSetDepthBounds;
3301 if (!strcmp(funcName, "vkCmdSetStencilCompareMask"))
3302 return (PFN_vkVoidFunction) vkCmdSetStencilCompareMask;
3303 if (!strcmp(funcName, "vkCmdSetStencilWriteMask"))
3304 return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
3305 if (!strcmp(funcName, "vkCmdSetStencilReference"))
3306 return (PFN_vkVoidFunction) vkCmdSetStencilReference;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003307 if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003308 return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06003309 if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003310 return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003311 if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003312 return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003313 if (!strcmp(funcName, "vkCmdDraw"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003314 return (PFN_vkVoidFunction) vkCmdDraw;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003315 if (!strcmp(funcName, "vkCmdDrawIndexed"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003316 return (PFN_vkVoidFunction) vkCmdDrawIndexed;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003317 if (!strcmp(funcName, "vkCmdDrawIndirect"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003318 return (PFN_vkVoidFunction) vkCmdDrawIndirect;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003319 if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003320 return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003321 if (!strcmp(funcName, "vkCmdDispatch"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003322 return (PFN_vkVoidFunction) vkCmdDispatch;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003323 if (!strcmp(funcName, "vkCmdDispatchIndirect"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003324 return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003325 if (!strcmp(funcName, "vkCmdCopyBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003326 return (PFN_vkVoidFunction) vkCmdCopyBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003327 if (!strcmp(funcName, "vkCmdCopyImage"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003328 return (PFN_vkVoidFunction) vkCmdCopyImage;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003329 if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003330 return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003331 if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003332 return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003333 if (!strcmp(funcName, "vkCmdUpdateBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003334 return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003335 if (!strcmp(funcName, "vkCmdFillBuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003336 return (PFN_vkVoidFunction) vkCmdFillBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003337 if (!strcmp(funcName, "vkCmdClearColorImage"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003338 return (PFN_vkVoidFunction) vkCmdClearColorImage;
Chris Forbes2951d7d2015-06-22 17:21:59 +12003339 if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003340 return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06003341 if (!strcmp(funcName, "vkCmdClearColorAttachment"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003342 return (PFN_vkVoidFunction) vkCmdClearColorAttachment;
Tobin Ehlis8cd650e2015-07-01 16:46:13 -06003343 if (!strcmp(funcName, "vkCmdClearDepthStencilAttachment"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003344 return (PFN_vkVoidFunction) vkCmdClearDepthStencilAttachment;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003345 if (!strcmp(funcName, "vkCmdResolveImage"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003346 return (PFN_vkVoidFunction) vkCmdResolveImage;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003347 if (!strcmp(funcName, "vkCmdSetEvent"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003348 return (PFN_vkVoidFunction) vkCmdSetEvent;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003349 if (!strcmp(funcName, "vkCmdResetEvent"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003350 return (PFN_vkVoidFunction) vkCmdResetEvent;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003351 if (!strcmp(funcName, "vkCmdWaitEvents"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003352 return (PFN_vkVoidFunction) vkCmdWaitEvents;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003353 if (!strcmp(funcName, "vkCmdPipelineBarrier"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003354 return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003355 if (!strcmp(funcName, "vkCmdBeginQuery"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003356 return (PFN_vkVoidFunction) vkCmdBeginQuery;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003357 if (!strcmp(funcName, "vkCmdEndQuery"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003358 return (PFN_vkVoidFunction) vkCmdEndQuery;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003359 if (!strcmp(funcName, "vkCmdResetQueryPool"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003360 return (PFN_vkVoidFunction) vkCmdResetQueryPool;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003361 if (!strcmp(funcName, "vkCmdWriteTimestamp"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003362 return (PFN_vkVoidFunction) vkCmdWriteTimestamp;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003363 if (!strcmp(funcName, "vkCreateFramebuffer"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003364 return (PFN_vkVoidFunction) vkCreateFramebuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003365 if (!strcmp(funcName, "vkCreateRenderPass"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003366 return (PFN_vkVoidFunction) vkCreateRenderPass;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003367 if (!strcmp(funcName, "vkCmdBeginRenderPass"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003368 return (PFN_vkVoidFunction) vkCmdBeginRenderPass;
Chia-I Wuc278df82015-07-07 11:50:03 +08003369 if (!strcmp(funcName, "vkCmdNextSubpass"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003370 return (PFN_vkVoidFunction) vkCmdNextSubpass;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06003371 if (!strcmp(funcName, "vkCmdEndRenderPass"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003372 return (PFN_vkVoidFunction) vkCmdEndRenderPass;
Tobin Ehlis5f728d32015-09-17 14:18:16 -06003373 if (!strcmp(funcName, "vkCmdExecuteCommands"))
3374 return (PFN_vkVoidFunction) vkCmdExecuteCommands;
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003375
Jon Ashburn7e07faf2015-06-18 15:02:58 -06003376 VkLayerDispatchTable* pTable = get_dispatch_table(draw_state_device_table_map, dev);
3377 if (deviceExtMap.size() == 0 || deviceExtMap[pTable].debug_marker_enabled)
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003378 {
Jon Ashburn7e07faf2015-06-18 15:02:58 -06003379 if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003380 return (PFN_vkVoidFunction) vkCmdDbgMarkerBegin;
Jon Ashburn7e07faf2015-06-18 15:02:58 -06003381 if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003382 return (PFN_vkVoidFunction) vkCmdDbgMarkerEnd;
Tobin Ehlis1dce5f12015-07-07 10:42:20 -06003383// if (!strcmp(funcName, "vkDbgSetObjectTag"))
3384// return (void*) vkDbgSetObjectTag;
3385// if (!strcmp(funcName, "vkDbgSetObjectName"))
3386// return (void*) vkDbgSetObjectName;
Jon Ashburn6f8cd632015-06-01 09:37:38 -06003387 }
3388 {
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003389 if (pTable->GetDeviceProcAddr == NULL)
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003390 return NULL;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003391 return pTable->GetDeviceProcAddr(dev, funcName);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06003392 }
3393}
3394
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003395VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
Jon Ashburn79b78ac2015-05-05 14:22:52 -06003396{
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003397 PFN_vkVoidFunction fptr;
Jon Ashburn79b78ac2015-05-05 14:22:52 -06003398 if (instance == NULL)
3399 return NULL;
3400
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003401 /* loader uses this to force layer initialization; instance object is wrapped */
3402 if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06003403 initInstanceTable(draw_state_instance_table_map, (const VkBaseLayerObject *) instance);
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003404 return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003405 }
Courtney Goeltzenleuchter3c9f6ec2015-06-01 14:29:58 -06003406 if (!strcmp(funcName, "vkCreateInstance"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003407 return (PFN_vkVoidFunction) vkCreateInstance;
Jon Ashburne0fa2282015-05-20 09:00:28 -06003408 if (!strcmp(funcName, "vkDestroyInstance"))
Courtney Goeltzenleuchtera4c8c712015-07-12 14:35:22 -06003409 return (PFN_vkVoidFunction) vkDestroyInstance;
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -06003410 if (!strcmp(funcName, "vkEnumerateInstanceLayerProperties"))
3411 return (PFN_vkVoidFunction) vkEnumerateInstanceLayerProperties;
3412 if (!strcmp(funcName, "vkEnumerateInstanceExtensionProperties"))
3413 return (PFN_vkVoidFunction) vkEnumerateInstanceExtensionProperties;
3414 if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties"))
3415 return (PFN_vkVoidFunction) vkEnumerateDeviceLayerProperties;
3416 if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties"))
3417 return (PFN_vkVoidFunction) vkEnumerateDeviceExtensionProperties;
Courtney Goeltzenleuchtercc899fe2015-06-01 14:33:14 -06003418
Tobin Ehlisfde4dce2015-06-16 15:50:44 -06003419 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
3420 fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
Courtney Goeltzenleuchtercc899fe2015-06-01 14:33:14 -06003421 if (fptr)
3422 return fptr;
3423
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003424 {
Courtney Goeltzenleuchterc280adc2015-06-13 21:23:09 -06003425 VkLayerInstanceDispatchTable* pTable = get_dispatch_table(draw_state_instance_table_map, instance);
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003426 if (pTable->GetInstanceProcAddr == NULL)
Jon Ashburn79b78ac2015-05-05 14:22:52 -06003427 return NULL;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06003428 return pTable->GetInstanceProcAddr(instance, funcName);
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003429 }
Tobin Ehlis63bb9482015-03-17 16:24:32 -06003430}