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