Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 2d034fd483f9181399561cf3207ddf12bf4e5b6a / . / layers / param_checker.cpp
blob: 8fa33ceb7547c27d2ef6d2e9e062fff1762ba837 [file] [log] [blame]
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1/*
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2 * Vulkan
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3 *
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
29#include <iostream>
30#include <string>
31#include <sstream>
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]32#include <unordered_map>
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]33#include <vector>
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]34
35#include "loader_platform.h"
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]36#include "vkLayer.h"
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]37#include "layers_config.h"
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]38#include "vk_enum_validate_helper.h"
39#include "vk_struct_validate_helper.h"
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]40//The following is #included again to catch certain OS-specific functions being used:
41#include "loader_platform.h"
42
Jon Ashburn5a10d212015-06-01 10:02:09 -0600[diff] [blame]43#include "layers_table.h"
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]44#include "layer_data.h"
45#include "layer_logging.h"
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]46
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]47typedef struct _layer_data {
48 debug_report_data *report_data;
49 VkDbgMsgCallback logging_callback;
50} layer_data;
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]51
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]52static std::unordered_map<void*, layer_data*> layer_data_map;
53static device_table_map pc_device_table_map;
54static instance_table_map pc_instance_table_map;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]55
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]56#define PC_LAYER_EXT_ARRAY_SIZE 2
57static const VkExtensionProperties pcExts[PC_LAYER_EXT_ARRAY_SIZE] = {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]58 {
59 VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
60 "ParamChecker",
61 0x10,
62 "Sample layer: ParamChecker",
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600[diff] [blame]63 },
64 {
65 VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
66 "Validation",
67 0x10,
68 "Sample layer: ParamChecker",
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]69 }
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]70};
71
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]72// "my instance data"
73debug_report_data *mid(VkInstance object)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]74{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]75 dispatch_key key = get_dispatch_key(object);
76 layer_data *data = get_my_data_ptr(get_dispatch_key(object), layer_data_map);
77#if DISPATCH_MAP_DEBUG
78 fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
79#endif
80 assert(data->report_data != NULL);
81
82 return data->report_data;
83}
84
85// "my device data"
86debug_report_data *mdd(VkObject object)
87{
88 dispatch_key key = get_dispatch_key(object);
89 layer_data *data = get_my_data_ptr(key, layer_data_map);
90#if DISPATCH_MAP_DEBUG
91 fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
92#endif
93 assert(data->report_data != NULL);
94 return data->report_data;
95}
96
97static void InitParamChecker(layer_data *data)
98{
99 uint32_t report_flags = getLayerOptionFlags("ParamCheckerReportFlags", 0);
100
101 uint32_t debug_action = 0;
102 getLayerOptionEnum("ParamCheckerDebugAction", (uint32_t *) &debug_action);
103 if(debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
104 {
105 FILE *log_output = NULL;
106 const char* option_str = getLayerOption("ParamCheckerLogFilename");
107 if(option_str)
108 {
109 log_output = fopen(option_str, "w");
110 }
111 if(log_output == NULL)
112 {
113 log_output = stdout;
114 }
115
116 layer_create_msg_callback(data->report_data, report_flags, log_callback, (void*)log_output, &data->logging_callback);
117 }
118}
119
120VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
121 VkInstance instance,
122 VkFlags msgFlags,
123 const PFN_vkDbgMsgCallback pfnMsgCallback,
124 void* pUserData,
125 VkDbgMsgCallback* pMsgCallback)
126{
127 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
128 VkResult result = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
129
130 if (result == VK_SUCCESS)
131 {
132 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
133 result = layer_create_msg_callback(data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
134 }
135
136 return result;
137}
138
139VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
140 VkInstance instance,
141 VkDbgMsgCallback msgCallback)
142{
143 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
144 VkResult result = pTable->DbgDestroyMsgCallback(instance, msgCallback);
145
146 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
147 layer_destroy_msg_callback(data->report_data, msgCallback);
148
149 return result;
150}
151
152VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionCount(uint32_t* pCount)
153{
154 *pCount = PC_LAYER_EXT_ARRAY_SIZE;
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]155 return VK_SUCCESS;
156}
157
158VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionProperties(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]159 uint32_t extensionIndex,
160 VkExtensionProperties* pProperties)
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]161{
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]162 /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]163 if (extensionIndex >= PC_LAYER_EXT_ARRAY_SIZE)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]164 return VK_ERROR_INVALID_VALUE;
165 memcpy(pProperties, &pcExts[extensionIndex], sizeof(VkExtensionProperties));
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]166
167 return VK_SUCCESS;
168}
169
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]170VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionCount(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]171 VkPhysicalDevice gpu,
172 uint32_t* pCount)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]173{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]174 *pCount = PC_LAYER_EXT_ARRAY_SIZE;
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]175 return VK_SUCCESS;
176}
177
178VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]179 VkPhysicalDevice gpu,
180 uint32_t extensionIndex,
181 VkExtensionProperties* pProperties)
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]182{
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600[diff] [blame]183 /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]184 if (extensionIndex >= PC_LAYER_EXT_ARRAY_SIZE)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]185 return VK_ERROR_INVALID_VALUE;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]186 memcpy(pProperties, &pcExts[extensionIndex], sizeof(VkExtensionProperties));
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600[diff] [blame]187
188 return VK_SUCCESS;
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]189}
190
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]191// Version: 0.111.0
192
193static
194std::string EnumeratorString(VkResult const& enumerator)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]195{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]196 switch(enumerator)
197 {
198 case VK_ERROR_MEMORY_NOT_BOUND:
199 {
200 return "VK_ERROR_MEMORY_NOT_BOUND";
201 break;
202 }
203 case VK_ERROR_BUILDING_COMMAND_BUFFER:
204 {
205 return "VK_ERROR_BUILDING_COMMAND_BUFFER";
206 break;
207 }
208 case VK_ERROR_INCOMPATIBLE_DRIVER:
209 {
210 return "VK_ERROR_INCOMPATIBLE_DRIVER";
211 break;
212 }
213 case VK_ERROR_MEMORY_UNMAP_FAILED:
214 {
215 return "VK_ERROR_MEMORY_UNMAP_FAILED";
216 break;
217 }
218 case VK_ERROR_MEMORY_MAP_FAILED:
219 {
220 return "VK_ERROR_MEMORY_MAP_FAILED";
221 break;
222 }
223 case VK_ERROR_BAD_PIPELINE_DATA:
224 {
225 return "VK_ERROR_BAD_PIPELINE_DATA";
226 break;
227 }
228 case VK_ERROR_INVALID_OBJECT_TYPE:
229 {
230 return "VK_ERROR_INVALID_OBJECT_TYPE";
231 break;
232 }
233 case VK_ERROR_INVALID_QUEUE_TYPE:
234 {
235 return "VK_ERROR_INVALID_QUEUE_TYPE";
236 break;
237 }
238 case VK_ERROR_BAD_SHADER_CODE:
239 {
240 return "VK_ERROR_BAD_SHADER_CODE";
241 break;
242 }
243 case VK_ERROR_INVALID_IMAGE:
244 {
245 return "VK_ERROR_INVALID_IMAGE";
246 break;
247 }
248 case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
249 {
250 return "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
251 break;
252 }
253 case VK_ERROR_INITIALIZATION_FAILED:
254 {
255 return "VK_ERROR_INITIALIZATION_FAILED";
256 break;
257 }
258 case VK_NOT_READY:
259 {
260 return "VK_NOT_READY";
261 break;
262 }
263 case VK_ERROR_INVALID_POINTER:
264 {
265 return "VK_ERROR_INVALID_POINTER";
266 break;
267 }
268 case VK_ERROR_INVALID_VALUE:
269 {
270 return "VK_ERROR_INVALID_VALUE";
271 break;
272 }
273 case VK_ERROR_UNAVAILABLE:
274 {
275 return "VK_ERROR_UNAVAILABLE";
276 break;
277 }
278 case VK_ERROR_OUT_OF_HOST_MEMORY:
279 {
280 return "VK_ERROR_OUT_OF_HOST_MEMORY";
281 break;
282 }
283 case VK_ERROR_UNKNOWN:
284 {
285 return "VK_ERROR_UNKNOWN";
286 break;
287 }
288 case VK_ERROR_NOT_MAPPABLE:
289 {
290 return "VK_ERROR_NOT_MAPPABLE";
291 break;
292 }
293 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
294 {
295 return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
296 break;
297 }
298 case VK_EVENT_SET:
299 {
300 return "VK_EVENT_SET";
301 break;
302 }
303 case VK_TIMEOUT:
304 {
305 return "VK_TIMEOUT";
306 break;
307 }
308 case VK_ERROR_INVALID_FLAGS:
309 {
310 return "VK_ERROR_INVALID_FLAGS";
311 break;
312 }
313 case VK_EVENT_RESET:
314 {
315 return "VK_EVENT_RESET";
316 break;
317 }
318 case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA:
319 {
320 return "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA";
321 break;
322 }
323 case VK_UNSUPPORTED:
324 {
325 return "VK_UNSUPPORTED";
326 break;
327 }
328 case VK_ERROR_INVALID_HANDLE:
329 {
330 return "VK_ERROR_INVALID_HANDLE";
331 break;
332 }
333 case VK_ERROR_INCOMPATIBLE_DEVICE:
334 {
335 return "VK_ERROR_INCOMPATIBLE_DEVICE";
336 break;
337 }
338 case VK_SUCCESS:
339 {
340 return "VK_SUCCESS";
341 break;
342 }
343 case VK_ERROR_INCOMPATIBLE_QUEUE:
344 {
345 return "VK_ERROR_INCOMPATIBLE_QUEUE";
346 break;
347 }
348 case VK_ERROR_INVALID_EXTENSION:
349 {
350 return "VK_ERROR_INVALID_EXTENSION";
351 break;
352 }
353 case VK_ERROR_DEVICE_ALREADY_CREATED:
354 {
355 return "VK_ERROR_DEVICE_ALREADY_CREATED";
356 break;
357 }
358 case VK_ERROR_DEVICE_LOST:
359 {
360 return "VK_ERROR_DEVICE_LOST";
361 break;
362 }
363 case VK_ERROR_INVALID_ORDINAL:
364 {
365 return "VK_ERROR_INVALID_ORDINAL";
366 break;
367 }
368 case VK_ERROR_INVALID_MEMORY_SIZE:
369 {
370 return "VK_ERROR_INVALID_MEMORY_SIZE";
371 break;
372 }
373 case VK_ERROR_INCOMPLETE_COMMAND_BUFFER:
374 {
375 return "VK_ERROR_INCOMPLETE_COMMAND_BUFFER";
376 break;
377 }
378 case VK_ERROR_INVALID_ALIGNMENT:
379 {
380 return "VK_ERROR_INVALID_ALIGNMENT";
381 break;
382 }
383 case VK_ERROR_INVALID_FORMAT:
384 {
385 return "VK_ERROR_INVALID_FORMAT";
386 break;
387 }
388 default:
389 {
390 return "unrecognized enumerator";
391 break;
392 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]393 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]394}
395
396static
397bool ValidateEnumerator(VkQueueFlagBits const& enumerator)
398{
399 VkQueueFlagBits allFlags = (VkQueueFlagBits)(VK_QUEUE_EXTENDED_BIT |
400 VK_QUEUE_DMA_BIT |
401 VK_QUEUE_COMPUTE_BIT |
402 VK_QUEUE_SPARSE_MEMMGR_BIT |
403 VK_QUEUE_GRAPHICS_BIT);
404 if(enumerator & (~allFlags))
405 {
406 return false;
407 }
408
409 return true;
410}
411
412static
413std::string EnumeratorString(VkQueueFlagBits const& enumerator)
414{
415 if(!ValidateEnumerator(enumerator))
416 {
417 return "unrecognized enumerator";
418 }
419
420 std::vector<std::string> strings;
421 if(enumerator & VK_QUEUE_EXTENDED_BIT)
422 {
423 strings.push_back("VK_QUEUE_EXTENDED_BIT");
424 }
425 if(enumerator & VK_QUEUE_DMA_BIT)
426 {
427 strings.push_back("VK_QUEUE_DMA_BIT");
428 }
429 if(enumerator & VK_QUEUE_COMPUTE_BIT)
430 {
431 strings.push_back("VK_QUEUE_COMPUTE_BIT");
432 }
433 if(enumerator & VK_QUEUE_SPARSE_MEMMGR_BIT)
434 {
435 strings.push_back("VK_QUEUE_SPARSE_MEMMGR_BIT");
436 }
437 if(enumerator & VK_QUEUE_GRAPHICS_BIT)
438 {
439 strings.push_back("VK_QUEUE_GRAPHICS_BIT");
440 }
441
442 std::string enumeratorString;
443 for(auto const& string : strings)
444 {
445 enumeratorString += string;
446
447 if(string != strings.back())
448 {
449 enumeratorString += '|';
450 }
451 }
452
453 return enumeratorString;
454}
455
456static
457bool ValidateEnumerator(VkMemoryPropertyFlagBits const& enumerator)
458{
459 VkMemoryPropertyFlagBits allFlags = (VkMemoryPropertyFlagBits)(VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL |
460 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT |
461 VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT |
462 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
463 VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT |
464 VK_MEMORY_PROPERTY_DEVICE_ONLY);
465 if(enumerator & (~allFlags))
466 {
467 return false;
468 }
469
470 return true;
471}
472
473static
474std::string EnumeratorString(VkMemoryPropertyFlagBits const& enumerator)
475{
476 if(!ValidateEnumerator(enumerator))
477 {
478 return "unrecognized enumerator";
479 }
480
481 std::vector<std::string> strings;
482 if(enumerator & VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL)
483 {
484 strings.push_back("VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL");
485 }
486 if(enumerator & VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT)
487 {
488 strings.push_back("VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT");
489 }
490 if(enumerator & VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT)
491 {
492 strings.push_back("VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT");
493 }
494 if(enumerator & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
495 {
496 strings.push_back("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT");
497 }
498 if(enumerator & VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT)
499 {
500 strings.push_back("VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT");
501 }
502 if(enumerator & VK_MEMORY_PROPERTY_DEVICE_ONLY)
503 {
504 strings.push_back("VK_MEMORY_PROPERTY_DEVICE_ONLY");
505 }
506
507 std::string enumeratorString;
508 for(auto const& string : strings)
509 {
510 enumeratorString += string;
511
512 if(string != strings.back())
513 {
514 enumeratorString += '|';
515 }
516 }
517
518 return enumeratorString;
519}
520
521static
522bool ValidateEnumerator(VkMemoryOutputFlagBits const& enumerator)
523{
524 VkMemoryOutputFlagBits allFlags = (VkMemoryOutputFlagBits)(VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
525 VK_MEMORY_OUTPUT_TRANSFER_BIT |
526 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
527 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
528 VK_MEMORY_OUTPUT_HOST_WRITE_BIT);
529 if(enumerator & (~allFlags))
530 {
531 return false;
532 }
533
534 return true;
535}
536
537static
538std::string EnumeratorString(VkMemoryOutputFlagBits const& enumerator)
539{
540 if(!ValidateEnumerator(enumerator))
541 {
542 return "unrecognized enumerator";
543 }
544
545 std::vector<std::string> strings;
546 if(enumerator & VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT)
547 {
548 strings.push_back("VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT");
549 }
550 if(enumerator & VK_MEMORY_OUTPUT_TRANSFER_BIT)
551 {
552 strings.push_back("VK_MEMORY_OUTPUT_TRANSFER_BIT");
553 }
554 if(enumerator & VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT)
555 {
556 strings.push_back("VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT");
557 }
558 if(enumerator & VK_MEMORY_OUTPUT_SHADER_WRITE_BIT)
559 {
560 strings.push_back("VK_MEMORY_OUTPUT_SHADER_WRITE_BIT");
561 }
562 if(enumerator & VK_MEMORY_OUTPUT_HOST_WRITE_BIT)
563 {
564 strings.push_back("VK_MEMORY_OUTPUT_HOST_WRITE_BIT");
565 }
566
567 std::string enumeratorString;
568 for(auto const& string : strings)
569 {
570 enumeratorString += string;
571
572 if(string != strings.back())
573 {
574 enumeratorString += '|';
575 }
576 }
577
578 return enumeratorString;
579}
580
581static
582bool ValidateEnumerator(VkMemoryInputFlagBits const& enumerator)
583{
584 VkMemoryInputFlagBits allFlags = (VkMemoryInputFlagBits)(VK_MEMORY_INPUT_TRANSFER_BIT |
585 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
586 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
587 VK_MEMORY_INPUT_SHADER_READ_BIT |
588 VK_MEMORY_INPUT_UNIFORM_READ_BIT |
589 VK_MEMORY_INPUT_INDEX_FETCH_BIT |
590 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
591 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
592 VK_MEMORY_INPUT_HOST_READ_BIT);
593 if(enumerator & (~allFlags))
594 {
595 return false;
596 }
597
598 return true;
599}
600
601static
602std::string EnumeratorString(VkMemoryInputFlagBits const& enumerator)
603{
604 if(!ValidateEnumerator(enumerator))
605 {
606 return "unrecognized enumerator";
607 }
608
609 std::vector<std::string> strings;
610 if(enumerator & VK_MEMORY_INPUT_TRANSFER_BIT)
611 {
612 strings.push_back("VK_MEMORY_INPUT_TRANSFER_BIT");
613 }
614 if(enumerator & VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT)
615 {
616 strings.push_back("VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT");
617 }
618 if(enumerator & VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT)
619 {
620 strings.push_back("VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT");
621 }
622 if(enumerator & VK_MEMORY_INPUT_SHADER_READ_BIT)
623 {
624 strings.push_back("VK_MEMORY_INPUT_SHADER_READ_BIT");
625 }
626 if(enumerator & VK_MEMORY_INPUT_UNIFORM_READ_BIT)
627 {
628 strings.push_back("VK_MEMORY_INPUT_UNIFORM_READ_BIT");
629 }
630 if(enumerator & VK_MEMORY_INPUT_INDEX_FETCH_BIT)
631 {
632 strings.push_back("VK_MEMORY_INPUT_INDEX_FETCH_BIT");
633 }
634 if(enumerator & VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT)
635 {
636 strings.push_back("VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT");
637 }
638 if(enumerator & VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT)
639 {
640 strings.push_back("VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT");
641 }
642 if(enumerator & VK_MEMORY_INPUT_HOST_READ_BIT)
643 {
644 strings.push_back("VK_MEMORY_INPUT_HOST_READ_BIT");
645 }
646
647 std::string enumeratorString;
648 for(auto const& string : strings)
649 {
650 enumeratorString += string;
651
652 if(string != strings.back())
653 {
654 enumeratorString += '|';
655 }
656 }
657
658 return enumeratorString;
659}
660
661static
662bool ValidateEnumerator(VkBufferUsageFlagBits const& enumerator)
663{
664 VkBufferUsageFlagBits allFlags = (VkBufferUsageFlagBits)(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
665 VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
666 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
667 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
668 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
669 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT |
670 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
671 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT |
672 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
673 VK_BUFFER_USAGE_GENERAL);
674 if(enumerator & (~allFlags))
675 {
676 return false;
677 }
678
679 return true;
680}
681
682static
683std::string EnumeratorString(VkBufferUsageFlagBits const& enumerator)
684{
685 if(!ValidateEnumerator(enumerator))
686 {
687 return "unrecognized enumerator";
688 }
689
690 std::vector<std::string> strings;
691 if(enumerator & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
692 {
693 strings.push_back("VK_BUFFER_USAGE_VERTEX_BUFFER_BIT");
694 }
695 if(enumerator & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
696 {
697 strings.push_back("VK_BUFFER_USAGE_INDEX_BUFFER_BIT");
698 }
699 if(enumerator & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
700 {
701 strings.push_back("VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT");
702 }
703 if(enumerator & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
704 {
705 strings.push_back("VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT");
706 }
707 if(enumerator & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
708 {
709 strings.push_back("VK_BUFFER_USAGE_STORAGE_BUFFER_BIT");
710 }
711 if(enumerator & VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT)
712 {
713 strings.push_back("VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
714 }
715 if(enumerator & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
716 {
717 strings.push_back("VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT");
718 }
719 if(enumerator & VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT)
720 {
721 strings.push_back("VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
722 }
723 if(enumerator & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
724 {
725 strings.push_back("VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT");
726 }
727 if(enumerator & VK_BUFFER_USAGE_GENERAL)
728 {
729 strings.push_back("VK_BUFFER_USAGE_GENERAL");
730 }
731
732 std::string enumeratorString;
733 for(auto const& string : strings)
734 {
735 enumeratorString += string;
736
737 if(string != strings.back())
738 {
739 enumeratorString += '|';
740 }
741 }
742
743 return enumeratorString;
744}
745
746static
747bool ValidateEnumerator(VkBufferCreateFlagBits const& enumerator)
748{
749 VkBufferCreateFlagBits allFlags = (VkBufferCreateFlagBits)(VK_BUFFER_CREATE_SPARSE_BIT);
750 if(enumerator & (~allFlags))
751 {
752 return false;
753 }
754
755 return true;
756}
757
758static
759std::string EnumeratorString(VkBufferCreateFlagBits const& enumerator)
760{
761 if(!ValidateEnumerator(enumerator))
762 {
763 return "unrecognized enumerator";
764 }
765
766 std::vector<std::string> strings;
767 if(enumerator & VK_BUFFER_CREATE_SPARSE_BIT)
768 {
769 strings.push_back("VK_BUFFER_CREATE_SPARSE_BIT");
770 }
771
772 std::string enumeratorString;
773 for(auto const& string : strings)
774 {
775 enumeratorString += string;
776
777 if(string != strings.back())
778 {
779 enumeratorString += '|';
780 }
781 }
782
783 return enumeratorString;
784}
785
786static
787bool ValidateEnumerator(VkShaderStageFlagBits const& enumerator)
788{
789 VkShaderStageFlagBits allFlags = (VkShaderStageFlagBits)(VK_SHADER_STAGE_ALL |
790 VK_SHADER_STAGE_FRAGMENT_BIT |
791 VK_SHADER_STAGE_GEOMETRY_BIT |
792 VK_SHADER_STAGE_COMPUTE_BIT |
793 VK_SHADER_STAGE_TESS_EVALUATION_BIT |
794 VK_SHADER_STAGE_TESS_CONTROL_BIT |
795 VK_SHADER_STAGE_VERTEX_BIT);
796 if(enumerator & (~allFlags))
797 {
798 return false;
799 }
800
801 return true;
802}
803
804static
805std::string EnumeratorString(VkShaderStageFlagBits const& enumerator)
806{
807 if(!ValidateEnumerator(enumerator))
808 {
809 return "unrecognized enumerator";
810 }
811
812 std::vector<std::string> strings;
813 if(enumerator & VK_SHADER_STAGE_ALL)
814 {
815 strings.push_back("VK_SHADER_STAGE_ALL");
816 }
817 if(enumerator & VK_SHADER_STAGE_FRAGMENT_BIT)
818 {
819 strings.push_back("VK_SHADER_STAGE_FRAGMENT_BIT");
820 }
821 if(enumerator & VK_SHADER_STAGE_GEOMETRY_BIT)
822 {
823 strings.push_back("VK_SHADER_STAGE_GEOMETRY_BIT");
824 }
825 if(enumerator & VK_SHADER_STAGE_COMPUTE_BIT)
826 {
827 strings.push_back("VK_SHADER_STAGE_COMPUTE_BIT");
828 }
829 if(enumerator & VK_SHADER_STAGE_TESS_EVALUATION_BIT)
830 {
831 strings.push_back("VK_SHADER_STAGE_TESS_EVALUATION_BIT");
832 }
833 if(enumerator & VK_SHADER_STAGE_TESS_CONTROL_BIT)
834 {
835 strings.push_back("VK_SHADER_STAGE_TESS_CONTROL_BIT");
836 }
837 if(enumerator & VK_SHADER_STAGE_VERTEX_BIT)
838 {
839 strings.push_back("VK_SHADER_STAGE_VERTEX_BIT");
840 }
841
842 std::string enumeratorString;
843 for(auto const& string : strings)
844 {
845 enumeratorString += string;
846
847 if(string != strings.back())
848 {
849 enumeratorString += '|';
850 }
851 }
852
853 return enumeratorString;
854}
855
856static
857bool ValidateEnumerator(VkImageUsageFlagBits const& enumerator)
858{
859 VkImageUsageFlagBits allFlags = (VkImageUsageFlagBits)(VK_IMAGE_USAGE_DEPTH_STENCIL_BIT |
860 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
861 VK_IMAGE_USAGE_STORAGE_BIT |
862 VK_IMAGE_USAGE_SAMPLED_BIT |
863 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT |
864 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
865 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
866 VK_IMAGE_USAGE_GENERAL);
867 if(enumerator & (~allFlags))
868 {
869 return false;
870 }
871
872 return true;
873}
874
875static
876std::string EnumeratorString(VkImageUsageFlagBits const& enumerator)
877{
878 if(!ValidateEnumerator(enumerator))
879 {
880 return "unrecognized enumerator";
881 }
882
883 std::vector<std::string> strings;
884 if(enumerator & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)
885 {
886 strings.push_back("VK_IMAGE_USAGE_DEPTH_STENCIL_BIT");
887 }
888 if(enumerator & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
889 {
890 strings.push_back("VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT");
891 }
892 if(enumerator & VK_IMAGE_USAGE_STORAGE_BIT)
893 {
894 strings.push_back("VK_IMAGE_USAGE_STORAGE_BIT");
895 }
896 if(enumerator & VK_IMAGE_USAGE_SAMPLED_BIT)
897 {
898 strings.push_back("VK_IMAGE_USAGE_SAMPLED_BIT");
899 }
900 if(enumerator & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT)
901 {
902 strings.push_back("VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
903 }
904 if(enumerator & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)
905 {
906 strings.push_back("VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
907 }
908 if(enumerator & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT)
909 {
910 strings.push_back("VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
911 }
912 if(enumerator & VK_IMAGE_USAGE_GENERAL)
913 {
914 strings.push_back("VK_IMAGE_USAGE_GENERAL");
915 }
916
917 std::string enumeratorString;
918 for(auto const& string : strings)
919 {
920 enumeratorString += string;
921
922 if(string != strings.back())
923 {
924 enumeratorString += '|';
925 }
926 }
927
928 return enumeratorString;
929}
930
931static
932bool ValidateEnumerator(VkImageCreateFlagBits const& enumerator)
933{
934 VkImageCreateFlagBits allFlags = (VkImageCreateFlagBits)(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT |
935 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
936 VK_IMAGE_CREATE_SPARSE_BIT |
937 VK_IMAGE_CREATE_INVARIANT_DATA_BIT);
938 if(enumerator & (~allFlags))
939 {
940 return false;
941 }
942
943 return true;
944}
945
946static
947std::string EnumeratorString(VkImageCreateFlagBits const& enumerator)
948{
949 if(!ValidateEnumerator(enumerator))
950 {
951 return "unrecognized enumerator";
952 }
953
954 std::vector<std::string> strings;
955 if(enumerator & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
956 {
957 strings.push_back("VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
958 }
959 if(enumerator & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)
960 {
961 strings.push_back("VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT");
962 }
963 if(enumerator & VK_IMAGE_CREATE_SPARSE_BIT)
964 {
965 strings.push_back("VK_IMAGE_CREATE_SPARSE_BIT");
966 }
967 if(enumerator & VK_IMAGE_CREATE_INVARIANT_DATA_BIT)
968 {
969 strings.push_back("VK_IMAGE_CREATE_INVARIANT_DATA_BIT");
970 }
971
972 std::string enumeratorString;
973 for(auto const& string : strings)
974 {
975 enumeratorString += string;
976
977 if(string != strings.back())
978 {
979 enumeratorString += '|';
980 }
981 }
982
983 return enumeratorString;
984}
985
986static
987bool ValidateEnumerator(VkDepthStencilViewCreateFlagBits const& enumerator)
988{
989 VkDepthStencilViewCreateFlagBits allFlags = (VkDepthStencilViewCreateFlagBits)(VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT |
990 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT);
991 if(enumerator & (~allFlags))
992 {
993 return false;
994 }
995
996 return true;
997}
998
999static
1000std::string EnumeratorString(VkDepthStencilViewCreateFlagBits const& enumerator)
1001{
1002 if(!ValidateEnumerator(enumerator))
1003 {
1004 return "unrecognized enumerator";
1005 }
1006
1007 std::vector<std::string> strings;
1008 if(enumerator & VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT)
1009 {
1010 strings.push_back("VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT");
1011 }
1012 if(enumerator & VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT)
1013 {
1014 strings.push_back("VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT");
1015 }
1016
1017 std::string enumeratorString;
1018 for(auto const& string : strings)
1019 {
1020 enumeratorString += string;
1021
1022 if(string != strings.back())
1023 {
1024 enumeratorString += '|';
1025 }
1026 }
1027
1028 return enumeratorString;
1029}
1030
1031static
1032bool ValidateEnumerator(VkPipelineCreateFlagBits const& enumerator)
1033{
1034 VkPipelineCreateFlagBits allFlags = (VkPipelineCreateFlagBits)(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT |
1035 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
1036 if(enumerator & (~allFlags))
1037 {
1038 return false;
1039 }
1040
1041 return true;
1042}
1043
1044static
1045std::string EnumeratorString(VkPipelineCreateFlagBits const& enumerator)
1046{
1047 if(!ValidateEnumerator(enumerator))
1048 {
1049 return "unrecognized enumerator";
1050 }
1051
1052 std::vector<std::string> strings;
1053 if(enumerator & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)
1054 {
1055 strings.push_back("VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT");
1056 }
1057 if(enumerator & VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT)
1058 {
1059 strings.push_back("VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT");
1060 }
1061
1062 std::string enumeratorString;
1063 for(auto const& string : strings)
1064 {
1065 enumeratorString += string;
1066
1067 if(string != strings.back())
1068 {
1069 enumeratorString += '|';
1070 }
1071 }
1072
1073 return enumeratorString;
1074}
1075
1076static
1077bool ValidateEnumerator(VkChannelFlagBits const& enumerator)
1078{
1079 VkChannelFlagBits allFlags = (VkChannelFlagBits)(VK_CHANNEL_A_BIT |
1080 VK_CHANNEL_B_BIT |
1081 VK_CHANNEL_G_BIT |
1082 VK_CHANNEL_R_BIT);
1083 if(enumerator & (~allFlags))
1084 {
1085 return false;
1086 }
1087
1088 return true;
1089}
1090
1091static
1092std::string EnumeratorString(VkChannelFlagBits const& enumerator)
1093{
1094 if(!ValidateEnumerator(enumerator))
1095 {
1096 return "unrecognized enumerator";
1097 }
1098
1099 std::vector<std::string> strings;
1100 if(enumerator & VK_CHANNEL_A_BIT)
1101 {
1102 strings.push_back("VK_CHANNEL_A_BIT");
1103 }
1104 if(enumerator & VK_CHANNEL_B_BIT)
1105 {
1106 strings.push_back("VK_CHANNEL_B_BIT");
1107 }
1108 if(enumerator & VK_CHANNEL_G_BIT)
1109 {
1110 strings.push_back("VK_CHANNEL_G_BIT");
1111 }
1112 if(enumerator & VK_CHANNEL_R_BIT)
1113 {
1114 strings.push_back("VK_CHANNEL_R_BIT");
1115 }
1116
1117 std::string enumeratorString;
1118 for(auto const& string : strings)
1119 {
1120 enumeratorString += string;
1121
1122 if(string != strings.back())
1123 {
1124 enumeratorString += '|';
1125 }
1126 }
1127
1128 return enumeratorString;
1129}
1130
1131static
1132bool ValidateEnumerator(VkFenceCreateFlagBits const& enumerator)
1133{
1134 VkFenceCreateFlagBits allFlags = (VkFenceCreateFlagBits)(VK_FENCE_CREATE_SIGNALED_BIT);
1135 if(enumerator & (~allFlags))
1136 {
1137 return false;
1138 }
1139
1140 return true;
1141}
1142
1143static
1144std::string EnumeratorString(VkFenceCreateFlagBits const& enumerator)
1145{
1146 if(!ValidateEnumerator(enumerator))
1147 {
1148 return "unrecognized enumerator";
1149 }
1150
1151 std::vector<std::string> strings;
1152 if(enumerator & VK_FENCE_CREATE_SIGNALED_BIT)
1153 {
1154 strings.push_back("VK_FENCE_CREATE_SIGNALED_BIT");
1155 }
1156
1157 std::string enumeratorString;
1158 for(auto const& string : strings)
1159 {
1160 enumeratorString += string;
1161
1162 if(string != strings.back())
1163 {
1164 enumeratorString += '|';
1165 }
1166 }
1167
1168 return enumeratorString;
1169}
1170
1171static
1172bool ValidateEnumerator(VkFormatFeatureFlagBits const& enumerator)
1173{
1174 VkFormatFeatureFlagBits allFlags = (VkFormatFeatureFlagBits)(VK_FORMAT_FEATURE_CONVERSION_BIT |
1175 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT |
1176 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT |
1177 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT |
1178 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT |
1179 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
1180 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT |
1181 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT |
1182 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT |
1183 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
1184 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
1185 if(enumerator & (~allFlags))
1186 {
1187 return false;
1188 }
1189
1190 return true;
1191}
1192
1193static
1194std::string EnumeratorString(VkFormatFeatureFlagBits const& enumerator)
1195{
1196 if(!ValidateEnumerator(enumerator))
1197 {
1198 return "unrecognized enumerator";
1199 }
1200
1201 std::vector<std::string> strings;
1202 if(enumerator & VK_FORMAT_FEATURE_CONVERSION_BIT)
1203 {
1204 strings.push_back("VK_FORMAT_FEATURE_CONVERSION_BIT");
1205 }
1206 if(enumerator & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT)
1207 {
1208 strings.push_back("VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT");
1209 }
1210 if(enumerator & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)
1211 {
1212 strings.push_back("VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT");
1213 }
1214 if(enumerator & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)
1215 {
1216 strings.push_back("VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT");
1217 }
1218 if(enumerator & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT)
1219 {
1220 strings.push_back("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
1221 }
1222 if(enumerator & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
1223 {
1224 strings.push_back("VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT");
1225 }
1226 if(enumerator & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT)
1227 {
1228 strings.push_back("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT");
1229 }
1230 if(enumerator & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)
1231 {
1232 strings.push_back("VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT");
1233 }
1234 if(enumerator & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)
1235 {
1236 strings.push_back("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT");
1237 }
1238 if(enumerator & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)
1239 {
1240 strings.push_back("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT");
1241 }
1242 if(enumerator & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
1243 {
1244 strings.push_back("VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
1245 }
1246
1247 std::string enumeratorString;
1248 for(auto const& string : strings)
1249 {
1250 enumeratorString += string;
1251
1252 if(string != strings.back())
1253 {
1254 enumeratorString += '|';
1255 }
1256 }
1257
1258 return enumeratorString;
1259}
1260
1261static
1262bool ValidateEnumerator(VkQueryControlFlagBits const& enumerator)
1263{
1264 VkQueryControlFlagBits allFlags = (VkQueryControlFlagBits)(VK_QUERY_CONTROL_CONSERVATIVE_BIT);
1265 if(enumerator & (~allFlags))
1266 {
1267 return false;
1268 }
1269
1270 return true;
1271}
1272
1273static
1274std::string EnumeratorString(VkQueryControlFlagBits const& enumerator)
1275{
1276 if(!ValidateEnumerator(enumerator))
1277 {
1278 return "unrecognized enumerator";
1279 }
1280
1281 std::vector<std::string> strings;
1282 if(enumerator & VK_QUERY_CONTROL_CONSERVATIVE_BIT)
1283 {
1284 strings.push_back("VK_QUERY_CONTROL_CONSERVATIVE_BIT");
1285 }
1286
1287 std::string enumeratorString;
1288 for(auto const& string : strings)
1289 {
1290 enumeratorString += string;
1291
1292 if(string != strings.back())
1293 {
1294 enumeratorString += '|';
1295 }
1296 }
1297
1298 return enumeratorString;
1299}
1300
1301static
1302bool ValidateEnumerator(VkQueryResultFlagBits const& enumerator)
1303{
1304 VkQueryResultFlagBits allFlags = (VkQueryResultFlagBits)(VK_QUERY_RESULT_PARTIAL_BIT |
1305 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT |
1306 VK_QUERY_RESULT_WAIT_BIT |
1307 VK_QUERY_RESULT_64_BIT |
1308 VK_QUERY_RESULT_DEFAULT);
1309 if(enumerator & (~allFlags))
1310 {
1311 return false;
1312 }
1313
1314 return true;
1315}
1316
1317static
1318std::string EnumeratorString(VkQueryResultFlagBits const& enumerator)
1319{
1320 if(!ValidateEnumerator(enumerator))
1321 {
1322 return "unrecognized enumerator";
1323 }
1324
1325 std::vector<std::string> strings;
1326 if(enumerator & VK_QUERY_RESULT_PARTIAL_BIT)
1327 {
1328 strings.push_back("VK_QUERY_RESULT_PARTIAL_BIT");
1329 }
1330 if(enumerator & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
1331 {
1332 strings.push_back("VK_QUERY_RESULT_WITH_AVAILABILITY_BIT");
1333 }
1334 if(enumerator & VK_QUERY_RESULT_WAIT_BIT)
1335 {
1336 strings.push_back("VK_QUERY_RESULT_WAIT_BIT");
1337 }
1338 if(enumerator & VK_QUERY_RESULT_64_BIT)
1339 {
1340 strings.push_back("VK_QUERY_RESULT_64_BIT");
1341 }
1342 if(enumerator & VK_QUERY_RESULT_DEFAULT)
1343 {
1344 strings.push_back("VK_QUERY_RESULT_DEFAULT");
1345 }
1346
1347 std::string enumeratorString;
1348 for(auto const& string : strings)
1349 {
1350 enumeratorString += string;
1351
1352 if(string != strings.back())
1353 {
1354 enumeratorString += '|';
1355 }
1356 }
1357
1358 return enumeratorString;
1359}
1360
1361static
1362bool ValidateEnumerator(VkCmdBufferOptimizeFlagBits const& enumerator)
1363{
1364 VkCmdBufferOptimizeFlagBits allFlags = (VkCmdBufferOptimizeFlagBits)(VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT |
1365 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT |
1366 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT |
1367 VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT);
1368 if(enumerator & (~allFlags))
1369 {
1370 return false;
1371 }
1372
1373 return true;
1374}
1375
1376static
1377std::string EnumeratorString(VkCmdBufferOptimizeFlagBits const& enumerator)
1378{
1379 if(!ValidateEnumerator(enumerator))
1380 {
1381 return "unrecognized enumerator";
1382 }
1383
1384 std::vector<std::string> strings;
1385 if(enumerator & VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT)
1386 {
1387 strings.push_back("VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT");
1388 }
1389 if(enumerator & VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT)
1390 {
1391 strings.push_back("VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT");
1392 }
1393 if(enumerator & VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT)
1394 {
1395 strings.push_back("VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT");
1396 }
1397 if(enumerator & VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT)
1398 {
1399 strings.push_back("VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT");
1400 }
1401
1402 std::string enumeratorString;
1403 for(auto const& string : strings)
1404 {
1405 enumeratorString += string;
1406
1407 if(string != strings.back())
1408 {
1409 enumeratorString += '|';
1410 }
1411 }
1412
1413 return enumeratorString;
1414}
1415
1416static
1417bool ValidateEnumerator(VkQueryPipelineStatisticFlagBits const& enumerator)
1418{
1419 VkQueryPipelineStatisticFlagBits allFlags = (VkQueryPipelineStatisticFlagBits)(VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT |
1420 VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT |
1421 VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT |
1422 VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT |
1423 VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT |
1424 VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT |
1425 VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT |
1426 VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT |
1427 VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT |
1428 VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT |
1429 VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT);
1430 if(enumerator & (~allFlags))
1431 {
1432 return false;
1433 }
1434
1435 return true;
1436}
1437
1438static
1439std::string EnumeratorString(VkQueryPipelineStatisticFlagBits const& enumerator)
1440{
1441 if(!ValidateEnumerator(enumerator))
1442 {
1443 return "unrecognized enumerator";
1444 }
1445
1446 std::vector<std::string> strings;
1447 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT)
1448 {
1449 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT");
1450 }
1451 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT)
1452 {
1453 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT");
1454 }
1455 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT)
1456 {
1457 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT");
1458 }
1459 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT)
1460 {
1461 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT");
1462 }
1463 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT)
1464 {
1465 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT");
1466 }
1467 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT)
1468 {
1469 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT");
1470 }
1471 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT)
1472 {
1473 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT");
1474 }
1475 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT)
1476 {
1477 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT");
1478 }
1479 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT)
1480 {
1481 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT");
1482 }
1483 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT)
1484 {
1485 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT");
1486 }
1487 if(enumerator & VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT)
1488 {
1489 strings.push_back("VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT");
1490 }
1491
1492 std::string enumeratorString;
1493 for(auto const& string : strings)
1494 {
1495 enumeratorString += string;
1496
1497 if(string != strings.back())
1498 {
1499 enumeratorString += '|';
1500 }
1501 }
1502
1503 return enumeratorString;
1504}
1505
1506VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(
1507 const VkInstanceCreateInfo* pCreateInfo,
1508 VkInstance* pInstance)
1509{
1510 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, *pInstance);
1511 VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
1512
1513 if (result == VK_SUCCESS) {
1514 layer_data *data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
1515 data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->extensionCount,
1516 pCreateInfo->pEnabledExtensions);
1517
1518 InitParamChecker(data);
1519 }
1520
1521 return result;
1522}
1523
1524VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(
1525 VkInstance instance)
1526{
1527 // Grab the key before the instance is destroyed.
1528 dispatch_key key = get_dispatch_key(instance);
1529 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
1530 VkResult result = pTable->DestroyInstance(instance);
1531
1532 // Clean up logging callback, if any
1533 layer_data *data = get_my_data_ptr(key, layer_data_map);
1534 if(data->logging_callback)
1535 {
1536 layer_destroy_msg_callback(data->report_data, data->logging_callback);
1537 }
1538
1539 layer_debug_report_destroy_instance(mid(instance));
1540 layer_data_map.erase(pTable);
1541
1542 pc_instance_table_map.erase(key);
1543 assert(pc_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
1544
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1545 return result;
1546}
1547
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1548void PreEnumeratePhysicalDevices(
1549 VkInstance instance,
1550 VkPhysicalDevice* pPhysicalDevices)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1551{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1552 if(instance == nullptr)
1553 {
1554 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1555 "vkEnumeratePhysicalDevices parameter, VkInstance instance, is null pointer");
1556 return;
1557 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1558
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1559 if(pPhysicalDevices == nullptr)
1560 {
1561 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1562 "vkEnumeratePhysicalDevices parameter, VkPhysicalDevice* pPhysicalDevices, is null pointer");
1563 return;
1564 }
1565 if((*pPhysicalDevices) == nullptr)
1566 {
1567 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1568 "vkEnumeratePhysicalDevices parameter, VkPhysicalDevice* pPhysicalDevices, is null pointer");
1569 return;
1570 }
1571}
1572
1573void PostEnumeratePhysicalDevices(
1574 VkInstance instance,
1575 uint32_t* pPhysicalDeviceCount,
1576 VkPhysicalDevice* pPhysicalDevices,
1577 VkResult result)
1578{
1579 if(instance == nullptr)
1580 {
1581 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1582 "vkEnumeratePhysicalDevices parameter, VkInstance instance, is null pointer");
1583 return;
1584 }
1585
1586 if(pPhysicalDeviceCount == nullptr)
1587 {
1588 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1589 "vkEnumeratePhysicalDevices parameter, uint32_t* pPhysicalDeviceCount, is null pointer");
1590 return;
1591 }
1592
1593 if(pPhysicalDevices == nullptr)
1594 {
1595 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1596 "vkEnumeratePhysicalDevices parameter, VkPhysicalDevice* pPhysicalDevices, is null pointer");
1597 return;
1598 }
1599 if((*pPhysicalDevices) == nullptr)
1600 {
1601 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1602 "vkEnumeratePhysicalDevices parameter, VkPhysicalDevice* pPhysicalDevices, is null pointer");
1603 return;
1604 }
1605
1606 if(result != VK_SUCCESS)
1607 {
1608 std::string reason = "vkEnumeratePhysicalDevices parameter, VkResult result, is " + EnumeratorString(result);
1609 log_msg(mid(instance), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1610 return;
1611 }
1612}
1613
1614VK_LAYER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
1615 VkInstance instance,
1616 uint32_t* pPhysicalDeviceCount,
1617 VkPhysicalDevice* pPhysicalDevices)
1618{
1619 PreEnumeratePhysicalDevices(instance, pPhysicalDevices);
1620 VkResult result = get_dispatch_table(pc_instance_table_map, instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
1621
1622 PostEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices, result);
1623
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1624 return result;
1625}
1626
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1627void PreGetPhysicalDeviceFeatures(
1628 VkPhysicalDevice physicalDevice)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1629{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1630 if(physicalDevice == nullptr)
1631 {
1632 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1633 "vkGetPhysicalDeviceFeatures parameter, VkPhysicalDevice physicalDevice, is null pointer");
1634 return;
1635 }
1636}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1637
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1638void PostGetPhysicalDeviceFeatures(
1639 VkPhysicalDevice physicalDevice,
1640 VkPhysicalDeviceFeatures* pFeatures,
1641 VkResult result)
1642{
1643 if(physicalDevice == nullptr)
1644 {
1645 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1646 "vkGetPhysicalDeviceFeatures parameter, VkPhysicalDevice physicalDevice, is null pointer");
1647 return;
1648 }
1649
1650 if(pFeatures == nullptr)
1651 {
1652 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1653 "vkGetPhysicalDeviceFeatures parameter, VkPhysicalDeviceFeatures* pFeatures, is null pointer");
1654 return;
1655 }
1656
1657 if(result != VK_SUCCESS)
1658 {
1659 std::string reason = "vkGetPhysicalDeviceFeatures parameter, VkResult result, is " + EnumeratorString(result);
1660 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1661 return;
1662 }
1663}
1664
1665VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
1666 VkPhysicalDevice physicalDevice,
1667 VkPhysicalDeviceFeatures* pFeatures)
1668{
1669 PreGetPhysicalDeviceFeatures(physicalDevice);
1670 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
1671
1672 PostGetPhysicalDeviceFeatures(physicalDevice, pFeatures, result);
1673
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1674 return result;
1675}
1676
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1677void PreGetPhysicalDeviceFormatInfo(
1678 VkPhysicalDevice physicalDevice)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1679{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1680 if(physicalDevice == nullptr)
1681 {
1682 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1683 "vkGetPhysicalDeviceFormatInfo parameter, VkPhysicalDevice physicalDevice, is null pointer");
1684 return;
1685 }
1686}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1687
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1688void PostGetPhysicalDeviceFormatInfo(
1689 VkPhysicalDevice physicalDevice,
1690 VkFormat format,
1691 VkFormatProperties* pFormatInfo,
1692 VkResult result)
1693{
1694 if(physicalDevice == nullptr)
1695 {
1696 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1697 "vkGetPhysicalDeviceFormatInfo parameter, VkPhysicalDevice physicalDevice, is null pointer");
1698 return;
1699 }
1700
1701 if(format < VK_FORMAT_BEGIN_RANGE ||
1702 format > VK_FORMAT_END_RANGE)
1703 {
1704 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1705 "vkGetPhysicalDeviceFormatInfo parameter, VkFormat format, is unrecognized enumerator");
1706 return;
1707 }
1708
1709 if(pFormatInfo == nullptr)
1710 {
1711 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1712 "vkGetPhysicalDeviceFormatInfo parameter, VkFormatProperties* pFormatInfo, is null pointer");
1713 return;
1714 }
1715 if(!ValidateEnumerator((VkFormatFeatureFlagBits)pFormatInfo->linearTilingFeatures))
1716 {
1717 std::string reason = "vkGetPhysicalDeviceFormatInfo parameter, VkFormatFeatureFlags pFormatInfo->linearTilingFeatures, is " + EnumeratorString((VkFormatFeatureFlagBits)pFormatInfo->linearTilingFeatures);
1718 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1719 return;
1720 }
1721 if(!ValidateEnumerator((VkFormatFeatureFlagBits)pFormatInfo->optimalTilingFeatures))
1722 {
1723 std::string reason = "vkGetPhysicalDeviceFormatInfo parameter, VkFormatFeatureFlags pFormatInfo->optimalTilingFeatures, is " + EnumeratorString((VkFormatFeatureFlagBits)pFormatInfo->optimalTilingFeatures);
1724 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1725 return;
1726 }
1727
1728 if(result != VK_SUCCESS)
1729 {
1730 std::string reason = "vkGetPhysicalDeviceFormatInfo parameter, VkResult result, is " + EnumeratorString(result);
1731 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1732 return;
1733 }
1734}
1735
1736VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatInfo(
1737 VkPhysicalDevice physicalDevice,
1738 VkFormat format,
1739 VkFormatProperties* pFormatInfo)
1740{
1741 PreGetPhysicalDeviceFormatInfo(physicalDevice);
1742 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatInfo(physicalDevice, format, pFormatInfo);
1743
1744 PostGetPhysicalDeviceFormatInfo(physicalDevice, format, pFormatInfo, result);
1745
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1746 return result;
1747}
1748
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1749void PreGetPhysicalDeviceLimits(
1750 VkPhysicalDevice physicalDevice)
1751{
1752 if(physicalDevice == nullptr)
1753 {
1754 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1755 "vkGetPhysicalDeviceLimits parameter, VkPhysicalDevice physicalDevice, is null pointer");
1756 return;
1757 }
1758}
1759
1760void PostGetPhysicalDeviceLimits(
1761 VkPhysicalDevice physicalDevice,
1762 VkPhysicalDeviceLimits* pLimits,
1763 VkResult result)
1764{
1765 if(physicalDevice == nullptr)
1766 {
1767 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1768 "vkGetPhysicalDeviceLimits parameter, VkPhysicalDevice physicalDevice, is null pointer");
1769 return;
1770 }
1771
1772 if(pLimits == nullptr)
1773 {
1774 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1775 "vkGetPhysicalDeviceLimits parameter, VkPhysicalDeviceLimits* pLimits, is null pointer");
1776 return;
1777 }
1778
1779 if(result != VK_SUCCESS)
1780 {
1781 std::string reason = "vkGetPhysicalDeviceLimits parameter, VkResult result, is " + EnumeratorString(result);
1782 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1783 return;
1784 }
1785}
1786
1787VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLimits(
1788 VkPhysicalDevice physicalDevice,
1789 VkPhysicalDeviceLimits* pLimits)
1790{
1791 PreGetPhysicalDeviceLimits(physicalDevice);
1792 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceLimits(physicalDevice, pLimits);
1793
1794 PostGetPhysicalDeviceLimits(physicalDevice, pLimits, result);
1795
1796 return result;
1797}
1798
1799VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
1800 VkPhysicalDevice physicalDevice,
1801 const VkDeviceCreateInfo* pCreateInfo,
1802 VkDevice* pDevice)
1803{
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600[diff] [blame]1804 VkLayerDispatchTable *pTable = get_dispatch_table(pc_device_table_map, *pDevice);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]1805 VkResult result = pTable->CreateDevice(physicalDevice, pCreateInfo, pDevice);
1806 if(result == VK_SUCCESS)
1807 {
1808 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
1809 layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
1810 device_data->report_data = layer_debug_report_create_device(instance_data->report_data, *pDevice);
1811 }
1812
1813 return result;
1814}
1815
1816VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(
1817 VkDevice device)
1818{
1819 layer_debug_report_destroy_device(device);
1820
1821 dispatch_key key = get_dispatch_key(device);
1822#if DISPATCH_MAP_DEBUG
1823 fprintf(stderr, "Device: %p, key: %p\n", device, key);
1824#endif
1825
1826 VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device);
1827 pc_device_table_map.erase(key);
1828 assert(pc_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
1829
1830 return result;
1831}
1832
1833void PreGetPhysicalDeviceProperties(
1834 VkPhysicalDevice physicalDevice)
1835{
1836 if(physicalDevice == nullptr)
1837 {
1838 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1839 "vkGetPhysicalDeviceProperties parameter, VkPhysicalDevice physicalDevice, is null pointer");
1840 return;
1841 }
1842}
1843
1844void PostGetPhysicalDeviceProperties(
1845 VkPhysicalDevice physicalDevice,
1846 VkPhysicalDeviceProperties* pProperties,
1847 VkResult result)
1848{
1849 if(physicalDevice == nullptr)
1850 {
1851 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1852 "vkGetPhysicalDeviceProperties parameter, VkPhysicalDevice physicalDevice, is null pointer");
1853 return;
1854 }
1855
1856 if(pProperties == nullptr)
1857 {
1858 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1859 "vkGetPhysicalDeviceProperties parameter, VkPhysicalDeviceProperties* pProperties, is null pointer");
1860 return;
1861 }
1862 if(pProperties->deviceType < VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE ||
1863 pProperties->deviceType > VK_PHYSICAL_DEVICE_TYPE_END_RANGE)
1864 {
1865 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1866 "vkGetPhysicalDeviceProperties parameter, VkPhysicalDeviceType pProperties->deviceType, is unrecognized enumerator");
1867 return;
1868 }
1869
1870 if(result != VK_SUCCESS)
1871 {
1872 std::string reason = "vkGetPhysicalDeviceProperties parameter, VkResult result, is " + EnumeratorString(result);
1873 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1874 return;
1875 }
1876}
1877
1878VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
1879 VkPhysicalDevice physicalDevice,
1880 VkPhysicalDeviceProperties* pProperties)
1881{
1882 PreGetPhysicalDeviceProperties(physicalDevice);
1883 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
1884
1885 PostGetPhysicalDeviceProperties(physicalDevice, pProperties, result);
1886
1887 return result;
1888}
1889
1890void PreGetPhysicalDevicePerformance(
1891 VkPhysicalDevice physicalDevice)
1892{
1893 if(physicalDevice == nullptr)
1894 {
1895 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1896 "vkGetPhysicalDevicePerformance parameter, VkPhysicalDevice physicalDevice, is null pointer");
1897 return;
1898 }
1899}
1900
1901void PostGetPhysicalDevicePerformance(
1902 VkPhysicalDevice physicalDevice,
1903 VkPhysicalDevicePerformance* pPerformance,
1904 VkResult result)
1905{
1906 if(physicalDevice == nullptr)
1907 {
1908 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1909 "vkGetPhysicalDevicePerformance parameter, VkPhysicalDevice physicalDevice, is null pointer");
1910 return;
1911 }
1912
1913 if(pPerformance == nullptr)
1914 {
1915 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1916 "vkGetPhysicalDevicePerformance parameter, VkPhysicalDevicePerformance* pPerformance, is null pointer");
1917 return;
1918 }
1919
1920 if(result != VK_SUCCESS)
1921 {
1922 std::string reason = "vkGetPhysicalDevicePerformance parameter, VkResult result, is " + EnumeratorString(result);
1923 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1924 return;
1925 }
1926}
1927
1928VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDevicePerformance(
1929 VkPhysicalDevice physicalDevice,
1930 VkPhysicalDevicePerformance* pPerformance)
1931{
1932 PreGetPhysicalDevicePerformance(physicalDevice);
1933 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDevicePerformance(physicalDevice, pPerformance);
1934
1935 PostGetPhysicalDevicePerformance(physicalDevice, pPerformance, result);
1936
1937 return result;
1938}
1939
1940void PreGetPhysicalDeviceQueueCount(
1941 VkPhysicalDevice physicalDevice)
1942{
1943 if(physicalDevice == nullptr)
1944 {
1945 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1946 "vkGetPhysicalDeviceQueueCount parameter, VkPhysicalDevice physicalDevice, is null pointer");
1947 return;
1948 }
1949}
1950
1951void PostGetPhysicalDeviceQueueCount(
1952 VkPhysicalDevice physicalDevice,
1953 uint32_t* pCount,
1954 VkResult result)
1955{
1956 if(physicalDevice == nullptr)
1957 {
1958 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1959 "vkGetPhysicalDeviceQueueCount parameter, VkPhysicalDevice physicalDevice, is null pointer");
1960 return;
1961 }
1962
1963 if(pCount == nullptr)
1964 {
1965 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1966 "vkGetPhysicalDeviceQueueCount parameter, uint32_t* pCount, is null pointer");
1967 return;
1968 }
1969
1970 if(result != VK_SUCCESS)
1971 {
1972 std::string reason = "vkGetPhysicalDeviceQueueCount parameter, VkResult result, is " + EnumeratorString(result);
1973 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
1974 return;
1975 }
1976}
1977
1978VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueCount(
1979 VkPhysicalDevice physicalDevice,
1980 uint32_t* pCount)
1981{
1982 PreGetPhysicalDeviceQueueCount(physicalDevice);
1983 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueCount(physicalDevice, pCount);
1984
1985 PostGetPhysicalDeviceQueueCount(physicalDevice, pCount, result);
1986
1987 return result;
1988}
1989
1990void PreGetPhysicalDeviceQueueProperties(
1991 VkPhysicalDevice physicalDevice)
1992{
1993 if(physicalDevice == nullptr)
1994 {
1995 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
1996 "vkGetPhysicalDeviceQueueProperties parameter, VkPhysicalDevice physicalDevice, is null pointer");
1997 return;
1998 }
1999}
2000
2001void PostGetPhysicalDeviceQueueProperties(
2002 VkPhysicalDevice physicalDevice,
2003 uint32_t count,
2004 VkPhysicalDeviceQueueProperties* pQueueProperties,
2005 VkResult result)
2006{
2007 if(physicalDevice == nullptr)
2008 {
2009 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2010 "vkGetPhysicalDeviceQueueProperties parameter, VkPhysicalDevice physicalDevice, is null pointer");
2011 return;
2012 }
2013
2014
2015 if(pQueueProperties == nullptr)
2016 {
2017 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2018 "vkGetPhysicalDeviceQueueProperties parameter, VkPhysicalDeviceQueueProperties* pQueueProperties, is null pointer");
2019 return;
2020 }
2021 if(!ValidateEnumerator((VkQueueFlagBits)pQueueProperties->queueFlags))
2022 {
2023 std::string reason = "vkGetPhysicalDeviceQueueProperties parameter, VkQueueFlags pQueueProperties->queueFlags, is " + EnumeratorString((VkQueueFlagBits)pQueueProperties->queueFlags);
2024 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2025 return;
2026 }
2027
2028 if(result != VK_SUCCESS)
2029 {
2030 std::string reason = "vkGetPhysicalDeviceQueueProperties parameter, VkResult result, is " + EnumeratorString(result);
2031 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2032 return;
2033 }
2034}
2035
2036VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueProperties(
2037 VkPhysicalDevice physicalDevice,
2038 uint32_t count,
2039 VkPhysicalDeviceQueueProperties* pQueueProperties)
2040{
2041 PreGetPhysicalDeviceQueueProperties(physicalDevice);
2042 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties);
2043
2044 PostGetPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties, result);
2045
2046 return result;
2047}
2048
2049void PreGetPhysicalDeviceMemoryProperties(
2050 VkPhysicalDevice physicalDevice)
2051{
2052 if(physicalDevice == nullptr)
2053 {
2054 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2055 "vkGetPhysicalDeviceMemoryProperties parameter, VkPhysicalDevice physicalDevice, is null pointer");
2056 return;
2057 }
2058}
2059
2060void PostGetPhysicalDeviceMemoryProperties(
2061 VkPhysicalDevice physicalDevice,
2062 VkPhysicalDeviceMemoryProperties* pMemoryProperies,
2063 VkResult result)
2064{
2065 if(physicalDevice == nullptr)
2066 {
2067 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2068 "vkGetPhysicalDeviceMemoryProperties parameter, VkPhysicalDevice physicalDevice, is null pointer");
2069 return;
2070 }
2071
2072 if(pMemoryProperies == nullptr)
2073 {
2074 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2075 "vkGetPhysicalDeviceMemoryProperties parameter, VkPhysicalDeviceMemoryProperties* pMemoryProperies, is null pointer");
2076 return;
2077 }
2078
2079 if(result != VK_SUCCESS)
2080 {
2081 std::string reason = "vkGetPhysicalDeviceMemoryProperties parameter, VkResult result, is " + EnumeratorString(result);
2082 log_msg(mdd(physicalDevice), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2083 return;
2084 }
2085}
2086
2087VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
2088 VkPhysicalDevice physicalDevice,
2089 VkPhysicalDeviceMemoryProperties* pMemoryProperies)
2090{
2091 PreGetPhysicalDeviceMemoryProperties(physicalDevice);
2092 VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperies);
2093
2094 PostGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperies, result);
2095
2096 return result;
2097}
2098
2099void PreGetDeviceQueue(
2100 VkDevice device,
2101 VkQueue* pQueue)
2102{
2103 if(device == nullptr)
2104 {
2105 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2106 "vkGetDeviceQueue parameter, VkDevice device, is null pointer");
2107 return;
2108 }
2109
2110 if(pQueue == nullptr)
2111 {
2112 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2113 "vkGetDeviceQueue parameter, VkQueue* pQueue, is null pointer");
2114 return;
2115 }
2116 if((*pQueue) == nullptr)
2117 {
2118 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2119 "vkGetDeviceQueue parameter, VkQueue* pQueue, is null pointer");
2120 return;
2121 }
2122}
2123
2124void PostGetDeviceQueue(
2125 VkDevice device,
2126 uint32_t queueNodeIndex,
2127 uint32_t queueIndex,
2128 VkQueue* pQueue,
2129 VkResult result)
2130{
2131 if(device == nullptr)
2132 {
2133 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2134 "vkGetDeviceQueue parameter, VkDevice device, is null pointer");
2135 return;
2136 }
2137
2138
2139
2140 if(pQueue == nullptr)
2141 {
2142 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2143 "vkGetDeviceQueue parameter, VkQueue* pQueue, is null pointer");
2144 return;
2145 }
2146 if((*pQueue) == nullptr)
2147 {
2148 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2149 "vkGetDeviceQueue parameter, VkQueue* pQueue, is null pointer");
2150 return;
2151 }
2152
2153 if(result != VK_SUCCESS)
2154 {
2155 std::string reason = "vkGetDeviceQueue parameter, VkResult result, is " + EnumeratorString(result);
2156 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2157 return;
2158 }
2159}
2160
2161VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(
2162 VkDevice device,
2163 uint32_t queueNodeIndex,
2164 uint32_t queueIndex,
2165 VkQueue* pQueue)
2166{
2167 PreGetDeviceQueue(device, pQueue);
2168 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
2169
2170 PostGetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue, result);
2171
2172 return result;
2173}
2174
2175void PreQueueSubmit(
2176 VkQueue queue,
2177 const VkCmdBuffer* pCmdBuffers)
2178{
2179 if(queue == nullptr)
2180 {
2181 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2182 "vkQueueSubmit parameter, VkQueue queue, is null pointer");
2183 return;
2184 }
2185
2186 if(pCmdBuffers == nullptr)
2187 {
2188 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2189 "vkQueueSubmit parameter, const VkCmdBuffer* pCmdBuffers, is null pointer");
2190 return;
2191 }
2192 if((*pCmdBuffers) == nullptr)
2193 {
2194 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2195 "vkQueueSubmit parameter, const VkCmdBuffer* pCmdBuffers, is null pointer");
2196 return;
2197 }
2198}
2199
2200void PostQueueSubmit(
2201 VkQueue queue,
2202 uint32_t cmdBufferCount,
2203 VkFence fence,
2204 VkResult result)
2205{
2206 if(queue == nullptr)
2207 {
2208 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2209 "vkQueueSubmit parameter, VkQueue queue, is null pointer");
2210 return;
2211 }
2212
2213
2214 if(fence == nullptr)
2215 {
2216 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2217 "vkQueueSubmit parameter, VkFence fence, is null pointer");
2218 return;
2219 }
2220
2221 if(result != VK_SUCCESS)
2222 {
2223 std::string reason = "vkQueueSubmit parameter, VkResult result, is " + EnumeratorString(result);
2224 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2225 return;
2226 }
2227}
2228
2229VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
2230 VkQueue queue,
2231 uint32_t cmdBufferCount,
2232 const VkCmdBuffer* pCmdBuffers,
2233 VkFence fence)
2234{
2235 PreQueueSubmit(queue, pCmdBuffers);
2236 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
2237
2238 PostQueueSubmit(queue, cmdBufferCount, fence, result);
2239
2240 return result;
2241}
2242
2243void PreQueueWaitIdle(
2244 VkQueue queue)
2245{
2246 if(queue == nullptr)
2247 {
2248 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2249 "vkQueueWaitIdle parameter, VkQueue queue, is null pointer");
2250 return;
2251 }
2252}
2253
2254void PostQueueWaitIdle(
2255 VkQueue queue,
2256 VkResult result)
2257{
2258 if(queue == nullptr)
2259 {
2260 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2261 "vkQueueWaitIdle parameter, VkQueue queue, is null pointer");
2262 return;
2263 }
2264
2265 if(result != VK_SUCCESS)
2266 {
2267 std::string reason = "vkQueueWaitIdle parameter, VkResult result, is " + EnumeratorString(result);
2268 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2269 return;
2270 }
2271}
2272
2273VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(
2274 VkQueue queue)
2275{
2276 PreQueueWaitIdle(queue);
2277 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueWaitIdle(queue);
2278
2279 PostQueueWaitIdle(queue, result);
2280
2281 return result;
2282}
2283
2284void PreDeviceWaitIdle(
2285 VkDevice device)
2286{
2287 if(device == nullptr)
2288 {
2289 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2290 "vkDeviceWaitIdle parameter, VkDevice device, is null pointer");
2291 return;
2292 }
2293}
2294
2295void PostDeviceWaitIdle(
2296 VkDevice device,
2297 VkResult result)
2298{
2299 if(device == nullptr)
2300 {
2301 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2302 "vkDeviceWaitIdle parameter, VkDevice device, is null pointer");
2303 return;
2304 }
2305
2306 if(result != VK_SUCCESS)
2307 {
2308 std::string reason = "vkDeviceWaitIdle parameter, VkResult result, is " + EnumeratorString(result);
2309 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2310 return;
2311 }
2312}
2313
2314VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(
2315 VkDevice device)
2316{
2317 PreDeviceWaitIdle(device);
2318 VkResult result = get_dispatch_table(pc_device_table_map, device)->DeviceWaitIdle(device);
2319
2320 PostDeviceWaitIdle(device, result);
2321
2322 return result;
2323}
2324
2325void PreAllocMemory(
2326 VkDevice device,
2327 const VkMemoryAllocInfo* pAllocInfo)
2328{
2329 if(device == nullptr)
2330 {
2331 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2332 "vkAllocMemory parameter, VkDevice device, is null pointer");
2333 return;
2334 }
2335
2336 if(pAllocInfo == nullptr)
2337 {
2338 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2339 "vkAllocMemory parameter, const VkMemoryAllocInfo* pAllocInfo, is null pointer");
2340 return;
2341 }
2342 if(pAllocInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
2343 pAllocInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
2344 {
2345 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2346 "vkAllocMemory parameter, VkStructureType pAllocInfo->sType, is unrecognized enumerator");
2347 return;
2348 }
2349 if(!ValidateEnumerator((VkMemoryPropertyFlagBits)pAllocInfo->memProps))
2350 {
2351 std::string reason = "vkAllocMemory parameter, VkMemoryPropertyFlags pAllocInfo->memProps, is " + EnumeratorString((VkMemoryPropertyFlagBits)pAllocInfo->memProps);
2352 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2353 return;
2354 }
2355}
2356
2357void PostAllocMemory(
2358 VkDevice device,
2359 VkDeviceMemory* pMem,
2360 VkResult result)
2361{
2362 if(device == nullptr)
2363 {
2364 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2365 "vkAllocMemory parameter, VkDevice device, is null pointer");
2366 return;
2367 }
2368
2369 if(pMem == nullptr)
2370 {
2371 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2372 "vkAllocMemory parameter, VkDeviceMemory* pMem, is null pointer");
2373 return;
2374 }
2375 if((*pMem) == nullptr)
2376 {
2377 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2378 "vkAllocMemory parameter, VkDeviceMemory* pMem, is null pointer");
2379 return;
2380 }
2381
2382 if(result != VK_SUCCESS)
2383 {
2384 std::string reason = "vkAllocMemory parameter, VkResult result, is " + EnumeratorString(result);
2385 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2386 return;
2387 }
2388}
2389
2390VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
2391 VkDevice device,
2392 const VkMemoryAllocInfo* pAllocInfo,
2393 VkDeviceMemory* pMem)
2394{
2395 PreAllocMemory(device, pAllocInfo);
2396 VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pMem);
2397
2398 PostAllocMemory(device, pMem, result);
2399
2400 return result;
2401}
2402
2403void PreFreeMemory(
2404 VkDevice device)
2405{
2406 if(device == nullptr)
2407 {
2408 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2409 "vkFreeMemory parameter, VkDevice device, is null pointer");
2410 return;
2411 }
2412}
2413
2414void PostFreeMemory(
2415 VkDevice device,
2416 VkDeviceMemory mem,
2417 VkResult result)
2418{
2419 if(device == nullptr)
2420 {
2421 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2422 "vkFreeMemory parameter, VkDevice device, is null pointer");
2423 return;
2424 }
2425
2426 if(mem == nullptr)
2427 {
2428 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2429 "vkFreeMemory parameter, VkDeviceMemory mem, is null pointer");
2430 return;
2431 }
2432
2433 if(result != VK_SUCCESS)
2434 {
2435 std::string reason = "vkFreeMemory parameter, VkResult result, is " + EnumeratorString(result);
2436 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2437 return;
2438 }
2439}
2440
2441VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(
2442 VkDevice device,
2443 VkDeviceMemory mem)
2444{
2445 PreFreeMemory(device);
2446 VkResult result = get_dispatch_table(pc_device_table_map, device)->FreeMemory(device, mem);
2447
2448 PostFreeMemory(device, mem, result);
2449
2450 return result;
2451}
2452
2453void PreMapMemory(
2454 VkDevice device)
2455{
2456 if(device == nullptr)
2457 {
2458 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2459 "vkMapMemory parameter, VkDevice device, is null pointer");
2460 return;
2461 }
2462}
2463
2464void PostMapMemory(
2465 VkDevice device,
2466 VkDeviceMemory mem,
2467 VkDeviceSize offset,
2468 VkDeviceSize size,
2469 VkMemoryMapFlags flags,
2470 void** ppData,
2471 VkResult result)
2472{
2473 if(device == nullptr)
2474 {
2475 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2476 "vkMapMemory parameter, VkDevice device, is null pointer");
2477 return;
2478 }
2479
2480 if(mem == nullptr)
2481 {
2482 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2483 "vkMapMemory parameter, VkDeviceMemory mem, is null pointer");
2484 return;
2485 }
2486
2487
2488
2489
2490 if(ppData == nullptr)
2491 {
2492 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2493 "vkMapMemory parameter, void** ppData, is null pointer");
2494 return;
2495 }
2496
2497 if(result != VK_SUCCESS)
2498 {
2499 std::string reason = "vkMapMemory parameter, VkResult result, is " + EnumeratorString(result);
2500 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2501 return;
2502 }
2503}
2504
2505VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
2506 VkDevice device,
2507 VkDeviceMemory mem,
2508 VkDeviceSize offset,
2509 VkDeviceSize size,
2510 VkMemoryMapFlags flags,
2511 void** ppData)
2512{
2513 PreMapMemory(device);
2514 VkResult result = get_dispatch_table(pc_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData);
2515
2516 PostMapMemory(device, mem, offset, size, flags, ppData, result);
2517
2518 return result;
2519}
2520
2521void PreUnmapMemory(
2522 VkDevice device)
2523{
2524 if(device == nullptr)
2525 {
2526 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2527 "vkUnmapMemory parameter, VkDevice device, is null pointer");
2528 return;
2529 }
2530}
2531
2532void PostUnmapMemory(
2533 VkDevice device,
2534 VkDeviceMemory mem,
2535 VkResult result)
2536{
2537 if(device == nullptr)
2538 {
2539 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2540 "vkUnmapMemory parameter, VkDevice device, is null pointer");
2541 return;
2542 }
2543
2544 if(mem == nullptr)
2545 {
2546 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2547 "vkUnmapMemory parameter, VkDeviceMemory mem, is null pointer");
2548 return;
2549 }
2550
2551 if(result != VK_SUCCESS)
2552 {
2553 std::string reason = "vkUnmapMemory parameter, VkResult result, is " + EnumeratorString(result);
2554 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2555 return;
2556 }
2557}
2558
2559VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(
2560 VkDevice device,
2561 VkDeviceMemory mem)
2562{
2563 PreUnmapMemory(device);
2564 VkResult result = get_dispatch_table(pc_device_table_map, device)->UnmapMemory(device, mem);
2565
2566 PostUnmapMemory(device, mem, result);
2567
2568 return result;
2569}
2570
2571void PreFlushMappedMemoryRanges(
2572 VkDevice device,
2573 const VkMappedMemoryRange* pMemRanges)
2574{
2575 if(device == nullptr)
2576 {
2577 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2578 "vkFlushMappedMemoryRanges parameter, VkDevice device, is null pointer");
2579 return;
2580 }
2581
2582 if(pMemRanges == nullptr)
2583 {
2584 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2585 "vkFlushMappedMemoryRanges parameter, const VkMappedMemoryRange* pMemRanges, is null pointer");
2586 return;
2587 }
2588 if(pMemRanges->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
2589 pMemRanges->sType > VK_STRUCTURE_TYPE_END_RANGE)
2590 {
2591 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2592 "vkFlushMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is unrecognized enumerator");
2593 return;
2594 }
2595 if(pMemRanges->mem == nullptr)
2596 {
2597 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2598 "vkFlushMappedMemoryRanges parameter, VkDeviceMemory pMemRanges->mem, is null pointer");
2599 return;
2600 }
2601}
2602
2603void PostFlushMappedMemoryRanges(
2604 VkDevice device,
2605 uint32_t memRangeCount,
2606 VkResult result)
2607{
2608 if(device == nullptr)
2609 {
2610 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2611 "vkFlushMappedMemoryRanges parameter, VkDevice device, is null pointer");
2612 return;
2613 }
2614
2615
2616 if(result != VK_SUCCESS)
2617 {
2618 std::string reason = "vkFlushMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result);
2619 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2620 return;
2621 }
2622}
2623
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2624VK_LAYER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2625 VkDevice device,
2626 uint32_t memRangeCount,
2627 const VkMappedMemoryRange* pMemRanges)
Tony Barbour859ceab2015-04-16 19:23:13 -0600[diff] [blame]2628{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2629 PreFlushMappedMemoryRanges(device, pMemRanges);
2630 VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
Tony Barbour859ceab2015-04-16 19:23:13 -0600[diff] [blame]2631
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2632 PostFlushMappedMemoryRanges(device, memRangeCount, result);
2633
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2634 return result;
2635}
2636
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2637void PreInvalidateMappedMemoryRanges(
2638 VkDevice device,
2639 const VkMappedMemoryRange* pMemRanges)
2640{
2641 if(device == nullptr)
2642 {
2643 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2644 "vkInvalidateMappedMemoryRanges parameter, VkDevice device, is null pointer");
2645 return;
2646 }
2647
2648 if(pMemRanges == nullptr)
2649 {
2650 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2651 "vkInvalidateMappedMemoryRanges parameter, const VkMappedMemoryRange* pMemRanges, is null pointer");
2652 return;
2653 }
2654 if(pMemRanges->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
2655 pMemRanges->sType > VK_STRUCTURE_TYPE_END_RANGE)
2656 {
2657 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2658 "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is unrecognized enumerator");
2659 return;
2660 }
2661 if(pMemRanges->mem == nullptr)
2662 {
2663 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2664 "vkInvalidateMappedMemoryRanges parameter, VkDeviceMemory pMemRanges->mem, is null pointer");
2665 return;
2666 }
2667}
2668
2669void PostInvalidateMappedMemoryRanges(
2670 VkDevice device,
2671 uint32_t memRangeCount,
2672 VkResult result)
2673{
2674 if(device == nullptr)
2675 {
2676 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2677 "vkInvalidateMappedMemoryRanges parameter, VkDevice device, is null pointer");
2678 return;
2679 }
2680
2681
2682 if(result != VK_SUCCESS)
2683 {
2684 std::string reason = "vkInvalidateMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result);
2685 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2686 return;
2687 }
2688}
2689
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2690VK_LAYER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2691 VkDevice device,
2692 uint32_t memRangeCount,
2693 const VkMappedMemoryRange* pMemRanges)
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2694{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2695 PreInvalidateMappedMemoryRanges(device, pMemRanges);
2696 VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2697
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2698 PostInvalidateMappedMemoryRanges(device, memRangeCount, result);
2699
Tony Barbour859ceab2015-04-16 19:23:13 -0600[diff] [blame]2700 return result;
2701}
2702
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2703void PreDestroyObject(
2704 VkDevice device)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2705{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2706 if(device == nullptr)
2707 {
2708 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2709 "vkDestroyObject parameter, VkDevice device, is null pointer");
2710 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2711 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2712}
2713
2714void PostDestroyObject(
2715 VkDevice device,
2716 VkObjectType objType,
2717 VkObject object,
2718 VkResult result)
2719{
2720 if(device == nullptr)
2721 {
2722 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2723 "vkDestroyObject parameter, VkDevice device, is null pointer");
2724 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2725 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2726
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2727 if(objType < VK_OBJECT_TYPE_BEGIN_RANGE ||
2728 objType > VK_OBJECT_TYPE_END_RANGE)
2729 {
2730 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2731 "vkDestroyObject parameter, VkObjectType objType, is unrecognized enumerator");
2732 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2733 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2734
2735 if(object == nullptr)
2736 {
2737 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2738 "vkDestroyObject parameter, VkObject object, is null pointer");
2739 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2740 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2741
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2742 if(result != VK_SUCCESS)
2743 {
2744 std::string reason = "vkDestroyObject parameter, VkResult result, is " + EnumeratorString(result);
2745 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2746 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2747 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2748}
2749
2750VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(
2751 VkDevice device,
2752 VkObjectType objType,
2753 VkObject object)
2754{
2755 PreDestroyObject(device);
2756 VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyObject(device, objType, object);
2757
2758 PostDestroyObject(device, objType, object, result);
2759
2760 return result;
2761}
2762
2763void PreBindObjectMemory(
2764 VkDevice device)
2765{
2766 if(device == nullptr)
2767 {
2768 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2769 "vkBindObjectMemory parameter, VkDevice device, is null pointer");
2770 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2771 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2772}
2773
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2774void PostBindObjectMemory(
2775 VkDevice device,
2776 VkObjectType objType,
2777 VkObject object,
2778 VkDeviceMemory mem,
2779 VkDeviceSize memOffset,
2780 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2781{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2782 if(device == nullptr)
2783 {
2784 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2785 "vkBindObjectMemory parameter, VkDevice device, is null pointer");
2786 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2787 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2788
2789 if(objType < VK_OBJECT_TYPE_BEGIN_RANGE ||
2790 objType > VK_OBJECT_TYPE_END_RANGE)
2791 {
2792 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2793 "vkBindObjectMemory parameter, VkObjectType objType, is unrecognized enumerator");
2794 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2795 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2796
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2797 if(object == nullptr)
2798 {
2799 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2800 "vkBindObjectMemory parameter, VkObject object, is null pointer");
2801 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2802 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2803
2804 if(mem == nullptr)
2805 {
2806 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2807 "vkBindObjectMemory parameter, VkDeviceMemory mem, is null pointer");
2808 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2809 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2810
2811
2812 if(result != VK_SUCCESS)
2813 {
2814 std::string reason = "vkBindObjectMemory parameter, VkResult result, is " + EnumeratorString(result);
2815 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2816 return;
2817 }
2818}
2819
2820VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(
2821 VkDevice device,
2822 VkObjectType objType,
2823 VkObject object,
2824 VkDeviceMemory mem,
2825 VkDeviceSize memOffset)
2826{
2827 PreBindObjectMemory(device);
2828 VkResult result = get_dispatch_table(pc_device_table_map, device)->BindObjectMemory(device, objType, object, mem, memOffset);
2829
2830 PostBindObjectMemory(device, objType, object, mem, memOffset, result);
2831
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2832 return result;
2833}
2834
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2835void PreGetObjectMemoryRequirements(
2836 VkDevice device)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2837{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2838 if(device == nullptr)
2839 {
2840 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2841 "vkGetObjectMemoryRequirements parameter, VkDevice device, is null pointer");
2842 return;
2843 }
2844}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2845
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2846void PostGetObjectMemoryRequirements(
2847 VkDevice device,
2848 VkObjectType objType,
2849 VkObject object,
2850 VkMemoryRequirements* pMemoryRequirements,
2851 VkResult result)
2852{
2853 if(device == nullptr)
2854 {
2855 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2856 "vkGetObjectMemoryRequirements parameter, VkDevice device, is null pointer");
2857 return;
2858 }
2859
2860 if(objType < VK_OBJECT_TYPE_BEGIN_RANGE ||
2861 objType > VK_OBJECT_TYPE_END_RANGE)
2862 {
2863 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2864 "vkGetObjectMemoryRequirements parameter, VkObjectType objType, is unrecognized enumerator");
2865 return;
2866 }
2867
2868 if(object == nullptr)
2869 {
2870 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2871 "vkGetObjectMemoryRequirements parameter, VkObject object, is null pointer");
2872 return;
2873 }
2874
2875 if(pMemoryRequirements == nullptr)
2876 {
2877 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2878 "vkGetObjectMemoryRequirements parameter, VkMemoryRequirements* pMemoryRequirements, is null pointer");
2879 return;
2880 }
2881 if(!ValidateEnumerator((VkMemoryPropertyFlagBits)pMemoryRequirements->memPropsAllowed))
2882 {
2883 std::string reason = "vkGetObjectMemoryRequirements parameter, VkMemoryPropertyFlags pMemoryRequirements->memPropsAllowed, is " + EnumeratorString((VkMemoryPropertyFlagBits)pMemoryRequirements->memPropsAllowed);
2884 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2885 return;
2886 }
2887 if(!ValidateEnumerator((VkMemoryPropertyFlagBits)pMemoryRequirements->memPropsRequired))
2888 {
2889 std::string reason = "vkGetObjectMemoryRequirements parameter, VkMemoryPropertyFlags pMemoryRequirements->memPropsRequired, is " + EnumeratorString((VkMemoryPropertyFlagBits)pMemoryRequirements->memPropsRequired);
2890 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2891 return;
2892 }
2893
2894 if(result != VK_SUCCESS)
2895 {
2896 std::string reason = "vkGetObjectMemoryRequirements parameter, VkResult result, is " + EnumeratorString(result);
2897 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2898 return;
2899 }
2900}
2901
2902VK_LAYER_EXPORT VkResult VKAPI vkGetObjectMemoryRequirements(
2903 VkDevice device,
2904 VkObjectType objType,
2905 VkObject object,
2906 VkMemoryRequirements* pMemoryRequirements)
2907{
2908 PreGetObjectMemoryRequirements(device);
2909 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetObjectMemoryRequirements(device, objType, object, pMemoryRequirements);
2910
2911 PostGetObjectMemoryRequirements(device, objType, object, pMemoryRequirements, result);
2912
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2913 return result;
2914}
2915
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2916void PreQueueBindSparseBufferMemory(
2917 VkQueue queue)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2918{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2919 if(queue == nullptr)
2920 {
2921 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2922 "vkQueueBindSparseBufferMemory parameter, VkQueue queue, is null pointer");
2923 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2924 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2925}
2926
2927void PostQueueBindSparseBufferMemory(
2928 VkQueue queue,
2929 VkBuffer buffer,
2930 VkDeviceSize rangeOffset,
2931 VkDeviceSize rangeSize,
2932 VkDeviceMemory mem,
2933 VkDeviceSize memOffset,
2934 VkResult result)
2935{
2936 if(queue == nullptr)
2937 {
2938 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2939 "vkQueueBindSparseBufferMemory parameter, VkQueue queue, is null pointer");
2940 return;
2941 }
2942
2943 if(buffer == nullptr)
2944 {
2945 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2946 "vkQueueBindSparseBufferMemory parameter, VkBuffer buffer, is null pointer");
2947 return;
2948 }
2949
2950
2951
2952 if(mem == nullptr)
2953 {
2954 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2955 "vkQueueBindSparseBufferMemory parameter, VkDeviceMemory mem, is null pointer");
2956 return;
2957 }
2958
2959
2960 if(result != VK_SUCCESS)
2961 {
2962 std::string reason = "vkQueueBindSparseBufferMemory parameter, VkResult result, is " + EnumeratorString(result);
2963 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2964 return;
2965 }
2966}
2967
2968VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
2969 VkQueue queue,
2970 VkBuffer buffer,
2971 VkDeviceSize rangeOffset,
2972 VkDeviceSize rangeSize,
2973 VkDeviceMemory mem,
2974 VkDeviceSize memOffset)
2975{
2976 PreQueueBindSparseBufferMemory(queue);
2977 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
2978
2979 PostQueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset, result);
2980
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2981 return result;
2982}
2983
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2984void PreQueueBindSparseImageMemory(
2985 VkQueue queue,
2986 const VkImageMemoryBindInfo* pBindInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2987{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2988 if(queue == nullptr)
2989 {
2990 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2991 "vkQueueBindSparseImageMemory parameter, VkQueue queue, is null pointer");
2992 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2993 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2994
2995 if(pBindInfo == nullptr)
2996 {
2997 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2998 "vkQueueBindSparseImageMemory parameter, const VkImageMemoryBindInfo* pBindInfo, is null pointer");
2999 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3000 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3001 if(pBindInfo->subresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
3002 pBindInfo->subresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
3003 {
3004 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3005 "vkQueueBindSparseImageMemory parameter, VkImageAspect pBindInfo->subresource.aspect, is unrecognized enumerator");
3006 return;
3007 }
3008}
3009
3010void PostQueueBindSparseImageMemory(
3011 VkQueue queue,
3012 VkImage image,
3013 VkDeviceMemory mem,
3014 VkDeviceSize memOffset,
3015 VkResult result)
3016{
3017 if(queue == nullptr)
3018 {
3019 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3020 "vkQueueBindSparseImageMemory parameter, VkQueue queue, is null pointer");
3021 return;
3022 }
3023
3024 if(image == nullptr)
3025 {
3026 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3027 "vkQueueBindSparseImageMemory parameter, VkImage image, is null pointer");
3028 return;
3029 }
3030
3031 if(mem == nullptr)
3032 {
3033 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3034 "vkQueueBindSparseImageMemory parameter, VkDeviceMemory mem, is null pointer");
3035 return;
3036 }
3037
3038
3039 if(result != VK_SUCCESS)
3040 {
3041 std::string reason = "vkQueueBindSparseImageMemory parameter, VkResult result, is " + EnumeratorString(result);
3042 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3043 return;
3044 }
3045}
3046
3047VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
3048 VkQueue queue,
3049 VkImage image,
3050 const VkImageMemoryBindInfo* pBindInfo,
3051 VkDeviceMemory mem,
3052 VkDeviceSize memOffset)
3053{
3054 PreQueueBindSparseImageMemory(queue, pBindInfo);
3055 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
3056
3057 PostQueueBindSparseImageMemory(queue, image, mem, memOffset, result);
3058
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3059 return result;
3060}
3061
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3062void PreCreateFence(
3063 VkDevice device,
3064 const VkFenceCreateInfo* pCreateInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3065{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3066 if(device == nullptr)
3067 {
3068 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3069 "vkCreateFence parameter, VkDevice device, is null pointer");
3070 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3071 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3072
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3073 if(pCreateInfo == nullptr)
3074 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3075 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3076 "vkCreateFence parameter, const VkFenceCreateInfo* pCreateInfo, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3077 return;
3078 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3079 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3080 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3081 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3082 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3083 "vkCreateFence parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3084 return;
3085 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3086 if(!ValidateEnumerator((VkFenceCreateFlagBits)pCreateInfo->flags))
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3087 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3088 std::string reason = "vkCreateFence parameter, VkFenceCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkFenceCreateFlagBits)pCreateInfo->flags);
3089 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3090 return;
3091 }
3092}
3093
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3094void PostCreateFence(
3095 VkDevice device,
3096 VkFence* pFence,
3097 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3098{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3099 if(device == nullptr)
3100 {
3101 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3102 "vkCreateFence parameter, VkDevice device, is null pointer");
3103 return;
3104 }
3105
3106 if(pFence == nullptr)
3107 {
3108 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3109 "vkCreateFence parameter, VkFence* pFence, is null pointer");
3110 return;
3111 }
3112 if((*pFence) == nullptr)
3113 {
3114 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3115 "vkCreateFence parameter, VkFence* pFence, is null pointer");
3116 return;
3117 }
3118
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]3119 if(result != VK_SUCCESS)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3120 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3121 std::string reason = "vkCreateFence parameter, VkResult result, is " + EnumeratorString(result);
3122 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3123 return;
3124 }
3125}
3126
3127VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
3128 VkDevice device,
3129 const VkFenceCreateInfo* pCreateInfo,
3130 VkFence* pFence)
3131{
3132 PreCreateFence(device, pCreateInfo);
3133 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
3134
3135 PostCreateFence(device, pFence, result);
3136
3137 return result;
3138}
3139
3140void PreResetFences(
3141 VkDevice device,
3142 const VkFence* pFences)
3143{
3144 if(device == nullptr)
3145 {
3146 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3147 "vkResetFences parameter, VkDevice device, is null pointer");
3148 return;
3149 }
3150
3151 if(pFences == nullptr)
3152 {
3153 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3154 "vkResetFences parameter, const VkFence* pFences, is null pointer");
3155 return;
3156 }
3157 if((*pFences) == nullptr)
3158 {
3159 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3160 "vkResetFences parameter, const VkFence* pFences, is null pointer");
3161 return;
3162 }
3163}
3164
3165void PostResetFences(
3166 VkDevice device,
3167 uint32_t fenceCount,
3168 VkResult result)
3169{
3170 if(device == nullptr)
3171 {
3172 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3173 "vkResetFences parameter, VkDevice device, is null pointer");
3174 return;
3175 }
3176
3177
3178 if(result != VK_SUCCESS)
3179 {
3180 std::string reason = "vkResetFences parameter, VkResult result, is " + EnumeratorString(result);
3181 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3182 return;
3183 }
3184}
3185
3186VK_LAYER_EXPORT VkResult VKAPI vkResetFences(
3187 VkDevice device,
3188 uint32_t fenceCount,
3189 const VkFence* pFences)
3190{
3191 PreResetFences(device, pFences);
3192 VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetFences(device, fenceCount, pFences);
3193
3194 PostResetFences(device, fenceCount, result);
3195
3196 return result;
3197}
3198
3199void PreGetFenceStatus(
3200 VkDevice device)
3201{
3202 if(device == nullptr)
3203 {
3204 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3205 "vkGetFenceStatus parameter, VkDevice device, is null pointer");
3206 return;
3207 }
3208}
3209
3210void PostGetFenceStatus(
3211 VkDevice device,
3212 VkFence fence,
3213 VkResult result)
3214{
3215 if(device == nullptr)
3216 {
3217 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3218 "vkGetFenceStatus parameter, VkDevice device, is null pointer");
3219 return;
3220 }
3221
3222 if(fence == nullptr)
3223 {
3224 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3225 "vkGetFenceStatus parameter, VkFence fence, is null pointer");
3226 return;
3227 }
3228
3229 if(result != VK_SUCCESS)
3230 {
3231 std::string reason = "vkGetFenceStatus parameter, VkResult result, is " + EnumeratorString(result);
3232 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3233 return;
3234 }
3235}
3236
3237VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(
3238 VkDevice device,
3239 VkFence fence)
3240{
3241 PreGetFenceStatus(device);
3242 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetFenceStatus(device, fence);
3243
3244 PostGetFenceStatus(device, fence, result);
3245
3246 return result;
3247}
3248
3249void PreWaitForFences(
3250 VkDevice device,
3251 const VkFence* pFences)
3252{
3253 if(device == nullptr)
3254 {
3255 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3256 "vkWaitForFences parameter, VkDevice device, is null pointer");
3257 return;
3258 }
3259
3260 if(pFences == nullptr)
3261 {
3262 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3263 "vkWaitForFences parameter, const VkFence* pFences, is null pointer");
3264 return;
3265 }
3266 if((*pFences) == nullptr)
3267 {
3268 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3269 "vkWaitForFences parameter, const VkFence* pFences, is null pointer");
3270 return;
3271 }
3272}
3273
3274void PostWaitForFences(
3275 VkDevice device,
3276 uint32_t fenceCount,
3277 bool32_t waitAll,
3278 uint64_t timeout,
3279 VkResult result)
3280{
3281 if(device == nullptr)
3282 {
3283 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3284 "vkWaitForFences parameter, VkDevice device, is null pointer");
3285 return;
3286 }
3287
3288
3289
3290
3291 if(result != VK_SUCCESS)
3292 {
3293 std::string reason = "vkWaitForFences parameter, VkResult result, is " + EnumeratorString(result);
3294 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3295 return;
3296 }
3297}
3298
3299VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(
3300 VkDevice device,
3301 uint32_t fenceCount,
3302 const VkFence* pFences,
3303 bool32_t waitAll,
3304 uint64_t timeout)
3305{
3306 PreWaitForFences(device, pFences);
3307 VkResult result = get_dispatch_table(pc_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
3308
3309 PostWaitForFences(device, fenceCount, waitAll, timeout, result);
3310
3311 return result;
3312}
3313
3314void PreCreateSemaphore(
3315 VkDevice device,
3316 const VkSemaphoreCreateInfo* pCreateInfo)
3317{
3318 if(device == nullptr)
3319 {
3320 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3321 "vkCreateSemaphore parameter, VkDevice device, is null pointer");
3322 return;
3323 }
3324
3325 if(pCreateInfo == nullptr)
3326 {
3327 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3328 "vkCreateSemaphore parameter, const VkSemaphoreCreateInfo* pCreateInfo, is null pointer");
3329 return;
3330 }
3331 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3332 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3333 {
3334 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3335 "vkCreateSemaphore parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3336 return;
3337 }
3338}
3339
3340void PostCreateSemaphore(
3341 VkDevice device,
3342 VkSemaphore* pSemaphore,
3343 VkResult result)
3344{
3345 if(device == nullptr)
3346 {
3347 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3348 "vkCreateSemaphore parameter, VkDevice device, is null pointer");
3349 return;
3350 }
3351
3352 if(pSemaphore == nullptr)
3353 {
3354 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3355 "vkCreateSemaphore parameter, VkSemaphore* pSemaphore, is null pointer");
3356 return;
3357 }
3358 if((*pSemaphore) == nullptr)
3359 {
3360 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3361 "vkCreateSemaphore parameter, VkSemaphore* pSemaphore, is null pointer");
3362 return;
3363 }
3364
3365 if(result != VK_SUCCESS)
3366 {
3367 std::string reason = "vkCreateSemaphore parameter, VkResult result, is " + EnumeratorString(result);
3368 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3369 return;
3370 }
3371}
3372
3373VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
3374 VkDevice device,
3375 const VkSemaphoreCreateInfo* pCreateInfo,
3376 VkSemaphore* pSemaphore)
3377{
3378 PreCreateSemaphore(device, pCreateInfo);
3379 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore);
3380
3381 PostCreateSemaphore(device, pSemaphore, result);
3382
3383 return result;
3384}
3385
3386void PreQueueSignalSemaphore(
3387 VkQueue queue)
3388{
3389 if(queue == nullptr)
3390 {
3391 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3392 "vkQueueSignalSemaphore parameter, VkQueue queue, is null pointer");
3393 return;
3394 }
3395}
3396
3397void PostQueueSignalSemaphore(
3398 VkQueue queue,
3399 VkSemaphore semaphore,
3400 VkResult result)
3401{
3402 if(queue == nullptr)
3403 {
3404 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3405 "vkQueueSignalSemaphore parameter, VkQueue queue, is null pointer");
3406 return;
3407 }
3408
3409 if(semaphore == nullptr)
3410 {
3411 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3412 "vkQueueSignalSemaphore parameter, VkSemaphore semaphore, is null pointer");
3413 return;
3414 }
3415
3416 if(result != VK_SUCCESS)
3417 {
3418 std::string reason = "vkQueueSignalSemaphore parameter, VkResult result, is " + EnumeratorString(result);
3419 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3420 return;
3421 }
3422}
3423
3424VK_LAYER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(
3425 VkQueue queue,
3426 VkSemaphore semaphore)
3427{
3428 PreQueueSignalSemaphore(queue);
3429 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueSignalSemaphore(queue, semaphore);
3430
3431 PostQueueSignalSemaphore(queue, semaphore, result);
3432
3433 return result;
3434}
3435
3436void PreQueueWaitSemaphore(
3437 VkQueue queue)
3438{
3439 if(queue == nullptr)
3440 {
3441 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3442 "vkQueueWaitSemaphore parameter, VkQueue queue, is null pointer");
3443 return;
3444 }
3445}
3446
3447void PostQueueWaitSemaphore(
3448 VkQueue queue,
3449 VkSemaphore semaphore,
3450 VkResult result)
3451{
3452 if(queue == nullptr)
3453 {
3454 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3455 "vkQueueWaitSemaphore parameter, VkQueue queue, is null pointer");
3456 return;
3457 }
3458
3459 if(semaphore == nullptr)
3460 {
3461 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3462 "vkQueueWaitSemaphore parameter, VkSemaphore semaphore, is null pointer");
3463 return;
3464 }
3465
3466 if(result != VK_SUCCESS)
3467 {
3468 std::string reason = "vkQueueWaitSemaphore parameter, VkResult result, is " + EnumeratorString(result);
3469 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3470 return;
3471 }
3472}
3473
3474VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(
3475 VkQueue queue,
3476 VkSemaphore semaphore)
3477{
3478 PreQueueWaitSemaphore(queue);
3479 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueWaitSemaphore(queue, semaphore);
3480
3481 PostQueueWaitSemaphore(queue, semaphore, result);
3482
3483 return result;
3484}
3485
3486void PreCreateEvent(
3487 VkDevice device,
3488 const VkEventCreateInfo* pCreateInfo)
3489{
3490 if(device == nullptr)
3491 {
3492 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3493 "vkCreateEvent parameter, VkDevice device, is null pointer");
3494 return;
3495 }
3496
3497 if(pCreateInfo == nullptr)
3498 {
3499 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3500 "vkCreateEvent parameter, const VkEventCreateInfo* pCreateInfo, is null pointer");
3501 return;
3502 }
3503 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3504 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3505 {
3506 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3507 "vkCreateEvent parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3508 return;
3509 }
3510}
3511
3512void PostCreateEvent(
3513 VkDevice device,
3514 VkEvent* pEvent,
3515 VkResult result)
3516{
3517 if(device == nullptr)
3518 {
3519 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3520 "vkCreateEvent parameter, VkDevice device, is null pointer");
3521 return;
3522 }
3523
3524 if(pEvent == nullptr)
3525 {
3526 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3527 "vkCreateEvent parameter, VkEvent* pEvent, is null pointer");
3528 return;
3529 }
3530 if((*pEvent) == nullptr)
3531 {
3532 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3533 "vkCreateEvent parameter, VkEvent* pEvent, is null pointer");
3534 return;
3535 }
3536
3537 if(result != VK_SUCCESS)
3538 {
3539 std::string reason = "vkCreateEvent parameter, VkResult result, is " + EnumeratorString(result);
3540 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3541 return;
3542 }
3543}
3544
3545VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
3546 VkDevice device,
3547 const VkEventCreateInfo* pCreateInfo,
3548 VkEvent* pEvent)
3549{
3550 PreCreateEvent(device, pCreateInfo);
3551 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pEvent);
3552
3553 PostCreateEvent(device, pEvent, result);
3554
3555 return result;
3556}
3557
3558void PreGetEventStatus(
3559 VkDevice device)
3560{
3561 if(device == nullptr)
3562 {
3563 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3564 "vkGetEventStatus parameter, VkDevice device, is null pointer");
3565 return;
3566 }
3567}
3568
3569void PostGetEventStatus(
3570 VkDevice device,
3571 VkEvent event,
3572 VkResult result)
3573{
3574 if(device == nullptr)
3575 {
3576 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3577 "vkGetEventStatus parameter, VkDevice device, is null pointer");
3578 return;
3579 }
3580
3581 if(event == nullptr)
3582 {
3583 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3584 "vkGetEventStatus parameter, VkEvent event, is null pointer");
3585 return;
3586 }
3587
3588 if(result != VK_SUCCESS)
3589 {
3590 std::string reason = "vkGetEventStatus parameter, VkResult result, is " + EnumeratorString(result);
3591 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3592 return;
3593 }
3594}
3595
3596VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(
3597 VkDevice device,
3598 VkEvent event)
3599{
3600 PreGetEventStatus(device);
3601 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetEventStatus(device, event);
3602
3603 PostGetEventStatus(device, event, result);
3604
3605 return result;
3606}
3607
3608void PreSetEvent(
3609 VkDevice device)
3610{
3611 if(device == nullptr)
3612 {
3613 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3614 "vkSetEvent parameter, VkDevice device, is null pointer");
3615 return;
3616 }
3617}
3618
3619void PostSetEvent(
3620 VkDevice device,
3621 VkEvent event,
3622 VkResult result)
3623{
3624 if(device == nullptr)
3625 {
3626 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3627 "vkSetEvent parameter, VkDevice device, is null pointer");
3628 return;
3629 }
3630
3631 if(event == nullptr)
3632 {
3633 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3634 "vkSetEvent parameter, VkEvent event, is null pointer");
3635 return;
3636 }
3637
3638 if(result != VK_SUCCESS)
3639 {
3640 std::string reason = "vkSetEvent parameter, VkResult result, is " + EnumeratorString(result);
3641 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3642 return;
3643 }
3644}
3645
3646VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(
3647 VkDevice device,
3648 VkEvent event)
3649{
3650 PreSetEvent(device);
3651 VkResult result = get_dispatch_table(pc_device_table_map, device)->SetEvent(device, event);
3652
3653 PostSetEvent(device, event, result);
3654
3655 return result;
3656}
3657
3658void PreResetEvent(
3659 VkDevice device)
3660{
3661 if(device == nullptr)
3662 {
3663 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3664 "vkResetEvent parameter, VkDevice device, is null pointer");
3665 return;
3666 }
3667}
3668
3669void PostResetEvent(
3670 VkDevice device,
3671 VkEvent event,
3672 VkResult result)
3673{
3674 if(device == nullptr)
3675 {
3676 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3677 "vkResetEvent parameter, VkDevice device, is null pointer");
3678 return;
3679 }
3680
3681 if(event == nullptr)
3682 {
3683 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3684 "vkResetEvent parameter, VkEvent event, is null pointer");
3685 return;
3686 }
3687
3688 if(result != VK_SUCCESS)
3689 {
3690 std::string reason = "vkResetEvent parameter, VkResult result, is " + EnumeratorString(result);
3691 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3692 return;
3693 }
3694}
3695
3696VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(
3697 VkDevice device,
3698 VkEvent event)
3699{
3700 PreResetEvent(device);
3701 VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetEvent(device, event);
3702
3703 PostResetEvent(device, event, result);
3704
3705 return result;
3706}
3707
3708void PreCreateQueryPool(
3709 VkDevice device,
3710 const VkQueryPoolCreateInfo* pCreateInfo)
3711{
3712 if(device == nullptr)
3713 {
3714 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3715 "vkCreateQueryPool parameter, VkDevice device, is null pointer");
3716 return;
3717 }
3718
3719 if(pCreateInfo == nullptr)
3720 {
3721 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3722 "vkCreateQueryPool parameter, const VkQueryPoolCreateInfo* pCreateInfo, is null pointer");
3723 return;
3724 }
3725 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3726 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3727 {
3728 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3729 "vkCreateQueryPool parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3730 return;
3731 }
3732 if(pCreateInfo->queryType < VK_QUERY_TYPE_BEGIN_RANGE ||
3733 pCreateInfo->queryType > VK_QUERY_TYPE_END_RANGE)
3734 {
3735 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3736 "vkCreateQueryPool parameter, VkQueryType pCreateInfo->queryType, is unrecognized enumerator");
3737 return;
3738 }
3739 if(!ValidateEnumerator((VkQueryPipelineStatisticFlagBits)pCreateInfo->pipelineStatistics))
3740 {
3741 std::string reason = "vkCreateQueryPool parameter, VkQueryPipelineStatisticFlags pCreateInfo->pipelineStatistics, is " + EnumeratorString((VkQueryPipelineStatisticFlagBits)pCreateInfo->pipelineStatistics);
3742 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3743 return;
3744 }
3745}
3746
3747void PostCreateQueryPool(
3748 VkDevice device,
3749 VkQueryPool* pQueryPool,
3750 VkResult result)
3751{
3752 if(device == nullptr)
3753 {
3754 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3755 "vkCreateQueryPool parameter, VkDevice device, is null pointer");
3756 return;
3757 }
3758
3759 if(pQueryPool == nullptr)
3760 {
3761 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3762 "vkCreateQueryPool parameter, VkQueryPool* pQueryPool, is null pointer");
3763 return;
3764 }
3765 if((*pQueryPool) == nullptr)
3766 {
3767 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3768 "vkCreateQueryPool parameter, VkQueryPool* pQueryPool, is null pointer");
3769 return;
3770 }
3771
3772 if(result != VK_SUCCESS)
3773 {
3774 std::string reason = "vkCreateQueryPool parameter, VkResult result, is " + EnumeratorString(result);
3775 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3776 return;
3777 }
3778}
3779
3780VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
3781 VkDevice device,
3782 const VkQueryPoolCreateInfo* pCreateInfo,
3783 VkQueryPool* pQueryPool)
3784{
3785 PreCreateQueryPool(device, pCreateInfo);
3786 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
3787
3788 PostCreateQueryPool(device, pQueryPool, result);
3789
3790 return result;
3791}
3792
3793void PreGetQueryPoolResults(
3794 VkDevice device)
3795{
3796 if(device == nullptr)
3797 {
3798 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3799 "vkGetQueryPoolResults parameter, VkDevice device, is null pointer");
3800 return;
3801 }
3802}
3803
3804void PostGetQueryPoolResults(
3805 VkDevice device,
3806 VkQueryPool queryPool,
3807 uint32_t startQuery,
3808 uint32_t queryCount,
3809 size_t* pDataSize,
3810 void* pData,
3811 VkQueryResultFlags flags,
3812 VkResult result)
3813{
3814 if(device == nullptr)
3815 {
3816 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3817 "vkGetQueryPoolResults parameter, VkDevice device, is null pointer");
3818 return;
3819 }
3820
3821 if(queryPool == nullptr)
3822 {
3823 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3824 "vkGetQueryPoolResults parameter, VkQueryPool queryPool, is null pointer");
3825 return;
3826 }
3827
3828
3829
3830 if(pDataSize == nullptr)
3831 {
3832 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3833 "vkGetQueryPoolResults parameter, size_t* pDataSize, is null pointer");
3834 return;
3835 }
3836
3837 if(pData == nullptr)
3838 {
3839 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3840 "vkGetQueryPoolResults parameter, void* pData, is null pointer");
3841 return;
3842 }
3843
3844 if(!ValidateEnumerator((VkQueryResultFlagBits)flags))
3845 {
3846 std::string reason = "vkGetQueryPoolResults parameter, VkQueryResultFlags flags, is " + EnumeratorString((VkQueryResultFlagBits)flags);
3847 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3848 return;
3849 }
3850
3851 if(result != VK_SUCCESS)
3852 {
3853 std::string reason = "vkGetQueryPoolResults parameter, VkResult result, is " + EnumeratorString(result);
3854 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3855 return;
3856 }
3857}
3858
3859VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(
3860 VkDevice device,
3861 VkQueryPool queryPool,
3862 uint32_t startQuery,
3863 uint32_t queryCount,
3864 size_t* pDataSize,
3865 void* pData,
3866 VkQueryResultFlags flags)
3867{
3868 PreGetQueryPoolResults(device);
3869 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
3870
3871 PostGetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags, result);
3872
3873 return result;
3874}
3875
3876void PreCreateBuffer(
3877 VkDevice device,
3878 const VkBufferCreateInfo* pCreateInfo)
3879{
3880 if(device == nullptr)
3881 {
3882 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3883 "vkCreateBuffer parameter, VkDevice device, is null pointer");
3884 return;
3885 }
3886
3887 if(pCreateInfo == nullptr)
3888 {
3889 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3890 "vkCreateBuffer parameter, const VkBufferCreateInfo* pCreateInfo, is null pointer");
3891 return;
3892 }
3893 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3894 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3895 {
3896 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3897 "vkCreateBuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3898 return;
3899 }
3900 if(!ValidateEnumerator((VkBufferUsageFlagBits)pCreateInfo->usage))
3901 {
3902 std::string reason = "vkCreateBuffer parameter, VkBufferUsageFlags pCreateInfo->usage, is " + EnumeratorString((VkBufferUsageFlagBits)pCreateInfo->usage);
3903 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3904 return;
3905 }
3906 if(!ValidateEnumerator((VkBufferCreateFlagBits)pCreateInfo->flags))
3907 {
3908 std::string reason = "vkCreateBuffer parameter, VkBufferCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkBufferCreateFlagBits)pCreateInfo->flags);
3909 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3910 return;
3911 }
3912}
3913
3914void PostCreateBuffer(
3915 VkDevice device,
3916 VkBuffer* pBuffer,
3917 VkResult result)
3918{
3919 if(device == nullptr)
3920 {
3921 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3922 "vkCreateBuffer parameter, VkDevice device, is null pointer");
3923 return;
3924 }
3925
3926 if(pBuffer == nullptr)
3927 {
3928 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3929 "vkCreateBuffer parameter, VkBuffer* pBuffer, is null pointer");
3930 return;
3931 }
3932 if((*pBuffer) == nullptr)
3933 {
3934 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3935 "vkCreateBuffer parameter, VkBuffer* pBuffer, is null pointer");
3936 return;
3937 }
3938
3939 if(result != VK_SUCCESS)
3940 {
3941 std::string reason = "vkCreateBuffer parameter, VkResult result, is " + EnumeratorString(result);
3942 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3943 return;
3944 }
3945}
3946
3947VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
3948 VkDevice device,
3949 const VkBufferCreateInfo* pCreateInfo,
3950 VkBuffer* pBuffer)
3951{
3952 PreCreateBuffer(device, pCreateInfo);
3953 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
3954
3955 PostCreateBuffer(device, pBuffer, result);
3956
3957 return result;
3958}
3959
3960void PreCreateBufferView(
3961 VkDevice device,
3962 const VkBufferViewCreateInfo* pCreateInfo)
3963{
3964 if(device == nullptr)
3965 {
3966 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3967 "vkCreateBufferView parameter, VkDevice device, is null pointer");
3968 return;
3969 }
3970
3971 if(pCreateInfo == nullptr)
3972 {
3973 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3974 "vkCreateBufferView parameter, const VkBufferViewCreateInfo* pCreateInfo, is null pointer");
3975 return;
3976 }
3977 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3978 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3979 {
3980 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3981 "vkCreateBufferView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3982 return;
3983 }
3984 if(pCreateInfo->buffer == nullptr)
3985 {
3986 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3987 "vkCreateBufferView parameter, VkBuffer pCreateInfo->buffer, is null pointer");
3988 return;
3989 }
3990 if(pCreateInfo->viewType < VK_BUFFER_VIEW_TYPE_BEGIN_RANGE ||
3991 pCreateInfo->viewType > VK_BUFFER_VIEW_TYPE_END_RANGE)
3992 {
3993 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3994 "vkCreateBufferView parameter, VkBufferViewType pCreateInfo->viewType, is unrecognized enumerator");
3995 return;
3996 }
3997 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
3998 pCreateInfo->format > VK_FORMAT_END_RANGE)
3999 {
4000 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4001 "vkCreateBufferView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4002 return;
4003 }
4004}
4005
4006void PostCreateBufferView(
4007 VkDevice device,
4008 VkBufferView* pView,
4009 VkResult result)
4010{
4011 if(device == nullptr)
4012 {
4013 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4014 "vkCreateBufferView parameter, VkDevice device, is null pointer");
4015 return;
4016 }
4017
4018 if(pView == nullptr)
4019 {
4020 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4021 "vkCreateBufferView parameter, VkBufferView* pView, is null pointer");
4022 return;
4023 }
4024 if((*pView) == nullptr)
4025 {
4026 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4027 "vkCreateBufferView parameter, VkBufferView* pView, is null pointer");
4028 return;
4029 }
4030
4031 if(result != VK_SUCCESS)
4032 {
4033 std::string reason = "vkCreateBufferView parameter, VkResult result, is " + EnumeratorString(result);
4034 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4035 return;
4036 }
4037}
4038
4039VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
4040 VkDevice device,
4041 const VkBufferViewCreateInfo* pCreateInfo,
4042 VkBufferView* pView)
4043{
4044 PreCreateBufferView(device, pCreateInfo);
4045 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
4046
4047 PostCreateBufferView(device, pView, result);
4048
4049 return result;
4050}
4051
4052void PreCreateImage(
4053 VkDevice device,
4054 const VkImageCreateInfo* pCreateInfo)
4055{
4056 if(device == nullptr)
4057 {
4058 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4059 "vkCreateImage parameter, VkDevice device, is null pointer");
4060 return;
4061 }
4062
4063 if(pCreateInfo == nullptr)
4064 {
4065 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4066 "vkCreateImage parameter, const VkImageCreateInfo* pCreateInfo, is null pointer");
4067 return;
4068 }
4069 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4070 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4071 {
4072 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4073 "vkCreateImage parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4074 return;
4075 }
4076 if(pCreateInfo->imageType < VK_IMAGE_TYPE_BEGIN_RANGE ||
4077 pCreateInfo->imageType > VK_IMAGE_TYPE_END_RANGE)
4078 {
4079 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4080 "vkCreateImage parameter, VkImageType pCreateInfo->imageType, is unrecognized enumerator");
4081 return;
4082 }
4083 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
4084 pCreateInfo->format > VK_FORMAT_END_RANGE)
4085 {
4086 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4087 "vkCreateImage parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4088 return;
4089 }
4090 if(pCreateInfo->tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
4091 pCreateInfo->tiling > VK_IMAGE_TILING_END_RANGE)
4092 {
4093 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4094 "vkCreateImage parameter, VkImageTiling pCreateInfo->tiling, is unrecognized enumerator");
4095 return;
4096 }
4097 if(!ValidateEnumerator((VkImageUsageFlagBits)pCreateInfo->usage))
4098 {
4099 std::string reason = "vkCreateImage parameter, VkImageUsageFlags pCreateInfo->usage, is " + EnumeratorString((VkImageUsageFlagBits)pCreateInfo->usage);
4100 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4101 return;
4102 }
4103 if(!ValidateEnumerator((VkImageCreateFlagBits)pCreateInfo->flags))
4104 {
4105 std::string reason = "vkCreateImage parameter, VkImageCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkImageCreateFlagBits)pCreateInfo->flags);
4106 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4107 return;
4108 }
4109}
4110
4111void PostCreateImage(
4112 VkDevice device,
4113 VkImage* pImage,
4114 VkResult result)
4115{
4116 if(device == nullptr)
4117 {
4118 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4119 "vkCreateImage parameter, VkDevice device, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4120 return;
4121 }
4122
4123 if(pImage == nullptr)
4124 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4125 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4126 "vkCreateImage parameter, VkImage* pImage, is null pointer");
4127 return;
4128 }
4129 if((*pImage) == nullptr)
4130 {
4131 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4132 "vkCreateImage parameter, VkImage* pImage, is null pointer");
4133 return;
4134 }
4135
4136 if(result != VK_SUCCESS)
4137 {
4138 std::string reason = "vkCreateImage parameter, VkResult result, is " + EnumeratorString(result);
4139 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4140 return;
4141 }
4142}
4143
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4144VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
4145 VkDevice device,
4146 const VkImageCreateInfo* pCreateInfo,
4147 VkImage* pImage)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4148{
4149 PreCreateImage(device, pCreateInfo);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4150 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
4151
4152 PostCreateImage(device, pImage, result);
4153
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4154 return result;
4155}
4156
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4157void PreGetImageSubresourceLayout(
4158 VkDevice device,
4159 const VkImageSubresource* pSubresource)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4160{
4161 if(device == nullptr)
4162 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4163 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4164 "vkGetImageSubresourceLayout parameter, VkDevice device, is null pointer");
4165 return;
4166 }
4167
4168 if(pSubresource == nullptr)
4169 {
4170 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4171 "vkGetImageSubresourceLayout parameter, const VkImageSubresource* pSubresource, is null pointer");
4172 return;
4173 }
4174 if(pSubresource->aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
4175 pSubresource->aspect > VK_IMAGE_ASPECT_END_RANGE)
4176 {
4177 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4178 "vkGetImageSubresourceLayout parameter, VkImageAspect pSubresource->aspect, is unrecognized enumerator");
4179 return;
4180 }
4181}
4182
4183void PostGetImageSubresourceLayout(
4184 VkDevice device,
4185 VkImage image,
4186 VkSubresourceLayout* pLayout,
4187 VkResult result)
4188{
4189 if(device == nullptr)
4190 {
4191 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4192 "vkGetImageSubresourceLayout parameter, VkDevice device, is null pointer");
4193 return;
4194 }
4195
4196 if(image == nullptr)
4197 {
4198 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4199 "vkGetImageSubresourceLayout parameter, VkImage image, is null pointer");
4200 return;
4201 }
4202
4203 if(pLayout == nullptr)
4204 {
4205 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4206 "vkGetImageSubresourceLayout parameter, VkSubresourceLayout* pLayout, is null pointer");
4207 return;
4208 }
4209
4210 if(result != VK_SUCCESS)
4211 {
4212 std::string reason = "vkGetImageSubresourceLayout parameter, VkResult result, is " + EnumeratorString(result);
4213 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4214 return;
4215 }
4216}
4217
4218VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(
4219 VkDevice device,
4220 VkImage image,
4221 const VkImageSubresource* pSubresource,
4222 VkSubresourceLayout* pLayout)
4223{
4224 PreGetImageSubresourceLayout(device, pSubresource);
4225 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
4226
4227 PostGetImageSubresourceLayout(device, image, pLayout, result);
4228
4229 return result;
4230}
4231
4232void PreCreateImageView(
4233 VkDevice device,
4234 const VkImageViewCreateInfo* pCreateInfo)
4235{
4236 if(device == nullptr)
4237 {
4238 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4239 "vkCreateImageView parameter, VkDevice device, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4240 return;
4241 }
4242
4243 if(pCreateInfo == nullptr)
4244 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4245 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4246 "vkCreateImageView parameter, const VkImageViewCreateInfo* pCreateInfo, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4247 return;
4248 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4249 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4250 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4251 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4252 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4253 "vkCreateImageView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4254 return;
4255 }
4256 if(pCreateInfo->image == nullptr)
4257 {
4258 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4259 "vkCreateImageView parameter, VkImage pCreateInfo->image, is null pointer");
4260 return;
4261 }
4262 if(pCreateInfo->viewType < VK_IMAGE_VIEW_TYPE_BEGIN_RANGE ||
4263 pCreateInfo->viewType > VK_IMAGE_VIEW_TYPE_END_RANGE)
4264 {
4265 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4266 "vkCreateImageView parameter, VkImageViewType pCreateInfo->viewType, is unrecognized enumerator");
4267 return;
4268 }
4269 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
4270 pCreateInfo->format > VK_FORMAT_END_RANGE)
4271 {
4272 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4273 "vkCreateImageView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4274 return;
4275 }
4276 if(pCreateInfo->channels.r < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4277 pCreateInfo->channels.r > VK_CHANNEL_SWIZZLE_END_RANGE)
4278 {
4279 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4280 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.r, is unrecognized enumerator");
4281 return;
4282 }
4283 if(pCreateInfo->channels.g < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4284 pCreateInfo->channels.g > VK_CHANNEL_SWIZZLE_END_RANGE)
4285 {
4286 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4287 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.g, is unrecognized enumerator");
4288 return;
4289 }
4290 if(pCreateInfo->channels.b < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4291 pCreateInfo->channels.b > VK_CHANNEL_SWIZZLE_END_RANGE)
4292 {
4293 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4294 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.b, is unrecognized enumerator");
4295 return;
4296 }
4297 if(pCreateInfo->channels.a < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4298 pCreateInfo->channels.a > VK_CHANNEL_SWIZZLE_END_RANGE)
4299 {
4300 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4301 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.a, is unrecognized enumerator");
4302 return;
4303 }
4304 if(pCreateInfo->subresourceRange.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
4305 pCreateInfo->subresourceRange.aspect > VK_IMAGE_ASPECT_END_RANGE)
4306 {
4307 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4308 "vkCreateImageView parameter, VkImageAspect pCreateInfo->subresourceRange.aspect, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4309 return;
4310 }
4311}
4312
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4313void PostCreateImageView(
4314 VkDevice device,
4315 VkImageView* pView,
4316 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4317{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4318 if(device == nullptr)
4319 {
4320 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4321 "vkCreateImageView parameter, VkDevice device, is null pointer");
4322 return;
4323 }
4324
4325 if(pView == nullptr)
4326 {
4327 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4328 "vkCreateImageView parameter, VkImageView* pView, is null pointer");
4329 return;
4330 }
4331 if((*pView) == nullptr)
4332 {
4333 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4334 "vkCreateImageView parameter, VkImageView* pView, is null pointer");
4335 return;
4336 }
4337
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]4338 if(result != VK_SUCCESS)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4339 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4340 std::string reason = "vkCreateImageView parameter, VkResult result, is " + EnumeratorString(result);
4341 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4342 return;
4343 }
4344}
4345
4346VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
4347 VkDevice device,
4348 const VkImageViewCreateInfo* pCreateInfo,
4349 VkImageView* pView)
4350{
4351 PreCreateImageView(device, pCreateInfo);
4352 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
4353
4354 PostCreateImageView(device, pView, result);
4355
4356 return result;
4357}
4358
4359void PreCreateColorAttachmentView(
4360 VkDevice device,
4361 const VkColorAttachmentViewCreateInfo* pCreateInfo)
4362{
4363 if(device == nullptr)
4364 {
4365 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4366 "vkCreateColorAttachmentView parameter, VkDevice device, is null pointer");
4367 return;
4368 }
4369
4370 if(pCreateInfo == nullptr)
4371 {
4372 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4373 "vkCreateColorAttachmentView parameter, const VkColorAttachmentViewCreateInfo* pCreateInfo, is null pointer");
4374 return;
4375 }
4376 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4377 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4378 {
4379 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4380 "vkCreateColorAttachmentView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4381 return;
4382 }
4383 if(pCreateInfo->image == nullptr)
4384 {
4385 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4386 "vkCreateColorAttachmentView parameter, VkImage pCreateInfo->image, is null pointer");
4387 return;
4388 }
4389 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
4390 pCreateInfo->format > VK_FORMAT_END_RANGE)
4391 {
4392 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4393 "vkCreateColorAttachmentView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4394 return;
4395 }
4396 if(pCreateInfo->msaaResolveImage == nullptr)
4397 {
4398 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4399 "vkCreateColorAttachmentView parameter, VkImage pCreateInfo->msaaResolveImage, is null pointer");
4400 return;
4401 }
4402 if(pCreateInfo->msaaResolveSubResource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
4403 pCreateInfo->msaaResolveSubResource.aspect > VK_IMAGE_ASPECT_END_RANGE)
4404 {
4405 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4406 "vkCreateColorAttachmentView parameter, VkImageAspect pCreateInfo->msaaResolveSubResource.aspect, is unrecognized enumerator");
4407 return;
4408 }
4409}
4410
4411void PostCreateColorAttachmentView(
4412 VkDevice device,
4413 VkColorAttachmentView* pView,
4414 VkResult result)
4415{
4416 if(device == nullptr)
4417 {
4418 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4419 "vkCreateColorAttachmentView parameter, VkDevice device, is null pointer");
4420 return;
4421 }
4422
4423 if(pView == nullptr)
4424 {
4425 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4426 "vkCreateColorAttachmentView parameter, VkColorAttachmentView* pView, is null pointer");
4427 return;
4428 }
4429 if((*pView) == nullptr)
4430 {
4431 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4432 "vkCreateColorAttachmentView parameter, VkColorAttachmentView* pView, is null pointer");
4433 return;
4434 }
4435
4436 if(result != VK_SUCCESS)
4437 {
4438 std::string reason = "vkCreateColorAttachmentView parameter, VkResult result, is " + EnumeratorString(result);
4439 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4440 return;
4441 }
4442}
4443
4444VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
4445 VkDevice device,
4446 const VkColorAttachmentViewCreateInfo* pCreateInfo,
4447 VkColorAttachmentView* pView)
4448{
4449 PreCreateColorAttachmentView(device, pCreateInfo);
4450 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateColorAttachmentView(device, pCreateInfo, pView);
4451
4452 PostCreateColorAttachmentView(device, pView, result);
4453
4454 return result;
4455}
4456
4457void PreCreateDepthStencilView(
4458 VkDevice device,
4459 const VkDepthStencilViewCreateInfo* pCreateInfo)
4460{
4461 if(device == nullptr)
4462 {
4463 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4464 "vkCreateDepthStencilView parameter, VkDevice device, is null pointer");
4465 return;
4466 }
4467
4468 if(pCreateInfo == nullptr)
4469 {
4470 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4471 "vkCreateDepthStencilView parameter, const VkDepthStencilViewCreateInfo* pCreateInfo, is null pointer");
4472 return;
4473 }
4474 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4475 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4476 {
4477 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4478 "vkCreateDepthStencilView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4479 return;
4480 }
4481 if(pCreateInfo->image == nullptr)
4482 {
4483 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4484 "vkCreateDepthStencilView parameter, VkImage pCreateInfo->image, is null pointer");
4485 return;
4486 }
4487 if(!ValidateEnumerator((VkDepthStencilViewCreateFlagBits)pCreateInfo->flags))
4488 {
4489 std::string reason = "vkCreateDepthStencilView parameter, VkDepthStencilViewCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkDepthStencilViewCreateFlagBits)pCreateInfo->flags);
4490 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4491 return;
4492 }
4493}
4494
4495void PostCreateDepthStencilView(
4496 VkDevice device,
4497 VkDepthStencilView* pView,
4498 VkResult result)
4499{
4500 if(device == nullptr)
4501 {
4502 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4503 "vkCreateDepthStencilView parameter, VkDevice device, is null pointer");
4504 return;
4505 }
4506
4507 if(pView == nullptr)
4508 {
4509 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4510 "vkCreateDepthStencilView parameter, VkDepthStencilView* pView, is null pointer");
4511 return;
4512 }
4513 if((*pView) == nullptr)
4514 {
4515 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4516 "vkCreateDepthStencilView parameter, VkDepthStencilView* pView, is null pointer");
4517 return;
4518 }
4519
4520 if(result != VK_SUCCESS)
4521 {
4522 std::string reason = "vkCreateDepthStencilView parameter, VkResult result, is " + EnumeratorString(result);
4523 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4524 return;
4525 }
4526}
4527
4528VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(
4529 VkDevice device,
4530 const VkDepthStencilViewCreateInfo* pCreateInfo,
4531 VkDepthStencilView* pView)
4532{
4533 PreCreateDepthStencilView(device, pCreateInfo);
4534 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDepthStencilView(device, pCreateInfo, pView);
4535
4536 PostCreateDepthStencilView(device, pView, result);
4537
4538 return result;
4539}
4540
Courtney Goeltzenleuchter2d034fd2015-06-28 13:01:17 -0600[diff] [blame^]4541void PreCreateShaderModule(
4542 VkDevice device,
4543 const VkShaderModuleCreateInfo* pCreateInfo)
4544{
4545 if(device == nullptr)
4546 {
4547 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4548 "vkCreateShaderModule parameter, VkDevice device, is null pointer");
4549 return;
4550 }
4551
4552 if(pCreateInfo == nullptr)
4553 {
4554 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4555 "vkCreateShaderModule parameter, const VkShaderCreateInfo* pCreateInfo, is null pointer");
4556 return;
4557 }
4558 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4559 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4560 {
4561 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4562 "vkCreateShaderModule parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4563 return;
4564 }
4565 if(pCreateInfo->pCode == nullptr)
4566 {
4567 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4568 "vkCreateShaderModule parameter, const void* pCreateInfo->pCode, is null pointer");
4569 return;
4570 }
4571 if(pCreateInfo->codeSize == 0)
4572 {
4573 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4574 "vkCreateShaderModule parameter, size_t pCreateInfo->codeSize, is zero");
4575 return;
4576 }
4577}
4578
4579void PostCreateShaderModule(
4580 VkDevice device,
4581 VkShaderModule* pShaderModule,
4582 VkResult result)
4583{
4584 if(device == nullptr)
4585 {
4586 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4587 "vkCreateShaderModule parameter, VkDevice device, is null pointer");
4588 return;
4589 }
4590
4591 if(pShaderModule == nullptr)
4592 {
4593 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4594 "vkCreateShaderModule parameter, VkShader* pShader, is null pointer");
4595 return;
4596 }
4597 if((*pShaderModule) == nullptr)
4598 {
4599 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4600 "vkCreateShaderModule parameter, VkShader* pShader, is null pointer");
4601 return;
4602 }
4603
4604 if(result != VK_SUCCESS)
4605 {
4606 std::string reason = "vkCreateShaderModule parameter, VkResult result, is " + EnumeratorString(result);
4607 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4608 return;
4609 }
4610}
4611
4612VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
4613 VkDevice device,
4614 const VkShaderModuleCreateInfo* pCreateInfo,
4615 VkShaderModule* pShaderModule)
4616{
4617 PreCreateShaderModule(device, pCreateInfo);
4618 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pShaderModule);
4619
4620 PostCreateShaderModule(device, pShaderModule, result);
4621
4622 return result;
4623}
4624
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4625void PreCreateShader(
4626 VkDevice device,
4627 const VkShaderCreateInfo* pCreateInfo)
4628{
4629 if(device == nullptr)
4630 {
4631 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4632 "vkCreateShader parameter, VkDevice device, is null pointer");
4633 return;
4634 }
4635
4636 if(pCreateInfo == nullptr)
4637 {
4638 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4639 "vkCreateShader parameter, const VkShaderCreateInfo* pCreateInfo, is null pointer");
4640 return;
4641 }
4642 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4643 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4644 {
4645 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4646 "vkCreateShader parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4647 return;
4648 }
4649 if(pCreateInfo->module == nullptr)
4650 {
4651 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4652 "vkCreateShader parameter, VkShaderModule pCreateInfo->module, is null pointer");
4653 return;
4654 }
Courtney Goeltzenleuchter2d034fd2015-06-28 13:01:17 -0600[diff] [blame^]4655 if(pCreateInfo->pName == nullptr)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4656 {
4657 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4658 "vkCreateShader parameter, const char* pCreateInfo->name, is null pointer");
4659 return;
4660 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4661}
4662
4663void PostCreateShader(
4664 VkDevice device,
4665 VkShader* pShader,
4666 VkResult result)
4667{
4668 if(device == nullptr)
4669 {
4670 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4671 "vkCreateShader parameter, VkDevice device, is null pointer");
4672 return;
4673 }
4674
4675 if(pShader == nullptr)
4676 {
4677 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4678 "vkCreateShader parameter, VkShader* pShader, is null pointer");
4679 return;
4680 }
4681 if((*pShader) == nullptr)
4682 {
4683 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4684 "vkCreateShader parameter, VkShader* pShader, is null pointer");
4685 return;
4686 }
4687
4688 if(result != VK_SUCCESS)
4689 {
4690 std::string reason = "vkCreateShader parameter, VkResult result, is " + EnumeratorString(result);
4691 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4692 return;
4693 }
4694}
4695
4696VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
4697 VkDevice device,
4698 const VkShaderCreateInfo* pCreateInfo,
4699 VkShader* pShader)
4700{
4701 PreCreateShader(device, pCreateInfo);
4702 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
4703
4704 PostCreateShader(device, pShader, result);
4705
4706 return result;
4707}
4708
4709void PreCreateGraphicsPipeline(
4710 VkDevice device,
4711 const VkGraphicsPipelineCreateInfo* pCreateInfo)
4712{
4713 if(device == nullptr)
4714 {
4715 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4716 "vkCreateGraphicsPipeline parameter, VkDevice device, is null pointer");
4717 return;
4718 }
4719
4720 if(pCreateInfo == nullptr)
4721 {
4722 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4723 "vkCreateGraphicsPipeline parameter, const VkGraphicsPipelineCreateInfo* pCreateInfo, is null pointer");
4724 return;
4725 }
4726 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4727 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4728 {
4729 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4730 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4731 return;
4732 }
4733 if(pCreateInfo->pStages == nullptr)
4734 {
4735 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4736 "vkCreateGraphicsPipeline parameter, const VkPipelineShaderStageCreateInfo* pCreateInfo->pStages, is null pointer");
4737 return;
4738 }
4739 if(pCreateInfo->pStages->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4740 pCreateInfo->pStages->sType > VK_STRUCTURE_TYPE_END_RANGE)
4741 {
4742 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4743 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pStages->sType, is unrecognized enumerator");
4744 return;
4745 }
4746 if(pCreateInfo->pStages->pNext == nullptr)
4747 {
4748 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4749 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pStages->pNext, is null pointer");
4750 return;
4751 }
4752 if(pCreateInfo->pStages->stage < VK_SHADER_STAGE_BEGIN_RANGE ||
4753 pCreateInfo->pStages->stage > VK_SHADER_STAGE_END_RANGE)
4754 {
4755 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4756 "vkCreateGraphicsPipeline parameter, VkShaderStage pCreateInfo->pStages->stage, is unrecognized enumerator");
4757 return;
4758 }
4759 if(pCreateInfo->pStages->shader == nullptr)
4760 {
4761 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4762 "vkCreateGraphicsPipeline parameter, VkShader pCreateInfo->pStages->shader, is null pointer");
4763 return;
4764 }
4765 if(pCreateInfo->pStages->pLinkConstBufferInfo == nullptr)
4766 {
4767 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4768 "vkCreateGraphicsPipeline parameter, const VkLinkConstBuffer* pCreateInfo->pStages->pLinkConstBufferInfo, is null pointer");
4769 return;
4770 }
4771 if(pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData == nullptr)
4772 {
4773 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4774 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData, is null pointer");
4775 return;
4776 }
4777 if(pCreateInfo->pStages->pSpecializationInfo == nullptr)
4778 {
4779 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4780 "vkCreateGraphicsPipeline parameter, const VkSpecializationInfo* pCreateInfo->pStages->pSpecializationInfo, is null pointer");
4781 return;
4782 }
4783 if(pCreateInfo->pStages->pSpecializationInfo->pMap == nullptr)
4784 {
4785 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4786 "vkCreateGraphicsPipeline parameter, const VkSpecializationMapEntry* pCreateInfo->pStages->pSpecializationInfo->pMap, is null pointer");
4787 return;
4788 }
4789 if(pCreateInfo->pStages->pSpecializationInfo->pData == nullptr)
4790 {
4791 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4792 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pStages->pSpecializationInfo->pData, is null pointer");
4793 return;
4794 }
4795 if(pCreateInfo->pVertexInputState == nullptr)
4796 {
4797 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4798 "vkCreateGraphicsPipeline parameter, const VkPipelineVertexInputStateCreateInfo* pCreateInfo->pVertexInputState, is null pointer");
4799 return;
4800 }
4801 if(pCreateInfo->pVertexInputState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4802 pCreateInfo->pVertexInputState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4803 {
4804 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4805 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pVertexInputState->sType, is unrecognized enumerator");
4806 return;
4807 }
4808 if(pCreateInfo->pVertexInputState->pNext == nullptr)
4809 {
4810 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4811 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pVertexInputState->pNext, is null pointer");
4812 return;
4813 }
4814 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions == nullptr)
4815 {
4816 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4817 "vkCreateGraphicsPipeline parameter, const VkVertexInputBindingDescription* pCreateInfo->pVertexInputState->pVertexBindingDescriptions, is null pointer");
4818 return;
4819 }
4820 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate < VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE ||
4821 pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate > VK_VERTEX_INPUT_STEP_RATE_END_RANGE)
4822 {
4823 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4824 "vkCreateGraphicsPipeline parameter, VkVertexInputStepRate pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate, is unrecognized enumerator");
4825 return;
4826 }
4827 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions == nullptr)
4828 {
4829 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4830 "vkCreateGraphicsPipeline parameter, const VkVertexInputAttributeDescription* pCreateInfo->pVertexInputState->pVertexAttributeDescriptions, is null pointer");
4831 return;
4832 }
4833 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE ||
4834 pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE)
4835 {
4836 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4837 "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format, is unrecognized enumerator");
4838 return;
4839 }
4840 if(pCreateInfo->pIaState == nullptr)
4841 {
4842 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4843 "vkCreateGraphicsPipeline parameter, const VkPipelineIaStateCreateInfo* pCreateInfo->pIaState, is null pointer");
4844 return;
4845 }
4846 if(pCreateInfo->pIaState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4847 pCreateInfo->pIaState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4848 {
4849 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4850 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pIaState->sType, is unrecognized enumerator");
4851 return;
4852 }
4853 if(pCreateInfo->pIaState->pNext == nullptr)
4854 {
4855 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4856 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pIaState->pNext, is null pointer");
4857 return;
4858 }
4859 if(pCreateInfo->pIaState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE ||
4860 pCreateInfo->pIaState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE)
4861 {
4862 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4863 "vkCreateGraphicsPipeline parameter, VkPrimitiveTopology pCreateInfo->pIaState->topology, is unrecognized enumerator");
4864 return;
4865 }
4866 if(pCreateInfo->pTessState == nullptr)
4867 {
4868 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4869 "vkCreateGraphicsPipeline parameter, const VkPipelineTessStateCreateInfo* pCreateInfo->pTessState, is null pointer");
4870 return;
4871 }
4872 if(pCreateInfo->pTessState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4873 pCreateInfo->pTessState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4874 {
4875 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4876 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pTessState->sType, is unrecognized enumerator");
4877 return;
4878 }
4879 if(pCreateInfo->pTessState->pNext == nullptr)
4880 {
4881 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4882 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pTessState->pNext, is null pointer");
4883 return;
4884 }
4885 if(pCreateInfo->pVpState == nullptr)
4886 {
4887 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4888 "vkCreateGraphicsPipeline parameter, const VkPipelineVpStateCreateInfo* pCreateInfo->pVpState, is null pointer");
4889 return;
4890 }
4891 if(pCreateInfo->pVpState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4892 pCreateInfo->pVpState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4893 {
4894 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4895 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pVpState->sType, is unrecognized enumerator");
4896 return;
4897 }
4898 if(pCreateInfo->pVpState->pNext == nullptr)
4899 {
4900 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4901 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pVpState->pNext, is null pointer");
4902 return;
4903 }
4904 if(pCreateInfo->pVpState->clipOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
4905 pCreateInfo->pVpState->clipOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
4906 {
4907 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4908 "vkCreateGraphicsPipeline parameter, VkCoordinateOrigin pCreateInfo->pVpState->clipOrigin, is unrecognized enumerator");
4909 return;
4910 }
4911 if(pCreateInfo->pVpState->depthMode < VK_DEPTH_MODE_BEGIN_RANGE ||
4912 pCreateInfo->pVpState->depthMode > VK_DEPTH_MODE_END_RANGE)
4913 {
4914 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4915 "vkCreateGraphicsPipeline parameter, VkDepthMode pCreateInfo->pVpState->depthMode, is unrecognized enumerator");
4916 return;
4917 }
4918 if(pCreateInfo->pRsState == nullptr)
4919 {
4920 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4921 "vkCreateGraphicsPipeline parameter, const VkPipelineRsStateCreateInfo* pCreateInfo->pRsState, is null pointer");
4922 return;
4923 }
4924 if(pCreateInfo->pRsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4925 pCreateInfo->pRsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4926 {
4927 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4928 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pRsState->sType, is unrecognized enumerator");
4929 return;
4930 }
4931 if(pCreateInfo->pRsState->pNext == nullptr)
4932 {
4933 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4934 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pRsState->pNext, is null pointer");
4935 return;
4936 }
4937 if(pCreateInfo->pRsState->pointOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
4938 pCreateInfo->pRsState->pointOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
4939 {
4940 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4941 "vkCreateGraphicsPipeline parameter, VkCoordinateOrigin pCreateInfo->pRsState->pointOrigin, is unrecognized enumerator");
4942 return;
4943 }
4944 if(pCreateInfo->pRsState->provokingVertex < VK_PROVOKING_VERTEX_BEGIN_RANGE ||
4945 pCreateInfo->pRsState->provokingVertex > VK_PROVOKING_VERTEX_END_RANGE)
4946 {
4947 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4948 "vkCreateGraphicsPipeline parameter, VkProvokingVertex pCreateInfo->pRsState->provokingVertex, is unrecognized enumerator");
4949 return;
4950 }
4951 if(pCreateInfo->pRsState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
4952 pCreateInfo->pRsState->fillMode > VK_FILL_MODE_END_RANGE)
4953 {
4954 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4955 "vkCreateGraphicsPipeline parameter, VkFillMode pCreateInfo->pRsState->fillMode, is unrecognized enumerator");
4956 return;
4957 }
4958 if(pCreateInfo->pRsState->cullMode < VK_CULL_MODE_BEGIN_RANGE ||
4959 pCreateInfo->pRsState->cullMode > VK_CULL_MODE_END_RANGE)
4960 {
4961 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4962 "vkCreateGraphicsPipeline parameter, VkCullMode pCreateInfo->pRsState->cullMode, is unrecognized enumerator");
4963 return;
4964 }
4965 if(pCreateInfo->pRsState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
4966 pCreateInfo->pRsState->frontFace > VK_FRONT_FACE_END_RANGE)
4967 {
4968 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4969 "vkCreateGraphicsPipeline parameter, VkFrontFace pCreateInfo->pRsState->frontFace, is unrecognized enumerator");
4970 return;
4971 }
4972 if(pCreateInfo->pMsState == nullptr)
4973 {
4974 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4975 "vkCreateGraphicsPipeline parameter, const VkPipelineMsStateCreateInfo* pCreateInfo->pMsState, is null pointer");
4976 return;
4977 }
4978 if(pCreateInfo->pMsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4979 pCreateInfo->pMsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4980 {
4981 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4982 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pMsState->sType, is unrecognized enumerator");
4983 return;
4984 }
4985 if(pCreateInfo->pMsState->pNext == nullptr)
4986 {
4987 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4988 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pMsState->pNext, is null pointer");
4989 return;
4990 }
4991 if(pCreateInfo->pDsState == nullptr)
4992 {
4993 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4994 "vkCreateGraphicsPipeline parameter, const VkPipelineDsStateCreateInfo* pCreateInfo->pDsState, is null pointer");
4995 return;
4996 }
4997 if(pCreateInfo->pDsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4998 pCreateInfo->pDsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4999 {
5000 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5001 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pDsState->sType, is unrecognized enumerator");
5002 return;
5003 }
5004 if(pCreateInfo->pDsState->pNext == nullptr)
5005 {
5006 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5007 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pDsState->pNext, is null pointer");
5008 return;
5009 }
5010 if(pCreateInfo->pDsState->format < VK_FORMAT_BEGIN_RANGE ||
5011 pCreateInfo->pDsState->format > VK_FORMAT_END_RANGE)
5012 {
5013 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5014 "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pDsState->format, is unrecognized enumerator");
5015 return;
5016 }
5017 if(pCreateInfo->pDsState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5018 pCreateInfo->pDsState->depthCompareOp > VK_COMPARE_OP_END_RANGE)
5019 {
5020 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5021 "vkCreateGraphicsPipeline parameter, VkCompareOp pCreateInfo->pDsState->depthCompareOp, is unrecognized enumerator");
5022 return;
5023 }
5024 if(pCreateInfo->pDsState->front.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5025 pCreateInfo->pDsState->front.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5026 {
5027 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5028 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->front.stencilFailOp, is unrecognized enumerator");
5029 return;
5030 }
5031 if(pCreateInfo->pDsState->front.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5032 pCreateInfo->pDsState->front.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5033 {
5034 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5035 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->front.stencilPassOp, is unrecognized enumerator");
5036 return;
5037 }
5038 if(pCreateInfo->pDsState->front.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5039 pCreateInfo->pDsState->front.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5040 {
5041 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5042 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->front.stencilDepthFailOp, is unrecognized enumerator");
5043 return;
5044 }
5045 if(pCreateInfo->pDsState->front.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5046 pCreateInfo->pDsState->front.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5047 {
5048 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5049 "vkCreateGraphicsPipeline parameter, VkCompareOp pCreateInfo->pDsState->front.stencilCompareOp, is unrecognized enumerator");
5050 return;
5051 }
5052 if(pCreateInfo->pDsState->back.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5053 pCreateInfo->pDsState->back.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5054 {
5055 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5056 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->back.stencilFailOp, is unrecognized enumerator");
5057 return;
5058 }
5059 if(pCreateInfo->pDsState->back.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5060 pCreateInfo->pDsState->back.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5061 {
5062 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5063 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->back.stencilPassOp, is unrecognized enumerator");
5064 return;
5065 }
5066 if(pCreateInfo->pDsState->back.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5067 pCreateInfo->pDsState->back.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5068 {
5069 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5070 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->back.stencilDepthFailOp, is unrecognized enumerator");
5071 return;
5072 }
5073 if(pCreateInfo->pDsState->back.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5074 pCreateInfo->pDsState->back.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5075 {
5076 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5077 "vkCreateGraphicsPipeline parameter, VkCompareOp pCreateInfo->pDsState->back.stencilCompareOp, is unrecognized enumerator");
5078 return;
5079 }
5080 if(pCreateInfo->pCbState == nullptr)
5081 {
5082 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5083 "vkCreateGraphicsPipeline parameter, const VkPipelineCbStateCreateInfo* pCreateInfo->pCbState, is null pointer");
5084 return;
5085 }
5086 if(pCreateInfo->pCbState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5087 pCreateInfo->pCbState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5088 {
5089 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5090 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pCbState->sType, is unrecognized enumerator");
5091 return;
5092 }
5093 if(pCreateInfo->pCbState->pNext == nullptr)
5094 {
5095 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5096 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pCbState->pNext, is null pointer");
5097 return;
5098 }
5099 if(pCreateInfo->pCbState->logicOp < VK_LOGIC_OP_BEGIN_RANGE ||
5100 pCreateInfo->pCbState->logicOp > VK_LOGIC_OP_END_RANGE)
5101 {
5102 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5103 "vkCreateGraphicsPipeline parameter, VkLogicOp pCreateInfo->pCbState->logicOp, is unrecognized enumerator");
5104 return;
5105 }
5106 if(pCreateInfo->pCbState->pAttachments == nullptr)
5107 {
5108 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5109 "vkCreateGraphicsPipeline parameter, const VkPipelineCbAttachmentState* pCreateInfo->pCbState->pAttachments, is null pointer");
5110 return;
5111 }
5112 if(pCreateInfo->pCbState->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
5113 pCreateInfo->pCbState->pAttachments->format > VK_FORMAT_END_RANGE)
5114 {
5115 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5116 "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pCbState->pAttachments->format, is unrecognized enumerator");
5117 return;
5118 }
5119 if(pCreateInfo->pCbState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE ||
5120 pCreateInfo->pCbState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE)
5121 {
5122 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5123 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendColor, is unrecognized enumerator");
5124 return;
5125 }
5126 if(pCreateInfo->pCbState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE ||
5127 pCreateInfo->pCbState->pAttachments->destBlendColor > VK_BLEND_END_RANGE)
5128 {
5129 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5130 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendColor, is unrecognized enumerator");
5131 return;
5132 }
5133 if(pCreateInfo->pCbState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
5134 pCreateInfo->pCbState->pAttachments->blendOpColor > VK_BLEND_OP_END_RANGE)
5135 {
5136 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5137 "vkCreateGraphicsPipeline parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpColor, is unrecognized enumerator");
5138 return;
5139 }
5140 if(pCreateInfo->pCbState->pAttachments->srcBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5141 pCreateInfo->pCbState->pAttachments->srcBlendAlpha > VK_BLEND_END_RANGE)
5142 {
5143 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5144 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendAlpha, is unrecognized enumerator");
5145 return;
5146 }
5147 if(pCreateInfo->pCbState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5148 pCreateInfo->pCbState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE)
5149 {
5150 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5151 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendAlpha, is unrecognized enumerator");
5152 return;
5153 }
5154 if(pCreateInfo->pCbState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
5155 pCreateInfo->pCbState->pAttachments->blendOpAlpha > VK_BLEND_OP_END_RANGE)
5156 {
5157 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5158 "vkCreateGraphicsPipeline parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpAlpha, is unrecognized enumerator");
5159 return;
5160 }
5161 if(!ValidateEnumerator((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask))
5162 {
5163 std::string reason = "vkCreateGraphicsPipeline parameter, VkChannelFlags pCreateInfo->pCbState->pAttachments->channelWriteMask, is " + EnumeratorString((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask);
5164 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5165 return;
5166 }
5167 if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags))
5168 {
5169 std::string reason = "vkCreateGraphicsPipeline parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags);
5170 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5171 return;
5172 }
5173 if(pCreateInfo->layout == nullptr)
5174 {
5175 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5176 "vkCreateGraphicsPipeline parameter, VkPipelineLayout pCreateInfo->layout, is null pointer");
5177 return;
5178 }
5179}
5180
5181void PostCreateGraphicsPipeline(
5182 VkDevice device,
5183 VkPipeline* pPipeline,
5184 VkResult result)
5185{
5186 if(device == nullptr)
5187 {
5188 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5189 "vkCreateGraphicsPipeline parameter, VkDevice device, is null pointer");
5190 return;
5191 }
5192
5193 if(pPipeline == nullptr)
5194 {
5195 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5196 "vkCreateGraphicsPipeline parameter, VkPipeline* pPipeline, is null pointer");
5197 return;
5198 }
5199 if((*pPipeline) == nullptr)
5200 {
5201 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5202 "vkCreateGraphicsPipeline parameter, VkPipeline* pPipeline, is null pointer");
5203 return;
5204 }
5205
5206 if(result != VK_SUCCESS)
5207 {
5208 std::string reason = "vkCreateGraphicsPipeline parameter, VkResult result, is " + EnumeratorString(result);
5209 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5210 return;
5211 }
5212}
5213
5214VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(
5215 VkDevice device,
5216 const VkGraphicsPipelineCreateInfo* pCreateInfo,
5217 VkPipeline* pPipeline)
5218{
5219 PreCreateGraphicsPipeline(device, pCreateInfo);
5220 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
5221
5222 PostCreateGraphicsPipeline(device, pPipeline, result);
5223
5224 return result;
5225}
5226
5227void PreCreateGraphicsPipelineDerivative(
5228 VkDevice device,
5229 const VkGraphicsPipelineCreateInfo* pCreateInfo)
5230{
5231 if(device == nullptr)
5232 {
5233 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5234 "vkCreateGraphicsPipelineDerivative parameter, VkDevice device, is null pointer");
5235 return;
5236 }
5237
5238 if(pCreateInfo == nullptr)
5239 {
5240 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5241 "vkCreateGraphicsPipelineDerivative parameter, const VkGraphicsPipelineCreateInfo* pCreateInfo, is null pointer");
5242 return;
5243 }
5244 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5245 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
5246 {
5247 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5248 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
5249 return;
5250 }
5251 if(pCreateInfo->pStages == nullptr)
5252 {
5253 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5254 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineShaderStageCreateInfo* pCreateInfo->pStages, is null pointer");
5255 return;
5256 }
5257 if(pCreateInfo->pStages->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5258 pCreateInfo->pStages->sType > VK_STRUCTURE_TYPE_END_RANGE)
5259 {
5260 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5261 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pStages->sType, is unrecognized enumerator");
5262 return;
5263 }
5264 if(pCreateInfo->pStages->pNext == nullptr)
5265 {
5266 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5267 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pNext, is null pointer");
5268 return;
5269 }
5270 if(pCreateInfo->pStages->stage < VK_SHADER_STAGE_BEGIN_RANGE ||
5271 pCreateInfo->pStages->stage > VK_SHADER_STAGE_END_RANGE)
5272 {
5273 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5274 "vkCreateGraphicsPipelineDerivative parameter, VkShaderStage pCreateInfo->pStages->stage, is unrecognized enumerator");
5275 return;
5276 }
5277 if(pCreateInfo->pStages->shader == nullptr)
5278 {
5279 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5280 "vkCreateGraphicsPipelineDerivative parameter, VkShader pCreateInfo->pStages->shader, is null pointer");
5281 return;
5282 }
5283 if(pCreateInfo->pStages->pLinkConstBufferInfo == nullptr)
5284 {
5285 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5286 "vkCreateGraphicsPipelineDerivative parameter, const VkLinkConstBuffer* pCreateInfo->pStages->pLinkConstBufferInfo, is null pointer");
5287 return;
5288 }
5289 if(pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData == nullptr)
5290 {
5291 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5292 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData, is null pointer");
5293 return;
5294 }
5295 if(pCreateInfo->pStages->pSpecializationInfo == nullptr)
5296 {
5297 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5298 "vkCreateGraphicsPipelineDerivative parameter, const VkSpecializationInfo* pCreateInfo->pStages->pSpecializationInfo, is null pointer");
5299 return;
5300 }
5301 if(pCreateInfo->pStages->pSpecializationInfo->pMap == nullptr)
5302 {
5303 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5304 "vkCreateGraphicsPipelineDerivative parameter, const VkSpecializationMapEntry* pCreateInfo->pStages->pSpecializationInfo->pMap, is null pointer");
5305 return;
5306 }
5307 if(pCreateInfo->pStages->pSpecializationInfo->pData == nullptr)
5308 {
5309 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5310 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pSpecializationInfo->pData, is null pointer");
5311 return;
5312 }
5313 if(pCreateInfo->pVertexInputState == nullptr)
5314 {
5315 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5316 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineVertexInputStateCreateInfo* pCreateInfo->pVertexInputState, is null pointer");
5317 return;
5318 }
5319 if(pCreateInfo->pVertexInputState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5320 pCreateInfo->pVertexInputState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5321 {
5322 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5323 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pVertexInputState->sType, is unrecognized enumerator");
5324 return;
5325 }
5326 if(pCreateInfo->pVertexInputState->pNext == nullptr)
5327 {
5328 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5329 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pVertexInputState->pNext, is null pointer");
5330 return;
5331 }
5332 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions == nullptr)
5333 {
5334 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5335 "vkCreateGraphicsPipelineDerivative parameter, const VkVertexInputBindingDescription* pCreateInfo->pVertexInputState->pVertexBindingDescriptions, is null pointer");
5336 return;
5337 }
5338 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate < VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE ||
5339 pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate > VK_VERTEX_INPUT_STEP_RATE_END_RANGE)
5340 {
5341 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5342 "vkCreateGraphicsPipelineDerivative parameter, VkVertexInputStepRate pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate, is unrecognized enumerator");
5343 return;
5344 }
5345 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions == nullptr)
5346 {
5347 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5348 "vkCreateGraphicsPipelineDerivative parameter, const VkVertexInputAttributeDescription* pCreateInfo->pVertexInputState->pVertexAttributeDescriptions, is null pointer");
5349 return;
5350 }
5351 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE ||
5352 pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE)
5353 {
5354 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5355 "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format, is unrecognized enumerator");
5356 return;
5357 }
5358 if(pCreateInfo->pIaState == nullptr)
5359 {
5360 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5361 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineIaStateCreateInfo* pCreateInfo->pIaState, is null pointer");
5362 return;
5363 }
5364 if(pCreateInfo->pIaState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5365 pCreateInfo->pIaState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5366 {
5367 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5368 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pIaState->sType, is unrecognized enumerator");
5369 return;
5370 }
5371 if(pCreateInfo->pIaState->pNext == nullptr)
5372 {
5373 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5374 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pIaState->pNext, is null pointer");
5375 return;
5376 }
5377 if(pCreateInfo->pIaState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE ||
5378 pCreateInfo->pIaState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE)
5379 {
5380 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5381 "vkCreateGraphicsPipelineDerivative parameter, VkPrimitiveTopology pCreateInfo->pIaState->topology, is unrecognized enumerator");
5382 return;
5383 }
5384 if(pCreateInfo->pTessState == nullptr)
5385 {
5386 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5387 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineTessStateCreateInfo* pCreateInfo->pTessState, is null pointer");
5388 return;
5389 }
5390 if(pCreateInfo->pTessState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5391 pCreateInfo->pTessState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5392 {
5393 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5394 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pTessState->sType, is unrecognized enumerator");
5395 return;
5396 }
5397 if(pCreateInfo->pTessState->pNext == nullptr)
5398 {
5399 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5400 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pTessState->pNext, is null pointer");
5401 return;
5402 }
5403 if(pCreateInfo->pVpState == nullptr)
5404 {
5405 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5406 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineVpStateCreateInfo* pCreateInfo->pVpState, is null pointer");
5407 return;
5408 }
5409 if(pCreateInfo->pVpState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5410 pCreateInfo->pVpState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5411 {
5412 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5413 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pVpState->sType, is unrecognized enumerator");
5414 return;
5415 }
5416 if(pCreateInfo->pVpState->pNext == nullptr)
5417 {
5418 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5419 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pVpState->pNext, is null pointer");
5420 return;
5421 }
5422 if(pCreateInfo->pVpState->clipOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
5423 pCreateInfo->pVpState->clipOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
5424 {
5425 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5426 "vkCreateGraphicsPipelineDerivative parameter, VkCoordinateOrigin pCreateInfo->pVpState->clipOrigin, is unrecognized enumerator");
5427 return;
5428 }
5429 if(pCreateInfo->pVpState->depthMode < VK_DEPTH_MODE_BEGIN_RANGE ||
5430 pCreateInfo->pVpState->depthMode > VK_DEPTH_MODE_END_RANGE)
5431 {
5432 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5433 "vkCreateGraphicsPipelineDerivative parameter, VkDepthMode pCreateInfo->pVpState->depthMode, is unrecognized enumerator");
5434 return;
5435 }
5436 if(pCreateInfo->pRsState == nullptr)
5437 {
5438 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5439 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineRsStateCreateInfo* pCreateInfo->pRsState, is null pointer");
5440 return;
5441 }
5442 if(pCreateInfo->pRsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5443 pCreateInfo->pRsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5444 {
5445 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5446 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pRsState->sType, is unrecognized enumerator");
5447 return;
5448 }
5449 if(pCreateInfo->pRsState->pNext == nullptr)
5450 {
5451 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5452 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pRsState->pNext, is null pointer");
5453 return;
5454 }
5455 if(pCreateInfo->pRsState->pointOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
5456 pCreateInfo->pRsState->pointOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
5457 {
5458 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5459 "vkCreateGraphicsPipelineDerivative parameter, VkCoordinateOrigin pCreateInfo->pRsState->pointOrigin, is unrecognized enumerator");
5460 return;
5461 }
5462 if(pCreateInfo->pRsState->provokingVertex < VK_PROVOKING_VERTEX_BEGIN_RANGE ||
5463 pCreateInfo->pRsState->provokingVertex > VK_PROVOKING_VERTEX_END_RANGE)
5464 {
5465 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5466 "vkCreateGraphicsPipelineDerivative parameter, VkProvokingVertex pCreateInfo->pRsState->provokingVertex, is unrecognized enumerator");
5467 return;
5468 }
5469 if(pCreateInfo->pRsState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
5470 pCreateInfo->pRsState->fillMode > VK_FILL_MODE_END_RANGE)
5471 {
5472 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5473 "vkCreateGraphicsPipelineDerivative parameter, VkFillMode pCreateInfo->pRsState->fillMode, is unrecognized enumerator");
5474 return;
5475 }
5476 if(pCreateInfo->pRsState->cullMode < VK_CULL_MODE_BEGIN_RANGE ||
5477 pCreateInfo->pRsState->cullMode > VK_CULL_MODE_END_RANGE)
5478 {
5479 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5480 "vkCreateGraphicsPipelineDerivative parameter, VkCullMode pCreateInfo->pRsState->cullMode, is unrecognized enumerator");
5481 return;
5482 }
5483 if(pCreateInfo->pRsState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
5484 pCreateInfo->pRsState->frontFace > VK_FRONT_FACE_END_RANGE)
5485 {
5486 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5487 "vkCreateGraphicsPipelineDerivative parameter, VkFrontFace pCreateInfo->pRsState->frontFace, is unrecognized enumerator");
5488 return;
5489 }
5490 if(pCreateInfo->pMsState == nullptr)
5491 {
5492 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5493 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineMsStateCreateInfo* pCreateInfo->pMsState, is null pointer");
5494 return;
5495 }
5496 if(pCreateInfo->pMsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5497 pCreateInfo->pMsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5498 {
5499 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5500 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pMsState->sType, is unrecognized enumerator");
5501 return;
5502 }
5503 if(pCreateInfo->pMsState->pNext == nullptr)
5504 {
5505 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5506 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pMsState->pNext, is null pointer");
5507 return;
5508 }
5509 if(pCreateInfo->pDsState == nullptr)
5510 {
5511 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5512 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineDsStateCreateInfo* pCreateInfo->pDsState, is null pointer");
5513 return;
5514 }
5515 if(pCreateInfo->pDsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5516 pCreateInfo->pDsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5517 {
5518 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5519 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pDsState->sType, is unrecognized enumerator");
5520 return;
5521 }
5522 if(pCreateInfo->pDsState->pNext == nullptr)
5523 {
5524 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5525 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pDsState->pNext, is null pointer");
5526 return;
5527 }
5528 if(pCreateInfo->pDsState->format < VK_FORMAT_BEGIN_RANGE ||
5529 pCreateInfo->pDsState->format > VK_FORMAT_END_RANGE)
5530 {
5531 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5532 "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pDsState->format, is unrecognized enumerator");
5533 return;
5534 }
5535 if(pCreateInfo->pDsState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5536 pCreateInfo->pDsState->depthCompareOp > VK_COMPARE_OP_END_RANGE)
5537 {
5538 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5539 "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->depthCompareOp, is unrecognized enumerator");
5540 return;
5541 }
5542 if(pCreateInfo->pDsState->front.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5543 pCreateInfo->pDsState->front.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5544 {
5545 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5546 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilFailOp, is unrecognized enumerator");
5547 return;
5548 }
5549 if(pCreateInfo->pDsState->front.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5550 pCreateInfo->pDsState->front.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5551 {
5552 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5553 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilPassOp, is unrecognized enumerator");
5554 return;
5555 }
5556 if(pCreateInfo->pDsState->front.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5557 pCreateInfo->pDsState->front.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5558 {
5559 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5560 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilDepthFailOp, is unrecognized enumerator");
5561 return;
5562 }
5563 if(pCreateInfo->pDsState->front.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5564 pCreateInfo->pDsState->front.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5565 {
5566 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5567 "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->front.stencilCompareOp, is unrecognized enumerator");
5568 return;
5569 }
5570 if(pCreateInfo->pDsState->back.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5571 pCreateInfo->pDsState->back.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5572 {
5573 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5574 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilFailOp, is unrecognized enumerator");
5575 return;
5576 }
5577 if(pCreateInfo->pDsState->back.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5578 pCreateInfo->pDsState->back.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5579 {
5580 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5581 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilPassOp, is unrecognized enumerator");
5582 return;
5583 }
5584 if(pCreateInfo->pDsState->back.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5585 pCreateInfo->pDsState->back.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5586 {
5587 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5588 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilDepthFailOp, is unrecognized enumerator");
5589 return;
5590 }
5591 if(pCreateInfo->pDsState->back.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5592 pCreateInfo->pDsState->back.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5593 {
5594 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5595 "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->back.stencilCompareOp, is unrecognized enumerator");
5596 return;
5597 }
5598 if(pCreateInfo->pCbState == nullptr)
5599 {
5600 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5601 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineCbStateCreateInfo* pCreateInfo->pCbState, is null pointer");
5602 return;
5603 }
5604 if(pCreateInfo->pCbState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5605 pCreateInfo->pCbState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5606 {
5607 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5608 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pCbState->sType, is unrecognized enumerator");
5609 return;
5610 }
5611 if(pCreateInfo->pCbState->pNext == nullptr)
5612 {
5613 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5614 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pCbState->pNext, is null pointer");
5615 return;
5616 }
5617 if(pCreateInfo->pCbState->logicOp < VK_LOGIC_OP_BEGIN_RANGE ||
5618 pCreateInfo->pCbState->logicOp > VK_LOGIC_OP_END_RANGE)
5619 {
5620 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5621 "vkCreateGraphicsPipelineDerivative parameter, VkLogicOp pCreateInfo->pCbState->logicOp, is unrecognized enumerator");
5622 return;
5623 }
5624 if(pCreateInfo->pCbState->pAttachments == nullptr)
5625 {
5626 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5627 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineCbAttachmentState* pCreateInfo->pCbState->pAttachments, is null pointer");
5628 return;
5629 }
5630 if(pCreateInfo->pCbState->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
5631 pCreateInfo->pCbState->pAttachments->format > VK_FORMAT_END_RANGE)
5632 {
5633 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5634 "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pCbState->pAttachments->format, is unrecognized enumerator");
5635 return;
5636 }
5637 if(pCreateInfo->pCbState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE ||
5638 pCreateInfo->pCbState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE)
5639 {
5640 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5641 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendColor, is unrecognized enumerator");
5642 return;
5643 }
5644 if(pCreateInfo->pCbState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE ||
5645 pCreateInfo->pCbState->pAttachments->destBlendColor > VK_BLEND_END_RANGE)
5646 {
5647 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5648 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendColor, is unrecognized enumerator");
5649 return;
5650 }
5651 if(pCreateInfo->pCbState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
5652 pCreateInfo->pCbState->pAttachments->blendOpColor > VK_BLEND_OP_END_RANGE)
5653 {
5654 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5655 "vkCreateGraphicsPipelineDerivative parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpColor, is unrecognized enumerator");
5656 return;
5657 }
5658 if(pCreateInfo->pCbState->pAttachments->srcBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5659 pCreateInfo->pCbState->pAttachments->srcBlendAlpha > VK_BLEND_END_RANGE)
5660 {
5661 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5662 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendAlpha, is unrecognized enumerator");
5663 return;
5664 }
5665 if(pCreateInfo->pCbState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5666 pCreateInfo->pCbState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE)
5667 {
5668 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5669 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendAlpha, is unrecognized enumerator");
5670 return;
5671 }
5672 if(pCreateInfo->pCbState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
5673 pCreateInfo->pCbState->pAttachments->blendOpAlpha > VK_BLEND_OP_END_RANGE)
5674 {
5675 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5676 "vkCreateGraphicsPipelineDerivative parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpAlpha, is unrecognized enumerator");
5677 return;
5678 }
5679 if(!ValidateEnumerator((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask))
5680 {
5681 std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkChannelFlags pCreateInfo->pCbState->pAttachments->channelWriteMask, is " + EnumeratorString((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask);
5682 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5683 return;
5684 }
5685 if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags))
5686 {
5687 std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags);
5688 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5689 return;
5690 }
5691 if(pCreateInfo->layout == nullptr)
5692 {
5693 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5694 "vkCreateGraphicsPipelineDerivative parameter, VkPipelineLayout pCreateInfo->layout, is null pointer");
5695 return;
5696 }
5697}
5698
5699void PostCreateGraphicsPipelineDerivative(
5700 VkDevice device,
5701 VkPipeline basePipeline,
5702 VkPipeline* pPipeline,
5703 VkResult result)
5704{
5705 if(device == nullptr)
5706 {
5707 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5708 "vkCreateGraphicsPipelineDerivative parameter, VkDevice device, is null pointer");
5709 return;
5710 }
5711
5712 if(basePipeline == nullptr)
5713 {
5714 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5715 "vkCreateGraphicsPipelineDerivative parameter, VkPipeline basePipeline, is null pointer");
5716 return;
5717 }
5718
5719 if(pPipeline == nullptr)
5720 {
5721 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5722 "vkCreateGraphicsPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
5723 return;
5724 }
5725 if((*pPipeline) == nullptr)
5726 {
5727 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5728 "vkCreateGraphicsPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
5729 return;
5730 }
5731
5732 if(result != VK_SUCCESS)
5733 {
5734 std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkResult result, is " + EnumeratorString(result);
5735 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5736 return;
5737 }
5738}
5739
5740VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(
5741 VkDevice device,
5742 const VkGraphicsPipelineCreateInfo* pCreateInfo,
5743 VkPipeline basePipeline,
5744 VkPipeline* pPipeline)
5745{
5746 PreCreateGraphicsPipelineDerivative(device, pCreateInfo);
5747 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
5748
5749 PostCreateGraphicsPipelineDerivative(device, basePipeline, pPipeline, result);
5750
5751 return result;
5752}
5753
5754void PreCreateComputePipeline(
5755 VkDevice device,
5756 const VkComputePipelineCreateInfo* pCreateInfo)
5757{
5758 if(device == nullptr)
5759 {
5760 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5761 "vkCreateComputePipeline parameter, VkDevice device, is null pointer");
5762 return;
5763 }
5764
5765 if(pCreateInfo == nullptr)
5766 {
5767 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5768 "vkCreateComputePipeline parameter, const VkComputePipelineCreateInfo* pCreateInfo, is null pointer");
5769 return;
5770 }
5771 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5772 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
5773 {
5774 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5775 "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
5776 return;
5777 }
5778 if(pCreateInfo->cs.sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5779 pCreateInfo->cs.sType > VK_STRUCTURE_TYPE_END_RANGE)
5780 {
5781 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5782 "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->cs.sType, is unrecognized enumerator");
5783 return;
5784 }
5785 if(pCreateInfo->cs.pNext == nullptr)
5786 {
5787 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5788 "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pNext, is null pointer");
5789 return;
5790 }
5791 if(pCreateInfo->cs.stage < VK_SHADER_STAGE_BEGIN_RANGE ||
5792 pCreateInfo->cs.stage > VK_SHADER_STAGE_END_RANGE)
5793 {
5794 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5795 "vkCreateComputePipeline parameter, VkShaderStage pCreateInfo->cs.stage, is unrecognized enumerator");
5796 return;
5797 }
5798 if(pCreateInfo->cs.shader == nullptr)
5799 {
5800 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5801 "vkCreateComputePipeline parameter, VkShader pCreateInfo->cs.shader, is null pointer");
5802 return;
5803 }
5804 if(pCreateInfo->cs.pLinkConstBufferInfo == nullptr)
5805 {
5806 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5807 "vkCreateComputePipeline parameter, const VkLinkConstBuffer* pCreateInfo->cs.pLinkConstBufferInfo, is null pointer");
5808 return;
5809 }
5810 if(pCreateInfo->cs.pLinkConstBufferInfo->pBufferData == nullptr)
5811 {
5812 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5813 "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pLinkConstBufferInfo->pBufferData, is null pointer");
5814 return;
5815 }
5816 if(pCreateInfo->cs.pSpecializationInfo == nullptr)
5817 {
5818 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5819 "vkCreateComputePipeline parameter, const VkSpecializationInfo* pCreateInfo->cs.pSpecializationInfo, is null pointer");
5820 return;
5821 }
5822 if(pCreateInfo->cs.pSpecializationInfo->pMap == nullptr)
5823 {
5824 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5825 "vkCreateComputePipeline parameter, const VkSpecializationMapEntry* pCreateInfo->cs.pSpecializationInfo->pMap, is null pointer");
5826 return;
5827 }
5828 if(pCreateInfo->cs.pSpecializationInfo->pData == nullptr)
5829 {
5830 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5831 "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pSpecializationInfo->pData, is null pointer");
5832 return;
5833 }
5834 if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags))
5835 {
5836 std::string reason = "vkCreateComputePipeline parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags);
5837 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5838 return;
5839 }
5840 if(pCreateInfo->layout == nullptr)
5841 {
5842 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5843 "vkCreateComputePipeline parameter, VkPipelineLayout pCreateInfo->layout, is null pointer");
5844 return;
5845 }
5846}
5847
5848void PostCreateComputePipeline(
5849 VkDevice device,
5850 VkPipeline* pPipeline,
5851 VkResult result)
5852{
5853 if(device == nullptr)
5854 {
5855 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5856 "vkCreateComputePipeline parameter, VkDevice device, is null pointer");
5857 return;
5858 }
5859
5860 if(pPipeline == nullptr)
5861 {
5862 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5863 "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer");
5864 return;
5865 }
5866 if((*pPipeline) == nullptr)
5867 {
5868 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5869 "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer");
5870 return;
5871 }
5872
5873 if(result != VK_SUCCESS)
5874 {
5875 std::string reason = "vkCreateComputePipeline parameter, VkResult result, is " + EnumeratorString(result);
5876 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5877 return;
5878 }
5879}
5880
5881VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(
5882 VkDevice device,
5883 const VkComputePipelineCreateInfo* pCreateInfo,
5884 VkPipeline* pPipeline)
5885{
5886 PreCreateComputePipeline(device, pCreateInfo);
5887 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipeline(device, pCreateInfo, pPipeline);
5888
5889 PostCreateComputePipeline(device, pPipeline, result);
5890
5891 return result;
5892}
5893
5894void PreStorePipeline(
5895 VkDevice device)
5896{
5897 if(device == nullptr)
5898 {
5899 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5900 "vkStorePipeline parameter, VkDevice device, is null pointer");
5901 return;
5902 }
5903}
5904
5905void PostStorePipeline(
5906 VkDevice device,
5907 VkPipeline pipeline,
5908 size_t* pDataSize,
5909 void* pData,
5910 VkResult result)
5911{
5912 if(device == nullptr)
5913 {
5914 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5915 "vkStorePipeline parameter, VkDevice device, is null pointer");
5916 return;
5917 }
5918
5919 if(pipeline == nullptr)
5920 {
5921 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5922 "vkStorePipeline parameter, VkPipeline pipeline, is null pointer");
5923 return;
5924 }
5925
5926 if(pDataSize == nullptr)
5927 {
5928 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5929 "vkStorePipeline parameter, size_t* pDataSize, is null pointer");
5930 return;
5931 }
5932
5933 if(pData == nullptr)
5934 {
5935 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5936 "vkStorePipeline parameter, void* pData, is null pointer");
5937 return;
5938 }
5939
5940 if(result != VK_SUCCESS)
5941 {
5942 std::string reason = "vkStorePipeline parameter, VkResult result, is " + EnumeratorString(result);
5943 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5944 return;
5945 }
5946}
5947
5948VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(
5949 VkDevice device,
5950 VkPipeline pipeline,
5951 size_t* pDataSize,
5952 void* pData)
5953{
5954 PreStorePipeline(device);
5955 VkResult result = get_dispatch_table(pc_device_table_map, device)->StorePipeline(device, pipeline, pDataSize, pData);
5956
5957 PostStorePipeline(device, pipeline, pDataSize, pData, result);
5958
5959 return result;
5960}
5961
5962void PreLoadPipeline(
5963 VkDevice device,
5964 const void* pData)
5965{
5966 if(device == nullptr)
5967 {
5968 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5969 "vkLoadPipeline parameter, VkDevice device, is null pointer");
5970 return;
5971 }
5972
5973 if(pData == nullptr)
5974 {
5975 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5976 "vkLoadPipeline parameter, const void* pData, is null pointer");
5977 return;
5978 }
5979}
5980
5981void PostLoadPipeline(
5982 VkDevice device,
5983 size_t dataSize,
5984 VkPipeline* pPipeline,
5985 VkResult result)
5986{
5987 if(device == nullptr)
5988 {
5989 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5990 "vkLoadPipeline parameter, VkDevice device, is null pointer");
5991 return;
5992 }
5993
5994
5995 if(pPipeline == nullptr)
5996 {
5997 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5998 "vkLoadPipeline parameter, VkPipeline* pPipeline, is null pointer");
5999 return;
6000 }
6001 if((*pPipeline) == nullptr)
6002 {
6003 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6004 "vkLoadPipeline parameter, VkPipeline* pPipeline, is null pointer");
6005 return;
6006 }
6007
6008 if(result != VK_SUCCESS)
6009 {
6010 std::string reason = "vkLoadPipeline parameter, VkResult result, is " + EnumeratorString(result);
6011 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6012 return;
6013 }
6014}
6015
6016VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline(
6017 VkDevice device,
6018 size_t dataSize,
6019 const void* pData,
6020 VkPipeline* pPipeline)
6021{
6022 PreLoadPipeline(device, pData);
6023 VkResult result = get_dispatch_table(pc_device_table_map, device)->LoadPipeline(device, dataSize, pData, pPipeline);
6024
6025 PostLoadPipeline(device, dataSize, pPipeline, result);
6026
6027 return result;
6028}
6029
6030void PreLoadPipelineDerivative(
6031 VkDevice device,
6032 const void* pData)
6033{
6034 if(device == nullptr)
6035 {
6036 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6037 "vkLoadPipelineDerivative parameter, VkDevice device, is null pointer");
6038 return;
6039 }
6040
6041 if(pData == nullptr)
6042 {
6043 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6044 "vkLoadPipelineDerivative parameter, const void* pData, is null pointer");
6045 return;
6046 }
6047}
6048
6049void PostLoadPipelineDerivative(
6050 VkDevice device,
6051 size_t dataSize,
6052 VkPipeline basePipeline,
6053 VkPipeline* pPipeline,
6054 VkResult result)
6055{
6056 if(device == nullptr)
6057 {
6058 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6059 "vkLoadPipelineDerivative parameter, VkDevice device, is null pointer");
6060 return;
6061 }
6062
6063
6064 if(basePipeline == nullptr)
6065 {
6066 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6067 "vkLoadPipelineDerivative parameter, VkPipeline basePipeline, is null pointer");
6068 return;
6069 }
6070
6071 if(pPipeline == nullptr)
6072 {
6073 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6074 "vkLoadPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
6075 return;
6076 }
6077 if((*pPipeline) == nullptr)
6078 {
6079 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6080 "vkLoadPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
6081 return;
6082 }
6083
6084 if(result != VK_SUCCESS)
6085 {
6086 std::string reason = "vkLoadPipelineDerivative parameter, VkResult result, is " + EnumeratorString(result);
6087 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6088 return;
6089 }
6090}
6091
6092VK_LAYER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(
6093 VkDevice device,
6094 size_t dataSize,
6095 const void* pData,
6096 VkPipeline basePipeline,
6097 VkPipeline* pPipeline)
6098{
6099 PreLoadPipelineDerivative(device, pData);
6100 VkResult result = get_dispatch_table(pc_device_table_map, device)->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
6101
6102 PostLoadPipelineDerivative(device, dataSize, basePipeline, pPipeline, result);
6103
6104 return result;
6105}
6106
6107void PreCreatePipelineLayout(
6108 VkDevice device,
6109 const VkPipelineLayoutCreateInfo* pCreateInfo)
6110{
6111 if(device == nullptr)
6112 {
6113 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6114 "vkCreatePipelineLayout parameter, VkDevice device, is null pointer");
6115 return;
6116 }
6117
6118 if(pCreateInfo == nullptr)
6119 {
6120 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6121 "vkCreatePipelineLayout parameter, const VkPipelineLayoutCreateInfo* pCreateInfo, is null pointer");
6122 return;
6123 }
6124 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6125 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6126 {
6127 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6128 "vkCreatePipelineLayout parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6129 return;
6130 }
6131 if(pCreateInfo->pSetLayouts == nullptr)
6132 {
6133 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6134 "vkCreatePipelineLayout parameter, const VkDescriptorSetLayout* pCreateInfo->pSetLayouts, is null pointer");
6135 return;
6136 }
6137 if((*pCreateInfo->pSetLayouts) == nullptr)
6138 {
6139 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6140 "vkCreatePipelineLayout parameter, const VkDescriptorSetLayout* pCreateInfo->pSetLayouts, is null pointer");
6141 return;
6142 }
6143}
6144
6145void PostCreatePipelineLayout(
6146 VkDevice device,
6147 VkPipelineLayout* pPipelineLayout,
6148 VkResult result)
6149{
6150 if(device == nullptr)
6151 {
6152 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6153 "vkCreatePipelineLayout parameter, VkDevice device, is null pointer");
6154 return;
6155 }
6156
6157 if(pPipelineLayout == nullptr)
6158 {
6159 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6160 "vkCreatePipelineLayout parameter, VkPipelineLayout* pPipelineLayout, is null pointer");
6161 return;
6162 }
6163 if((*pPipelineLayout) == nullptr)
6164 {
6165 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6166 "vkCreatePipelineLayout parameter, VkPipelineLayout* pPipelineLayout, is null pointer");
6167 return;
6168 }
6169
6170 if(result != VK_SUCCESS)
6171 {
6172 std::string reason = "vkCreatePipelineLayout parameter, VkResult result, is " + EnumeratorString(result);
6173 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6174 return;
6175 }
6176}
6177
6178VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
6179 VkDevice device,
6180 const VkPipelineLayoutCreateInfo* pCreateInfo,
6181 VkPipelineLayout* pPipelineLayout)
6182{
6183 PreCreatePipelineLayout(device, pCreateInfo);
6184 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
6185
6186 PostCreatePipelineLayout(device, pPipelineLayout, result);
6187
6188 return result;
6189}
6190
6191void PreCreateSampler(
6192 VkDevice device,
6193 const VkSamplerCreateInfo* pCreateInfo)
6194{
6195 if(device == nullptr)
6196 {
6197 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6198 "vkCreateSampler parameter, VkDevice device, is null pointer");
6199 return;
6200 }
6201
6202 if(pCreateInfo == nullptr)
6203 {
6204 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6205 "vkCreateSampler parameter, const VkSamplerCreateInfo* pCreateInfo, is null pointer");
6206 return;
6207 }
6208 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6209 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6210 {
6211 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6212 "vkCreateSampler parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6213 return;
6214 }
6215 if(pCreateInfo->magFilter < VK_TEX_FILTER_BEGIN_RANGE ||
6216 pCreateInfo->magFilter > VK_TEX_FILTER_END_RANGE)
6217 {
6218 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6219 "vkCreateSampler parameter, VkTexFilter pCreateInfo->magFilter, is unrecognized enumerator");
6220 return;
6221 }
6222 if(pCreateInfo->minFilter < VK_TEX_FILTER_BEGIN_RANGE ||
6223 pCreateInfo->minFilter > VK_TEX_FILTER_END_RANGE)
6224 {
6225 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6226 "vkCreateSampler parameter, VkTexFilter pCreateInfo->minFilter, is unrecognized enumerator");
6227 return;
6228 }
6229 if(pCreateInfo->mipMode < VK_TEX_MIPMAP_MODE_BEGIN_RANGE ||
6230 pCreateInfo->mipMode > VK_TEX_MIPMAP_MODE_END_RANGE)
6231 {
6232 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6233 "vkCreateSampler parameter, VkTexMipmapMode pCreateInfo->mipMode, is unrecognized enumerator");
6234 return;
6235 }
6236 if(pCreateInfo->addressU < VK_TEX_ADDRESS_BEGIN_RANGE ||
6237 pCreateInfo->addressU > VK_TEX_ADDRESS_END_RANGE)
6238 {
6239 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6240 "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressU, is unrecognized enumerator");
6241 return;
6242 }
6243 if(pCreateInfo->addressV < VK_TEX_ADDRESS_BEGIN_RANGE ||
6244 pCreateInfo->addressV > VK_TEX_ADDRESS_END_RANGE)
6245 {
6246 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6247 "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressV, is unrecognized enumerator");
6248 return;
6249 }
6250 if(pCreateInfo->addressW < VK_TEX_ADDRESS_BEGIN_RANGE ||
6251 pCreateInfo->addressW > VK_TEX_ADDRESS_END_RANGE)
6252 {
6253 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6254 "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressW, is unrecognized enumerator");
6255 return;
6256 }
6257 if(pCreateInfo->compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
6258 pCreateInfo->compareOp > VK_COMPARE_OP_END_RANGE)
6259 {
6260 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6261 "vkCreateSampler parameter, VkCompareOp pCreateInfo->compareOp, is unrecognized enumerator");
6262 return;
6263 }
6264 if(pCreateInfo->borderColor < VK_BORDER_COLOR_BEGIN_RANGE ||
6265 pCreateInfo->borderColor > VK_BORDER_COLOR_END_RANGE)
6266 {
6267 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6268 "vkCreateSampler parameter, VkBorderColor pCreateInfo->borderColor, is unrecognized enumerator");
6269 return;
6270 }
6271}
6272
6273void PostCreateSampler(
6274 VkDevice device,
6275 VkSampler* pSampler,
6276 VkResult result)
6277{
6278 if(device == nullptr)
6279 {
6280 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6281 "vkCreateSampler parameter, VkDevice device, is null pointer");
6282 return;
6283 }
6284
6285 if(pSampler == nullptr)
6286 {
6287 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6288 "vkCreateSampler parameter, VkSampler* pSampler, is null pointer");
6289 return;
6290 }
6291 if((*pSampler) == nullptr)
6292 {
6293 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6294 "vkCreateSampler parameter, VkSampler* pSampler, is null pointer");
6295 return;
6296 }
6297
6298 if(result != VK_SUCCESS)
6299 {
6300 std::string reason = "vkCreateSampler parameter, VkResult result, is " + EnumeratorString(result);
6301 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6302 return;
6303 }
6304}
6305
6306VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
6307 VkDevice device,
6308 const VkSamplerCreateInfo* pCreateInfo,
6309 VkSampler* pSampler)
6310{
6311 PreCreateSampler(device, pCreateInfo);
6312 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
6313
6314 PostCreateSampler(device, pSampler, result);
6315
6316 return result;
6317}
6318
6319void PreCreateDescriptorSetLayout(
6320 VkDevice device,
6321 const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
6322{
6323 if(device == nullptr)
6324 {
6325 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6326 "vkCreateDescriptorSetLayout parameter, VkDevice device, is null pointer");
6327 return;
6328 }
6329
6330 if(pCreateInfo == nullptr)
6331 {
6332 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6333 "vkCreateDescriptorSetLayout parameter, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, is null pointer");
6334 return;
6335 }
6336 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6337 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6338 {
6339 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6340 "vkCreateDescriptorSetLayout parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6341 return;
6342 }
6343 if(pCreateInfo->pBinding == nullptr)
6344 {
6345 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6346 "vkCreateDescriptorSetLayout parameter, const VkDescriptorSetLayoutBinding* pCreateInfo->pBinding, is null pointer");
6347 return;
6348 }
6349 if(pCreateInfo->pBinding->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
6350 pCreateInfo->pBinding->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
6351 {
6352 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6353 "vkCreateDescriptorSetLayout parameter, VkDescriptorType pCreateInfo->pBinding->descriptorType, is unrecognized enumerator");
6354 return;
6355 }
6356 if(!ValidateEnumerator((VkShaderStageFlagBits)pCreateInfo->pBinding->stageFlags))
6357 {
6358 std::string reason = "vkCreateDescriptorSetLayout parameter, VkShaderStageFlags pCreateInfo->pBinding->stageFlags, is " + EnumeratorString((VkShaderStageFlagBits)pCreateInfo->pBinding->stageFlags);
6359 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6360 return;
6361 }
6362 if(pCreateInfo->pBinding->pImmutableSamplers == nullptr)
6363 {
6364 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6365 "vkCreateDescriptorSetLayout parameter, const VkSampler* pCreateInfo->pBinding->pImmutableSamplers, is null pointer");
6366 return;
6367 }
6368 if((*pCreateInfo->pBinding->pImmutableSamplers) == nullptr)
6369 {
6370 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6371 "vkCreateDescriptorSetLayout parameter, const VkSampler* pCreateInfo->pBinding->pImmutableSamplers, is null pointer");
6372 return;
6373 }
6374}
6375
6376void PostCreateDescriptorSetLayout(
6377 VkDevice device,
6378 VkDescriptorSetLayout* pSetLayout,
6379 VkResult result)
6380{
6381 if(device == nullptr)
6382 {
6383 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6384 "vkCreateDescriptorSetLayout parameter, VkDevice device, is null pointer");
6385 return;
6386 }
6387
6388 if(pSetLayout == nullptr)
6389 {
6390 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6391 "vkCreateDescriptorSetLayout parameter, VkDescriptorSetLayout* pSetLayout, is null pointer");
6392 return;
6393 }
6394 if((*pSetLayout) == nullptr)
6395 {
6396 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6397 "vkCreateDescriptorSetLayout parameter, VkDescriptorSetLayout* pSetLayout, is null pointer");
6398 return;
6399 }
6400
6401 if(result != VK_SUCCESS)
6402 {
6403 std::string reason = "vkCreateDescriptorSetLayout parameter, VkResult result, is " + EnumeratorString(result);
6404 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6405 return;
6406 }
6407}
6408
6409VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
6410 VkDevice device,
6411 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
6412 VkDescriptorSetLayout* pSetLayout)
6413{
6414 PreCreateDescriptorSetLayout(device, pCreateInfo);
6415 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
6416
6417 PostCreateDescriptorSetLayout(device, pSetLayout, result);
6418
6419 return result;
6420}
6421
6422void PreCreateDescriptorPool(
6423 VkDevice device,
6424 const VkDescriptorPoolCreateInfo* pCreateInfo)
6425{
6426 if(device == nullptr)
6427 {
6428 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6429 "vkCreateDescriptorPool parameter, VkDevice device, is null pointer");
6430 return;
6431 }
6432
6433 if(pCreateInfo == nullptr)
6434 {
6435 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6436 "vkCreateDescriptorPool parameter, const VkDescriptorPoolCreateInfo* pCreateInfo, is null pointer");
6437 return;
6438 }
6439 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6440 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6441 {
6442 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6443 "vkCreateDescriptorPool parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6444 return;
6445 }
6446 if(pCreateInfo->pTypeCount == nullptr)
6447 {
6448 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6449 "vkCreateDescriptorPool parameter, const VkDescriptorTypeCount* pCreateInfo->pTypeCount, is null pointer");
6450 return;
6451 }
6452 if(pCreateInfo->pTypeCount->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
6453 pCreateInfo->pTypeCount->type > VK_DESCRIPTOR_TYPE_END_RANGE)
6454 {
6455 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6456 "vkCreateDescriptorPool parameter, VkDescriptorType pCreateInfo->pTypeCount->type, is unrecognized enumerator");
6457 return;
6458 }
6459}
6460
6461void PostCreateDescriptorPool(
6462 VkDevice device,
6463 VkDescriptorPoolUsage poolUsage,
6464 uint32_t maxSets,
6465 VkDescriptorPool* pDescriptorPool,
6466 VkResult result)
6467{
6468 if(device == nullptr)
6469 {
6470 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6471 "vkCreateDescriptorPool parameter, VkDevice device, is null pointer");
6472 return;
6473 }
6474
6475 if(poolUsage < VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE ||
6476 poolUsage > VK_DESCRIPTOR_POOL_USAGE_END_RANGE)
6477 {
6478 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6479 "vkCreateDescriptorPool parameter, VkDescriptorPoolUsage poolUsage, is unrecognized enumerator");
6480 return;
6481 }
6482
6483
6484 if(pDescriptorPool == nullptr)
6485 {
6486 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6487 "vkCreateDescriptorPool parameter, VkDescriptorPool* pDescriptorPool, is null pointer");
6488 return;
6489 }
6490 if((*pDescriptorPool) == nullptr)
6491 {
6492 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6493 "vkCreateDescriptorPool parameter, VkDescriptorPool* pDescriptorPool, is null pointer");
6494 return;
6495 }
6496
6497 if(result != VK_SUCCESS)
6498 {
6499 std::string reason = "vkCreateDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
6500 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6501 return;
6502 }
6503}
6504
6505VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
6506 VkDevice device,
6507 VkDescriptorPoolUsage poolUsage,
6508 uint32_t maxSets,
6509 const VkDescriptorPoolCreateInfo* pCreateInfo,
6510 VkDescriptorPool* pDescriptorPool)
6511{
6512 PreCreateDescriptorPool(device, pCreateInfo);
6513 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
6514
6515 PostCreateDescriptorPool(device, poolUsage, maxSets, pDescriptorPool, result);
6516
6517 return result;
6518}
6519
6520void PreResetDescriptorPool(
6521 VkDevice device)
6522{
6523 if(device == nullptr)
6524 {
6525 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6526 "vkResetDescriptorPool parameter, VkDevice device, is null pointer");
6527 return;
6528 }
6529}
6530
6531void PostResetDescriptorPool(
6532 VkDevice device,
6533 VkDescriptorPool descriptorPool,
6534 VkResult result)
6535{
6536 if(device == nullptr)
6537 {
6538 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6539 "vkResetDescriptorPool parameter, VkDevice device, is null pointer");
6540 return;
6541 }
6542
6543 if(descriptorPool == nullptr)
6544 {
6545 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6546 "vkResetDescriptorPool parameter, VkDescriptorPool descriptorPool, is null pointer");
6547 return;
6548 }
6549
6550 if(result != VK_SUCCESS)
6551 {
6552 std::string reason = "vkResetDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
6553 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6554 return;
6555 }
6556}
6557
6558VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(
6559 VkDevice device,
6560 VkDescriptorPool descriptorPool)
6561{
6562 PreResetDescriptorPool(device);
6563 VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetDescriptorPool(device, descriptorPool);
6564
6565 PostResetDescriptorPool(device, descriptorPool, result);
6566
6567 return result;
6568}
6569
6570void PreAllocDescriptorSets(
6571 VkDevice device,
6572 const VkDescriptorSetLayout* pSetLayouts)
6573{
6574 if(device == nullptr)
6575 {
6576 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6577 "vkAllocDescriptorSets parameter, VkDevice device, is null pointer");
6578 return;
6579 }
6580
6581 if(pSetLayouts == nullptr)
6582 {
6583 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6584 "vkAllocDescriptorSets parameter, const VkDescriptorSetLayout* pSetLayouts, is null pointer");
6585 return;
6586 }
6587 if((*pSetLayouts) == nullptr)
6588 {
6589 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6590 "vkAllocDescriptorSets parameter, const VkDescriptorSetLayout* pSetLayouts, is null pointer");
6591 return;
6592 }
6593}
6594
6595void PostAllocDescriptorSets(
6596 VkDevice device,
6597 VkDescriptorPool descriptorPool,
6598 VkDescriptorSetUsage setUsage,
6599 uint32_t count,
6600 VkDescriptorSet* pDescriptorSets,
6601 uint32_t* pCount,
6602 VkResult result)
6603{
6604 if(device == nullptr)
6605 {
6606 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6607 "vkAllocDescriptorSets parameter, VkDevice device, is null pointer");
6608 return;
6609 }
6610
6611 if(descriptorPool == nullptr)
6612 {
6613 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6614 "vkAllocDescriptorSets parameter, VkDescriptorPool descriptorPool, is null pointer");
6615 return;
6616 }
6617
6618 if(setUsage < VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE ||
6619 setUsage > VK_DESCRIPTOR_SET_USAGE_END_RANGE)
6620 {
6621 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6622 "vkAllocDescriptorSets parameter, VkDescriptorSetUsage setUsage, is unrecognized enumerator");
6623 return;
6624 }
6625
6626
6627 if(pDescriptorSets == nullptr)
6628 {
6629 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6630 "vkAllocDescriptorSets parameter, VkDescriptorSet* pDescriptorSets, is null pointer");
6631 return;
6632 }
6633 if((*pDescriptorSets) == nullptr)
6634 {
6635 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6636 "vkAllocDescriptorSets parameter, VkDescriptorSet* pDescriptorSets, is null pointer");
6637 return;
6638 }
6639
6640 if(pCount == nullptr)
6641 {
6642 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6643 "vkAllocDescriptorSets parameter, uint32_t* pCount, is null pointer");
6644 return;
6645 }
6646
6647 if(result != VK_SUCCESS)
6648 {
6649 std::string reason = "vkAllocDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
6650 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6651 return;
6652 }
6653}
6654
6655VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(
6656 VkDevice device,
6657 VkDescriptorPool descriptorPool,
6658 VkDescriptorSetUsage setUsage,
6659 uint32_t count,
6660 const VkDescriptorSetLayout* pSetLayouts,
6661 VkDescriptorSet* pDescriptorSets,
6662 uint32_t* pCount)
6663{
6664 PreAllocDescriptorSets(device, pSetLayouts);
6665 VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
6666
6667 PostAllocDescriptorSets(device, descriptorPool, setUsage, count, pDescriptorSets, pCount, result);
6668
6669 return result;
6670}
6671
6672void PreUpdateDescriptorSets(
6673 VkDevice device,
6674 const VkWriteDescriptorSet* pDescriptorWrites,
6675 const VkCopyDescriptorSet* pDescriptorCopies)
6676{
6677 if(device == nullptr)
6678 {
6679 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6680 "vkUpdateDescriptorSets parameter, VkDevice device, is null pointer");
6681 return;
6682 }
6683
6684 if(pDescriptorWrites == nullptr)
6685 {
6686 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6687 "vkUpdateDescriptorSets parameter, const VkWriteDescriptorSet* pDescriptorWrites, is null pointer");
6688 return;
6689 }
6690 if(pDescriptorWrites->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6691 pDescriptorWrites->sType > VK_STRUCTURE_TYPE_END_RANGE)
6692 {
6693 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6694 "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorWrites->sType, is unrecognized enumerator");
6695 return;
6696 }
6697 if(pDescriptorWrites->pNext == nullptr)
6698 {
6699 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6700 "vkUpdateDescriptorSets parameter, const void* pDescriptorWrites->pNext, is null pointer");
6701 return;
6702 }
6703 if(pDescriptorWrites->destSet == nullptr)
6704 {
6705 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6706 "vkUpdateDescriptorSets parameter, VkDescriptorSet pDescriptorWrites->destSet, is null pointer");
6707 return;
6708 }
6709 if(pDescriptorWrites->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
6710 pDescriptorWrites->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
6711 {
6712 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6713 "vkUpdateDescriptorSets parameter, VkDescriptorType pDescriptorWrites->descriptorType, is unrecognized enumerator");
6714 return;
6715 }
6716 if(pDescriptorWrites->pDescriptors == nullptr)
6717 {
6718 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6719 "vkUpdateDescriptorSets parameter, const VkDescriptorInfo* pDescriptorWrites->pDescriptors, is null pointer");
6720 return;
6721 }
6722 if(pDescriptorWrites->pDescriptors->bufferView == nullptr)
6723 {
6724 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6725 "vkUpdateDescriptorSets parameter, VkBufferView pDescriptorWrites->pDescriptors->bufferView, is null pointer");
6726 return;
6727 }
6728 if(pDescriptorWrites->pDescriptors->sampler == nullptr)
6729 {
6730 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6731 "vkUpdateDescriptorSets parameter, VkSampler pDescriptorWrites->pDescriptors->sampler, is null pointer");
6732 return;
6733 }
6734 if(pDescriptorWrites->pDescriptors->imageView == nullptr)
6735 {
6736 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6737 "vkUpdateDescriptorSets parameter, VkImageView pDescriptorWrites->pDescriptors->imageView, is null pointer");
6738 return;
6739 }
6740 if(pDescriptorWrites->pDescriptors->imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
6741 pDescriptorWrites->pDescriptors->imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
6742 {
6743 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6744 "vkUpdateDescriptorSets parameter, VkImageLayout pDescriptorWrites->pDescriptors->imageLayout, is unrecognized enumerator");
6745 return;
6746 }
6747
6748 if(pDescriptorCopies == nullptr)
6749 {
6750 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6751 "vkUpdateDescriptorSets parameter, const VkCopyDescriptorSet* pDescriptorCopies, is null pointer");
6752 return;
6753 }
6754 if(pDescriptorCopies->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6755 pDescriptorCopies->sType > VK_STRUCTURE_TYPE_END_RANGE)
6756 {
6757 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6758 "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorCopies->sType, is unrecognized enumerator");
6759 return;
6760 }
6761 if(pDescriptorCopies->pNext == nullptr)
6762 {
6763 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6764 "vkUpdateDescriptorSets parameter, const void* pDescriptorCopies->pNext, is null pointer");
6765 return;
6766 }
6767 if(pDescriptorCopies->srcSet == nullptr)
6768 {
6769 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6770 "vkUpdateDescriptorSets parameter, VkDescriptorSet pDescriptorCopies->srcSet, is null pointer");
6771 return;
6772 }
6773 if(pDescriptorCopies->destSet == nullptr)
6774 {
6775 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6776 "vkUpdateDescriptorSets parameter, VkDescriptorSet pDescriptorCopies->destSet, is null pointer");
6777 return;
6778 }
6779}
6780
6781void PostUpdateDescriptorSets(
6782 VkDevice device,
6783 uint32_t writeCount,
6784 uint32_t copyCount,
6785 VkResult result)
6786{
6787 if(device == nullptr)
6788 {
6789 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6790 "vkUpdateDescriptorSets parameter, VkDevice device, is null pointer");
6791 return;
6792 }
6793
6794
6795
6796 if(result != VK_SUCCESS)
6797 {
6798 std::string reason = "vkUpdateDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
6799 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6800 return;
6801 }
6802}
6803
6804VK_LAYER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(
6805 VkDevice device,
6806 uint32_t writeCount,
6807 const VkWriteDescriptorSet* pDescriptorWrites,
6808 uint32_t copyCount,
6809 const VkCopyDescriptorSet* pDescriptorCopies)
6810{
6811 PreUpdateDescriptorSets(device, pDescriptorWrites, pDescriptorCopies);
6812 VkResult result = get_dispatch_table(pc_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
6813
6814 PostUpdateDescriptorSets(device, writeCount, copyCount, result);
6815
6816 return result;
6817}
6818
6819void PreCreateDynamicViewportState(
6820 VkDevice device,
6821 const VkDynamicVpStateCreateInfo* pCreateInfo)
6822{
6823 if(device == nullptr)
6824 {
6825 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6826 "vkCreateDynamicViewportState parameter, VkDevice device, is null pointer");
6827 return;
6828 }
6829
6830 if(pCreateInfo == nullptr)
6831 {
6832 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6833 "vkCreateDynamicViewportState parameter, const VkDynamicVpStateCreateInfo* pCreateInfo, is null pointer");
6834 return;
6835 }
6836 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6837 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6838 {
6839 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6840 "vkCreateDynamicViewportState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6841 return;
6842 }
6843 if(pCreateInfo->pViewports == nullptr)
6844 {
6845 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6846 "vkCreateDynamicViewportState parameter, const VkViewport* pCreateInfo->pViewports, is null pointer");
6847 return;
6848 }
6849 if(pCreateInfo->pScissors == nullptr)
6850 {
6851 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6852 "vkCreateDynamicViewportState parameter, const VkRect* pCreateInfo->pScissors, is null pointer");
6853 return;
6854 }
6855}
6856
6857void PostCreateDynamicViewportState(
6858 VkDevice device,
6859 VkDynamicVpState* pState,
6860 VkResult result)
6861{
6862 if(device == nullptr)
6863 {
6864 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6865 "vkCreateDynamicViewportState parameter, VkDevice device, is null pointer");
6866 return;
6867 }
6868
6869 if(pState == nullptr)
6870 {
6871 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6872 "vkCreateDynamicViewportState parameter, VkDynamicVpState* pState, is null pointer");
6873 return;
6874 }
6875 if((*pState) == nullptr)
6876 {
6877 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6878 "vkCreateDynamicViewportState parameter, VkDynamicVpState* pState, is null pointer");
6879 return;
6880 }
6881
6882 if(result != VK_SUCCESS)
6883 {
6884 std::string reason = "vkCreateDynamicViewportState parameter, VkResult result, is " + EnumeratorString(result);
6885 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6886 return;
6887 }
6888}
6889
6890VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(
6891 VkDevice device,
6892 const VkDynamicVpStateCreateInfo* pCreateInfo,
6893 VkDynamicVpState* pState)
6894{
6895 PreCreateDynamicViewportState(device, pCreateInfo);
6896 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicViewportState(device, pCreateInfo, pState);
6897
6898 PostCreateDynamicViewportState(device, pState, result);
6899
6900 return result;
6901}
6902
6903void PreCreateDynamicRasterState(
6904 VkDevice device,
6905 const VkDynamicRsStateCreateInfo* pCreateInfo)
6906{
6907 if(device == nullptr)
6908 {
6909 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6910 "vkCreateDynamicRasterState parameter, VkDevice device, is null pointer");
6911 return;
6912 }
6913
6914 if(pCreateInfo == nullptr)
6915 {
6916 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6917 "vkCreateDynamicRasterState parameter, const VkDynamicRsStateCreateInfo* pCreateInfo, is null pointer");
6918 return;
6919 }
6920 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6921 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6922 {
6923 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6924 "vkCreateDynamicRasterState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6925 return;
6926 }
6927}
6928
6929void PostCreateDynamicRasterState(
6930 VkDevice device,
6931 VkDynamicRsState* pState,
6932 VkResult result)
6933{
6934 if(device == nullptr)
6935 {
6936 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6937 "vkCreateDynamicRasterState parameter, VkDevice device, is null pointer");
6938 return;
6939 }
6940
6941 if(pState == nullptr)
6942 {
6943 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6944 "vkCreateDynamicRasterState parameter, VkDynamicRsState* pState, is null pointer");
6945 return;
6946 }
6947 if((*pState) == nullptr)
6948 {
6949 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6950 "vkCreateDynamicRasterState parameter, VkDynamicRsState* pState, is null pointer");
6951 return;
6952 }
6953
6954 if(result != VK_SUCCESS)
6955 {
6956 std::string reason = "vkCreateDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result);
6957 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6958 return;
6959 }
6960}
6961
6962VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
6963 VkDevice device,
6964 const VkDynamicRsStateCreateInfo* pCreateInfo,
6965 VkDynamicRsState* pState)
6966{
6967 PreCreateDynamicRasterState(device, pCreateInfo);
6968 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
6969
6970 PostCreateDynamicRasterState(device, pState, result);
6971
6972 return result;
6973}
6974
6975void PreCreateDynamicColorBlendState(
6976 VkDevice device,
6977 const VkDynamicCbStateCreateInfo* pCreateInfo)
6978{
6979 if(device == nullptr)
6980 {
6981 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6982 "vkCreateDynamicColorBlendState parameter, VkDevice device, is null pointer");
6983 return;
6984 }
6985
6986 if(pCreateInfo == nullptr)
6987 {
6988 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6989 "vkCreateDynamicColorBlendState parameter, const VkDynamicCbStateCreateInfo* pCreateInfo, is null pointer");
6990 return;
6991 }
6992 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6993 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6994 {
6995 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6996 "vkCreateDynamicColorBlendState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6997 return;
6998 }
6999}
7000
7001void PostCreateDynamicColorBlendState(
7002 VkDevice device,
7003 VkDynamicCbState* pState,
7004 VkResult result)
7005{
7006 if(device == nullptr)
7007 {
7008 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7009 "vkCreateDynamicColorBlendState parameter, VkDevice device, is null pointer");
7010 return;
7011 }
7012
7013 if(pState == nullptr)
7014 {
7015 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7016 "vkCreateDynamicColorBlendState parameter, VkDynamicCbState* pState, is null pointer");
7017 return;
7018 }
7019 if((*pState) == nullptr)
7020 {
7021 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7022 "vkCreateDynamicColorBlendState parameter, VkDynamicCbState* pState, is null pointer");
7023 return;
7024 }
7025
7026 if(result != VK_SUCCESS)
7027 {
7028 std::string reason = "vkCreateDynamicColorBlendState parameter, VkResult result, is " + EnumeratorString(result);
7029 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7030 return;
7031 }
7032}
7033
7034VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(
7035 VkDevice device,
7036 const VkDynamicCbStateCreateInfo* pCreateInfo,
7037 VkDynamicCbState* pState)
7038{
7039 PreCreateDynamicColorBlendState(device, pCreateInfo);
7040 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
7041
7042 PostCreateDynamicColorBlendState(device, pState, result);
7043
7044 return result;
7045}
7046
7047void PreCreateDynamicDepthStencilState(
7048 VkDevice device,
7049 const VkDynamicDsStateCreateInfo* pCreateInfo)
7050{
7051 if(device == nullptr)
7052 {
7053 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7054 "vkCreateDynamicDepthStencilState parameter, VkDevice device, is null pointer");
7055 return;
7056 }
7057
7058 if(pCreateInfo == nullptr)
7059 {
7060 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7061 "vkCreateDynamicDepthStencilState parameter, const VkDynamicDsStateCreateInfo* pCreateInfo, is null pointer");
7062 return;
7063 }
7064 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
7065 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
7066 {
7067 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7068 "vkCreateDynamicDepthStencilState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
7069 return;
7070 }
7071}
7072
7073void PostCreateDynamicDepthStencilState(
7074 VkDevice device,
7075 VkDynamicDsState* pState,
7076 VkResult result)
7077{
7078 if(device == nullptr)
7079 {
7080 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7081 "vkCreateDynamicDepthStencilState parameter, VkDevice device, is null pointer");
7082 return;
7083 }
7084
7085 if(pState == nullptr)
7086 {
7087 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7088 "vkCreateDynamicDepthStencilState parameter, VkDynamicDsState* pState, is null pointer");
7089 return;
7090 }
7091 if((*pState) == nullptr)
7092 {
7093 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7094 "vkCreateDynamicDepthStencilState parameter, VkDynamicDsState* pState, is null pointer");
7095 return;
7096 }
7097
7098 if(result != VK_SUCCESS)
7099 {
7100 std::string reason = "vkCreateDynamicDepthStencilState parameter, VkResult result, is " + EnumeratorString(result);
7101 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7102 return;
7103 }
7104}
7105
7106VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(
7107 VkDevice device,
7108 const VkDynamicDsStateCreateInfo* pCreateInfo,
7109 VkDynamicDsState* pState)
7110{
7111 PreCreateDynamicDepthStencilState(device, pCreateInfo);
7112 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
7113
7114 PostCreateDynamicDepthStencilState(device, pState, result);
7115
7116 return result;
7117}
7118
7119void PreCreateCommandBuffer(
7120 VkDevice device,
7121 const VkCmdBufferCreateInfo* pCreateInfo,
7122 VkCmdBuffer* pCmdBuffer)
7123{
7124 if(device == nullptr)
7125 {
7126 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7127 "vkCreateCommandBuffer parameter, VkDevice device, is null pointer");
7128 return;
7129 }
7130
7131 if(pCreateInfo == nullptr)
7132 {
7133 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7134 "vkCreateCommandBuffer parameter, const VkCmdBufferCreateInfo* pCreateInfo, is null pointer");
7135 return;
7136 }
7137 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
7138 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
7139 {
7140 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7141 "vkCreateCommandBuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7142 return;
7143 }
7144
7145 if(pCmdBuffer == nullptr)
7146 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7147 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7148 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
7149 return;
7150 }
7151 if((*pCmdBuffer) == nullptr)
7152 {
7153 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7154 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7155 return;
7156 }
7157}
7158
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7159void PostCreateCommandBuffer(
7160 VkDevice device,
7161 VkCmdBuffer* pCmdBuffer,
7162 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7163{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7164 if(device == nullptr)
7165 {
7166 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7167 "vkCreateCommandBuffer parameter, VkDevice device, is null pointer");
7168 return;
7169 }
7170
7171 if(pCmdBuffer == nullptr)
7172 {
7173 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7174 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
7175 return;
7176 }
7177 if((*pCmdBuffer) == nullptr)
7178 {
7179 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7180 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
7181 return;
7182 }
7183
7184 if(result != VK_SUCCESS)
7185 {
7186 std::string reason = "vkCreateCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7187 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7188 return;
7189 }
7190}
7191
7192VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(
7193 VkDevice device,
7194 const VkCmdBufferCreateInfo* pCreateInfo,
7195 VkCmdBuffer* pCmdBuffer)
7196{
7197 PreCreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
7198 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
7199
7200 PostCreateCommandBuffer(device, pCmdBuffer, result);
7201
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7202 return result;
7203}
7204
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7205void PreBeginCommandBuffer(
7206 VkCmdBuffer cmdBuffer,
7207 const VkCmdBufferBeginInfo* pBeginInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7208{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7209 if(cmdBuffer == nullptr)
7210 {
7211 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7212 "vkBeginCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7213 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7214 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7215
7216 if(pBeginInfo == nullptr)
7217 {
7218 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7219 "vkBeginCommandBuffer parameter, const VkCmdBufferBeginInfo* pBeginInfo, is null pointer");
7220 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7221 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7222 if(pBeginInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
7223 pBeginInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
7224 {
7225 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7226 "vkBeginCommandBuffer parameter, VkStructureType pBeginInfo->sType, is unrecognized enumerator");
7227 return;
7228 }
7229 if(!ValidateEnumerator((VkCmdBufferOptimizeFlagBits)pBeginInfo->flags))
7230 {
7231 std::string reason = "vkBeginCommandBuffer parameter, VkCmdBufferOptimizeFlags pBeginInfo->flags, is " + EnumeratorString((VkCmdBufferOptimizeFlagBits)pBeginInfo->flags);
7232 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7233 return;
7234 }
7235}
7236
7237void PostBeginCommandBuffer(
7238 VkCmdBuffer cmdBuffer,
7239 VkResult result)
7240{
7241 if(cmdBuffer == nullptr)
7242 {
7243 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7244 "vkBeginCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7245 return;
7246 }
7247
7248 if(result != VK_SUCCESS)
7249 {
7250 std::string reason = "vkBeginCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7251 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7252 return;
7253 }
7254}
7255
7256VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
7257 VkCmdBuffer cmdBuffer,
7258 const VkCmdBufferBeginInfo* pBeginInfo)
7259{
7260 PreBeginCommandBuffer(cmdBuffer, pBeginInfo);
7261 VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
7262
7263 PostBeginCommandBuffer(cmdBuffer, result);
7264
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7265 return result;
7266}
7267
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7268void PreEndCommandBuffer(
7269 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7270{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7271 if(cmdBuffer == nullptr)
7272 {
7273 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7274 "vkEndCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7275 return;
7276 }
7277}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7278
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7279void PostEndCommandBuffer(
7280 VkCmdBuffer cmdBuffer,
7281 VkResult result)
7282{
7283 if(cmdBuffer == nullptr)
7284 {
7285 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7286 "vkEndCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7287 return;
7288 }
7289
7290 if(result != VK_SUCCESS)
7291 {
7292 std::string reason = "vkEndCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7293 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7294 return;
7295 }
7296}
7297
7298VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
7299 VkCmdBuffer cmdBuffer)
7300{
7301 PreEndCommandBuffer(cmdBuffer);
7302 VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
7303
7304 PostEndCommandBuffer(cmdBuffer, result);
7305
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7306 return result;
7307}
7308
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7309void PreResetCommandBuffer(
7310 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7311{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7312 if(cmdBuffer == nullptr)
7313 {
7314 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7315 "vkResetCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7316 return;
7317 }
7318}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7319
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7320void PostResetCommandBuffer(
7321 VkCmdBuffer cmdBuffer,
7322 VkResult result)
7323{
7324 if(cmdBuffer == nullptr)
7325 {
7326 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7327 "vkResetCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7328 return;
7329 }
7330
7331 if(result != VK_SUCCESS)
7332 {
7333 std::string reason = "vkResetCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7334 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7335 return;
7336 }
7337}
7338
7339VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
7340 VkCmdBuffer cmdBuffer)
7341{
7342 PreResetCommandBuffer(cmdBuffer);
7343 VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer);
7344
7345 PostResetCommandBuffer(cmdBuffer, result);
7346
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7347 return result;
7348}
7349
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7350void PreCmdBindPipeline(
7351 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7352{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7353 if(cmdBuffer == nullptr)
7354 {
7355 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7356 "vkCmdBindPipeline parameter, VkCmdBuffer cmdBuffer, is null pointer");
7357 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7358 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7359}
7360
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7361void PostCmdBindPipeline(
7362 VkCmdBuffer cmdBuffer,
7363 VkPipelineBindPoint pipelineBindPoint,
7364 VkPipeline pipeline)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7365{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7366 if(cmdBuffer == nullptr)
7367 {
7368 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7369 "vkCmdBindPipeline parameter, VkCmdBuffer cmdBuffer, is null pointer");
7370 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7371 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7372
7373 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
7374 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
7375 {
7376 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7377 "vkCmdBindPipeline parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
7378 return;
7379 }
7380
7381 if(pipeline == nullptr)
7382 {
7383 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7384 "vkCmdBindPipeline parameter, VkPipeline pipeline, is null pointer");
7385 return;
7386 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7387}
7388
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7389VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
7390 VkCmdBuffer cmdBuffer,
7391 VkPipelineBindPoint pipelineBindPoint,
7392 VkPipeline pipeline)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7393{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7394 PreCmdBindPipeline(cmdBuffer);
7395 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
7396
7397 PostCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
7398}
7399
7400void PreCmdBindDynamicStateObject(
7401 VkCmdBuffer cmdBuffer)
7402{
7403 if(cmdBuffer == nullptr)
7404 {
7405 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7406 "vkCmdBindDynamicStateObject parameter, VkCmdBuffer cmdBuffer, is null pointer");
7407 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7408 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7409}
7410
7411void PostCmdBindDynamicStateObject(
7412 VkCmdBuffer cmdBuffer,
7413 VkStateBindPoint stateBindPoint,
7414 VkDynamicStateObject dynamicState)
7415{
7416 if(cmdBuffer == nullptr)
7417 {
7418 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7419 "vkCmdBindDynamicStateObject parameter, VkCmdBuffer cmdBuffer, is null pointer");
7420 return;
7421 }
7422
7423 if(stateBindPoint < VK_STATE_BIND_POINT_BEGIN_RANGE ||
7424 stateBindPoint > VK_STATE_BIND_POINT_END_RANGE)
7425 {
7426 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7427 "vkCmdBindDynamicStateObject parameter, VkStateBindPoint stateBindPoint, is unrecognized enumerator");
7428 return;
7429 }
7430
7431 if(dynamicState == nullptr)
7432 {
7433 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7434 "vkCmdBindDynamicStateObject parameter, VkDynamicStateObject dynamicState, is null pointer");
7435 return;
7436 }
7437}
7438
7439VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(
7440 VkCmdBuffer cmdBuffer,
7441 VkStateBindPoint stateBindPoint,
7442 VkDynamicStateObject dynamicState)
7443{
7444 PreCmdBindDynamicStateObject(cmdBuffer);
7445 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, dynamicState);
7446
7447 PostCmdBindDynamicStateObject(cmdBuffer, stateBindPoint, dynamicState);
7448}
7449
7450void PreCmdBindDescriptorSets(
7451 VkCmdBuffer cmdBuffer,
7452 const VkDescriptorSet* pDescriptorSets,
7453 const uint32_t* pDynamicOffsets)
7454{
7455 if(cmdBuffer == nullptr)
7456 {
7457 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7458 "vkCmdBindDescriptorSets parameter, VkCmdBuffer cmdBuffer, is null pointer");
7459 return;
7460 }
7461
7462 if(pDescriptorSets == nullptr)
7463 {
7464 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7465 "vkCmdBindDescriptorSets parameter, const VkDescriptorSet* pDescriptorSets, is null pointer");
7466 return;
7467 }
7468 if((*pDescriptorSets) == nullptr)
7469 {
7470 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7471 "vkCmdBindDescriptorSets parameter, const VkDescriptorSet* pDescriptorSets, is null pointer");
7472 return;
7473 }
7474
7475 if(pDynamicOffsets == nullptr)
7476 {
7477 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7478 "vkCmdBindDescriptorSets parameter, const uint32_t* pDynamicOffsets, is null pointer");
7479 return;
7480 }
7481}
7482
7483void PostCmdBindDescriptorSets(
7484 VkCmdBuffer cmdBuffer,
7485 VkPipelineBindPoint pipelineBindPoint,
7486 VkPipelineLayout layout,
7487 uint32_t firstSet,
7488 uint32_t setCount,
7489 uint32_t dynamicOffsetCount)
7490{
7491 if(cmdBuffer == nullptr)
7492 {
7493 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7494 "vkCmdBindDescriptorSets parameter, VkCmdBuffer cmdBuffer, is null pointer");
7495 return;
7496 }
7497
7498 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
7499 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
7500 {
7501 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7502 "vkCmdBindDescriptorSets parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
7503 return;
7504 }
7505
7506 if(layout == nullptr)
7507 {
7508 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7509 "vkCmdBindDescriptorSets parameter, VkPipelineLayout layout, is null pointer");
7510 return;
7511 }
7512
7513
7514
7515}
7516
7517VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
7518 VkCmdBuffer cmdBuffer,
7519 VkPipelineBindPoint pipelineBindPoint,
7520 VkPipelineLayout layout,
7521 uint32_t firstSet,
7522 uint32_t setCount,
7523 const VkDescriptorSet* pDescriptorSets,
7524 uint32_t dynamicOffsetCount,
7525 const uint32_t* pDynamicOffsets)
7526{
7527 PreCmdBindDescriptorSets(cmdBuffer, pDescriptorSets, pDynamicOffsets);
7528 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
7529
7530 PostCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
7531}
7532
7533void PreCmdBindIndexBuffer(
7534 VkCmdBuffer cmdBuffer)
7535{
7536 if(cmdBuffer == nullptr)
7537 {
7538 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7539 "vkCmdBindIndexBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7540 return;
7541 }
7542}
7543
7544void PostCmdBindIndexBuffer(
7545 VkCmdBuffer cmdBuffer,
7546 VkBuffer buffer,
7547 VkDeviceSize offset,
7548 VkIndexType indexType)
7549{
7550 if(cmdBuffer == nullptr)
7551 {
7552 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7553 "vkCmdBindIndexBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7554 return;
7555 }
7556
7557 if(buffer == nullptr)
7558 {
7559 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7560 "vkCmdBindIndexBuffer parameter, VkBuffer buffer, is null pointer");
7561 return;
7562 }
7563
7564
7565 if(indexType < VK_INDEX_TYPE_BEGIN_RANGE ||
7566 indexType > VK_INDEX_TYPE_END_RANGE)
7567 {
7568 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7569 "vkCmdBindIndexBuffer parameter, VkIndexType indexType, is unrecognized enumerator");
7570 return;
7571 }
7572}
7573
7574VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
7575 VkCmdBuffer cmdBuffer,
7576 VkBuffer buffer,
7577 VkDeviceSize offset,
7578 VkIndexType indexType)
7579{
7580 PreCmdBindIndexBuffer(cmdBuffer);
7581 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
7582
7583 PostCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
7584}
7585
7586void PreCmdBindVertexBuffers(
7587 VkCmdBuffer cmdBuffer,
7588 const VkBuffer* pBuffers,
7589 const VkDeviceSize* pOffsets)
7590{
7591 if(cmdBuffer == nullptr)
7592 {
7593 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7594 "vkCmdBindVertexBuffers parameter, VkCmdBuffer cmdBuffer, is null pointer");
7595 return;
7596 }
7597
7598 if(pBuffers == nullptr)
7599 {
7600 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7601 "vkCmdBindVertexBuffers parameter, const VkBuffer* pBuffers, is null pointer");
7602 return;
7603 }
7604 if((*pBuffers) == nullptr)
7605 {
7606 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7607 "vkCmdBindVertexBuffers parameter, const VkBuffer* pBuffers, is null pointer");
7608 return;
7609 }
7610
7611 if(pOffsets == nullptr)
7612 {
7613 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7614 "vkCmdBindVertexBuffers parameter, const VkDeviceSize* pOffsets, is null pointer");
7615 return;
7616 }
7617}
7618
7619void PostCmdBindVertexBuffers(
7620 VkCmdBuffer cmdBuffer,
7621 uint32_t startBinding,
7622 uint32_t bindingCount)
7623{
7624 if(cmdBuffer == nullptr)
7625 {
7626 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7627 "vkCmdBindVertexBuffers parameter, VkCmdBuffer cmdBuffer, is null pointer");
7628 return;
7629 }
7630
7631
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7632}
7633
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -0600[diff] [blame]7634VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7635 VkCmdBuffer cmdBuffer,
7636 uint32_t startBinding,
7637 uint32_t bindingCount,
7638 const VkBuffer* pBuffers,
7639 const VkDeviceSize* pOffsets)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7640{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7641 PreCmdBindVertexBuffers(cmdBuffer, pBuffers, pOffsets);
7642 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
7643
7644 PostCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7645}
7646
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7647void PreCmdDraw(
7648 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7649{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7650 if(cmdBuffer == nullptr)
7651 {
7652 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7653 "vkCmdDraw parameter, VkCmdBuffer cmdBuffer, is null pointer");
7654 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7655 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7656}
7657
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7658void PostCmdDraw(
7659 VkCmdBuffer cmdBuffer,
7660 uint32_t firstVertex,
7661 uint32_t vertexCount,
7662 uint32_t firstInstance,
7663 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7664{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7665 if(cmdBuffer == nullptr)
7666 {
7667 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7668 "vkCmdDraw parameter, VkCmdBuffer cmdBuffer, is null pointer");
7669 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7670 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7671
7672
7673
7674
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7675}
7676
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7677VK_LAYER_EXPORT void VKAPI vkCmdDraw(
7678 VkCmdBuffer cmdBuffer,
7679 uint32_t firstVertex,
7680 uint32_t vertexCount,
7681 uint32_t firstInstance,
7682 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7683{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7684 PreCmdDraw(cmdBuffer);
7685 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
7686
7687 PostCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7688}
7689
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7690void PreCmdDrawIndexed(
7691 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7692{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7693 if(cmdBuffer == nullptr)
7694 {
7695 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7696 "vkCmdDrawIndexed parameter, VkCmdBuffer cmdBuffer, is null pointer");
7697 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7698 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7699}
7700
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7701void PostCmdDrawIndexed(
7702 VkCmdBuffer cmdBuffer,
7703 uint32_t firstIndex,
7704 uint32_t indexCount,
7705 int32_t vertexOffset,
7706 uint32_t firstInstance,
7707 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7708{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7709 if(cmdBuffer == nullptr)
7710 {
7711 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7712 "vkCmdDrawIndexed parameter, VkCmdBuffer cmdBuffer, is null pointer");
7713 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7714 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7715
7716
7717
7718
7719
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7720}
7721
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7722VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(
7723 VkCmdBuffer cmdBuffer,
7724 uint32_t firstIndex,
7725 uint32_t indexCount,
7726 int32_t vertexOffset,
7727 uint32_t firstInstance,
7728 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7729{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7730 PreCmdDrawIndexed(cmdBuffer);
7731 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
7732
7733 PostCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
7734}
7735
7736void PreCmdDrawIndirect(
7737 VkCmdBuffer cmdBuffer)
7738{
7739 if(cmdBuffer == nullptr)
7740 {
7741 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7742 "vkCmdDrawIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7743 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7744 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7745}
7746
7747void PostCmdDrawIndirect(
7748 VkCmdBuffer cmdBuffer,
7749 VkBuffer buffer,
7750 VkDeviceSize offset,
7751 uint32_t count,
7752 uint32_t stride)
7753{
7754 if(cmdBuffer == nullptr)
7755 {
7756 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7757 "vkCmdDrawIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7758 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7759 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7760
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7761 if(buffer == nullptr)
7762 {
7763 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7764 "vkCmdDrawIndirect parameter, VkBuffer buffer, is null pointer");
7765 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7766 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7767
7768
7769
7770}
7771
7772VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
7773 VkCmdBuffer cmdBuffer,
7774 VkBuffer buffer,
7775 VkDeviceSize offset,
7776 uint32_t count,
7777 uint32_t stride)
7778{
7779 PreCmdDrawIndirect(cmdBuffer);
7780 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
7781
7782 PostCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
7783}
7784
7785void PreCmdDrawIndexedIndirect(
7786 VkCmdBuffer cmdBuffer)
7787{
7788 if(cmdBuffer == nullptr)
7789 {
7790 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7791 "vkCmdDrawIndexedIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7792 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7793 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7794}
7795
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7796void PostCmdDrawIndexedIndirect(
7797 VkCmdBuffer cmdBuffer,
7798 VkBuffer buffer,
7799 VkDeviceSize offset,
7800 uint32_t count,
7801 uint32_t stride)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7802{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7803 if(cmdBuffer == nullptr)
7804 {
7805 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7806 "vkCmdDrawIndexedIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7807 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7808 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7809
7810 if(buffer == nullptr)
7811 {
7812 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7813 "vkCmdDrawIndexedIndirect parameter, VkBuffer buffer, is null pointer");
7814 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7815 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7816
7817
7818
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7819}
7820
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7821VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
7822 VkCmdBuffer cmdBuffer,
7823 VkBuffer buffer,
7824 VkDeviceSize offset,
7825 uint32_t count,
7826 uint32_t stride)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7827{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7828 PreCmdDrawIndexedIndirect(cmdBuffer);
7829 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
7830
7831 PostCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
7832}
7833
7834void PreCmdDispatch(
7835 VkCmdBuffer cmdBuffer)
7836{
7837 if(cmdBuffer == nullptr)
7838 {
7839 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7840 "vkCmdDispatch parameter, VkCmdBuffer cmdBuffer, is null pointer");
7841 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7842 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7843}
7844
7845void PostCmdDispatch(
7846 VkCmdBuffer cmdBuffer,
7847 uint32_t x,
7848 uint32_t y,
7849 uint32_t z)
7850{
7851 if(cmdBuffer == nullptr)
7852 {
7853 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7854 "vkCmdDispatch parameter, VkCmdBuffer cmdBuffer, is null pointer");
7855 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7856 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7857
7858
7859
7860}
7861
7862VK_LAYER_EXPORT void VKAPI vkCmdDispatch(
7863 VkCmdBuffer cmdBuffer,
7864 uint32_t x,
7865 uint32_t y,
7866 uint32_t z)
7867{
7868 PreCmdDispatch(cmdBuffer);
7869 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
7870
7871 PostCmdDispatch(cmdBuffer, x, y, z);
7872}
7873
7874void PreCmdDispatchIndirect(
7875 VkCmdBuffer cmdBuffer)
7876{
7877 if(cmdBuffer == nullptr)
7878 {
7879 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7880 "vkCmdDispatchIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7881 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7882 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7883}
7884
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7885void PostCmdDispatchIndirect(
7886 VkCmdBuffer cmdBuffer,
7887 VkBuffer buffer,
7888 VkDeviceSize offset)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7889{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7890 if(cmdBuffer == nullptr)
7891 {
7892 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7893 "vkCmdDispatchIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7894 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7895 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7896
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7897 if(buffer == nullptr)
7898 {
7899 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7900 "vkCmdDispatchIndirect parameter, VkBuffer buffer, is null pointer");
7901 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7902 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7903
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7904}
7905
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7906VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
7907 VkCmdBuffer cmdBuffer,
7908 VkBuffer buffer,
7909 VkDeviceSize offset)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7910{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7911 PreCmdDispatchIndirect(cmdBuffer);
7912 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
7913
7914 PostCmdDispatchIndirect(cmdBuffer, buffer, offset);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7915}
7916
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7917void PreCmdCopyBuffer(
7918 VkCmdBuffer cmdBuffer,
7919 const VkBufferCopy* pRegions)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7920{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7921 if(cmdBuffer == nullptr)
7922 {
7923 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7924 "vkCmdCopyBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7925 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7926 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7927
7928 if(pRegions == nullptr)
7929 {
7930 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7931 "vkCmdCopyBuffer parameter, const VkBufferCopy* pRegions, is null pointer");
7932 return;
7933 }
7934}
7935
7936void PostCmdCopyBuffer(
7937 VkCmdBuffer cmdBuffer,
7938 VkBuffer srcBuffer,
7939 VkBuffer destBuffer,
7940 uint32_t regionCount)
7941{
7942 if(cmdBuffer == nullptr)
7943 {
7944 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7945 "vkCmdCopyBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7946 return;
7947 }
7948
7949 if(srcBuffer == nullptr)
7950 {
7951 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7952 "vkCmdCopyBuffer parameter, VkBuffer srcBuffer, is null pointer");
7953 return;
7954 }
7955
7956 if(destBuffer == nullptr)
7957 {
7958 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7959 "vkCmdCopyBuffer parameter, VkBuffer destBuffer, is null pointer");
7960 return;
7961 }
7962
7963}
7964
7965VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
7966 VkCmdBuffer cmdBuffer,
7967 VkBuffer srcBuffer,
7968 VkBuffer destBuffer,
7969 uint32_t regionCount,
7970 const VkBufferCopy* pRegions)
7971{
7972 PreCmdCopyBuffer(cmdBuffer, pRegions);
7973 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
7974
7975 PostCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount);
7976}
7977
7978void PreCmdCopyImage(
7979 VkCmdBuffer cmdBuffer,
7980 const VkImageCopy* pRegions)
7981{
7982 if(cmdBuffer == nullptr)
7983 {
7984 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7985 "vkCmdCopyImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
7986 return;
7987 }
7988
7989 if(pRegions == nullptr)
7990 {
7991 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7992 "vkCmdCopyImage parameter, const VkImageCopy* pRegions, is null pointer");
7993 return;
7994 }
7995 if(pRegions->srcSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
7996 pRegions->srcSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
7997 {
7998 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7999 "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is unrecognized enumerator");
8000 return;
8001 }
8002 if(pRegions->destSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8003 pRegions->destSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8004 {
8005 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8006 "vkCmdCopyImage parameter, VkImageAspect pRegions->destSubresource.aspect, is unrecognized enumerator");
8007 return;
8008 }
8009}
8010
8011void PostCmdCopyImage(
8012 VkCmdBuffer cmdBuffer,
8013 VkImage srcImage,
8014 VkImageLayout srcImageLayout,
8015 VkImage destImage,
8016 VkImageLayout destImageLayout,
8017 uint32_t regionCount)
8018{
8019 if(cmdBuffer == nullptr)
8020 {
8021 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8022 "vkCmdCopyImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8023 return;
8024 }
8025
8026 if(srcImage == nullptr)
8027 {
8028 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8029 "vkCmdCopyImage parameter, VkImage srcImage, is null pointer");
8030 return;
8031 }
8032
8033 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8034 srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8035 {
8036 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8037 "vkCmdCopyImage parameter, VkImageLayout srcImageLayout, is unrecognized enumerator");
8038 return;
8039 }
8040
8041 if(destImage == nullptr)
8042 {
8043 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8044 "vkCmdCopyImage parameter, VkImage destImage, is null pointer");
8045 return;
8046 }
8047
8048 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8049 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8050 {
8051 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8052 "vkCmdCopyImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8053 return;
8054 }
8055
8056}
8057
8058VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
8059 VkCmdBuffer cmdBuffer,
8060 VkImage srcImage,
8061 VkImageLayout srcImageLayout,
8062 VkImage destImage,
8063 VkImageLayout destImageLayout,
8064 uint32_t regionCount,
8065 const VkImageCopy* pRegions)
8066{
8067 PreCmdCopyImage(cmdBuffer, pRegions);
8068 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
8069
8070 PostCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
8071}
8072
8073void PreCmdBlitImage(
8074 VkCmdBuffer cmdBuffer,
8075 const VkImageBlit* pRegions)
8076{
8077 if(cmdBuffer == nullptr)
8078 {
8079 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8080 "vkCmdBlitImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8081 return;
8082 }
8083
8084 if(pRegions == nullptr)
8085 {
8086 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8087 "vkCmdBlitImage parameter, const VkImageBlit* pRegions, is null pointer");
8088 return;
8089 }
8090 if(pRegions->srcSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8091 pRegions->srcSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8092 {
8093 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8094 "vkCmdBlitImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is unrecognized enumerator");
8095 return;
8096 }
8097 if(pRegions->destSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8098 pRegions->destSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8099 {
8100 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8101 "vkCmdBlitImage parameter, VkImageAspect pRegions->destSubresource.aspect, is unrecognized enumerator");
8102 return;
8103 }
8104}
8105
8106void PostCmdBlitImage(
8107 VkCmdBuffer cmdBuffer,
8108 VkImage srcImage,
8109 VkImageLayout srcImageLayout,
8110 VkImage destImage,
8111 VkImageLayout destImageLayout,
8112 uint32_t regionCount,
8113 VkTexFilter filter)
8114{
8115 if(cmdBuffer == nullptr)
8116 {
8117 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8118 "vkCmdBlitImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8119 return;
8120 }
8121
8122 if(srcImage == nullptr)
8123 {
8124 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8125 "vkCmdBlitImage parameter, VkImage srcImage, is null pointer");
8126 return;
8127 }
8128
8129 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8130 srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8131 {
8132 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8133 "vkCmdBlitImage parameter, VkImageLayout srcImageLayout, is unrecognized enumerator");
8134 return;
8135 }
8136
8137 if(destImage == nullptr)
8138 {
8139 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8140 "vkCmdBlitImage parameter, VkImage destImage, is null pointer");
8141 return;
8142 }
8143
8144 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8145 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8146 {
8147 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8148 "vkCmdBlitImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8149 return;
8150 }
8151
8152
8153 if(filter < VK_TEX_FILTER_BEGIN_RANGE ||
8154 filter > VK_TEX_FILTER_END_RANGE)
8155 {
8156 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8157 "vkCmdBlitImage parameter, VkTexFilter filter, is unrecognized enumerator");
8158 return;
8159 }
8160}
8161
8162VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
8163 VkCmdBuffer cmdBuffer,
8164 VkImage srcImage,
8165 VkImageLayout srcImageLayout,
8166 VkImage destImage,
8167 VkImageLayout destImageLayout,
8168 uint32_t regionCount,
8169 const VkImageBlit* pRegions,
8170 VkTexFilter filter)
8171{
8172 PreCmdBlitImage(cmdBuffer, pRegions);
8173 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
8174
8175 PostCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, filter);
8176}
8177
8178void PreCmdCopyBufferToImage(
8179 VkCmdBuffer cmdBuffer,
8180 const VkBufferImageCopy* pRegions)
8181{
8182 if(cmdBuffer == nullptr)
8183 {
8184 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8185 "vkCmdCopyBufferToImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8186 return;
8187 }
8188
8189 if(pRegions == nullptr)
8190 {
8191 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8192 "vkCmdCopyBufferToImage parameter, const VkBufferImageCopy* pRegions, is null pointer");
8193 return;
8194 }
8195 if(pRegions->imageSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8196 pRegions->imageSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8197 {
8198 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8199 "vkCmdCopyBufferToImage parameter, VkImageAspect pRegions->imageSubresource.aspect, is unrecognized enumerator");
8200 return;
8201 }
8202}
8203
8204void PostCmdCopyBufferToImage(
8205 VkCmdBuffer cmdBuffer,
8206 VkBuffer srcBuffer,
8207 VkImage destImage,
8208 VkImageLayout destImageLayout,
8209 uint32_t regionCount)
8210{
8211 if(cmdBuffer == nullptr)
8212 {
8213 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8214 "vkCmdCopyBufferToImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8215 return;
8216 }
8217
8218 if(srcBuffer == nullptr)
8219 {
8220 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8221 "vkCmdCopyBufferToImage parameter, VkBuffer srcBuffer, is null pointer");
8222 return;
8223 }
8224
8225 if(destImage == nullptr)
8226 {
8227 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8228 "vkCmdCopyBufferToImage parameter, VkImage destImage, is null pointer");
8229 return;
8230 }
8231
8232 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8233 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8234 {
8235 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8236 "vkCmdCopyBufferToImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8237 return;
8238 }
8239
8240}
8241
8242VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
8243 VkCmdBuffer cmdBuffer,
8244 VkBuffer srcBuffer,
8245 VkImage destImage,
8246 VkImageLayout destImageLayout,
8247 uint32_t regionCount,
8248 const VkBufferImageCopy* pRegions)
8249{
8250 PreCmdCopyBufferToImage(cmdBuffer, pRegions);
8251 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
8252
8253 PostCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount);
8254}
8255
8256void PreCmdCopyImageToBuffer(
8257 VkCmdBuffer cmdBuffer,
8258 const VkBufferImageCopy* pRegions)
8259{
8260 if(cmdBuffer == nullptr)
8261 {
8262 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8263 "vkCmdCopyImageToBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8264 return;
8265 }
8266
8267 if(pRegions == nullptr)
8268 {
8269 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8270 "vkCmdCopyImageToBuffer parameter, const VkBufferImageCopy* pRegions, is null pointer");
8271 return;
8272 }
8273 if(pRegions->imageSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8274 pRegions->imageSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8275 {
8276 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8277 "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspect, is unrecognized enumerator");
8278 return;
8279 }
8280}
8281
8282void PostCmdCopyImageToBuffer(
8283 VkCmdBuffer cmdBuffer,
8284 VkImage srcImage,
8285 VkImageLayout srcImageLayout,
8286 VkBuffer destBuffer,
8287 uint32_t regionCount)
8288{
8289 if(cmdBuffer == nullptr)
8290 {
8291 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8292 "vkCmdCopyImageToBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8293 return;
8294 }
8295
8296 if(srcImage == nullptr)
8297 {
8298 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8299 "vkCmdCopyImageToBuffer parameter, VkImage srcImage, is null pointer");
8300 return;
8301 }
8302
8303 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8304 srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8305 {
8306 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8307 "vkCmdCopyImageToBuffer parameter, VkImageLayout srcImageLayout, is unrecognized enumerator");
8308 return;
8309 }
8310
8311 if(destBuffer == nullptr)
8312 {
8313 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8314 "vkCmdCopyImageToBuffer parameter, VkBuffer destBuffer, is null pointer");
8315 return;
8316 }
8317
8318}
8319
8320VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
8321 VkCmdBuffer cmdBuffer,
8322 VkImage srcImage,
8323 VkImageLayout srcImageLayout,
8324 VkBuffer destBuffer,
8325 uint32_t regionCount,
8326 const VkBufferImageCopy* pRegions)
8327{
8328 PreCmdCopyImageToBuffer(cmdBuffer, pRegions);
8329 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
8330
8331 PostCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount);
8332}
8333
8334void PreCmdUpdateBuffer(
8335 VkCmdBuffer cmdBuffer,
8336 const uint32_t* pData)
8337{
8338 if(cmdBuffer == nullptr)
8339 {
8340 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8341 "vkCmdUpdateBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8342 return;
8343 }
8344
8345 if(pData == nullptr)
8346 {
8347 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8348 "vkCmdUpdateBuffer parameter, const uint32_t* pData, is null pointer");
8349 return;
8350 }
8351}
8352
8353void PostCmdUpdateBuffer(
8354 VkCmdBuffer cmdBuffer,
8355 VkBuffer destBuffer,
8356 VkDeviceSize destOffset,
8357 VkDeviceSize dataSize)
8358{
8359 if(cmdBuffer == nullptr)
8360 {
8361 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8362 "vkCmdUpdateBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8363 return;
8364 }
8365
8366 if(destBuffer == nullptr)
8367 {
8368 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8369 "vkCmdUpdateBuffer parameter, VkBuffer destBuffer, is null pointer");
8370 return;
8371 }
8372
8373
8374}
8375
8376VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
8377 VkCmdBuffer cmdBuffer,
8378 VkBuffer destBuffer,
8379 VkDeviceSize destOffset,
8380 VkDeviceSize dataSize,
8381 const uint32_t* pData)
8382{
8383 PreCmdUpdateBuffer(cmdBuffer, pData);
8384 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
8385
8386 PostCmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize);
8387}
8388
8389void PreCmdFillBuffer(
8390 VkCmdBuffer cmdBuffer)
8391{
8392 if(cmdBuffer == nullptr)
8393 {
8394 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8395 "vkCmdFillBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8396 return;
8397 }
8398}
8399
8400void PostCmdFillBuffer(
8401 VkCmdBuffer cmdBuffer,
8402 VkBuffer destBuffer,
8403 VkDeviceSize destOffset,
8404 VkDeviceSize fillSize,
8405 uint32_t data)
8406{
8407 if(cmdBuffer == nullptr)
8408 {
8409 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8410 "vkCmdFillBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8411 return;
8412 }
8413
8414 if(destBuffer == nullptr)
8415 {
8416 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8417 "vkCmdFillBuffer parameter, VkBuffer destBuffer, is null pointer");
8418 return;
8419 }
8420
8421
8422
8423}
8424
8425VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
8426 VkCmdBuffer cmdBuffer,
8427 VkBuffer destBuffer,
8428 VkDeviceSize destOffset,
8429 VkDeviceSize fillSize,
8430 uint32_t data)
8431{
8432 PreCmdFillBuffer(cmdBuffer);
8433 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
8434
8435 PostCmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
8436}
8437
8438void PreCmdClearColorImage(
8439 VkCmdBuffer cmdBuffer,
8440 const VkClearColor* pColor,
8441 const VkImageSubresourceRange* pRanges)
8442{
8443 if(cmdBuffer == nullptr)
8444 {
8445 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8446 "vkCmdClearColorImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8447 return;
8448 }
8449
8450 if(pColor == nullptr)
8451 {
8452 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8453 "vkCmdClearColorImage parameter, const VkClearColor* pColor, is null pointer");
8454 return;
8455 }
8456
8457 if(pRanges == nullptr)
8458 {
8459 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8460 "vkCmdClearColorImage parameter, const VkImageSubresourceRange* pRanges, is null pointer");
8461 return;
8462 }
8463 if(pRanges->aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8464 pRanges->aspect > VK_IMAGE_ASPECT_END_RANGE)
8465 {
8466 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8467 "vkCmdClearColorImage parameter, VkImageAspect pRanges->aspect, is unrecognized enumerator");
8468 return;
8469 }
8470}
8471
8472void PostCmdClearColorImage(
8473 VkCmdBuffer cmdBuffer,
8474 VkImage image,
8475 VkImageLayout imageLayout,
8476 uint32_t rangeCount)
8477{
8478 if(cmdBuffer == nullptr)
8479 {
8480 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8481 "vkCmdClearColorImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8482 return;
8483 }
8484
8485 if(image == nullptr)
8486 {
8487 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8488 "vkCmdClearColorImage parameter, VkImage image, is null pointer");
8489 return;
8490 }
8491
8492 if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8493 imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8494 {
8495 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8496 "vkCmdClearColorImage parameter, VkImageLayout imageLayout, is unrecognized enumerator");
8497 return;
8498 }
8499
8500}
8501
8502VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
8503 VkCmdBuffer cmdBuffer,
8504 VkImage image,
8505 VkImageLayout imageLayout,
8506 const VkClearColor* pColor,
8507 uint32_t rangeCount,
8508 const VkImageSubresourceRange* pRanges)
8509{
8510 PreCmdClearColorImage(cmdBuffer, pColor, pRanges);
8511 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
8512
8513 PostCmdClearColorImage(cmdBuffer, image, imageLayout, rangeCount);
8514}
8515
8516void PreCmdClearDepthStencil(
8517 VkCmdBuffer cmdBuffer,
8518 const VkImageSubresourceRange* pRanges)
8519{
8520 if(cmdBuffer == nullptr)
8521 {
8522 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8523 "vkCmdClearDepthStencil parameter, VkCmdBuffer cmdBuffer, is null pointer");
8524 return;
8525 }
8526
8527 if(pRanges == nullptr)
8528 {
8529 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8530 "vkCmdClearDepthStencil parameter, const VkImageSubresourceRange* pRanges, is null pointer");
8531 return;
8532 }
8533 if(pRanges->aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8534 pRanges->aspect > VK_IMAGE_ASPECT_END_RANGE)
8535 {
8536 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8537 "vkCmdClearDepthStencil parameter, VkImageAspect pRanges->aspect, is unrecognized enumerator");
8538 return;
8539 }
8540}
8541
8542void PostCmdClearDepthStencil(
8543 VkCmdBuffer cmdBuffer,
8544 VkImage image,
8545 VkImageLayout imageLayout,
8546 float depth,
8547 uint32_t stencil,
8548 uint32_t rangeCount)
8549{
8550 if(cmdBuffer == nullptr)
8551 {
8552 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8553 "vkCmdClearDepthStencil parameter, VkCmdBuffer cmdBuffer, is null pointer");
8554 return;
8555 }
8556
8557 if(image == nullptr)
8558 {
8559 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8560 "vkCmdClearDepthStencil parameter, VkImage image, is null pointer");
8561 return;
8562 }
8563
8564 if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8565 imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8566 {
8567 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8568 "vkCmdClearDepthStencil parameter, VkImageLayout imageLayout, is unrecognized enumerator");
8569 return;
8570 }
8571
8572
8573
8574}
8575
8576VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(
8577 VkCmdBuffer cmdBuffer,
8578 VkImage image,
8579 VkImageLayout imageLayout,
8580 float depth,
8581 uint32_t stencil,
8582 uint32_t rangeCount,
8583 const VkImageSubresourceRange* pRanges)
8584{
8585 PreCmdClearDepthStencil(cmdBuffer, pRanges);
8586 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
8587
8588 PostCmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount);
8589}
8590
8591void PreCmdResolveImage(
8592 VkCmdBuffer cmdBuffer,
8593 const VkImageResolve* pRegions)
8594{
8595 if(cmdBuffer == nullptr)
8596 {
8597 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8598 "vkCmdResolveImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8599 return;
8600 }
8601
8602 if(pRegions == nullptr)
8603 {
8604 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8605 "vkCmdResolveImage parameter, const VkImageResolve* pRegions, is null pointer");
8606 return;
8607 }
8608 if(pRegions->srcSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8609 pRegions->srcSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8610 {
8611 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8612 "vkCmdResolveImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is unrecognized enumerator");
8613 return;
8614 }
8615 if(pRegions->destSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8616 pRegions->destSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8617 {
8618 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8619 "vkCmdResolveImage parameter, VkImageAspect pRegions->destSubresource.aspect, is unrecognized enumerator");
8620 return;
8621 }
8622}
8623
8624void PostCmdResolveImage(
8625 VkCmdBuffer cmdBuffer,
8626 VkImage srcImage,
8627 VkImageLayout srcImageLayout,
8628 VkImage destImage,
8629 VkImageLayout destImageLayout,
8630 uint32_t regionCount)
8631{
8632 if(cmdBuffer == nullptr)
8633 {
8634 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8635 "vkCmdResolveImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8636 return;
8637 }
8638
8639 if(srcImage == nullptr)
8640 {
8641 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8642 "vkCmdResolveImage parameter, VkImage srcImage, is null pointer");
8643 return;
8644 }
8645
8646 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8647 srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8648 {
8649 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8650 "vkCmdResolveImage parameter, VkImageLayout srcImageLayout, is unrecognized enumerator");
8651 return;
8652 }
8653
8654 if(destImage == nullptr)
8655 {
8656 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8657 "vkCmdResolveImage parameter, VkImage destImage, is null pointer");
8658 return;
8659 }
8660
8661 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8662 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8663 {
8664 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8665 "vkCmdResolveImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8666 return;
8667 }
8668
8669}
8670
8671VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
8672 VkCmdBuffer cmdBuffer,
8673 VkImage srcImage,
8674 VkImageLayout srcImageLayout,
8675 VkImage destImage,
8676 VkImageLayout destImageLayout,
8677 uint32_t regionCount,
8678 const VkImageResolve* pRegions)
8679{
8680 PreCmdResolveImage(cmdBuffer, pRegions);
8681 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
8682
8683 PostCmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
8684}
8685
8686void PreCmdSetEvent(
8687 VkCmdBuffer cmdBuffer)
8688{
8689 if(cmdBuffer == nullptr)
8690 {
8691 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8692 "vkCmdSetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8693 return;
8694 }
8695}
8696
8697void PostCmdSetEvent(
8698 VkCmdBuffer cmdBuffer,
8699 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8700 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8701{
8702 if(cmdBuffer == nullptr)
8703 {
8704 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8705 "vkCmdSetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8706 return;
8707 }
8708
8709 if(event == nullptr)
8710 {
8711 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8712 "vkCmdSetEvent parameter, VkEvent event, is null pointer");
8713 return;
8714 }
8715
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8716}
8717
8718VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(
8719 VkCmdBuffer cmdBuffer,
8720 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8721 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8722{
8723 PreCmdSetEvent(cmdBuffer);
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8724 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8725
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8726 PostCmdSetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8727}
8728
8729void PreCmdResetEvent(
8730 VkCmdBuffer cmdBuffer)
8731{
8732 if(cmdBuffer == nullptr)
8733 {
8734 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8735 "vkCmdResetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8736 return;
8737 }
8738}
8739
8740void PostCmdResetEvent(
8741 VkCmdBuffer cmdBuffer,
8742 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8743 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8744{
8745 if(cmdBuffer == nullptr)
8746 {
8747 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8748 "vkCmdResetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8749 return;
8750 }
8751
8752 if(event == nullptr)
8753 {
8754 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8755 "vkCmdResetEvent parameter, VkEvent event, is null pointer");
8756 return;
8757 }
8758
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8759}
8760
8761VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(
8762 VkCmdBuffer cmdBuffer,
8763 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8764 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8765{
8766 PreCmdResetEvent(cmdBuffer);
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8767 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8768
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8769 PostCmdResetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8770}
8771
8772void PreCmdWaitEvents(
8773 VkCmdBuffer cmdBuffer,
8774 const VkEvent* pEvents,
8775 const void** ppMemBarriers)
8776{
8777 if(cmdBuffer == nullptr)
8778 {
8779 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8780 "vkCmdWaitEvents parameter, VkCmdBuffer cmdBuffer, is null pointer");
8781 return;
8782 }
8783
8784 if(pEvents == nullptr)
8785 {
8786 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8787 "vkCmdWaitEvents parameter, const VkEvent* pEvents, is null pointer");
8788 return;
8789 }
8790 if((*pEvents) == nullptr)
8791 {
8792 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8793 "vkCmdWaitEvents parameter, const VkEvent* pEvents, is null pointer");
8794 return;
8795 }
8796
8797 if(ppMemBarriers == nullptr)
8798 {
8799 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8800 "vkCmdWaitEvents parameter, const void** ppMemBarriers, is null pointer");
8801 return;
8802 }
8803}
8804
8805void PostCmdWaitEvents(
8806 VkCmdBuffer cmdBuffer,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8807 uint32_t eventCount,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8808 VkPipelineStageFlags sourceStageMask,
8809 VkPipelineStageFlags destStageMask,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8810 uint32_t memBarrierCount)
8811{
8812 if(cmdBuffer == nullptr)
8813 {
8814 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8815 "vkCmdWaitEvents parameter, VkCmdBuffer cmdBuffer, is null pointer");
8816 return;
8817 }
8818
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8819
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8820
8821
8822}
8823
8824VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(
8825 VkCmdBuffer cmdBuffer,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8826 uint32_t eventCount,
8827 const VkEvent* pEvents,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8828 VkPipelineStageFlags sourceStageMask,
8829 VkPipelineStageFlags destStageMask,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8830 uint32_t memBarrierCount,
8831 const void** ppMemBarriers)
8832{
8833 PreCmdWaitEvents(cmdBuffer, pEvents, ppMemBarriers);
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8834 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8835
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8836 PostCmdWaitEvents(cmdBuffer, eventCount, sourceStageMask, destStageMask, memBarrierCount);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8837}
8838
8839void PreCmdPipelineBarrier(
8840 VkCmdBuffer cmdBuffer,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8841 const void** ppMemBarriers)
8842{
8843 if(cmdBuffer == nullptr)
8844 {
8845 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8846 "vkCmdPipelineBarrier parameter, VkCmdBuffer cmdBuffer, is null pointer");
8847 return;
8848 }
8849
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8850 if(ppMemBarriers == nullptr)
8851 {
8852 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8853 "vkCmdPipelineBarrier parameter, const void** ppMemBarriers, is null pointer");
8854 return;
8855 }
8856}
8857
8858void PostCmdPipelineBarrier(
8859 VkCmdBuffer cmdBuffer,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8860 VkPipelineStageFlags sourceStageMask,
8861 VkPipelineStageFlags destStageMask,
8862 bool32_t byRegion,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8863 uint32_t memBarrierCount)
8864{
8865 if(cmdBuffer == nullptr)
8866 {
8867 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8868 "vkCmdPipelineBarrier parameter, VkCmdBuffer cmdBuffer, is null pointer");
8869 return;
8870 }
8871
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8872
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8873
8874
8875}
8876
8877VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(
8878 VkCmdBuffer cmdBuffer,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8879 VkPipelineStageFlags sourceStageMask,
8880 VkPipelineStageFlags destStageMask,
8881 bool32_t byRegion,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8882 uint32_t memBarrierCount,
8883 const void** ppMemBarriers)
8884{
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8885 PreCmdPipelineBarrier(cmdBuffer, ppMemBarriers);
8886 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8887
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8888 PostCmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8889}
8890
8891void PreCmdBeginQuery(
8892 VkCmdBuffer cmdBuffer)
8893{
8894 if(cmdBuffer == nullptr)
8895 {
8896 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8897 "vkCmdBeginQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8898 return;
8899 }
8900}
8901
8902void PostCmdBeginQuery(
8903 VkCmdBuffer cmdBuffer,
8904 VkQueryPool queryPool,
8905 uint32_t slot,
8906 VkQueryControlFlags flags)
8907{
8908 if(cmdBuffer == nullptr)
8909 {
8910 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8911 "vkCmdBeginQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8912 return;
8913 }
8914
8915 if(queryPool == nullptr)
8916 {
8917 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8918 "vkCmdBeginQuery parameter, VkQueryPool queryPool, is null pointer");
8919 return;
8920 }
8921
8922
8923 if(!ValidateEnumerator((VkQueryControlFlagBits)flags))
8924 {
8925 std::string reason = "vkCmdBeginQuery parameter, VkQueryControlFlags flags, is " + EnumeratorString((VkQueryControlFlagBits)flags);
8926 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
8927 return;
8928 }
8929}
8930
8931VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
8932 VkCmdBuffer cmdBuffer,
8933 VkQueryPool queryPool,
8934 uint32_t slot,
8935 VkQueryControlFlags flags)
8936{
8937 PreCmdBeginQuery(cmdBuffer);
8938 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
8939
8940 PostCmdBeginQuery(cmdBuffer, queryPool, slot, flags);
8941}
8942
8943void PreCmdEndQuery(
8944 VkCmdBuffer cmdBuffer)
8945{
8946 if(cmdBuffer == nullptr)
8947 {
8948 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8949 "vkCmdEndQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8950 return;
8951 }
8952}
8953
8954void PostCmdEndQuery(
8955 VkCmdBuffer cmdBuffer,
8956 VkQueryPool queryPool,
8957 uint32_t slot)
8958{
8959 if(cmdBuffer == nullptr)
8960 {
8961 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8962 "vkCmdEndQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8963 return;
8964 }
8965
8966 if(queryPool == nullptr)
8967 {
8968 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8969 "vkCmdEndQuery parameter, VkQueryPool queryPool, is null pointer");
8970 return;
8971 }
8972
8973}
8974
8975VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
8976 VkCmdBuffer cmdBuffer,
8977 VkQueryPool queryPool,
8978 uint32_t slot)
8979{
8980 PreCmdEndQuery(cmdBuffer);
8981 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
8982
8983 PostCmdEndQuery(cmdBuffer, queryPool, slot);
8984}
8985
8986void PreCmdResetQueryPool(
8987 VkCmdBuffer cmdBuffer)
8988{
8989 if(cmdBuffer == nullptr)
8990 {
8991 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8992 "vkCmdResetQueryPool parameter, VkCmdBuffer cmdBuffer, is null pointer");
8993 return;
8994 }
8995}
8996
8997void PostCmdResetQueryPool(
8998 VkCmdBuffer cmdBuffer,
8999 VkQueryPool queryPool,
9000 uint32_t startQuery,
9001 uint32_t queryCount)
9002{
9003 if(cmdBuffer == nullptr)
9004 {
9005 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9006 "vkCmdResetQueryPool parameter, VkCmdBuffer cmdBuffer, is null pointer");
9007 return;
9008 }
9009
9010 if(queryPool == nullptr)
9011 {
9012 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9013 "vkCmdResetQueryPool parameter, VkQueryPool queryPool, is null pointer");
9014 return;
9015 }
9016
9017
9018}
9019
9020VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
9021 VkCmdBuffer cmdBuffer,
9022 VkQueryPool queryPool,
9023 uint32_t startQuery,
9024 uint32_t queryCount)
9025{
9026 PreCmdResetQueryPool(cmdBuffer);
9027 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
9028
9029 PostCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
9030}
9031
9032void PreCmdWriteTimestamp(
9033 VkCmdBuffer cmdBuffer)
9034{
9035 if(cmdBuffer == nullptr)
9036 {
9037 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9038 "vkCmdWriteTimestamp parameter, VkCmdBuffer cmdBuffer, is null pointer");
9039 return;
9040 }
9041}
9042
9043void PostCmdWriteTimestamp(
9044 VkCmdBuffer cmdBuffer,
9045 VkTimestampType timestampType,
9046 VkBuffer destBuffer,
9047 VkDeviceSize destOffset)
9048{
9049 if(cmdBuffer == nullptr)
9050 {
9051 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9052 "vkCmdWriteTimestamp parameter, VkCmdBuffer cmdBuffer, is null pointer");
9053 return;
9054 }
9055
9056 if(timestampType < VK_TIMESTAMP_TYPE_BEGIN_RANGE ||
9057 timestampType > VK_TIMESTAMP_TYPE_END_RANGE)
9058 {
9059 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9060 "vkCmdWriteTimestamp parameter, VkTimestampType timestampType, is unrecognized enumerator");
9061 return;
9062 }
9063
9064 if(destBuffer == nullptr)
9065 {
9066 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9067 "vkCmdWriteTimestamp parameter, VkBuffer destBuffer, is null pointer");
9068 return;
9069 }
9070
9071}
9072
9073VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(
9074 VkCmdBuffer cmdBuffer,
9075 VkTimestampType timestampType,
9076 VkBuffer destBuffer,
9077 VkDeviceSize destOffset)
9078{
9079 PreCmdWriteTimestamp(cmdBuffer);
9080 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
9081
9082 PostCmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
9083}
9084
9085void PreCmdCopyQueryPoolResults(
9086 VkCmdBuffer cmdBuffer)
9087{
9088 if(cmdBuffer == nullptr)
9089 {
9090 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9091 "vkCmdCopyQueryPoolResults parameter, VkCmdBuffer cmdBuffer, is null pointer");
9092 return;
9093 }
9094}
9095
9096void PostCmdCopyQueryPoolResults(
9097 VkCmdBuffer cmdBuffer,
9098 VkQueryPool queryPool,
9099 uint32_t startQuery,
9100 uint32_t queryCount,
9101 VkBuffer destBuffer,
9102 VkDeviceSize destOffset,
9103 VkDeviceSize destStride,
9104 VkQueryResultFlags flags)
9105{
9106 if(cmdBuffer == nullptr)
9107 {
9108 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9109 "vkCmdCopyQueryPoolResults parameter, VkCmdBuffer cmdBuffer, is null pointer");
9110 return;
9111 }
9112
9113 if(queryPool == nullptr)
9114 {
9115 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9116 "vkCmdCopyQueryPoolResults parameter, VkQueryPool queryPool, is null pointer");
9117 return;
9118 }
9119
9120
9121
9122 if(destBuffer == nullptr)
9123 {
9124 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9125 "vkCmdCopyQueryPoolResults parameter, VkBuffer destBuffer, is null pointer");
9126 return;
9127 }
9128
9129
9130
9131 if(!ValidateEnumerator((VkQueryResultFlagBits)flags))
9132 {
9133 std::string reason = "vkCmdCopyQueryPoolResults parameter, VkQueryResultFlags flags, is " + EnumeratorString((VkQueryResultFlagBits)flags);
9134 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
9135 return;
9136 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9137}
9138
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]9139VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9140 VkCmdBuffer cmdBuffer,
9141 VkQueryPool queryPool,
9142 uint32_t startQuery,
9143 uint32_t queryCount,
9144 VkBuffer destBuffer,
9145 VkDeviceSize destOffset,
9146 VkDeviceSize destStride,
9147 VkQueryResultFlags flags)
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]9148{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9149 PreCmdCopyQueryPoolResults(cmdBuffer);
9150 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
9151
9152 PostCmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]9153}
9154
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9155void PreCmdInitAtomicCounters(
9156 VkCmdBuffer cmdBuffer,
9157 const uint32_t* pData)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9158{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9159 if(cmdBuffer == nullptr)
9160 {
9161 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9162 "vkCmdInitAtomicCounters parameter, VkCmdBuffer cmdBuffer, is null pointer");
9163 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9164 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9165
9166 if(pData == nullptr)
9167 {
9168 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9169 "vkCmdInitAtomicCounters parameter, const uint32_t* pData, is null pointer");
9170 return;
9171 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9172}
9173
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9174void PostCmdInitAtomicCounters(
9175 VkCmdBuffer cmdBuffer,
9176 VkPipelineBindPoint pipelineBindPoint,
9177 uint32_t startCounter,
9178 uint32_t counterCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9179{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9180 if(cmdBuffer == nullptr)
9181 {
9182 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9183 "vkCmdInitAtomicCounters parameter, VkCmdBuffer cmdBuffer, is null pointer");
9184 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9185 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9186
9187 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
9188 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
9189 {
9190 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9191 "vkCmdInitAtomicCounters parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
9192 return;
9193 }
9194
9195
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9196}
9197
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9198VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(
9199 VkCmdBuffer cmdBuffer,
9200 VkPipelineBindPoint pipelineBindPoint,
9201 uint32_t startCounter,
9202 uint32_t counterCount,
9203 const uint32_t* pData)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9204{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9205 PreCmdInitAtomicCounters(cmdBuffer, pData);
9206 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
9207
9208 PostCmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9209}
9210
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9211void PreCmdLoadAtomicCounters(
9212 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9213{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9214 if(cmdBuffer == nullptr)
9215 {
9216 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9217 "vkCmdLoadAtomicCounters parameter, VkCmdBuffer cmdBuffer, is null pointer");
9218 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9219 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9220}
9221
9222void PostCmdLoadAtomicCounters(
9223 VkCmdBuffer cmdBuffer,
9224 VkPipelineBindPoint pipelineBindPoint,
9225 uint32_t startCounter,
9226 uint32_t counterCount,
9227 VkBuffer srcBuffer,
9228 VkDeviceSize srcOffset)
9229{
9230 if(cmdBuffer == nullptr)
9231 {
9232 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9233 "vkCmdLoadAtomicCounters parameter, VkCmdBuffer cmdBuffer, is null pointer");
9234 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9235 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9236
9237 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
9238 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
9239 {
9240 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9241 "vkCmdLoadAtomicCounters parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
9242 return;
9243 }
9244
9245
9246
9247 if(srcBuffer == nullptr)
9248 {
9249 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9250 "vkCmdLoadAtomicCounters parameter, VkBuffer srcBuffer, is null pointer");
9251 return;
9252 }
9253
9254}
9255
9256VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(
9257 VkCmdBuffer cmdBuffer,
9258 VkPipelineBindPoint pipelineBindPoint,
9259 uint32_t startCounter,
9260 uint32_t counterCount,
9261 VkBuffer srcBuffer,
9262 VkDeviceSize srcOffset)
9263{
9264 PreCmdLoadAtomicCounters(cmdBuffer);
9265 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
9266
9267 PostCmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
9268}
9269
9270void PreCmdSaveAtomicCounters(
9271 VkCmdBuffer cmdBuffer)
9272{
9273 if(cmdBuffer == nullptr)
9274 {
9275 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9276 "vkCmdSaveAtomicCounters parameter, VkCmdBuffer cmdBuffer, is null pointer");
9277 return;
9278 }
9279}
9280
9281void PostCmdSaveAtomicCounters(
9282 VkCmdBuffer cmdBuffer,
9283 VkPipelineBindPoint pipelineBindPoint,
9284 uint32_t startCounter,
9285 uint32_t counterCount,
9286 VkBuffer destBuffer,
9287 VkDeviceSize destOffset)
9288{
9289 if(cmdBuffer == nullptr)
9290 {
9291 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9292 "vkCmdSaveAtomicCounters parameter, VkCmdBuffer cmdBuffer, is null pointer");
9293 return;
9294 }
9295
9296 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
9297 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
9298 {
9299 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9300 "vkCmdSaveAtomicCounters parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
9301 return;
9302 }
9303
9304
9305
9306 if(destBuffer == nullptr)
9307 {
9308 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9309 "vkCmdSaveAtomicCounters parameter, VkBuffer destBuffer, is null pointer");
9310 return;
9311 }
9312
9313}
9314
9315VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(
9316 VkCmdBuffer cmdBuffer,
9317 VkPipelineBindPoint pipelineBindPoint,
9318 uint32_t startCounter,
9319 uint32_t counterCount,
9320 VkBuffer destBuffer,
9321 VkDeviceSize destOffset)
9322{
9323 PreCmdSaveAtomicCounters(cmdBuffer);
9324 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
9325
9326 PostCmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
9327}
9328
9329void PreCreateFramebuffer(
9330 VkDevice device,
9331 const VkFramebufferCreateInfo* pCreateInfo)
9332{
9333 if(device == nullptr)
9334 {
9335 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9336 "vkCreateFramebuffer parameter, VkDevice device, is null pointer");
9337 return;
9338 }
9339
9340 if(pCreateInfo == nullptr)
9341 {
9342 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9343 "vkCreateFramebuffer parameter, const VkFramebufferCreateInfo* pCreateInfo, is null pointer");
9344 return;
9345 }
9346 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
9347 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
9348 {
9349 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9350 "vkCreateFramebuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
9351 return;
9352 }
9353 if(pCreateInfo->pColorAttachments == nullptr)
9354 {
9355 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9356 "vkCreateFramebuffer parameter, const VkColorAttachmentBindInfo* pCreateInfo->pColorAttachments, is null pointer");
9357 return;
9358 }
9359 if(pCreateInfo->pColorAttachments->view == nullptr)
9360 {
9361 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9362 "vkCreateFramebuffer parameter, VkColorAttachmentView pCreateInfo->pColorAttachments->view, is null pointer");
9363 return;
9364 }
9365 if(pCreateInfo->pColorAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9366 pCreateInfo->pColorAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE)
9367 {
9368 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9369 "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pColorAttachments->layout, is unrecognized enumerator");
9370 return;
9371 }
9372 if(pCreateInfo->pDepthStencilAttachment == nullptr)
9373 {
9374 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9375 "vkCreateFramebuffer parameter, const VkDepthStencilBindInfo* pCreateInfo->pDepthStencilAttachment, is null pointer");
9376 return;
9377 }
9378 if(pCreateInfo->pDepthStencilAttachment->view == nullptr)
9379 {
9380 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9381 "vkCreateFramebuffer parameter, VkDepthStencilView pCreateInfo->pDepthStencilAttachment->view, is null pointer");
9382 return;
9383 }
9384 if(pCreateInfo->pDepthStencilAttachment->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9385 pCreateInfo->pDepthStencilAttachment->layout > VK_IMAGE_LAYOUT_END_RANGE)
9386 {
9387 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9388 "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pDepthStencilAttachment->layout, is unrecognized enumerator");
9389 return;
9390 }
9391}
9392
9393void PostCreateFramebuffer(
9394 VkDevice device,
9395 VkFramebuffer* pFramebuffer,
9396 VkResult result)
9397{
9398 if(device == nullptr)
9399 {
9400 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9401 "vkCreateFramebuffer parameter, VkDevice device, is null pointer");
9402 return;
9403 }
9404
9405 if(pFramebuffer == nullptr)
9406 {
9407 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9408 "vkCreateFramebuffer parameter, VkFramebuffer* pFramebuffer, is null pointer");
9409 return;
9410 }
9411 if((*pFramebuffer) == nullptr)
9412 {
9413 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9414 "vkCreateFramebuffer parameter, VkFramebuffer* pFramebuffer, is null pointer");
9415 return;
9416 }
9417
9418 if(result != VK_SUCCESS)
9419 {
9420 std::string reason = "vkCreateFramebuffer parameter, VkResult result, is " + EnumeratorString(result);
9421 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
9422 return;
9423 }
9424}
9425
9426VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(
9427 VkDevice device,
9428 const VkFramebufferCreateInfo* pCreateInfo,
9429 VkFramebuffer* pFramebuffer)
9430{
9431 PreCreateFramebuffer(device, pCreateInfo);
9432 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
9433
9434 PostCreateFramebuffer(device, pFramebuffer, result);
9435
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9436 return result;
9437}
9438
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9439void PreCreateRenderPass(
9440 VkDevice device,
9441 const VkRenderPassCreateInfo* pCreateInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9442{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9443 if(device == nullptr)
9444 {
9445 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9446 "vkCreateRenderPass parameter, VkDevice device, is null pointer");
9447 return;
9448 }
9449
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9450 if(pCreateInfo == nullptr)
9451 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9452 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9453 "vkCreateRenderPass parameter, const VkRenderPassCreateInfo* pCreateInfo, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9454 return;
9455 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9456 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
9457 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9458 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9459 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9460 "vkCreateRenderPass parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9461 return;
9462 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9463 if(pCreateInfo->pColorFormats == nullptr)
9464 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9465 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9466 "vkCreateRenderPass parameter, const VkFormat* pCreateInfo->pColorFormats, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9467 return;
9468 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9469 if((*pCreateInfo->pColorFormats) < VK_FORMAT_BEGIN_RANGE ||
9470 (*pCreateInfo->pColorFormats) > VK_FORMAT_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9471 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9472 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9473 "vkCreateRenderPass parameter, const VkFormat* pCreateInfo->pColorFormats, is unrecognized enumerator");
9474 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9475 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9476 if(pCreateInfo->pColorLayouts == nullptr)
9477 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9478 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9479 "vkCreateRenderPass parameter, const VkImageLayout* pCreateInfo->pColorLayouts, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9480 return;
9481 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9482 if((*pCreateInfo->pColorLayouts) < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9483 (*pCreateInfo->pColorLayouts) > VK_IMAGE_LAYOUT_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9484 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9485 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9486 "vkCreateRenderPass parameter, const VkImageLayout* pCreateInfo->pColorLayouts, is unrecognized enumerator");
9487 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9488 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9489 if(pCreateInfo->pColorLoadOps == nullptr)
9490 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9491 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9492 "vkCreateRenderPass parameter, const VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9493 return;
9494 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9495 if((*pCreateInfo->pColorLoadOps) < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
9496 (*pCreateInfo->pColorLoadOps) > VK_ATTACHMENT_LOAD_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9497 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9498 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9499 "vkCreateRenderPass parameter, const VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, is unrecognized enumerator");
9500 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9501 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9502 if(pCreateInfo->pColorStoreOps == nullptr)
9503 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9504 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9505 "vkCreateRenderPass parameter, const VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9506 return;
9507 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9508 if((*pCreateInfo->pColorStoreOps) < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
9509 (*pCreateInfo->pColorStoreOps) > VK_ATTACHMENT_STORE_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9510 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9511 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9512 "vkCreateRenderPass parameter, const VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, is unrecognized enumerator");
9513 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9514 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9515 if(pCreateInfo->pColorLoadClearValues == nullptr)
9516 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9517 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9518 "vkCreateRenderPass parameter, const VkClearColor* pCreateInfo->pColorLoadClearValues, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9519 return;
9520 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9521 if(pCreateInfo->depthStencilFormat < VK_FORMAT_BEGIN_RANGE ||
9522 pCreateInfo->depthStencilFormat > VK_FORMAT_END_RANGE)
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9523 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9524 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9525 "vkCreateRenderPass parameter, VkFormat pCreateInfo->depthStencilFormat, is unrecognized enumerator");
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9526 return;
9527 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9528 if(pCreateInfo->depthStencilLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9529 pCreateInfo->depthStencilLayout > VK_IMAGE_LAYOUT_END_RANGE)
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9530 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9531 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9532 "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->depthStencilLayout, is unrecognized enumerator");
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9533 return;
9534 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9535 if(pCreateInfo->depthLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
9536 pCreateInfo->depthLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9537 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9538 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9539 "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->depthLoadOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9540 return;
9541 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9542 if(pCreateInfo->depthStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
9543 pCreateInfo->depthStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9544 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9545 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9546 "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->depthStoreOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9547 return;
9548 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9549 if(pCreateInfo->stencilLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
9550 pCreateInfo->stencilLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9551 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9552 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9553 "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->stencilLoadOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9554 return;
9555 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9556 if(pCreateInfo->stencilStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
9557 pCreateInfo->stencilStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9558 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9559 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9560 "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->stencilStoreOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9561 return;
9562 }
9563}
9564
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9565void PostCreateRenderPass(
9566 VkDevice device,
9567 VkRenderPass* pRenderPass,
9568 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9569{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9570 if(device == nullptr)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9571 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9572 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9573 "vkCreateRenderPass parameter, VkDevice device, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9574 return;
9575 }
9576
9577 if(pRenderPass == nullptr)
9578 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9579 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9580 "vkCreateRenderPass parameter, VkRenderPass* pRenderPass, is null pointer");
9581 return;
9582 }
9583 if((*pRenderPass) == nullptr)
9584 {
9585 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9586 "vkCreateRenderPass parameter, VkRenderPass* pRenderPass, is null pointer");
9587 return;
9588 }
9589
9590 if(result != VK_SUCCESS)
9591 {
9592 std::string reason = "vkCreateRenderPass parameter, VkResult result, is " + EnumeratorString(result);
9593 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9594 return;
9595 }
9596}
9597
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9598VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
9599 VkDevice device,
9600 const VkRenderPassCreateInfo* pCreateInfo,
9601 VkRenderPass* pRenderPass)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9602{
9603 PreCreateRenderPass(device, pCreateInfo);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9604 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
9605
9606 PostCreateRenderPass(device, pRenderPass, result);
9607
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9608 return result;
9609}
9610
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9611void PreCmdBeginRenderPass(
9612 VkCmdBuffer cmdBuffer,
9613 const VkRenderPassBegin* pRenderPassBegin)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9614{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9615 if(cmdBuffer == nullptr)
9616 {
9617 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9618 "vkCmdBeginRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9619 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9620 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9621
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9622 if(pRenderPassBegin == nullptr)
9623 {
9624 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9625 "vkCmdBeginRenderPass parameter, const VkRenderPassBegin* pRenderPassBegin, is null pointer");
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9626 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9627 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9628 if(pRenderPassBegin->renderPass == nullptr)
9629 {
9630 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9631 "vkCmdBeginRenderPass parameter, VkRenderPass pRenderPassBegin->renderPass, is null pointer");
9632 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9633 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9634 if(pRenderPassBegin->framebuffer == nullptr)
9635 {
9636 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9637 "vkCmdBeginRenderPass parameter, VkFramebuffer pRenderPassBegin->framebuffer, is null pointer");
9638 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9639 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9640}
9641
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9642void PostCmdBeginRenderPass(
9643 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9644{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9645 if(cmdBuffer == nullptr)
9646 {
9647 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9648 "vkCmdBeginRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
9649 return;
9650 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9651}
9652
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9653VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(
9654 VkCmdBuffer cmdBuffer,
9655 const VkRenderPassBegin* pRenderPassBegin)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9656{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9657 PreCmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
9658 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
9659
9660 PostCmdBeginRenderPass(cmdBuffer);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9661}
9662
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9663void PreCmdEndRenderPass(
9664 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9665{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9666 if(cmdBuffer == nullptr)
9667 {
9668 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9669 "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
9670 return;
9671 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9672}
9673
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9674void PostCmdEndRenderPass(
9675 VkCmdBuffer cmdBuffer,
9676 VkRenderPass renderPass)
Chia-I Wu5b66aa52015-04-16 22:02:10 +0800[diff] [blame]9677{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9678 if(cmdBuffer == nullptr)
9679 {
9680 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9681 "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
9682 return;
9683 }
9684
9685 if(renderPass == nullptr)
9686 {
9687 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9688 "vkCmdEndRenderPass parameter, VkRenderPass renderPass, is null pointer");
9689 return;
9690 }
Chia-I Wu5b66aa52015-04-16 22:02:10 +0800[diff] [blame]9691}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9692
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9693VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(
9694 VkCmdBuffer cmdBuffer,
9695 VkRenderPass renderPass)
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9696{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9697 PreCmdEndRenderPass(cmdBuffer);
9698 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer, renderPass);
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9699
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9700 PostCmdEndRenderPass(cmdBuffer, renderPass);
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9701}
9702
Jon Ashburn1245cec2015-05-18 13:20:15 -0600[diff] [blame]9703VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9704{
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9705 if (device == NULL) {
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9706 return NULL;
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9707 }
9708
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9709 /* loader uses this to force layer initialization; device object is wrapped */
9710 if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9711 initDeviceTable(pc_device_table_map, (const VkBaseLayerObject *) device);
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9712 return (void*) vkGetDeviceProcAddr;
9713 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9714
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600[diff] [blame]9715 if (!strcmp(funcName, "vkCreateDevice"))
9716 return (void*) vkCreateDevice;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9717 if (!strcmp(funcName, "vkDestroyDevice"))
9718 return (void*) vkDestroyDevice;
9719 if (!strcmp(funcName, "vkGetDeviceQueue"))
9720 return (void*) vkGetDeviceQueue;
9721 if (!strcmp(funcName, "vkQueueSubmit"))
9722 return (void*) vkQueueSubmit;
9723 if (!strcmp(funcName, "vkQueueWaitIdle"))
9724 return (void*) vkQueueWaitIdle;
9725 if (!strcmp(funcName, "vkDeviceWaitIdle"))
9726 return (void*) vkDeviceWaitIdle;
9727 if (!strcmp(funcName, "vkAllocMemory"))
9728 return (void*) vkAllocMemory;
9729 if (!strcmp(funcName, "vkFreeMemory"))
9730 return (void*) vkFreeMemory;
9731 if (!strcmp(funcName, "vkMapMemory"))
9732 return (void*) vkMapMemory;
9733 if (!strcmp(funcName, "vkUnmapMemory"))
9734 return (void*) vkUnmapMemory;
9735 if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
9736 return (void*) vkFlushMappedMemoryRanges;
9737 if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges"))
9738 return (void*) vkInvalidateMappedMemoryRanges;
9739 if (!strcmp(funcName, "vkDestroyObject"))
9740 return (void*) vkDestroyObject;
9741 if (!strcmp(funcName, "vkGetObjectMemoryRequirements"))
9742 return (void*) vkGetObjectMemoryRequirements;
9743 if (!strcmp(funcName, "vkCreateFence"))
9744 return (void*) vkCreateFence;
9745 if (!strcmp(funcName, "vkResetFences"))
9746 return (void*) vkResetFences;
9747 if (!strcmp(funcName, "vkGetFenceStatus"))
9748 return (void*) vkGetFenceStatus;
9749 if (!strcmp(funcName, "vkWaitForFences"))
9750 return (void*) vkWaitForFences;
9751 if (!strcmp(funcName, "vkCreateSemaphore"))
9752 return (void*) vkCreateSemaphore;
9753 if (!strcmp(funcName, "vkQueueSignalSemaphore"))
9754 return (void*) vkQueueSignalSemaphore;
9755 if (!strcmp(funcName, "vkQueueWaitSemaphore"))
9756 return (void*) vkQueueWaitSemaphore;
9757 if (!strcmp(funcName, "vkCreateEvent"))
9758 return (void*) vkCreateEvent;
9759 if (!strcmp(funcName, "vkGetEventStatus"))
9760 return (void*) vkGetEventStatus;
9761 if (!strcmp(funcName, "vkSetEvent"))
9762 return (void*) vkSetEvent;
9763 if (!strcmp(funcName, "vkResetEvent"))
9764 return (void*) vkResetEvent;
9765 if (!strcmp(funcName, "vkCreateQueryPool"))
9766 return (void*) vkCreateQueryPool;
9767 if (!strcmp(funcName, "vkGetQueryPoolResults"))
9768 return (void*) vkGetQueryPoolResults;
9769 if (!strcmp(funcName, "vkCreateBuffer"))
9770 return (void*) vkCreateBuffer;
9771 if (!strcmp(funcName, "vkCreateBufferView"))
9772 return (void*) vkCreateBufferView;
9773 if (!strcmp(funcName, "vkCreateImage"))
9774 return (void*) vkCreateImage;
9775 if (!strcmp(funcName, "vkGetImageSubresourceLayout"))
9776 return (void*) vkGetImageSubresourceLayout;
9777 if (!strcmp(funcName, "vkCreateImageView"))
9778 return (void*) vkCreateImageView;
9779 if (!strcmp(funcName, "vkCreateColorAttachmentView"))
9780 return (void*) vkCreateColorAttachmentView;
9781 if (!strcmp(funcName, "vkCreateDepthStencilView"))
9782 return (void*) vkCreateDepthStencilView;
9783 if (!strcmp(funcName, "vkCreateShader"))
9784 return (void*) vkCreateShader;
9785 if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
9786 return (void*) vkCreateGraphicsPipeline;
9787 if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
9788 return (void*) vkCreateGraphicsPipelineDerivative;
9789 if (!strcmp(funcName, "vkCreateComputePipeline"))
9790 return (void*) vkCreateComputePipeline;
9791 if (!strcmp(funcName, "vkStorePipeline"))
9792 return (void*) vkStorePipeline;
9793 if (!strcmp(funcName, "vkLoadPipeline"))
9794 return (void*) vkLoadPipeline;
9795 if (!strcmp(funcName, "vkLoadPipelineDerivative"))
9796 return (void*) vkLoadPipelineDerivative;
9797 if (!strcmp(funcName, "vkCreatePipelineLayout"))
9798 return (void*) vkCreatePipelineLayout;
9799 if (!strcmp(funcName, "vkCreateSampler"))
9800 return (void*) vkCreateSampler;
9801 if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
9802 return (void*) vkCreateDescriptorSetLayout;
9803 if (!strcmp(funcName, "vkCreateDescriptorPool"))
9804 return (void*) vkCreateDescriptorPool;
9805 if (!strcmp(funcName, "vkResetDescriptorPool"))
9806 return (void*) vkResetDescriptorPool;
9807 if (!strcmp(funcName, "vkAllocDescriptorSets"))
9808 return (void*) vkAllocDescriptorSets;
9809 if (!strcmp(funcName, "vkCreateDynamicViewportState"))
9810 return (void*) vkCreateDynamicViewportState;
9811 if (!strcmp(funcName, "vkCreateDynamicRasterState"))
9812 return (void*) vkCreateDynamicRasterState;
9813 if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
9814 return (void*) vkCreateDynamicColorBlendState;
9815 if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
9816 return (void*) vkCreateDynamicDepthStencilState;
9817 if (!strcmp(funcName, "vkCreateCommandBuffer"))
9818 return (void*) vkCreateCommandBuffer;
9819 if (!strcmp(funcName, "vkBeginCommandBuffer"))
9820 return (void*) vkBeginCommandBuffer;
9821 if (!strcmp(funcName, "vkEndCommandBuffer"))
9822 return (void*) vkEndCommandBuffer;
9823 if (!strcmp(funcName, "vkResetCommandBuffer"))
9824 return (void*) vkResetCommandBuffer;
9825 if (!strcmp(funcName, "vkCmdBindPipeline"))
9826 return (void*) vkCmdBindPipeline;
9827 if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
9828 return (void*) vkCmdBindDynamicStateObject;
9829 if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
9830 return (void*) vkCmdBindDescriptorSets;
9831 if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
9832 return (void*) vkCmdBindVertexBuffers;
9833 if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
9834 return (void*) vkCmdBindIndexBuffer;
9835 if (!strcmp(funcName, "vkCmdDraw"))
9836 return (void*) vkCmdDraw;
9837 if (!strcmp(funcName, "vkCmdDrawIndexed"))
9838 return (void*) vkCmdDrawIndexed;
9839 if (!strcmp(funcName, "vkCmdDrawIndirect"))
9840 return (void*) vkCmdDrawIndirect;
9841 if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
9842 return (void*) vkCmdDrawIndexedIndirect;
9843 if (!strcmp(funcName, "vkCmdDispatch"))
9844 return (void*) vkCmdDispatch;
9845 if (!strcmp(funcName, "vkCmdDispatchIndirect"))
9846 return (void*) vkCmdDispatchIndirect;
9847 if (!strcmp(funcName, "vkCmdCopyBuffer"))
9848 return (void*) vkCmdCopyBuffer;
9849 if (!strcmp(funcName, "vkCmdCopyImage"))
9850 return (void*) vkCmdCopyImage;
9851 if (!strcmp(funcName, "vkCmdBlitImage"))
9852 return (void*) vkCmdBlitImage;
9853 if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
9854 return (void*) vkCmdCopyBufferToImage;
9855 if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
9856 return (void*) vkCmdCopyImageToBuffer;
9857 if (!strcmp(funcName, "vkCmdUpdateBuffer"))
9858 return (void*) vkCmdUpdateBuffer;
9859 if (!strcmp(funcName, "vkCmdFillBuffer"))
9860 return (void*) vkCmdFillBuffer;
9861 if (!strcmp(funcName, "vkCmdClearColorImage"))
9862 return (void*) vkCmdClearColorImage;
9863 if (!strcmp(funcName, "vkCmdClearDepthStencil"))
9864 return (void*) vkCmdClearDepthStencil;
9865 if (!strcmp(funcName, "vkCmdResolveImage"))
9866 return (void*) vkCmdResolveImage;
9867 if (!strcmp(funcName, "vkCmdSetEvent"))
9868 return (void*) vkCmdSetEvent;
9869 if (!strcmp(funcName, "vkCmdResetEvent"))
9870 return (void*) vkCmdResetEvent;
9871 if (!strcmp(funcName, "vkCmdWaitEvents"))
9872 return (void*) vkCmdWaitEvents;
9873 if (!strcmp(funcName, "vkCmdPipelineBarrier"))
9874 return (void*) vkCmdPipelineBarrier;
9875 if (!strcmp(funcName, "vkCmdBeginQuery"))
9876 return (void*) vkCmdBeginQuery;
9877 if (!strcmp(funcName, "vkCmdEndQuery"))
9878 return (void*) vkCmdEndQuery;
9879 if (!strcmp(funcName, "vkCmdResetQueryPool"))
9880 return (void*) vkCmdResetQueryPool;
9881 if (!strcmp(funcName, "vkCmdWriteTimestamp"))
9882 return (void*) vkCmdWriteTimestamp;
9883 if (!strcmp(funcName, "vkCmdCopyQueryPoolResults"))
9884 return (void*) vkCmdCopyQueryPoolResults;
9885 if (!strcmp(funcName, "vkCmdInitAtomicCounters"))
9886 return (void*) vkCmdInitAtomicCounters;
9887 if (!strcmp(funcName, "vkCmdLoadAtomicCounters"))
9888 return (void*) vkCmdLoadAtomicCounters;
9889 if (!strcmp(funcName, "vkCmdSaveAtomicCounters"))
9890 return (void*) vkCmdSaveAtomicCounters;
9891 if (!strcmp(funcName, "vkCreateFramebuffer"))
9892 return (void*) vkCreateFramebuffer;
9893 if (!strcmp(funcName, "vkCreateRenderPass"))
9894 return (void*) vkCreateRenderPass;
9895 if (!strcmp(funcName, "vkCmdBeginRenderPass"))
9896 return (void*) vkCmdBeginRenderPass;
9897 if (!strcmp(funcName, "vkCmdEndRenderPass"))
9898 return (void*) vkCmdEndRenderPass;
9899 if (!strcmp(funcName, "vkGetGlobalExtensionCount"))
9900 return (void*) vkGetGlobalExtensionCount;
9901 if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
9902 return (void*) vkGetGlobalExtensionProperties;
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9903
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9904 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9905 if (get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr == NULL)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9906 return NULL;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9907 return get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr(device, funcName);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9908 }
9909}
9910
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9911VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9912{
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9913 if (instance == NULL) {
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9914 return NULL;
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9915 }
9916
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9917 /* loader uses this to force layer initialization; instance object is wrapped */
9918 if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9919 initInstanceTable(pc_instance_table_map, (const VkBaseLayerObject *) instance);
9920 return (void *) vkGetInstanceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9921 }
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9922
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9923 if (!strcmp(funcName, "vkCreateInstance"))
9924 return (void*) vkCreateInstance;
9925 if (!strcmp(funcName, "vkDestroyInstance"))
9926 return (void*) vkDestroyInstance;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9927 if (!strcmp(funcName, "vkEnumeratePhysicalDevices"))
9928 return (void*) vkEnumeratePhysicalDevices;
9929 if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionCount"))
9930 return (void*) vkGetPhysicalDeviceExtensionCount;
9931 if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
9932 return (void*) vkGetPhysicalDeviceExtensionProperties;
9933 if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
9934 return (void*) vkGetPhysicalDeviceProperties;
9935 if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures"))
9936 return (void*) vkGetPhysicalDeviceFeatures;
9937 if (!strcmp(funcName, "vkGetPhysicalDeviceFormatInfo"))
9938 return (void*) vkGetPhysicalDeviceFormatInfo;
9939 if (!strcmp(funcName, "vkGetPhysicalDeviceLimits"))
9940 return (void*) vkGetPhysicalDeviceLimits;
Courtney Goeltzenleuchter09f85042015-06-01 14:45:27 -0600[diff] [blame]9941
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9942 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
9943 void* fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
9944 if(fptr)
Courtney Goeltzenleuchter09f85042015-06-01 14:45:27 -0600[diff] [blame]9945 return fptr;
9946
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9947 {
9948 if (get_dispatch_table(pc_instance_table_map, instance)->GetInstanceProcAddr == NULL)
9949 return NULL;
9950 return get_dispatch_table(pc_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);
9951 }
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9952}