Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 2951d7d57326884c44f0ecc3e8b45941f44a00ba / . / layers / param_checker.cpp
blob: 643399a4680184095958c066ce84cc036f5b4e02 [file] [log] [blame]
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]1/*
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2 * Vulkan
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include <iostream>
30#include <string>
31#include <sstream>
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]32#include <unordered_map>
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]33#include <vector>
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]34
35#include "loader_platform.h"
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]36#include "vkLayer.h"
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]37#include "layers_config.h"
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]38#include "vk_enum_validate_helper.h"
39#include "vk_struct_validate_helper.h"
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]40//The following is #included again to catch certain OS-specific functions being used:
41#include "loader_platform.h"
42
Jon Ashburn5a10d212015-06-01 10:02:09 -0600[diff] [blame]43#include "layers_table.h"
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]44#include "layer_data.h"
45#include "layer_logging.h"
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]46
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]47typedef struct _layer_data {
48 debug_report_data *report_data;
49 VkDbgMsgCallback logging_callback;
50} layer_data;
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]51
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]52static std::unordered_map<void*, layer_data*> layer_data_map;
53static device_table_map pc_device_table_map;
54static instance_table_map pc_instance_table_map;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]55
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]56#define PC_LAYER_EXT_ARRAY_SIZE 2
57static const VkExtensionProperties pcExts[PC_LAYER_EXT_ARRAY_SIZE] = {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]58 {
59 VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
60 "ParamChecker",
61 0x10,
62 "Sample layer: ParamChecker",
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600[diff] [blame]63 },
64 {
65 VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
66 "Validation",
67 0x10,
68 "Sample layer: ParamChecker",
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]69 }
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]70};
71
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]72// "my instance data"
73debug_report_data *mid(VkInstance object)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]74{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]75 dispatch_key key = get_dispatch_key(object);
76 layer_data *data = get_my_data_ptr(get_dispatch_key(object), layer_data_map);
77#if DISPATCH_MAP_DEBUG
78 fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
79#endif
80 assert(data->report_data != NULL);
81
82 return data->report_data;
83}
84
85// "my device data"
86debug_report_data *mdd(VkObject object)
87{
88 dispatch_key key = get_dispatch_key(object);
89 layer_data *data = get_my_data_ptr(key, layer_data_map);
90#if DISPATCH_MAP_DEBUG
91 fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
92#endif
93 assert(data->report_data != NULL);
94 return data->report_data;
95}
96
97static void InitParamChecker(layer_data *data)
98{
99 uint32_t report_flags = getLayerOptionFlags("ParamCheckerReportFlags", 0);
100
101 uint32_t debug_action = 0;
102 getLayerOptionEnum("ParamCheckerDebugAction", (uint32_t *) &debug_action);
103 if(debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
104 {
105 FILE *log_output = NULL;
106 const char* option_str = getLayerOption("ParamCheckerLogFilename");
107 if(option_str)
108 {
109 log_output = fopen(option_str, "w");
110 }
111 if(log_output == NULL)
112 {
113 log_output = stdout;
114 }
115
116 layer_create_msg_callback(data->report_data, report_flags, log_callback, (void*)log_output, &data->logging_callback);
117 }
118}
119
120VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
121 VkInstance instance,
122 VkFlags msgFlags,
123 const PFN_vkDbgMsgCallback pfnMsgCallback,
124 void* pUserData,
125 VkDbgMsgCallback* pMsgCallback)
126{
127 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
128 VkResult result = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
129
130 if (result == VK_SUCCESS)
131 {
132 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
133 result = layer_create_msg_callback(data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
134 }
135
136 return result;
137}
138
139VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
140 VkInstance instance,
141 VkDbgMsgCallback msgCallback)
142{
143 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
144 VkResult result = pTable->DbgDestroyMsgCallback(instance, msgCallback);
145
146 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
147 layer_destroy_msg_callback(data->report_data, msgCallback);
148
149 return result;
150}
151
152VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionCount(uint32_t* pCount)
153{
154 *pCount = PC_LAYER_EXT_ARRAY_SIZE;
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]155 return VK_SUCCESS;
156}
157
158VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionProperties(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]159 uint32_t extensionIndex,
160 VkExtensionProperties* pProperties)
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]161{
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]162 /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]163 if (extensionIndex >= PC_LAYER_EXT_ARRAY_SIZE)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]164 return VK_ERROR_INVALID_VALUE;
165 memcpy(pProperties, &pcExts[extensionIndex], sizeof(VkExtensionProperties));
Jon Ashburneb2728b2015-04-10 14:33:07 -0600[diff] [blame]166
167 return VK_SUCCESS;
168}
169
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]170VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionCount(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]171 VkPhysicalDevice gpu,
172 uint32_t* pCount)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]173{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]174 *pCount = PC_LAYER_EXT_ARRAY_SIZE;
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]175 return VK_SUCCESS;
176}
177
178VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]179 VkPhysicalDevice gpu,
180 uint32_t extensionIndex,
181 VkExtensionProperties* pProperties)
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]182{
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600[diff] [blame]183 /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]184 if (extensionIndex >= PC_LAYER_EXT_ARRAY_SIZE)
Tony Barbour426b9052015-06-24 16:06:58 -0600[diff] [blame]185 return VK_ERROR_INVALID_VALUE;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]186 memcpy(pProperties, &pcExts[extensionIndex], sizeof(VkExtensionProperties));
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600[diff] [blame]187
188 return VK_SUCCESS;
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]189}
190
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]191// Version: 0.111.0
192
193static
194std::string EnumeratorString(VkResult const& enumerator)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]195{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]196 switch(enumerator)
197 {
198 case VK_ERROR_MEMORY_NOT_BOUND:
199 {
200 return "VK_ERROR_MEMORY_NOT_BOUND";
201 break;
202 }
203 case VK_ERROR_BUILDING_COMMAND_BUFFER:
204 {
205 return "VK_ERROR_BUILDING_COMMAND_BUFFER";
206 break;
207 }
208 case VK_ERROR_INCOMPATIBLE_DRIVER:
209 {
210 return "VK_ERROR_INCOMPATIBLE_DRIVER";
211 break;
212 }
213 case VK_ERROR_MEMORY_UNMAP_FAILED:
214 {
215 return "VK_ERROR_MEMORY_UNMAP_FAILED";
216 break;
217 }
218 case VK_ERROR_MEMORY_MAP_FAILED:
219 {
220 return "VK_ERROR_MEMORY_MAP_FAILED";
221 break;
222 }
223 case VK_ERROR_BAD_PIPELINE_DATA:
224 {
225 return "VK_ERROR_BAD_PIPELINE_DATA";
226 break;
227 }
228 case VK_ERROR_INVALID_OBJECT_TYPE:
229 {
230 return "VK_ERROR_INVALID_OBJECT_TYPE";
231 break;
232 }
233 case VK_ERROR_INVALID_QUEUE_TYPE:
234 {
235 return "VK_ERROR_INVALID_QUEUE_TYPE";
236 break;
237 }
238 case VK_ERROR_BAD_SHADER_CODE:
239 {
240 return "VK_ERROR_BAD_SHADER_CODE";
241 break;
242 }
243 case VK_ERROR_INVALID_IMAGE:
244 {
245 return "VK_ERROR_INVALID_IMAGE";
246 break;
247 }
248 case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
249 {
250 return "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
251 break;
252 }
253 case VK_ERROR_INITIALIZATION_FAILED:
254 {
255 return "VK_ERROR_INITIALIZATION_FAILED";
256 break;
257 }
258 case VK_NOT_READY:
259 {
260 return "VK_NOT_READY";
261 break;
262 }
263 case VK_ERROR_INVALID_POINTER:
264 {
265 return "VK_ERROR_INVALID_POINTER";
266 break;
267 }
268 case VK_ERROR_INVALID_VALUE:
269 {
270 return "VK_ERROR_INVALID_VALUE";
271 break;
272 }
273 case VK_ERROR_UNAVAILABLE:
274 {
275 return "VK_ERROR_UNAVAILABLE";
276 break;
277 }
278 case VK_ERROR_OUT_OF_HOST_MEMORY:
279 {
280 return "VK_ERROR_OUT_OF_HOST_MEMORY";
281 break;
282 }
283 case VK_ERROR_UNKNOWN:
284 {
285 return "VK_ERROR_UNKNOWN";
286 break;
287 }
288 case VK_ERROR_NOT_MAPPABLE:
289 {
290 return "VK_ERROR_NOT_MAPPABLE";
291 break;
292 }
293 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
294 {
295 return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
296 break;
297 }
298 case VK_EVENT_SET:
299 {
300 return "VK_EVENT_SET";
301 break;
302 }
303 case VK_TIMEOUT:
304 {
305 return "VK_TIMEOUT";
306 break;
307 }
308 case VK_ERROR_INVALID_FLAGS:
309 {
310 return "VK_ERROR_INVALID_FLAGS";
311 break;
312 }
313 case VK_EVENT_RESET:
314 {
315 return "VK_EVENT_RESET";
316 break;
317 }
318 case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA:
319 {
320 return "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA";
321 break;
322 }
323 case VK_UNSUPPORTED:
324 {
325 return "VK_UNSUPPORTED";
326 break;
327 }
328 case VK_ERROR_INVALID_HANDLE:
329 {
330 return "VK_ERROR_INVALID_HANDLE";
331 break;
332 }
333 case VK_ERROR_INCOMPATIBLE_DEVICE:
334 {
335 return "VK_ERROR_INCOMPATIBLE_DEVICE";
336 break;
337 }
338 case VK_SUCCESS:
339 {
340 return "VK_SUCCESS";
341 break;
342 }
343 case VK_ERROR_INCOMPATIBLE_QUEUE:
344 {
345 return "VK_ERROR_INCOMPATIBLE_QUEUE";
346 break;
347 }
348 case VK_ERROR_INVALID_EXTENSION:
349 {
350 return "VK_ERROR_INVALID_EXTENSION";
351 break;
352 }
353 case VK_ERROR_DEVICE_ALREADY_CREATED:
354 {
355 return "VK_ERROR_DEVICE_ALREADY_CREATED";
356 break;
357 }
358 case VK_ERROR_DEVICE_LOST:
359 {
360 return "VK_ERROR_DEVICE_LOST";
361 break;
362 }
363 case VK_ERROR_INVALID_ORDINAL:
364 {
365 return "VK_ERROR_INVALID_ORDINAL";
366 break;
367 }
368 case VK_ERROR_INVALID_MEMORY_SIZE:
369 {
370 return "VK_ERROR_INVALID_MEMORY_SIZE";
371 break;
372 }
373 case VK_ERROR_INCOMPLETE_COMMAND_BUFFER:
374 {
375 return "VK_ERROR_INCOMPLETE_COMMAND_BUFFER";
376 break;
377 }
378 case VK_ERROR_INVALID_ALIGNMENT:
379 {
380 return "VK_ERROR_INVALID_ALIGNMENT";
381 break;
382 }
383 case VK_ERROR_INVALID_FORMAT:
384 {
385 return "VK_ERROR_INVALID_FORMAT";
386 break;
387 }
388 default:
389 {
390 return "unrecognized enumerator";
391 break;
392 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]393 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]394}
395
396static
397bool ValidateEnumerator(VkQueueFlagBits const& enumerator)
398{
399 VkQueueFlagBits allFlags = (VkQueueFlagBits)(VK_QUEUE_EXTENDED_BIT |
400 VK_QUEUE_DMA_BIT |
401 VK_QUEUE_COMPUTE_BIT |
402 VK_QUEUE_SPARSE_MEMMGR_BIT |
403 VK_QUEUE_GRAPHICS_BIT);
404 if(enumerator & (~allFlags))
405 {
406 return false;
407 }
408
409 return true;
410}
411
412static
413std::string EnumeratorString(VkQueueFlagBits const& enumerator)
414{
415 if(!ValidateEnumerator(enumerator))
416 {
417 return "unrecognized enumerator";
418 }
419
420 std::vector<std::string> strings;
421 if(enumerator & VK_QUEUE_EXTENDED_BIT)
422 {
423 strings.push_back("VK_QUEUE_EXTENDED_BIT");
424 }
425 if(enumerator & VK_QUEUE_DMA_BIT)
426 {
427 strings.push_back("VK_QUEUE_DMA_BIT");
428 }
429 if(enumerator & VK_QUEUE_COMPUTE_BIT)
430 {
431 strings.push_back("VK_QUEUE_COMPUTE_BIT");
432 }
433 if(enumerator & VK_QUEUE_SPARSE_MEMMGR_BIT)
434 {
435 strings.push_back("VK_QUEUE_SPARSE_MEMMGR_BIT");
436 }
437 if(enumerator & VK_QUEUE_GRAPHICS_BIT)
438 {
439 strings.push_back("VK_QUEUE_GRAPHICS_BIT");
440 }
441
442 std::string enumeratorString;
443 for(auto const& string : strings)
444 {
445 enumeratorString += string;
446
447 if(string != strings.back())
448 {
449 enumeratorString += '|';
450 }
451 }
452
453 return enumeratorString;
454}
455
456static
457bool ValidateEnumerator(VkMemoryPropertyFlagBits const& enumerator)
458{
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
2209
2210 if(fence == nullptr)
2211 {
2212 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2213 "vkQueueSubmit parameter, VkFence fence, is null pointer");
2214 return;
2215 }
2216
2217 if(result != VK_SUCCESS)
2218 {
2219 std::string reason = "vkQueueSubmit parameter, VkResult result, is " + EnumeratorString(result);
2220 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2221 return;
2222 }
2223}
2224
2225VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
2226 VkQueue queue,
2227 uint32_t cmdBufferCount,
2228 const VkCmdBuffer* pCmdBuffers,
2229 VkFence fence)
2230{
2231 PreQueueSubmit(queue, pCmdBuffers);
2232 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
2233
2234 PostQueueSubmit(queue, cmdBufferCount, fence, result);
2235
2236 return result;
2237}
2238
2239void PreQueueWaitIdle(
2240 VkQueue queue)
2241{
2242 if(queue == nullptr)
2243 {
2244 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2245 "vkQueueWaitIdle parameter, VkQueue queue, is null pointer");
2246 return;
2247 }
2248}
2249
2250void PostQueueWaitIdle(
2251 VkQueue queue,
2252 VkResult result)
2253{
2254 if(queue == nullptr)
2255 {
2256 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2257 "vkQueueWaitIdle parameter, VkQueue queue, is null pointer");
2258 return;
2259 }
2260
2261 if(result != VK_SUCCESS)
2262 {
2263 std::string reason = "vkQueueWaitIdle parameter, VkResult result, is " + EnumeratorString(result);
2264 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2265 return;
2266 }
2267}
2268
2269VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(
2270 VkQueue queue)
2271{
2272 PreQueueWaitIdle(queue);
2273 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueWaitIdle(queue);
2274
2275 PostQueueWaitIdle(queue, result);
2276
2277 return result;
2278}
2279
2280void PreDeviceWaitIdle(
2281 VkDevice device)
2282{
2283 if(device == nullptr)
2284 {
2285 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2286 "vkDeviceWaitIdle parameter, VkDevice device, is null pointer");
2287 return;
2288 }
2289}
2290
2291void PostDeviceWaitIdle(
2292 VkDevice device,
2293 VkResult result)
2294{
2295 if(device == nullptr)
2296 {
2297 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2298 "vkDeviceWaitIdle parameter, VkDevice device, is null pointer");
2299 return;
2300 }
2301
2302 if(result != VK_SUCCESS)
2303 {
2304 std::string reason = "vkDeviceWaitIdle parameter, VkResult result, is " + EnumeratorString(result);
2305 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2306 return;
2307 }
2308}
2309
2310VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(
2311 VkDevice device)
2312{
2313 PreDeviceWaitIdle(device);
2314 VkResult result = get_dispatch_table(pc_device_table_map, device)->DeviceWaitIdle(device);
2315
2316 PostDeviceWaitIdle(device, result);
2317
2318 return result;
2319}
2320
2321void PreAllocMemory(
2322 VkDevice device,
2323 const VkMemoryAllocInfo* pAllocInfo)
2324{
2325 if(device == nullptr)
2326 {
2327 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2328 "vkAllocMemory parameter, VkDevice device, is null pointer");
2329 return;
2330 }
2331
2332 if(pAllocInfo == nullptr)
2333 {
2334 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2335 "vkAllocMemory parameter, const VkMemoryAllocInfo* pAllocInfo, is null pointer");
2336 return;
2337 }
2338 if(pAllocInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
2339 pAllocInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
2340 {
2341 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2342 "vkAllocMemory parameter, VkStructureType pAllocInfo->sType, is unrecognized enumerator");
2343 return;
2344 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2345}
2346
2347void PostAllocMemory(
2348 VkDevice device,
2349 VkDeviceMemory* pMem,
2350 VkResult result)
2351{
2352 if(device == nullptr)
2353 {
2354 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2355 "vkAllocMemory parameter, VkDevice device, is null pointer");
2356 return;
2357 }
2358
2359 if(pMem == nullptr)
2360 {
2361 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2362 "vkAllocMemory parameter, VkDeviceMemory* pMem, is null pointer");
2363 return;
2364 }
2365 if((*pMem) == nullptr)
2366 {
2367 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2368 "vkAllocMemory parameter, VkDeviceMemory* pMem, is null pointer");
2369 return;
2370 }
2371
2372 if(result != VK_SUCCESS)
2373 {
2374 std::string reason = "vkAllocMemory parameter, VkResult result, is " + EnumeratorString(result);
2375 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2376 return;
2377 }
2378}
2379
2380VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
2381 VkDevice device,
2382 const VkMemoryAllocInfo* pAllocInfo,
2383 VkDeviceMemory* pMem)
2384{
2385 PreAllocMemory(device, pAllocInfo);
2386 VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pMem);
2387
2388 PostAllocMemory(device, pMem, result);
2389
2390 return result;
2391}
2392
2393void PreFreeMemory(
2394 VkDevice device)
2395{
2396 if(device == nullptr)
2397 {
2398 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2399 "vkFreeMemory parameter, VkDevice device, is null pointer");
2400 return;
2401 }
2402}
2403
2404void PostFreeMemory(
2405 VkDevice device,
2406 VkDeviceMemory mem,
2407 VkResult result)
2408{
2409 if(device == nullptr)
2410 {
2411 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2412 "vkFreeMemory parameter, VkDevice device, is null pointer");
2413 return;
2414 }
2415
2416 if(mem == nullptr)
2417 {
2418 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2419 "vkFreeMemory parameter, VkDeviceMemory mem, is null pointer");
2420 return;
2421 }
2422
2423 if(result != VK_SUCCESS)
2424 {
2425 std::string reason = "vkFreeMemory parameter, VkResult result, is " + EnumeratorString(result);
2426 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2427 return;
2428 }
2429}
2430
2431VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(
2432 VkDevice device,
2433 VkDeviceMemory mem)
2434{
2435 PreFreeMemory(device);
2436 VkResult result = get_dispatch_table(pc_device_table_map, device)->FreeMemory(device, mem);
2437
2438 PostFreeMemory(device, mem, result);
2439
2440 return result;
2441}
2442
2443void PreMapMemory(
2444 VkDevice device)
2445{
2446 if(device == nullptr)
2447 {
2448 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2449 "vkMapMemory parameter, VkDevice device, is null pointer");
2450 return;
2451 }
2452}
2453
2454void PostMapMemory(
2455 VkDevice device,
2456 VkDeviceMemory mem,
2457 VkDeviceSize offset,
2458 VkDeviceSize size,
2459 VkMemoryMapFlags flags,
2460 void** ppData,
2461 VkResult result)
2462{
2463 if(device == nullptr)
2464 {
2465 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2466 "vkMapMemory parameter, VkDevice device, is null pointer");
2467 return;
2468 }
2469
2470 if(mem == nullptr)
2471 {
2472 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2473 "vkMapMemory parameter, VkDeviceMemory mem, is null pointer");
2474 return;
2475 }
2476
2477
2478
2479
2480 if(ppData == nullptr)
2481 {
2482 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2483 "vkMapMemory parameter, void** ppData, is null pointer");
2484 return;
2485 }
2486
2487 if(result != VK_SUCCESS)
2488 {
2489 std::string reason = "vkMapMemory parameter, VkResult result, is " + EnumeratorString(result);
2490 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2491 return;
2492 }
2493}
2494
2495VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
2496 VkDevice device,
2497 VkDeviceMemory mem,
2498 VkDeviceSize offset,
2499 VkDeviceSize size,
2500 VkMemoryMapFlags flags,
2501 void** ppData)
2502{
2503 PreMapMemory(device);
2504 VkResult result = get_dispatch_table(pc_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData);
2505
2506 PostMapMemory(device, mem, offset, size, flags, ppData, result);
2507
2508 return result;
2509}
2510
2511void PreUnmapMemory(
2512 VkDevice device)
2513{
2514 if(device == nullptr)
2515 {
2516 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2517 "vkUnmapMemory parameter, VkDevice device, is null pointer");
2518 return;
2519 }
2520}
2521
2522void PostUnmapMemory(
2523 VkDevice device,
2524 VkDeviceMemory mem,
2525 VkResult result)
2526{
2527 if(device == nullptr)
2528 {
2529 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2530 "vkUnmapMemory parameter, VkDevice device, is null pointer");
2531 return;
2532 }
2533
2534 if(mem == nullptr)
2535 {
2536 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2537 "vkUnmapMemory parameter, VkDeviceMemory mem, is null pointer");
2538 return;
2539 }
2540
2541 if(result != VK_SUCCESS)
2542 {
2543 std::string reason = "vkUnmapMemory parameter, VkResult result, is " + EnumeratorString(result);
2544 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2545 return;
2546 }
2547}
2548
2549VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(
2550 VkDevice device,
2551 VkDeviceMemory mem)
2552{
2553 PreUnmapMemory(device);
2554 VkResult result = get_dispatch_table(pc_device_table_map, device)->UnmapMemory(device, mem);
2555
2556 PostUnmapMemory(device, mem, result);
2557
2558 return result;
2559}
2560
2561void PreFlushMappedMemoryRanges(
2562 VkDevice device,
2563 const VkMappedMemoryRange* pMemRanges)
2564{
2565 if(device == nullptr)
2566 {
2567 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2568 "vkFlushMappedMemoryRanges parameter, VkDevice device, is null pointer");
2569 return;
2570 }
2571
2572 if(pMemRanges == nullptr)
2573 {
2574 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2575 "vkFlushMappedMemoryRanges parameter, const VkMappedMemoryRange* pMemRanges, is null pointer");
2576 return;
2577 }
2578 if(pMemRanges->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
2579 pMemRanges->sType > VK_STRUCTURE_TYPE_END_RANGE)
2580 {
2581 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2582 "vkFlushMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is unrecognized enumerator");
2583 return;
2584 }
2585 if(pMemRanges->mem == nullptr)
2586 {
2587 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2588 "vkFlushMappedMemoryRanges parameter, VkDeviceMemory pMemRanges->mem, is null pointer");
2589 return;
2590 }
2591}
2592
2593void PostFlushMappedMemoryRanges(
2594 VkDevice device,
2595 uint32_t memRangeCount,
2596 VkResult result)
2597{
2598 if(device == nullptr)
2599 {
2600 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2601 "vkFlushMappedMemoryRanges parameter, VkDevice device, is null pointer");
2602 return;
2603 }
2604
2605
2606 if(result != VK_SUCCESS)
2607 {
2608 std::string reason = "vkFlushMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result);
2609 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2610 return;
2611 }
2612}
2613
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2614VK_LAYER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2615 VkDevice device,
2616 uint32_t memRangeCount,
2617 const VkMappedMemoryRange* pMemRanges)
Tony Barbour859ceab2015-04-16 19:23:13 -0600[diff] [blame]2618{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2619 PreFlushMappedMemoryRanges(device, pMemRanges);
2620 VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
Tony Barbour859ceab2015-04-16 19:23:13 -0600[diff] [blame]2621
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2622 PostFlushMappedMemoryRanges(device, memRangeCount, result);
2623
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2624 return result;
2625}
2626
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2627void PreInvalidateMappedMemoryRanges(
2628 VkDevice device,
2629 const VkMappedMemoryRange* pMemRanges)
2630{
2631 if(device == nullptr)
2632 {
2633 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2634 "vkInvalidateMappedMemoryRanges parameter, VkDevice device, is null pointer");
2635 return;
2636 }
2637
2638 if(pMemRanges == nullptr)
2639 {
2640 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2641 "vkInvalidateMappedMemoryRanges parameter, const VkMappedMemoryRange* pMemRanges, is null pointer");
2642 return;
2643 }
2644 if(pMemRanges->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
2645 pMemRanges->sType > VK_STRUCTURE_TYPE_END_RANGE)
2646 {
2647 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2648 "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is unrecognized enumerator");
2649 return;
2650 }
2651 if(pMemRanges->mem == nullptr)
2652 {
2653 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2654 "vkInvalidateMappedMemoryRanges parameter, VkDeviceMemory pMemRanges->mem, is null pointer");
2655 return;
2656 }
2657}
2658
2659void PostInvalidateMappedMemoryRanges(
2660 VkDevice device,
2661 uint32_t memRangeCount,
2662 VkResult result)
2663{
2664 if(device == nullptr)
2665 {
2666 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2667 "vkInvalidateMappedMemoryRanges parameter, VkDevice device, is null pointer");
2668 return;
2669 }
2670
2671
2672 if(result != VK_SUCCESS)
2673 {
2674 std::string reason = "vkInvalidateMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result);
2675 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2676 return;
2677 }
2678}
2679
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2680VK_LAYER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2681 VkDevice device,
2682 uint32_t memRangeCount,
2683 const VkMappedMemoryRange* pMemRanges)
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2684{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2685 PreInvalidateMappedMemoryRanges(device, pMemRanges);
2686 VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
Courtney Goeltzenleuchtera569a502015-04-29 17:16:21 -0600[diff] [blame]2687
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2688 PostInvalidateMappedMemoryRanges(device, memRangeCount, result);
2689
Tony Barbour859ceab2015-04-16 19:23:13 -0600[diff] [blame]2690 return result;
2691}
2692
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2693void PreDestroyObject(
2694 VkDevice device)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2695{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2696 if(device == nullptr)
2697 {
2698 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2699 "vkDestroyObject parameter, VkDevice device, is null pointer");
2700 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2701 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2702}
2703
2704void PostDestroyObject(
2705 VkDevice device,
2706 VkObjectType objType,
2707 VkObject object,
2708 VkResult result)
2709{
2710 if(device == nullptr)
2711 {
2712 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2713 "vkDestroyObject parameter, VkDevice device, is null pointer");
2714 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2715 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2716
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2717 if(objType < VK_OBJECT_TYPE_BEGIN_RANGE ||
2718 objType > VK_OBJECT_TYPE_END_RANGE)
2719 {
2720 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2721 "vkDestroyObject parameter, VkObjectType objType, is unrecognized enumerator");
2722 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2723 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2724
2725 if(object == nullptr)
2726 {
2727 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2728 "vkDestroyObject parameter, VkObject object, is null pointer");
2729 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2730 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2731
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2732 if(result != VK_SUCCESS)
2733 {
2734 std::string reason = "vkDestroyObject parameter, VkResult result, is " + EnumeratorString(result);
2735 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2736 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2737 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2738}
2739
2740VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(
2741 VkDevice device,
2742 VkObjectType objType,
2743 VkObject object)
2744{
2745 PreDestroyObject(device);
2746 VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyObject(device, objType, object);
2747
2748 PostDestroyObject(device, objType, object, result);
2749
2750 return result;
2751}
2752
2753void PreBindObjectMemory(
2754 VkDevice device)
2755{
2756 if(device == nullptr)
2757 {
2758 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2759 "vkBindObjectMemory parameter, VkDevice device, is null pointer");
2760 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2761 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2762}
2763
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2764void PostBindObjectMemory(
2765 VkDevice device,
2766 VkObjectType objType,
2767 VkObject object,
2768 VkDeviceMemory mem,
2769 VkDeviceSize memOffset,
2770 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2771{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2772 if(device == nullptr)
2773 {
2774 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2775 "vkBindObjectMemory parameter, VkDevice device, is null pointer");
2776 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2777 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2778
2779 if(objType < VK_OBJECT_TYPE_BEGIN_RANGE ||
2780 objType > VK_OBJECT_TYPE_END_RANGE)
2781 {
2782 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2783 "vkBindObjectMemory parameter, VkObjectType objType, is unrecognized enumerator");
2784 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2785 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2786
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2787 if(object == nullptr)
2788 {
2789 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2790 "vkBindObjectMemory parameter, VkObject object, is null pointer");
2791 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2792 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2793
2794 if(mem == nullptr)
2795 {
2796 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2797 "vkBindObjectMemory parameter, VkDeviceMemory mem, is null pointer");
2798 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2799 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2800
2801
2802 if(result != VK_SUCCESS)
2803 {
2804 std::string reason = "vkBindObjectMemory parameter, VkResult result, is " + EnumeratorString(result);
2805 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2806 return;
2807 }
2808}
2809
2810VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(
2811 VkDevice device,
2812 VkObjectType objType,
2813 VkObject object,
2814 VkDeviceMemory mem,
2815 VkDeviceSize memOffset)
2816{
2817 PreBindObjectMemory(device);
2818 VkResult result = get_dispatch_table(pc_device_table_map, device)->BindObjectMemory(device, objType, object, mem, memOffset);
2819
2820 PostBindObjectMemory(device, objType, object, mem, memOffset, result);
2821
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2822 return result;
2823}
2824
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2825void PreGetObjectMemoryRequirements(
2826 VkDevice device)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2827{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2828 if(device == nullptr)
2829 {
2830 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2831 "vkGetObjectMemoryRequirements parameter, VkDevice device, is null pointer");
2832 return;
2833 }
2834}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2835
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2836void PostGetObjectMemoryRequirements(
2837 VkDevice device,
2838 VkObjectType objType,
2839 VkObject object,
2840 VkMemoryRequirements* pMemoryRequirements,
2841 VkResult result)
2842{
2843 if(device == nullptr)
2844 {
2845 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2846 "vkGetObjectMemoryRequirements parameter, VkDevice device, is null pointer");
2847 return;
2848 }
2849
2850 if(objType < VK_OBJECT_TYPE_BEGIN_RANGE ||
2851 objType > VK_OBJECT_TYPE_END_RANGE)
2852 {
2853 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2854 "vkGetObjectMemoryRequirements parameter, VkObjectType objType, is unrecognized enumerator");
2855 return;
2856 }
2857
2858 if(object == nullptr)
2859 {
2860 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2861 "vkGetObjectMemoryRequirements parameter, VkObject object, is null pointer");
2862 return;
2863 }
2864
2865 if(pMemoryRequirements == nullptr)
2866 {
2867 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2868 "vkGetObjectMemoryRequirements parameter, VkMemoryRequirements* pMemoryRequirements, is null pointer");
2869 return;
2870 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2871
2872 if(result != VK_SUCCESS)
2873 {
2874 std::string reason = "vkGetObjectMemoryRequirements parameter, VkResult result, is " + EnumeratorString(result);
2875 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2876 return;
2877 }
2878}
2879
2880VK_LAYER_EXPORT VkResult VKAPI vkGetObjectMemoryRequirements(
2881 VkDevice device,
2882 VkObjectType objType,
2883 VkObject object,
2884 VkMemoryRequirements* pMemoryRequirements)
2885{
2886 PreGetObjectMemoryRequirements(device);
2887 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetObjectMemoryRequirements(device, objType, object, pMemoryRequirements);
2888
2889 PostGetObjectMemoryRequirements(device, objType, object, pMemoryRequirements, result);
2890
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2891 return result;
2892}
2893
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2894void PreQueueBindSparseBufferMemory(
2895 VkQueue queue)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2896{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2897 if(queue == nullptr)
2898 {
2899 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2900 "vkQueueBindSparseBufferMemory parameter, VkQueue queue, is null pointer");
2901 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2902 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2903}
2904
2905void PostQueueBindSparseBufferMemory(
2906 VkQueue queue,
2907 VkBuffer buffer,
2908 VkDeviceSize rangeOffset,
2909 VkDeviceSize rangeSize,
2910 VkDeviceMemory mem,
2911 VkDeviceSize memOffset,
2912 VkResult result)
2913{
2914 if(queue == nullptr)
2915 {
2916 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2917 "vkQueueBindSparseBufferMemory parameter, VkQueue queue, is null pointer");
2918 return;
2919 }
2920
2921 if(buffer == nullptr)
2922 {
2923 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2924 "vkQueueBindSparseBufferMemory parameter, VkBuffer buffer, is null pointer");
2925 return;
2926 }
2927
2928
2929
2930 if(mem == nullptr)
2931 {
2932 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2933 "vkQueueBindSparseBufferMemory parameter, VkDeviceMemory mem, is null pointer");
2934 return;
2935 }
2936
2937
2938 if(result != VK_SUCCESS)
2939 {
2940 std::string reason = "vkQueueBindSparseBufferMemory parameter, VkResult result, is " + EnumeratorString(result);
2941 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
2942 return;
2943 }
2944}
2945
2946VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
2947 VkQueue queue,
2948 VkBuffer buffer,
2949 VkDeviceSize rangeOffset,
2950 VkDeviceSize rangeSize,
2951 VkDeviceMemory mem,
2952 VkDeviceSize memOffset)
2953{
2954 PreQueueBindSparseBufferMemory(queue);
2955 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
2956
2957 PostQueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset, result);
2958
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2959 return result;
2960}
2961
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2962void PreQueueBindSparseImageMemory(
2963 VkQueue queue,
2964 const VkImageMemoryBindInfo* pBindInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2965{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2966 if(queue == nullptr)
2967 {
2968 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2969 "vkQueueBindSparseImageMemory parameter, VkQueue queue, is null pointer");
2970 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2971 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2972
2973 if(pBindInfo == nullptr)
2974 {
2975 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2976 "vkQueueBindSparseImageMemory parameter, const VkImageMemoryBindInfo* pBindInfo, is null pointer");
2977 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]2978 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]2979 if(pBindInfo->subresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
2980 pBindInfo->subresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
2981 {
2982 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2983 "vkQueueBindSparseImageMemory parameter, VkImageAspect pBindInfo->subresource.aspect, is unrecognized enumerator");
2984 return;
2985 }
2986}
2987
2988void PostQueueBindSparseImageMemory(
2989 VkQueue queue,
2990 VkImage image,
2991 VkDeviceMemory mem,
2992 VkDeviceSize memOffset,
2993 VkResult result)
2994{
2995 if(queue == nullptr)
2996 {
2997 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
2998 "vkQueueBindSparseImageMemory parameter, VkQueue queue, is null pointer");
2999 return;
3000 }
3001
3002 if(image == nullptr)
3003 {
3004 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3005 "vkQueueBindSparseImageMemory parameter, VkImage image, is null pointer");
3006 return;
3007 }
3008
3009 if(mem == nullptr)
3010 {
3011 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3012 "vkQueueBindSparseImageMemory parameter, VkDeviceMemory mem, is null pointer");
3013 return;
3014 }
3015
3016
3017 if(result != VK_SUCCESS)
3018 {
3019 std::string reason = "vkQueueBindSparseImageMemory parameter, VkResult result, is " + EnumeratorString(result);
3020 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3021 return;
3022 }
3023}
3024
3025VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
3026 VkQueue queue,
3027 VkImage image,
3028 const VkImageMemoryBindInfo* pBindInfo,
3029 VkDeviceMemory mem,
3030 VkDeviceSize memOffset)
3031{
3032 PreQueueBindSparseImageMemory(queue, pBindInfo);
3033 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
3034
3035 PostQueueBindSparseImageMemory(queue, image, mem, memOffset, result);
3036
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3037 return result;
3038}
3039
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3040void PreCreateFence(
3041 VkDevice device,
3042 const VkFenceCreateInfo* pCreateInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3043{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3044 if(device == nullptr)
3045 {
3046 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3047 "vkCreateFence parameter, VkDevice device, is null pointer");
3048 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3049 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3050
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3051 if(pCreateInfo == nullptr)
3052 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3053 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3054 "vkCreateFence parameter, const VkFenceCreateInfo* pCreateInfo, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3055 return;
3056 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3057 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3058 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3059 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3060 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3061 "vkCreateFence parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3062 return;
3063 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3064 if(!ValidateEnumerator((VkFenceCreateFlagBits)pCreateInfo->flags))
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3065 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3066 std::string reason = "vkCreateFence parameter, VkFenceCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkFenceCreateFlagBits)pCreateInfo->flags);
3067 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]3068 return;
3069 }
3070}
3071
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3072void PostCreateFence(
3073 VkDevice device,
3074 VkFence* pFence,
3075 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3076{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3077 if(device == nullptr)
3078 {
3079 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3080 "vkCreateFence parameter, VkDevice device, is null pointer");
3081 return;
3082 }
3083
3084 if(pFence == nullptr)
3085 {
3086 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3087 "vkCreateFence parameter, VkFence* pFence, is null pointer");
3088 return;
3089 }
3090 if((*pFence) == nullptr)
3091 {
3092 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3093 "vkCreateFence parameter, VkFence* pFence, is null pointer");
3094 return;
3095 }
3096
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]3097 if(result != VK_SUCCESS)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]3098 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]3099 std::string reason = "vkCreateFence parameter, VkResult result, is " + EnumeratorString(result);
3100 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3101 return;
3102 }
3103}
3104
3105VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
3106 VkDevice device,
3107 const VkFenceCreateInfo* pCreateInfo,
3108 VkFence* pFence)
3109{
3110 PreCreateFence(device, pCreateInfo);
3111 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
3112
3113 PostCreateFence(device, pFence, result);
3114
3115 return result;
3116}
3117
3118void PreResetFences(
3119 VkDevice device,
3120 const VkFence* pFences)
3121{
3122 if(device == nullptr)
3123 {
3124 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3125 "vkResetFences parameter, VkDevice device, is null pointer");
3126 return;
3127 }
3128
3129 if(pFences == nullptr)
3130 {
3131 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3132 "vkResetFences parameter, const VkFence* pFences, is null pointer");
3133 return;
3134 }
3135 if((*pFences) == nullptr)
3136 {
3137 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3138 "vkResetFences parameter, const VkFence* pFences, is null pointer");
3139 return;
3140 }
3141}
3142
3143void PostResetFences(
3144 VkDevice device,
3145 uint32_t fenceCount,
3146 VkResult result)
3147{
3148 if(device == nullptr)
3149 {
3150 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3151 "vkResetFences parameter, VkDevice device, is null pointer");
3152 return;
3153 }
3154
3155
3156 if(result != VK_SUCCESS)
3157 {
3158 std::string reason = "vkResetFences parameter, VkResult result, is " + EnumeratorString(result);
3159 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3160 return;
3161 }
3162}
3163
3164VK_LAYER_EXPORT VkResult VKAPI vkResetFences(
3165 VkDevice device,
3166 uint32_t fenceCount,
3167 const VkFence* pFences)
3168{
3169 PreResetFences(device, pFences);
3170 VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetFences(device, fenceCount, pFences);
3171
3172 PostResetFences(device, fenceCount, result);
3173
3174 return result;
3175}
3176
3177void PreGetFenceStatus(
3178 VkDevice device)
3179{
3180 if(device == nullptr)
3181 {
3182 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3183 "vkGetFenceStatus parameter, VkDevice device, is null pointer");
3184 return;
3185 }
3186}
3187
3188void PostGetFenceStatus(
3189 VkDevice device,
3190 VkFence fence,
3191 VkResult result)
3192{
3193 if(device == nullptr)
3194 {
3195 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3196 "vkGetFenceStatus parameter, VkDevice device, is null pointer");
3197 return;
3198 }
3199
3200 if(fence == nullptr)
3201 {
3202 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3203 "vkGetFenceStatus parameter, VkFence fence, is null pointer");
3204 return;
3205 }
3206
3207 if(result != VK_SUCCESS)
3208 {
3209 std::string reason = "vkGetFenceStatus parameter, VkResult result, is " + EnumeratorString(result);
3210 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3211 return;
3212 }
3213}
3214
3215VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(
3216 VkDevice device,
3217 VkFence fence)
3218{
3219 PreGetFenceStatus(device);
3220 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetFenceStatus(device, fence);
3221
3222 PostGetFenceStatus(device, fence, result);
3223
3224 return result;
3225}
3226
3227void PreWaitForFences(
3228 VkDevice device,
3229 const VkFence* pFences)
3230{
3231 if(device == nullptr)
3232 {
3233 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3234 "vkWaitForFences parameter, VkDevice device, is null pointer");
3235 return;
3236 }
3237
3238 if(pFences == nullptr)
3239 {
3240 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3241 "vkWaitForFences parameter, const VkFence* pFences, is null pointer");
3242 return;
3243 }
3244 if((*pFences) == nullptr)
3245 {
3246 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3247 "vkWaitForFences parameter, const VkFence* pFences, is null pointer");
3248 return;
3249 }
3250}
3251
3252void PostWaitForFences(
3253 VkDevice device,
3254 uint32_t fenceCount,
3255 bool32_t waitAll,
3256 uint64_t timeout,
3257 VkResult result)
3258{
3259 if(device == nullptr)
3260 {
3261 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3262 "vkWaitForFences parameter, VkDevice device, is null pointer");
3263 return;
3264 }
3265
3266
3267
3268
3269 if(result != VK_SUCCESS)
3270 {
3271 std::string reason = "vkWaitForFences parameter, VkResult result, is " + EnumeratorString(result);
3272 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3273 return;
3274 }
3275}
3276
3277VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(
3278 VkDevice device,
3279 uint32_t fenceCount,
3280 const VkFence* pFences,
3281 bool32_t waitAll,
3282 uint64_t timeout)
3283{
3284 PreWaitForFences(device, pFences);
3285 VkResult result = get_dispatch_table(pc_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
3286
3287 PostWaitForFences(device, fenceCount, waitAll, timeout, result);
3288
3289 return result;
3290}
3291
3292void PreCreateSemaphore(
3293 VkDevice device,
3294 const VkSemaphoreCreateInfo* pCreateInfo)
3295{
3296 if(device == nullptr)
3297 {
3298 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3299 "vkCreateSemaphore parameter, VkDevice device, is null pointer");
3300 return;
3301 }
3302
3303 if(pCreateInfo == nullptr)
3304 {
3305 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3306 "vkCreateSemaphore parameter, const VkSemaphoreCreateInfo* pCreateInfo, is null pointer");
3307 return;
3308 }
3309 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3310 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3311 {
3312 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3313 "vkCreateSemaphore parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3314 return;
3315 }
3316}
3317
3318void PostCreateSemaphore(
3319 VkDevice device,
3320 VkSemaphore* pSemaphore,
3321 VkResult result)
3322{
3323 if(device == nullptr)
3324 {
3325 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3326 "vkCreateSemaphore parameter, VkDevice device, is null pointer");
3327 return;
3328 }
3329
3330 if(pSemaphore == nullptr)
3331 {
3332 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3333 "vkCreateSemaphore parameter, VkSemaphore* pSemaphore, is null pointer");
3334 return;
3335 }
3336 if((*pSemaphore) == nullptr)
3337 {
3338 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3339 "vkCreateSemaphore parameter, VkSemaphore* pSemaphore, is null pointer");
3340 return;
3341 }
3342
3343 if(result != VK_SUCCESS)
3344 {
3345 std::string reason = "vkCreateSemaphore parameter, VkResult result, is " + EnumeratorString(result);
3346 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3347 return;
3348 }
3349}
3350
3351VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
3352 VkDevice device,
3353 const VkSemaphoreCreateInfo* pCreateInfo,
3354 VkSemaphore* pSemaphore)
3355{
3356 PreCreateSemaphore(device, pCreateInfo);
3357 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore);
3358
3359 PostCreateSemaphore(device, pSemaphore, result);
3360
3361 return result;
3362}
3363
3364void PreQueueSignalSemaphore(
3365 VkQueue queue)
3366{
3367 if(queue == nullptr)
3368 {
3369 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3370 "vkQueueSignalSemaphore parameter, VkQueue queue, is null pointer");
3371 return;
3372 }
3373}
3374
3375void PostQueueSignalSemaphore(
3376 VkQueue queue,
3377 VkSemaphore semaphore,
3378 VkResult result)
3379{
3380 if(queue == nullptr)
3381 {
3382 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3383 "vkQueueSignalSemaphore parameter, VkQueue queue, is null pointer");
3384 return;
3385 }
3386
3387 if(semaphore == nullptr)
3388 {
3389 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3390 "vkQueueSignalSemaphore parameter, VkSemaphore semaphore, is null pointer");
3391 return;
3392 }
3393
3394 if(result != VK_SUCCESS)
3395 {
3396 std::string reason = "vkQueueSignalSemaphore parameter, VkResult result, is " + EnumeratorString(result);
3397 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3398 return;
3399 }
3400}
3401
3402VK_LAYER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(
3403 VkQueue queue,
3404 VkSemaphore semaphore)
3405{
3406 PreQueueSignalSemaphore(queue);
3407 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueSignalSemaphore(queue, semaphore);
3408
3409 PostQueueSignalSemaphore(queue, semaphore, result);
3410
3411 return result;
3412}
3413
3414void PreQueueWaitSemaphore(
3415 VkQueue queue)
3416{
3417 if(queue == nullptr)
3418 {
3419 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3420 "vkQueueWaitSemaphore parameter, VkQueue queue, is null pointer");
3421 return;
3422 }
3423}
3424
3425void PostQueueWaitSemaphore(
3426 VkQueue queue,
3427 VkSemaphore semaphore,
3428 VkResult result)
3429{
3430 if(queue == nullptr)
3431 {
3432 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3433 "vkQueueWaitSemaphore parameter, VkQueue queue, is null pointer");
3434 return;
3435 }
3436
3437 if(semaphore == nullptr)
3438 {
3439 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3440 "vkQueueWaitSemaphore parameter, VkSemaphore semaphore, is null pointer");
3441 return;
3442 }
3443
3444 if(result != VK_SUCCESS)
3445 {
3446 std::string reason = "vkQueueWaitSemaphore parameter, VkResult result, is " + EnumeratorString(result);
3447 log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3448 return;
3449 }
3450}
3451
3452VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(
3453 VkQueue queue,
3454 VkSemaphore semaphore)
3455{
3456 PreQueueWaitSemaphore(queue);
3457 VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueWaitSemaphore(queue, semaphore);
3458
3459 PostQueueWaitSemaphore(queue, semaphore, result);
3460
3461 return result;
3462}
3463
3464void PreCreateEvent(
3465 VkDevice device,
3466 const VkEventCreateInfo* pCreateInfo)
3467{
3468 if(device == nullptr)
3469 {
3470 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3471 "vkCreateEvent parameter, VkDevice device, is null pointer");
3472 return;
3473 }
3474
3475 if(pCreateInfo == nullptr)
3476 {
3477 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3478 "vkCreateEvent parameter, const VkEventCreateInfo* pCreateInfo, is null pointer");
3479 return;
3480 }
3481 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3482 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3483 {
3484 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3485 "vkCreateEvent parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3486 return;
3487 }
3488}
3489
3490void PostCreateEvent(
3491 VkDevice device,
3492 VkEvent* pEvent,
3493 VkResult result)
3494{
3495 if(device == nullptr)
3496 {
3497 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3498 "vkCreateEvent parameter, VkDevice device, is null pointer");
3499 return;
3500 }
3501
3502 if(pEvent == nullptr)
3503 {
3504 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3505 "vkCreateEvent parameter, VkEvent* pEvent, is null pointer");
3506 return;
3507 }
3508 if((*pEvent) == nullptr)
3509 {
3510 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3511 "vkCreateEvent parameter, VkEvent* pEvent, is null pointer");
3512 return;
3513 }
3514
3515 if(result != VK_SUCCESS)
3516 {
3517 std::string reason = "vkCreateEvent parameter, VkResult result, is " + EnumeratorString(result);
3518 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3519 return;
3520 }
3521}
3522
3523VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
3524 VkDevice device,
3525 const VkEventCreateInfo* pCreateInfo,
3526 VkEvent* pEvent)
3527{
3528 PreCreateEvent(device, pCreateInfo);
3529 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pEvent);
3530
3531 PostCreateEvent(device, pEvent, result);
3532
3533 return result;
3534}
3535
3536void PreGetEventStatus(
3537 VkDevice device)
3538{
3539 if(device == nullptr)
3540 {
3541 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3542 "vkGetEventStatus parameter, VkDevice device, is null pointer");
3543 return;
3544 }
3545}
3546
3547void PostGetEventStatus(
3548 VkDevice device,
3549 VkEvent event,
3550 VkResult result)
3551{
3552 if(device == nullptr)
3553 {
3554 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3555 "vkGetEventStatus parameter, VkDevice device, is null pointer");
3556 return;
3557 }
3558
3559 if(event == nullptr)
3560 {
3561 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3562 "vkGetEventStatus parameter, VkEvent event, is null pointer");
3563 return;
3564 }
3565
3566 if(result != VK_SUCCESS)
3567 {
3568 std::string reason = "vkGetEventStatus parameter, VkResult result, is " + EnumeratorString(result);
3569 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3570 return;
3571 }
3572}
3573
3574VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(
3575 VkDevice device,
3576 VkEvent event)
3577{
3578 PreGetEventStatus(device);
3579 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetEventStatus(device, event);
3580
3581 PostGetEventStatus(device, event, result);
3582
3583 return result;
3584}
3585
3586void PreSetEvent(
3587 VkDevice device)
3588{
3589 if(device == nullptr)
3590 {
3591 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3592 "vkSetEvent parameter, VkDevice device, is null pointer");
3593 return;
3594 }
3595}
3596
3597void PostSetEvent(
3598 VkDevice device,
3599 VkEvent event,
3600 VkResult result)
3601{
3602 if(device == nullptr)
3603 {
3604 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3605 "vkSetEvent parameter, VkDevice device, is null pointer");
3606 return;
3607 }
3608
3609 if(event == nullptr)
3610 {
3611 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3612 "vkSetEvent parameter, VkEvent event, is null pointer");
3613 return;
3614 }
3615
3616 if(result != VK_SUCCESS)
3617 {
3618 std::string reason = "vkSetEvent parameter, VkResult result, is " + EnumeratorString(result);
3619 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3620 return;
3621 }
3622}
3623
3624VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(
3625 VkDevice device,
3626 VkEvent event)
3627{
3628 PreSetEvent(device);
3629 VkResult result = get_dispatch_table(pc_device_table_map, device)->SetEvent(device, event);
3630
3631 PostSetEvent(device, event, result);
3632
3633 return result;
3634}
3635
3636void PreResetEvent(
3637 VkDevice device)
3638{
3639 if(device == nullptr)
3640 {
3641 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3642 "vkResetEvent parameter, VkDevice device, is null pointer");
3643 return;
3644 }
3645}
3646
3647void PostResetEvent(
3648 VkDevice device,
3649 VkEvent event,
3650 VkResult result)
3651{
3652 if(device == nullptr)
3653 {
3654 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3655 "vkResetEvent parameter, VkDevice device, is null pointer");
3656 return;
3657 }
3658
3659 if(event == nullptr)
3660 {
3661 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3662 "vkResetEvent parameter, VkEvent event, is null pointer");
3663 return;
3664 }
3665
3666 if(result != VK_SUCCESS)
3667 {
3668 std::string reason = "vkResetEvent parameter, VkResult result, is " + EnumeratorString(result);
3669 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3670 return;
3671 }
3672}
3673
3674VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(
3675 VkDevice device,
3676 VkEvent event)
3677{
3678 PreResetEvent(device);
3679 VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetEvent(device, event);
3680
3681 PostResetEvent(device, event, result);
3682
3683 return result;
3684}
3685
3686void PreCreateQueryPool(
3687 VkDevice device,
3688 const VkQueryPoolCreateInfo* pCreateInfo)
3689{
3690 if(device == nullptr)
3691 {
3692 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3693 "vkCreateQueryPool parameter, VkDevice device, is null pointer");
3694 return;
3695 }
3696
3697 if(pCreateInfo == nullptr)
3698 {
3699 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3700 "vkCreateQueryPool parameter, const VkQueryPoolCreateInfo* pCreateInfo, is null pointer");
3701 return;
3702 }
3703 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3704 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3705 {
3706 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3707 "vkCreateQueryPool parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3708 return;
3709 }
3710 if(pCreateInfo->queryType < VK_QUERY_TYPE_BEGIN_RANGE ||
3711 pCreateInfo->queryType > VK_QUERY_TYPE_END_RANGE)
3712 {
3713 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3714 "vkCreateQueryPool parameter, VkQueryType pCreateInfo->queryType, is unrecognized enumerator");
3715 return;
3716 }
3717 if(!ValidateEnumerator((VkQueryPipelineStatisticFlagBits)pCreateInfo->pipelineStatistics))
3718 {
3719 std::string reason = "vkCreateQueryPool parameter, VkQueryPipelineStatisticFlags pCreateInfo->pipelineStatistics, is " + EnumeratorString((VkQueryPipelineStatisticFlagBits)pCreateInfo->pipelineStatistics);
3720 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3721 return;
3722 }
3723}
3724
3725void PostCreateQueryPool(
3726 VkDevice device,
3727 VkQueryPool* pQueryPool,
3728 VkResult result)
3729{
3730 if(device == nullptr)
3731 {
3732 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3733 "vkCreateQueryPool parameter, VkDevice device, is null pointer");
3734 return;
3735 }
3736
3737 if(pQueryPool == nullptr)
3738 {
3739 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3740 "vkCreateQueryPool parameter, VkQueryPool* pQueryPool, is null pointer");
3741 return;
3742 }
3743 if((*pQueryPool) == nullptr)
3744 {
3745 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3746 "vkCreateQueryPool parameter, VkQueryPool* pQueryPool, is null pointer");
3747 return;
3748 }
3749
3750 if(result != VK_SUCCESS)
3751 {
3752 std::string reason = "vkCreateQueryPool parameter, VkResult result, is " + EnumeratorString(result);
3753 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3754 return;
3755 }
3756}
3757
3758VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
3759 VkDevice device,
3760 const VkQueryPoolCreateInfo* pCreateInfo,
3761 VkQueryPool* pQueryPool)
3762{
3763 PreCreateQueryPool(device, pCreateInfo);
3764 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
3765
3766 PostCreateQueryPool(device, pQueryPool, result);
3767
3768 return result;
3769}
3770
3771void PreGetQueryPoolResults(
3772 VkDevice device)
3773{
3774 if(device == nullptr)
3775 {
3776 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3777 "vkGetQueryPoolResults parameter, VkDevice device, is null pointer");
3778 return;
3779 }
3780}
3781
3782void PostGetQueryPoolResults(
3783 VkDevice device,
3784 VkQueryPool queryPool,
3785 uint32_t startQuery,
3786 uint32_t queryCount,
3787 size_t* pDataSize,
3788 void* pData,
3789 VkQueryResultFlags flags,
3790 VkResult result)
3791{
3792 if(device == nullptr)
3793 {
3794 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3795 "vkGetQueryPoolResults parameter, VkDevice device, is null pointer");
3796 return;
3797 }
3798
3799 if(queryPool == nullptr)
3800 {
3801 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3802 "vkGetQueryPoolResults parameter, VkQueryPool queryPool, is null pointer");
3803 return;
3804 }
3805
3806
3807
3808 if(pDataSize == nullptr)
3809 {
3810 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3811 "vkGetQueryPoolResults parameter, size_t* pDataSize, is null pointer");
3812 return;
3813 }
3814
3815 if(pData == nullptr)
3816 {
3817 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3818 "vkGetQueryPoolResults parameter, void* pData, is null pointer");
3819 return;
3820 }
3821
3822 if(!ValidateEnumerator((VkQueryResultFlagBits)flags))
3823 {
3824 std::string reason = "vkGetQueryPoolResults parameter, VkQueryResultFlags flags, is " + EnumeratorString((VkQueryResultFlagBits)flags);
3825 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3826 return;
3827 }
3828
3829 if(result != VK_SUCCESS)
3830 {
3831 std::string reason = "vkGetQueryPoolResults parameter, VkResult result, is " + EnumeratorString(result);
3832 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3833 return;
3834 }
3835}
3836
3837VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(
3838 VkDevice device,
3839 VkQueryPool queryPool,
3840 uint32_t startQuery,
3841 uint32_t queryCount,
3842 size_t* pDataSize,
3843 void* pData,
3844 VkQueryResultFlags flags)
3845{
3846 PreGetQueryPoolResults(device);
3847 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
3848
3849 PostGetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags, result);
3850
3851 return result;
3852}
3853
3854void PreCreateBuffer(
3855 VkDevice device,
3856 const VkBufferCreateInfo* pCreateInfo)
3857{
3858 if(device == nullptr)
3859 {
3860 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3861 "vkCreateBuffer parameter, VkDevice device, is null pointer");
3862 return;
3863 }
3864
3865 if(pCreateInfo == nullptr)
3866 {
3867 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3868 "vkCreateBuffer parameter, const VkBufferCreateInfo* pCreateInfo, is null pointer");
3869 return;
3870 }
3871 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3872 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3873 {
3874 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3875 "vkCreateBuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3876 return;
3877 }
3878 if(!ValidateEnumerator((VkBufferUsageFlagBits)pCreateInfo->usage))
3879 {
3880 std::string reason = "vkCreateBuffer parameter, VkBufferUsageFlags pCreateInfo->usage, is " + EnumeratorString((VkBufferUsageFlagBits)pCreateInfo->usage);
3881 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3882 return;
3883 }
3884 if(!ValidateEnumerator((VkBufferCreateFlagBits)pCreateInfo->flags))
3885 {
3886 std::string reason = "vkCreateBuffer parameter, VkBufferCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkBufferCreateFlagBits)pCreateInfo->flags);
3887 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3888 return;
3889 }
3890}
3891
3892void PostCreateBuffer(
3893 VkDevice device,
3894 VkBuffer* pBuffer,
3895 VkResult result)
3896{
3897 if(device == nullptr)
3898 {
3899 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3900 "vkCreateBuffer parameter, VkDevice device, is null pointer");
3901 return;
3902 }
3903
3904 if(pBuffer == nullptr)
3905 {
3906 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3907 "vkCreateBuffer parameter, VkBuffer* pBuffer, is null pointer");
3908 return;
3909 }
3910 if((*pBuffer) == nullptr)
3911 {
3912 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3913 "vkCreateBuffer parameter, VkBuffer* pBuffer, is null pointer");
3914 return;
3915 }
3916
3917 if(result != VK_SUCCESS)
3918 {
3919 std::string reason = "vkCreateBuffer parameter, VkResult result, is " + EnumeratorString(result);
3920 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
3921 return;
3922 }
3923}
3924
3925VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
3926 VkDevice device,
3927 const VkBufferCreateInfo* pCreateInfo,
3928 VkBuffer* pBuffer)
3929{
3930 PreCreateBuffer(device, pCreateInfo);
3931 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
3932
3933 PostCreateBuffer(device, pBuffer, result);
3934
3935 return result;
3936}
3937
3938void PreCreateBufferView(
3939 VkDevice device,
3940 const VkBufferViewCreateInfo* pCreateInfo)
3941{
3942 if(device == nullptr)
3943 {
3944 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3945 "vkCreateBufferView parameter, VkDevice device, is null pointer");
3946 return;
3947 }
3948
3949 if(pCreateInfo == nullptr)
3950 {
3951 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3952 "vkCreateBufferView parameter, const VkBufferViewCreateInfo* pCreateInfo, is null pointer");
3953 return;
3954 }
3955 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
3956 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
3957 {
3958 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3959 "vkCreateBufferView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
3960 return;
3961 }
3962 if(pCreateInfo->buffer == nullptr)
3963 {
3964 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3965 "vkCreateBufferView parameter, VkBuffer pCreateInfo->buffer, is null pointer");
3966 return;
3967 }
3968 if(pCreateInfo->viewType < VK_BUFFER_VIEW_TYPE_BEGIN_RANGE ||
3969 pCreateInfo->viewType > VK_BUFFER_VIEW_TYPE_END_RANGE)
3970 {
3971 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3972 "vkCreateBufferView parameter, VkBufferViewType pCreateInfo->viewType, is unrecognized enumerator");
3973 return;
3974 }
3975 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
3976 pCreateInfo->format > VK_FORMAT_END_RANGE)
3977 {
3978 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3979 "vkCreateBufferView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
3980 return;
3981 }
3982}
3983
3984void PostCreateBufferView(
3985 VkDevice device,
3986 VkBufferView* pView,
3987 VkResult result)
3988{
3989 if(device == nullptr)
3990 {
3991 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3992 "vkCreateBufferView parameter, VkDevice device, is null pointer");
3993 return;
3994 }
3995
3996 if(pView == nullptr)
3997 {
3998 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
3999 "vkCreateBufferView parameter, VkBufferView* pView, is null pointer");
4000 return;
4001 }
4002 if((*pView) == nullptr)
4003 {
4004 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4005 "vkCreateBufferView parameter, VkBufferView* pView, is null pointer");
4006 return;
4007 }
4008
4009 if(result != VK_SUCCESS)
4010 {
4011 std::string reason = "vkCreateBufferView parameter, VkResult result, is " + EnumeratorString(result);
4012 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4013 return;
4014 }
4015}
4016
4017VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
4018 VkDevice device,
4019 const VkBufferViewCreateInfo* pCreateInfo,
4020 VkBufferView* pView)
4021{
4022 PreCreateBufferView(device, pCreateInfo);
4023 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
4024
4025 PostCreateBufferView(device, pView, result);
4026
4027 return result;
4028}
4029
4030void PreCreateImage(
4031 VkDevice device,
4032 const VkImageCreateInfo* pCreateInfo)
4033{
4034 if(device == nullptr)
4035 {
4036 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4037 "vkCreateImage parameter, VkDevice device, is null pointer");
4038 return;
4039 }
4040
4041 if(pCreateInfo == nullptr)
4042 {
4043 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4044 "vkCreateImage parameter, const VkImageCreateInfo* pCreateInfo, is null pointer");
4045 return;
4046 }
4047 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4048 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4049 {
4050 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4051 "vkCreateImage parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4052 return;
4053 }
4054 if(pCreateInfo->imageType < VK_IMAGE_TYPE_BEGIN_RANGE ||
4055 pCreateInfo->imageType > VK_IMAGE_TYPE_END_RANGE)
4056 {
4057 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4058 "vkCreateImage parameter, VkImageType pCreateInfo->imageType, is unrecognized enumerator");
4059 return;
4060 }
4061 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
4062 pCreateInfo->format > VK_FORMAT_END_RANGE)
4063 {
4064 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4065 "vkCreateImage parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4066 return;
4067 }
4068 if(pCreateInfo->tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
4069 pCreateInfo->tiling > VK_IMAGE_TILING_END_RANGE)
4070 {
4071 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4072 "vkCreateImage parameter, VkImageTiling pCreateInfo->tiling, is unrecognized enumerator");
4073 return;
4074 }
4075 if(!ValidateEnumerator((VkImageUsageFlagBits)pCreateInfo->usage))
4076 {
4077 std::string reason = "vkCreateImage parameter, VkImageUsageFlags pCreateInfo->usage, is " + EnumeratorString((VkImageUsageFlagBits)pCreateInfo->usage);
4078 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4079 return;
4080 }
4081 if(!ValidateEnumerator((VkImageCreateFlagBits)pCreateInfo->flags))
4082 {
4083 std::string reason = "vkCreateImage parameter, VkImageCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkImageCreateFlagBits)pCreateInfo->flags);
4084 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4085 return;
4086 }
4087}
4088
4089void PostCreateImage(
4090 VkDevice device,
4091 VkImage* pImage,
4092 VkResult result)
4093{
4094 if(device == nullptr)
4095 {
4096 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4097 "vkCreateImage parameter, VkDevice device, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4098 return;
4099 }
4100
4101 if(pImage == nullptr)
4102 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4103 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4104 "vkCreateImage parameter, VkImage* pImage, is null pointer");
4105 return;
4106 }
4107 if((*pImage) == nullptr)
4108 {
4109 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4110 "vkCreateImage parameter, VkImage* pImage, is null pointer");
4111 return;
4112 }
4113
4114 if(result != VK_SUCCESS)
4115 {
4116 std::string reason = "vkCreateImage parameter, VkResult result, is " + EnumeratorString(result);
4117 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]4118 return;
4119 }
4120}
4121
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4122VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
4123 VkDevice device,
4124 const VkImageCreateInfo* pCreateInfo,
4125 VkImage* pImage)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4126{
4127 PreCreateImage(device, pCreateInfo);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4128 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
4129
4130 PostCreateImage(device, pImage, result);
4131
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4132 return result;
4133}
4134
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4135void PreGetImageSubresourceLayout(
4136 VkDevice device,
4137 const VkImageSubresource* pSubresource)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4138{
4139 if(device == nullptr)
4140 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4141 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4142 "vkGetImageSubresourceLayout parameter, VkDevice device, is null pointer");
4143 return;
4144 }
4145
4146 if(pSubresource == nullptr)
4147 {
4148 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4149 "vkGetImageSubresourceLayout parameter, const VkImageSubresource* pSubresource, is null pointer");
4150 return;
4151 }
4152 if(pSubresource->aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
4153 pSubresource->aspect > VK_IMAGE_ASPECT_END_RANGE)
4154 {
4155 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4156 "vkGetImageSubresourceLayout parameter, VkImageAspect pSubresource->aspect, is unrecognized enumerator");
4157 return;
4158 }
4159}
4160
4161void PostGetImageSubresourceLayout(
4162 VkDevice device,
4163 VkImage image,
4164 VkSubresourceLayout* pLayout,
4165 VkResult result)
4166{
4167 if(device == nullptr)
4168 {
4169 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4170 "vkGetImageSubresourceLayout parameter, VkDevice device, is null pointer");
4171 return;
4172 }
4173
4174 if(image == nullptr)
4175 {
4176 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4177 "vkGetImageSubresourceLayout parameter, VkImage image, is null pointer");
4178 return;
4179 }
4180
4181 if(pLayout == nullptr)
4182 {
4183 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4184 "vkGetImageSubresourceLayout parameter, VkSubresourceLayout* pLayout, is null pointer");
4185 return;
4186 }
4187
4188 if(result != VK_SUCCESS)
4189 {
4190 std::string reason = "vkGetImageSubresourceLayout parameter, VkResult result, is " + EnumeratorString(result);
4191 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4192 return;
4193 }
4194}
4195
4196VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(
4197 VkDevice device,
4198 VkImage image,
4199 const VkImageSubresource* pSubresource,
4200 VkSubresourceLayout* pLayout)
4201{
4202 PreGetImageSubresourceLayout(device, pSubresource);
4203 VkResult result = get_dispatch_table(pc_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
4204
4205 PostGetImageSubresourceLayout(device, image, pLayout, result);
4206
4207 return result;
4208}
4209
4210void PreCreateImageView(
4211 VkDevice device,
4212 const VkImageViewCreateInfo* pCreateInfo)
4213{
4214 if(device == nullptr)
4215 {
4216 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4217 "vkCreateImageView parameter, VkDevice device, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4218 return;
4219 }
4220
4221 if(pCreateInfo == nullptr)
4222 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4223 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4224 "vkCreateImageView parameter, const VkImageViewCreateInfo* pCreateInfo, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4225 return;
4226 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4227 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4228 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4229 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4230 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4231 "vkCreateImageView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4232 return;
4233 }
4234 if(pCreateInfo->image == nullptr)
4235 {
4236 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4237 "vkCreateImageView parameter, VkImage pCreateInfo->image, is null pointer");
4238 return;
4239 }
4240 if(pCreateInfo->viewType < VK_IMAGE_VIEW_TYPE_BEGIN_RANGE ||
4241 pCreateInfo->viewType > VK_IMAGE_VIEW_TYPE_END_RANGE)
4242 {
4243 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4244 "vkCreateImageView parameter, VkImageViewType pCreateInfo->viewType, is unrecognized enumerator");
4245 return;
4246 }
4247 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
4248 pCreateInfo->format > VK_FORMAT_END_RANGE)
4249 {
4250 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4251 "vkCreateImageView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4252 return;
4253 }
4254 if(pCreateInfo->channels.r < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4255 pCreateInfo->channels.r > VK_CHANNEL_SWIZZLE_END_RANGE)
4256 {
4257 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4258 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.r, is unrecognized enumerator");
4259 return;
4260 }
4261 if(pCreateInfo->channels.g < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4262 pCreateInfo->channels.g > VK_CHANNEL_SWIZZLE_END_RANGE)
4263 {
4264 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4265 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.g, is unrecognized enumerator");
4266 return;
4267 }
4268 if(pCreateInfo->channels.b < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4269 pCreateInfo->channels.b > VK_CHANNEL_SWIZZLE_END_RANGE)
4270 {
4271 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4272 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.b, is unrecognized enumerator");
4273 return;
4274 }
4275 if(pCreateInfo->channels.a < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
4276 pCreateInfo->channels.a > VK_CHANNEL_SWIZZLE_END_RANGE)
4277 {
4278 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4279 "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.a, is unrecognized enumerator");
4280 return;
4281 }
4282 if(pCreateInfo->subresourceRange.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
4283 pCreateInfo->subresourceRange.aspect > VK_IMAGE_ASPECT_END_RANGE)
4284 {
4285 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4286 "vkCreateImageView parameter, VkImageAspect pCreateInfo->subresourceRange.aspect, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4287 return;
4288 }
4289}
4290
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4291void PostCreateImageView(
4292 VkDevice device,
4293 VkImageView* pView,
4294 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4295{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4296 if(device == nullptr)
4297 {
4298 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4299 "vkCreateImageView parameter, VkDevice device, is null pointer");
4300 return;
4301 }
4302
4303 if(pView == nullptr)
4304 {
4305 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4306 "vkCreateImageView parameter, VkImageView* pView, is null pointer");
4307 return;
4308 }
4309 if((*pView) == nullptr)
4310 {
4311 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4312 "vkCreateImageView parameter, VkImageView* pView, is null pointer");
4313 return;
4314 }
4315
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]4316 if(result != VK_SUCCESS)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]4317 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4318 std::string reason = "vkCreateImageView parameter, VkResult result, is " + EnumeratorString(result);
4319 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4320 return;
4321 }
4322}
4323
4324VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
4325 VkDevice device,
4326 const VkImageViewCreateInfo* pCreateInfo,
4327 VkImageView* pView)
4328{
4329 PreCreateImageView(device, pCreateInfo);
4330 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
4331
4332 PostCreateImageView(device, pView, result);
4333
4334 return result;
4335}
4336
4337void PreCreateColorAttachmentView(
4338 VkDevice device,
4339 const VkColorAttachmentViewCreateInfo* pCreateInfo)
4340{
4341 if(device == nullptr)
4342 {
4343 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4344 "vkCreateColorAttachmentView parameter, VkDevice device, is null pointer");
4345 return;
4346 }
4347
4348 if(pCreateInfo == nullptr)
4349 {
4350 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4351 "vkCreateColorAttachmentView parameter, const VkColorAttachmentViewCreateInfo* pCreateInfo, is null pointer");
4352 return;
4353 }
4354 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4355 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4356 {
4357 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4358 "vkCreateColorAttachmentView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4359 return;
4360 }
4361 if(pCreateInfo->image == nullptr)
4362 {
4363 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4364 "vkCreateColorAttachmentView parameter, VkImage pCreateInfo->image, is null pointer");
4365 return;
4366 }
4367 if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
4368 pCreateInfo->format > VK_FORMAT_END_RANGE)
4369 {
4370 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4371 "vkCreateColorAttachmentView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
4372 return;
4373 }
4374 if(pCreateInfo->msaaResolveImage == nullptr)
4375 {
4376 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4377 "vkCreateColorAttachmentView parameter, VkImage pCreateInfo->msaaResolveImage, is null pointer");
4378 return;
4379 }
4380 if(pCreateInfo->msaaResolveSubResource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
4381 pCreateInfo->msaaResolveSubResource.aspect > VK_IMAGE_ASPECT_END_RANGE)
4382 {
4383 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4384 "vkCreateColorAttachmentView parameter, VkImageAspect pCreateInfo->msaaResolveSubResource.aspect, is unrecognized enumerator");
4385 return;
4386 }
4387}
4388
4389void PostCreateColorAttachmentView(
4390 VkDevice device,
4391 VkColorAttachmentView* pView,
4392 VkResult result)
4393{
4394 if(device == nullptr)
4395 {
4396 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4397 "vkCreateColorAttachmentView parameter, VkDevice device, is null pointer");
4398 return;
4399 }
4400
4401 if(pView == nullptr)
4402 {
4403 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4404 "vkCreateColorAttachmentView parameter, VkColorAttachmentView* pView, is null pointer");
4405 return;
4406 }
4407 if((*pView) == nullptr)
4408 {
4409 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4410 "vkCreateColorAttachmentView parameter, VkColorAttachmentView* pView, is null pointer");
4411 return;
4412 }
4413
4414 if(result != VK_SUCCESS)
4415 {
4416 std::string reason = "vkCreateColorAttachmentView parameter, VkResult result, is " + EnumeratorString(result);
4417 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4418 return;
4419 }
4420}
4421
4422VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
4423 VkDevice device,
4424 const VkColorAttachmentViewCreateInfo* pCreateInfo,
4425 VkColorAttachmentView* pView)
4426{
4427 PreCreateColorAttachmentView(device, pCreateInfo);
4428 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateColorAttachmentView(device, pCreateInfo, pView);
4429
4430 PostCreateColorAttachmentView(device, pView, result);
4431
4432 return result;
4433}
4434
4435void PreCreateDepthStencilView(
4436 VkDevice device,
4437 const VkDepthStencilViewCreateInfo* pCreateInfo)
4438{
4439 if(device == nullptr)
4440 {
4441 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4442 "vkCreateDepthStencilView parameter, VkDevice device, is null pointer");
4443 return;
4444 }
4445
4446 if(pCreateInfo == nullptr)
4447 {
4448 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4449 "vkCreateDepthStencilView parameter, const VkDepthStencilViewCreateInfo* pCreateInfo, is null pointer");
4450 return;
4451 }
4452 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4453 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4454 {
4455 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4456 "vkCreateDepthStencilView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4457 return;
4458 }
4459 if(pCreateInfo->image == nullptr)
4460 {
4461 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4462 "vkCreateDepthStencilView parameter, VkImage pCreateInfo->image, is null pointer");
4463 return;
4464 }
4465 if(!ValidateEnumerator((VkDepthStencilViewCreateFlagBits)pCreateInfo->flags))
4466 {
4467 std::string reason = "vkCreateDepthStencilView parameter, VkDepthStencilViewCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkDepthStencilViewCreateFlagBits)pCreateInfo->flags);
4468 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4469 return;
4470 }
4471}
4472
4473void PostCreateDepthStencilView(
4474 VkDevice device,
4475 VkDepthStencilView* pView,
4476 VkResult result)
4477{
4478 if(device == nullptr)
4479 {
4480 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4481 "vkCreateDepthStencilView parameter, VkDevice device, is null pointer");
4482 return;
4483 }
4484
4485 if(pView == nullptr)
4486 {
4487 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4488 "vkCreateDepthStencilView parameter, VkDepthStencilView* pView, is null pointer");
4489 return;
4490 }
4491 if((*pView) == nullptr)
4492 {
4493 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4494 "vkCreateDepthStencilView parameter, VkDepthStencilView* pView, is null pointer");
4495 return;
4496 }
4497
4498 if(result != VK_SUCCESS)
4499 {
4500 std::string reason = "vkCreateDepthStencilView parameter, VkResult result, is " + EnumeratorString(result);
4501 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4502 return;
4503 }
4504}
4505
4506VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(
4507 VkDevice device,
4508 const VkDepthStencilViewCreateInfo* pCreateInfo,
4509 VkDepthStencilView* pView)
4510{
4511 PreCreateDepthStencilView(device, pCreateInfo);
4512 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDepthStencilView(device, pCreateInfo, pView);
4513
4514 PostCreateDepthStencilView(device, pView, result);
4515
4516 return result;
4517}
4518
Courtney Goeltzenleuchter2d034fd2015-06-28 13:01:17 -0600[diff] [blame]4519void PreCreateShaderModule(
4520 VkDevice device,
4521 const VkShaderModuleCreateInfo* pCreateInfo)
4522{
4523 if(device == nullptr)
4524 {
4525 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4526 "vkCreateShaderModule parameter, VkDevice device, is null pointer");
4527 return;
4528 }
4529
4530 if(pCreateInfo == nullptr)
4531 {
4532 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4533 "vkCreateShaderModule parameter, const VkShaderCreateInfo* pCreateInfo, is null pointer");
4534 return;
4535 }
4536 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4537 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4538 {
4539 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4540 "vkCreateShaderModule parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4541 return;
4542 }
4543 if(pCreateInfo->pCode == nullptr)
4544 {
4545 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4546 "vkCreateShaderModule parameter, const void* pCreateInfo->pCode, is null pointer");
4547 return;
4548 }
4549 if(pCreateInfo->codeSize == 0)
4550 {
4551 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4552 "vkCreateShaderModule parameter, size_t pCreateInfo->codeSize, is zero");
4553 return;
4554 }
4555}
4556
4557void PostCreateShaderModule(
4558 VkDevice device,
4559 VkShaderModule* pShaderModule,
4560 VkResult result)
4561{
4562 if(device == nullptr)
4563 {
4564 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4565 "vkCreateShaderModule parameter, VkDevice device, is null pointer");
4566 return;
4567 }
4568
4569 if(pShaderModule == nullptr)
4570 {
4571 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4572 "vkCreateShaderModule parameter, VkShader* pShader, is null pointer");
4573 return;
4574 }
4575 if((*pShaderModule) == nullptr)
4576 {
4577 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4578 "vkCreateShaderModule parameter, VkShader* pShader, is null pointer");
4579 return;
4580 }
4581
4582 if(result != VK_SUCCESS)
4583 {
4584 std::string reason = "vkCreateShaderModule parameter, VkResult result, is " + EnumeratorString(result);
4585 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4586 return;
4587 }
4588}
4589
4590VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
4591 VkDevice device,
4592 const VkShaderModuleCreateInfo* pCreateInfo,
4593 VkShaderModule* pShaderModule)
4594{
4595 PreCreateShaderModule(device, pCreateInfo);
4596 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pShaderModule);
4597
4598 PostCreateShaderModule(device, pShaderModule, result);
4599
4600 return result;
4601}
4602
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4603void PreCreateShader(
4604 VkDevice device,
4605 const VkShaderCreateInfo* pCreateInfo)
4606{
4607 if(device == nullptr)
4608 {
4609 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4610 "vkCreateShader parameter, VkDevice device, is null pointer");
4611 return;
4612 }
4613
4614 if(pCreateInfo == nullptr)
4615 {
4616 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4617 "vkCreateShader parameter, const VkShaderCreateInfo* pCreateInfo, is null pointer");
4618 return;
4619 }
4620 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4621 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4622 {
4623 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4624 "vkCreateShader parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4625 return;
4626 }
4627 if(pCreateInfo->module == nullptr)
4628 {
4629 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4630 "vkCreateShader parameter, VkShaderModule pCreateInfo->module, is null pointer");
4631 return;
4632 }
Courtney Goeltzenleuchter2d034fd2015-06-28 13:01:17 -0600[diff] [blame]4633 if(pCreateInfo->pName == nullptr)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4634 {
4635 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4636 "vkCreateShader parameter, const char* pCreateInfo->name, is null pointer");
4637 return;
4638 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]4639}
4640
4641void PostCreateShader(
4642 VkDevice device,
4643 VkShader* pShader,
4644 VkResult result)
4645{
4646 if(device == nullptr)
4647 {
4648 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4649 "vkCreateShader parameter, VkDevice device, is null pointer");
4650 return;
4651 }
4652
4653 if(pShader == nullptr)
4654 {
4655 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4656 "vkCreateShader parameter, VkShader* pShader, is null pointer");
4657 return;
4658 }
4659 if((*pShader) == nullptr)
4660 {
4661 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4662 "vkCreateShader parameter, VkShader* pShader, is null pointer");
4663 return;
4664 }
4665
4666 if(result != VK_SUCCESS)
4667 {
4668 std::string reason = "vkCreateShader parameter, VkResult result, is " + EnumeratorString(result);
4669 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
4670 return;
4671 }
4672}
4673
4674VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
4675 VkDevice device,
4676 const VkShaderCreateInfo* pCreateInfo,
4677 VkShader* pShader)
4678{
4679 PreCreateShader(device, pCreateInfo);
4680 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
4681
4682 PostCreateShader(device, pShader, result);
4683
4684 return result;
4685}
4686
4687void PreCreateGraphicsPipeline(
4688 VkDevice device,
4689 const VkGraphicsPipelineCreateInfo* pCreateInfo)
4690{
4691 if(device == nullptr)
4692 {
4693 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4694 "vkCreateGraphicsPipeline parameter, VkDevice device, is null pointer");
4695 return;
4696 }
4697
4698 if(pCreateInfo == nullptr)
4699 {
4700 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4701 "vkCreateGraphicsPipeline parameter, const VkGraphicsPipelineCreateInfo* pCreateInfo, is null pointer");
4702 return;
4703 }
4704 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4705 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
4706 {
4707 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4708 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
4709 return;
4710 }
4711 if(pCreateInfo->pStages == nullptr)
4712 {
4713 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4714 "vkCreateGraphicsPipeline parameter, const VkPipelineShaderStageCreateInfo* pCreateInfo->pStages, is null pointer");
4715 return;
4716 }
4717 if(pCreateInfo->pStages->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4718 pCreateInfo->pStages->sType > VK_STRUCTURE_TYPE_END_RANGE)
4719 {
4720 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4721 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pStages->sType, is unrecognized enumerator");
4722 return;
4723 }
4724 if(pCreateInfo->pStages->pNext == nullptr)
4725 {
4726 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4727 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pStages->pNext, is null pointer");
4728 return;
4729 }
4730 if(pCreateInfo->pStages->stage < VK_SHADER_STAGE_BEGIN_RANGE ||
4731 pCreateInfo->pStages->stage > VK_SHADER_STAGE_END_RANGE)
4732 {
4733 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4734 "vkCreateGraphicsPipeline parameter, VkShaderStage pCreateInfo->pStages->stage, is unrecognized enumerator");
4735 return;
4736 }
4737 if(pCreateInfo->pStages->shader == nullptr)
4738 {
4739 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4740 "vkCreateGraphicsPipeline parameter, VkShader pCreateInfo->pStages->shader, is null pointer");
4741 return;
4742 }
4743 if(pCreateInfo->pStages->pLinkConstBufferInfo == nullptr)
4744 {
4745 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4746 "vkCreateGraphicsPipeline parameter, const VkLinkConstBuffer* pCreateInfo->pStages->pLinkConstBufferInfo, is null pointer");
4747 return;
4748 }
4749 if(pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData == nullptr)
4750 {
4751 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4752 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData, is null pointer");
4753 return;
4754 }
4755 if(pCreateInfo->pStages->pSpecializationInfo == nullptr)
4756 {
4757 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4758 "vkCreateGraphicsPipeline parameter, const VkSpecializationInfo* pCreateInfo->pStages->pSpecializationInfo, is null pointer");
4759 return;
4760 }
4761 if(pCreateInfo->pStages->pSpecializationInfo->pMap == nullptr)
4762 {
4763 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4764 "vkCreateGraphicsPipeline parameter, const VkSpecializationMapEntry* pCreateInfo->pStages->pSpecializationInfo->pMap, is null pointer");
4765 return;
4766 }
4767 if(pCreateInfo->pStages->pSpecializationInfo->pData == nullptr)
4768 {
4769 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4770 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pStages->pSpecializationInfo->pData, is null pointer");
4771 return;
4772 }
4773 if(pCreateInfo->pVertexInputState == nullptr)
4774 {
4775 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4776 "vkCreateGraphicsPipeline parameter, const VkPipelineVertexInputStateCreateInfo* pCreateInfo->pVertexInputState, is null pointer");
4777 return;
4778 }
4779 if(pCreateInfo->pVertexInputState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4780 pCreateInfo->pVertexInputState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4781 {
4782 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4783 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pVertexInputState->sType, is unrecognized enumerator");
4784 return;
4785 }
4786 if(pCreateInfo->pVertexInputState->pNext == nullptr)
4787 {
4788 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4789 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pVertexInputState->pNext, is null pointer");
4790 return;
4791 }
4792 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions == nullptr)
4793 {
4794 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4795 "vkCreateGraphicsPipeline parameter, const VkVertexInputBindingDescription* pCreateInfo->pVertexInputState->pVertexBindingDescriptions, is null pointer");
4796 return;
4797 }
4798 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate < VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE ||
4799 pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate > VK_VERTEX_INPUT_STEP_RATE_END_RANGE)
4800 {
4801 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4802 "vkCreateGraphicsPipeline parameter, VkVertexInputStepRate pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate, is unrecognized enumerator");
4803 return;
4804 }
4805 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions == nullptr)
4806 {
4807 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4808 "vkCreateGraphicsPipeline parameter, const VkVertexInputAttributeDescription* pCreateInfo->pVertexInputState->pVertexAttributeDescriptions, is null pointer");
4809 return;
4810 }
4811 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE ||
4812 pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE)
4813 {
4814 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4815 "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format, is unrecognized enumerator");
4816 return;
4817 }
4818 if(pCreateInfo->pIaState == nullptr)
4819 {
4820 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4821 "vkCreateGraphicsPipeline parameter, const VkPipelineIaStateCreateInfo* pCreateInfo->pIaState, is null pointer");
4822 return;
4823 }
4824 if(pCreateInfo->pIaState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4825 pCreateInfo->pIaState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4826 {
4827 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4828 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pIaState->sType, is unrecognized enumerator");
4829 return;
4830 }
4831 if(pCreateInfo->pIaState->pNext == nullptr)
4832 {
4833 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4834 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pIaState->pNext, is null pointer");
4835 return;
4836 }
4837 if(pCreateInfo->pIaState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE ||
4838 pCreateInfo->pIaState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE)
4839 {
4840 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4841 "vkCreateGraphicsPipeline parameter, VkPrimitiveTopology pCreateInfo->pIaState->topology, is unrecognized enumerator");
4842 return;
4843 }
4844 if(pCreateInfo->pTessState == nullptr)
4845 {
4846 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4847 "vkCreateGraphicsPipeline parameter, const VkPipelineTessStateCreateInfo* pCreateInfo->pTessState, is null pointer");
4848 return;
4849 }
4850 if(pCreateInfo->pTessState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4851 pCreateInfo->pTessState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4852 {
4853 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4854 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pTessState->sType, is unrecognized enumerator");
4855 return;
4856 }
4857 if(pCreateInfo->pTessState->pNext == nullptr)
4858 {
4859 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4860 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pTessState->pNext, is null pointer");
4861 return;
4862 }
4863 if(pCreateInfo->pVpState == nullptr)
4864 {
4865 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4866 "vkCreateGraphicsPipeline parameter, const VkPipelineVpStateCreateInfo* pCreateInfo->pVpState, is null pointer");
4867 return;
4868 }
4869 if(pCreateInfo->pVpState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4870 pCreateInfo->pVpState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4871 {
4872 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4873 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pVpState->sType, is unrecognized enumerator");
4874 return;
4875 }
4876 if(pCreateInfo->pVpState->pNext == nullptr)
4877 {
4878 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4879 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pVpState->pNext, is null pointer");
4880 return;
4881 }
4882 if(pCreateInfo->pVpState->clipOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
4883 pCreateInfo->pVpState->clipOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
4884 {
4885 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4886 "vkCreateGraphicsPipeline parameter, VkCoordinateOrigin pCreateInfo->pVpState->clipOrigin, is unrecognized enumerator");
4887 return;
4888 }
4889 if(pCreateInfo->pVpState->depthMode < VK_DEPTH_MODE_BEGIN_RANGE ||
4890 pCreateInfo->pVpState->depthMode > VK_DEPTH_MODE_END_RANGE)
4891 {
4892 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4893 "vkCreateGraphicsPipeline parameter, VkDepthMode pCreateInfo->pVpState->depthMode, is unrecognized enumerator");
4894 return;
4895 }
4896 if(pCreateInfo->pRsState == nullptr)
4897 {
4898 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4899 "vkCreateGraphicsPipeline parameter, const VkPipelineRsStateCreateInfo* pCreateInfo->pRsState, is null pointer");
4900 return;
4901 }
4902 if(pCreateInfo->pRsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4903 pCreateInfo->pRsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4904 {
4905 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4906 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pRsState->sType, is unrecognized enumerator");
4907 return;
4908 }
4909 if(pCreateInfo->pRsState->pNext == nullptr)
4910 {
4911 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4912 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pRsState->pNext, is null pointer");
4913 return;
4914 }
4915 if(pCreateInfo->pRsState->pointOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
4916 pCreateInfo->pRsState->pointOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
4917 {
4918 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4919 "vkCreateGraphicsPipeline parameter, VkCoordinateOrigin pCreateInfo->pRsState->pointOrigin, is unrecognized enumerator");
4920 return;
4921 }
4922 if(pCreateInfo->pRsState->provokingVertex < VK_PROVOKING_VERTEX_BEGIN_RANGE ||
4923 pCreateInfo->pRsState->provokingVertex > VK_PROVOKING_VERTEX_END_RANGE)
4924 {
4925 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4926 "vkCreateGraphicsPipeline parameter, VkProvokingVertex pCreateInfo->pRsState->provokingVertex, is unrecognized enumerator");
4927 return;
4928 }
4929 if(pCreateInfo->pRsState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
4930 pCreateInfo->pRsState->fillMode > VK_FILL_MODE_END_RANGE)
4931 {
4932 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4933 "vkCreateGraphicsPipeline parameter, VkFillMode pCreateInfo->pRsState->fillMode, is unrecognized enumerator");
4934 return;
4935 }
4936 if(pCreateInfo->pRsState->cullMode < VK_CULL_MODE_BEGIN_RANGE ||
4937 pCreateInfo->pRsState->cullMode > VK_CULL_MODE_END_RANGE)
4938 {
4939 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4940 "vkCreateGraphicsPipeline parameter, VkCullMode pCreateInfo->pRsState->cullMode, is unrecognized enumerator");
4941 return;
4942 }
4943 if(pCreateInfo->pRsState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
4944 pCreateInfo->pRsState->frontFace > VK_FRONT_FACE_END_RANGE)
4945 {
4946 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4947 "vkCreateGraphicsPipeline parameter, VkFrontFace pCreateInfo->pRsState->frontFace, is unrecognized enumerator");
4948 return;
4949 }
4950 if(pCreateInfo->pMsState == nullptr)
4951 {
4952 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4953 "vkCreateGraphicsPipeline parameter, const VkPipelineMsStateCreateInfo* pCreateInfo->pMsState, is null pointer");
4954 return;
4955 }
4956 if(pCreateInfo->pMsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4957 pCreateInfo->pMsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4958 {
4959 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4960 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pMsState->sType, is unrecognized enumerator");
4961 return;
4962 }
4963 if(pCreateInfo->pMsState->pNext == nullptr)
4964 {
4965 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4966 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pMsState->pNext, is null pointer");
4967 return;
4968 }
4969 if(pCreateInfo->pDsState == nullptr)
4970 {
4971 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4972 "vkCreateGraphicsPipeline parameter, const VkPipelineDsStateCreateInfo* pCreateInfo->pDsState, is null pointer");
4973 return;
4974 }
4975 if(pCreateInfo->pDsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
4976 pCreateInfo->pDsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
4977 {
4978 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4979 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pDsState->sType, is unrecognized enumerator");
4980 return;
4981 }
4982 if(pCreateInfo->pDsState->pNext == nullptr)
4983 {
4984 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4985 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pDsState->pNext, is null pointer");
4986 return;
4987 }
4988 if(pCreateInfo->pDsState->format < VK_FORMAT_BEGIN_RANGE ||
4989 pCreateInfo->pDsState->format > VK_FORMAT_END_RANGE)
4990 {
4991 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4992 "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pDsState->format, is unrecognized enumerator");
4993 return;
4994 }
4995 if(pCreateInfo->pDsState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
4996 pCreateInfo->pDsState->depthCompareOp > VK_COMPARE_OP_END_RANGE)
4997 {
4998 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
4999 "vkCreateGraphicsPipeline parameter, VkCompareOp pCreateInfo->pDsState->depthCompareOp, is unrecognized enumerator");
5000 return;
5001 }
5002 if(pCreateInfo->pDsState->front.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5003 pCreateInfo->pDsState->front.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5004 {
5005 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5006 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->front.stencilFailOp, is unrecognized enumerator");
5007 return;
5008 }
5009 if(pCreateInfo->pDsState->front.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5010 pCreateInfo->pDsState->front.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5011 {
5012 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5013 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->front.stencilPassOp, is unrecognized enumerator");
5014 return;
5015 }
5016 if(pCreateInfo->pDsState->front.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5017 pCreateInfo->pDsState->front.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5018 {
5019 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5020 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->front.stencilDepthFailOp, is unrecognized enumerator");
5021 return;
5022 }
5023 if(pCreateInfo->pDsState->front.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5024 pCreateInfo->pDsState->front.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5025 {
5026 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5027 "vkCreateGraphicsPipeline parameter, VkCompareOp pCreateInfo->pDsState->front.stencilCompareOp, is unrecognized enumerator");
5028 return;
5029 }
5030 if(pCreateInfo->pDsState->back.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5031 pCreateInfo->pDsState->back.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5032 {
5033 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5034 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->back.stencilFailOp, is unrecognized enumerator");
5035 return;
5036 }
5037 if(pCreateInfo->pDsState->back.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5038 pCreateInfo->pDsState->back.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5039 {
5040 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5041 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->back.stencilPassOp, is unrecognized enumerator");
5042 return;
5043 }
5044 if(pCreateInfo->pDsState->back.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5045 pCreateInfo->pDsState->back.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5046 {
5047 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5048 "vkCreateGraphicsPipeline parameter, VkStencilOp pCreateInfo->pDsState->back.stencilDepthFailOp, is unrecognized enumerator");
5049 return;
5050 }
5051 if(pCreateInfo->pDsState->back.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5052 pCreateInfo->pDsState->back.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5053 {
5054 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5055 "vkCreateGraphicsPipeline parameter, VkCompareOp pCreateInfo->pDsState->back.stencilCompareOp, is unrecognized enumerator");
5056 return;
5057 }
5058 if(pCreateInfo->pCbState == nullptr)
5059 {
5060 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5061 "vkCreateGraphicsPipeline parameter, const VkPipelineCbStateCreateInfo* pCreateInfo->pCbState, is null pointer");
5062 return;
5063 }
5064 if(pCreateInfo->pCbState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5065 pCreateInfo->pCbState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5066 {
5067 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5068 "vkCreateGraphicsPipeline parameter, VkStructureType pCreateInfo->pCbState->sType, is unrecognized enumerator");
5069 return;
5070 }
5071 if(pCreateInfo->pCbState->pNext == nullptr)
5072 {
5073 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5074 "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pCbState->pNext, is null pointer");
5075 return;
5076 }
5077 if(pCreateInfo->pCbState->logicOp < VK_LOGIC_OP_BEGIN_RANGE ||
5078 pCreateInfo->pCbState->logicOp > VK_LOGIC_OP_END_RANGE)
5079 {
5080 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5081 "vkCreateGraphicsPipeline parameter, VkLogicOp pCreateInfo->pCbState->logicOp, is unrecognized enumerator");
5082 return;
5083 }
5084 if(pCreateInfo->pCbState->pAttachments == nullptr)
5085 {
5086 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5087 "vkCreateGraphicsPipeline parameter, const VkPipelineCbAttachmentState* pCreateInfo->pCbState->pAttachments, is null pointer");
5088 return;
5089 }
5090 if(pCreateInfo->pCbState->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
5091 pCreateInfo->pCbState->pAttachments->format > VK_FORMAT_END_RANGE)
5092 {
5093 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5094 "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pCbState->pAttachments->format, is unrecognized enumerator");
5095 return;
5096 }
5097 if(pCreateInfo->pCbState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE ||
5098 pCreateInfo->pCbState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE)
5099 {
5100 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5101 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendColor, is unrecognized enumerator");
5102 return;
5103 }
5104 if(pCreateInfo->pCbState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE ||
5105 pCreateInfo->pCbState->pAttachments->destBlendColor > VK_BLEND_END_RANGE)
5106 {
5107 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5108 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendColor, is unrecognized enumerator");
5109 return;
5110 }
5111 if(pCreateInfo->pCbState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
5112 pCreateInfo->pCbState->pAttachments->blendOpColor > VK_BLEND_OP_END_RANGE)
5113 {
5114 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5115 "vkCreateGraphicsPipeline parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpColor, is unrecognized enumerator");
5116 return;
5117 }
5118 if(pCreateInfo->pCbState->pAttachments->srcBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5119 pCreateInfo->pCbState->pAttachments->srcBlendAlpha > VK_BLEND_END_RANGE)
5120 {
5121 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5122 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendAlpha, is unrecognized enumerator");
5123 return;
5124 }
5125 if(pCreateInfo->pCbState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5126 pCreateInfo->pCbState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE)
5127 {
5128 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5129 "vkCreateGraphicsPipeline parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendAlpha, is unrecognized enumerator");
5130 return;
5131 }
5132 if(pCreateInfo->pCbState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
5133 pCreateInfo->pCbState->pAttachments->blendOpAlpha > VK_BLEND_OP_END_RANGE)
5134 {
5135 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5136 "vkCreateGraphicsPipeline parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpAlpha, is unrecognized enumerator");
5137 return;
5138 }
5139 if(!ValidateEnumerator((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask))
5140 {
5141 std::string reason = "vkCreateGraphicsPipeline parameter, VkChannelFlags pCreateInfo->pCbState->pAttachments->channelWriteMask, is " + EnumeratorString((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask);
5142 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5143 return;
5144 }
5145 if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags))
5146 {
5147 std::string reason = "vkCreateGraphicsPipeline parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags);
5148 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5149 return;
5150 }
5151 if(pCreateInfo->layout == nullptr)
5152 {
5153 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5154 "vkCreateGraphicsPipeline parameter, VkPipelineLayout pCreateInfo->layout, is null pointer");
5155 return;
5156 }
5157}
5158
5159void PostCreateGraphicsPipeline(
5160 VkDevice device,
5161 VkPipeline* pPipeline,
5162 VkResult result)
5163{
5164 if(device == nullptr)
5165 {
5166 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5167 "vkCreateGraphicsPipeline parameter, VkDevice device, is null pointer");
5168 return;
5169 }
5170
5171 if(pPipeline == nullptr)
5172 {
5173 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5174 "vkCreateGraphicsPipeline parameter, VkPipeline* pPipeline, is null pointer");
5175 return;
5176 }
5177 if((*pPipeline) == nullptr)
5178 {
5179 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5180 "vkCreateGraphicsPipeline parameter, VkPipeline* pPipeline, is null pointer");
5181 return;
5182 }
5183
5184 if(result != VK_SUCCESS)
5185 {
5186 std::string reason = "vkCreateGraphicsPipeline parameter, VkResult result, is " + EnumeratorString(result);
5187 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5188 return;
5189 }
5190}
5191
5192VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(
5193 VkDevice device,
5194 const VkGraphicsPipelineCreateInfo* pCreateInfo,
5195 VkPipeline* pPipeline)
5196{
5197 PreCreateGraphicsPipeline(device, pCreateInfo);
5198 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
5199
5200 PostCreateGraphicsPipeline(device, pPipeline, result);
5201
5202 return result;
5203}
5204
5205void PreCreateGraphicsPipelineDerivative(
5206 VkDevice device,
5207 const VkGraphicsPipelineCreateInfo* pCreateInfo)
5208{
5209 if(device == nullptr)
5210 {
5211 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5212 "vkCreateGraphicsPipelineDerivative parameter, VkDevice device, is null pointer");
5213 return;
5214 }
5215
5216 if(pCreateInfo == nullptr)
5217 {
5218 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5219 "vkCreateGraphicsPipelineDerivative parameter, const VkGraphicsPipelineCreateInfo* pCreateInfo, is null pointer");
5220 return;
5221 }
5222 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5223 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
5224 {
5225 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5226 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
5227 return;
5228 }
5229 if(pCreateInfo->pStages == nullptr)
5230 {
5231 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5232 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineShaderStageCreateInfo* pCreateInfo->pStages, is null pointer");
5233 return;
5234 }
5235 if(pCreateInfo->pStages->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5236 pCreateInfo->pStages->sType > VK_STRUCTURE_TYPE_END_RANGE)
5237 {
5238 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5239 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pStages->sType, is unrecognized enumerator");
5240 return;
5241 }
5242 if(pCreateInfo->pStages->pNext == nullptr)
5243 {
5244 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5245 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pNext, is null pointer");
5246 return;
5247 }
5248 if(pCreateInfo->pStages->stage < VK_SHADER_STAGE_BEGIN_RANGE ||
5249 pCreateInfo->pStages->stage > VK_SHADER_STAGE_END_RANGE)
5250 {
5251 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5252 "vkCreateGraphicsPipelineDerivative parameter, VkShaderStage pCreateInfo->pStages->stage, is unrecognized enumerator");
5253 return;
5254 }
5255 if(pCreateInfo->pStages->shader == nullptr)
5256 {
5257 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5258 "vkCreateGraphicsPipelineDerivative parameter, VkShader pCreateInfo->pStages->shader, is null pointer");
5259 return;
5260 }
5261 if(pCreateInfo->pStages->pLinkConstBufferInfo == nullptr)
5262 {
5263 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5264 "vkCreateGraphicsPipelineDerivative parameter, const VkLinkConstBuffer* pCreateInfo->pStages->pLinkConstBufferInfo, is null pointer");
5265 return;
5266 }
5267 if(pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData == nullptr)
5268 {
5269 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5270 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData, is null pointer");
5271 return;
5272 }
5273 if(pCreateInfo->pStages->pSpecializationInfo == nullptr)
5274 {
5275 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5276 "vkCreateGraphicsPipelineDerivative parameter, const VkSpecializationInfo* pCreateInfo->pStages->pSpecializationInfo, is null pointer");
5277 return;
5278 }
5279 if(pCreateInfo->pStages->pSpecializationInfo->pMap == nullptr)
5280 {
5281 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5282 "vkCreateGraphicsPipelineDerivative parameter, const VkSpecializationMapEntry* pCreateInfo->pStages->pSpecializationInfo->pMap, is null pointer");
5283 return;
5284 }
5285 if(pCreateInfo->pStages->pSpecializationInfo->pData == nullptr)
5286 {
5287 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5288 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pSpecializationInfo->pData, is null pointer");
5289 return;
5290 }
5291 if(pCreateInfo->pVertexInputState == nullptr)
5292 {
5293 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5294 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineVertexInputStateCreateInfo* pCreateInfo->pVertexInputState, is null pointer");
5295 return;
5296 }
5297 if(pCreateInfo->pVertexInputState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5298 pCreateInfo->pVertexInputState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5299 {
5300 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5301 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pVertexInputState->sType, is unrecognized enumerator");
5302 return;
5303 }
5304 if(pCreateInfo->pVertexInputState->pNext == nullptr)
5305 {
5306 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5307 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pVertexInputState->pNext, is null pointer");
5308 return;
5309 }
5310 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions == nullptr)
5311 {
5312 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5313 "vkCreateGraphicsPipelineDerivative parameter, const VkVertexInputBindingDescription* pCreateInfo->pVertexInputState->pVertexBindingDescriptions, is null pointer");
5314 return;
5315 }
5316 if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate < VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE ||
5317 pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate > VK_VERTEX_INPUT_STEP_RATE_END_RANGE)
5318 {
5319 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5320 "vkCreateGraphicsPipelineDerivative parameter, VkVertexInputStepRate pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate, is unrecognized enumerator");
5321 return;
5322 }
5323 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions == nullptr)
5324 {
5325 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5326 "vkCreateGraphicsPipelineDerivative parameter, const VkVertexInputAttributeDescription* pCreateInfo->pVertexInputState->pVertexAttributeDescriptions, is null pointer");
5327 return;
5328 }
5329 if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE ||
5330 pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE)
5331 {
5332 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5333 "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format, is unrecognized enumerator");
5334 return;
5335 }
5336 if(pCreateInfo->pIaState == nullptr)
5337 {
5338 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5339 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineIaStateCreateInfo* pCreateInfo->pIaState, is null pointer");
5340 return;
5341 }
5342 if(pCreateInfo->pIaState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5343 pCreateInfo->pIaState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5344 {
5345 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5346 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pIaState->sType, is unrecognized enumerator");
5347 return;
5348 }
5349 if(pCreateInfo->pIaState->pNext == nullptr)
5350 {
5351 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5352 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pIaState->pNext, is null pointer");
5353 return;
5354 }
5355 if(pCreateInfo->pIaState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE ||
5356 pCreateInfo->pIaState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE)
5357 {
5358 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5359 "vkCreateGraphicsPipelineDerivative parameter, VkPrimitiveTopology pCreateInfo->pIaState->topology, is unrecognized enumerator");
5360 return;
5361 }
5362 if(pCreateInfo->pTessState == nullptr)
5363 {
5364 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5365 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineTessStateCreateInfo* pCreateInfo->pTessState, is null pointer");
5366 return;
5367 }
5368 if(pCreateInfo->pTessState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5369 pCreateInfo->pTessState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5370 {
5371 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5372 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pTessState->sType, is unrecognized enumerator");
5373 return;
5374 }
5375 if(pCreateInfo->pTessState->pNext == nullptr)
5376 {
5377 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5378 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pTessState->pNext, is null pointer");
5379 return;
5380 }
5381 if(pCreateInfo->pVpState == nullptr)
5382 {
5383 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5384 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineVpStateCreateInfo* pCreateInfo->pVpState, is null pointer");
5385 return;
5386 }
5387 if(pCreateInfo->pVpState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5388 pCreateInfo->pVpState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5389 {
5390 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5391 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pVpState->sType, is unrecognized enumerator");
5392 return;
5393 }
5394 if(pCreateInfo->pVpState->pNext == nullptr)
5395 {
5396 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5397 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pVpState->pNext, is null pointer");
5398 return;
5399 }
5400 if(pCreateInfo->pVpState->clipOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
5401 pCreateInfo->pVpState->clipOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
5402 {
5403 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5404 "vkCreateGraphicsPipelineDerivative parameter, VkCoordinateOrigin pCreateInfo->pVpState->clipOrigin, is unrecognized enumerator");
5405 return;
5406 }
5407 if(pCreateInfo->pVpState->depthMode < VK_DEPTH_MODE_BEGIN_RANGE ||
5408 pCreateInfo->pVpState->depthMode > VK_DEPTH_MODE_END_RANGE)
5409 {
5410 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5411 "vkCreateGraphicsPipelineDerivative parameter, VkDepthMode pCreateInfo->pVpState->depthMode, is unrecognized enumerator");
5412 return;
5413 }
5414 if(pCreateInfo->pRsState == nullptr)
5415 {
5416 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5417 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineRsStateCreateInfo* pCreateInfo->pRsState, is null pointer");
5418 return;
5419 }
5420 if(pCreateInfo->pRsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5421 pCreateInfo->pRsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5422 {
5423 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5424 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pRsState->sType, is unrecognized enumerator");
5425 return;
5426 }
5427 if(pCreateInfo->pRsState->pNext == nullptr)
5428 {
5429 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5430 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pRsState->pNext, is null pointer");
5431 return;
5432 }
5433 if(pCreateInfo->pRsState->pointOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE ||
5434 pCreateInfo->pRsState->pointOrigin > VK_COORDINATE_ORIGIN_END_RANGE)
5435 {
5436 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5437 "vkCreateGraphicsPipelineDerivative parameter, VkCoordinateOrigin pCreateInfo->pRsState->pointOrigin, is unrecognized enumerator");
5438 return;
5439 }
5440 if(pCreateInfo->pRsState->provokingVertex < VK_PROVOKING_VERTEX_BEGIN_RANGE ||
5441 pCreateInfo->pRsState->provokingVertex > VK_PROVOKING_VERTEX_END_RANGE)
5442 {
5443 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5444 "vkCreateGraphicsPipelineDerivative parameter, VkProvokingVertex pCreateInfo->pRsState->provokingVertex, is unrecognized enumerator");
5445 return;
5446 }
5447 if(pCreateInfo->pRsState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
5448 pCreateInfo->pRsState->fillMode > VK_FILL_MODE_END_RANGE)
5449 {
5450 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5451 "vkCreateGraphicsPipelineDerivative parameter, VkFillMode pCreateInfo->pRsState->fillMode, is unrecognized enumerator");
5452 return;
5453 }
5454 if(pCreateInfo->pRsState->cullMode < VK_CULL_MODE_BEGIN_RANGE ||
5455 pCreateInfo->pRsState->cullMode > VK_CULL_MODE_END_RANGE)
5456 {
5457 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5458 "vkCreateGraphicsPipelineDerivative parameter, VkCullMode pCreateInfo->pRsState->cullMode, is unrecognized enumerator");
5459 return;
5460 }
5461 if(pCreateInfo->pRsState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
5462 pCreateInfo->pRsState->frontFace > VK_FRONT_FACE_END_RANGE)
5463 {
5464 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5465 "vkCreateGraphicsPipelineDerivative parameter, VkFrontFace pCreateInfo->pRsState->frontFace, is unrecognized enumerator");
5466 return;
5467 }
5468 if(pCreateInfo->pMsState == nullptr)
5469 {
5470 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5471 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineMsStateCreateInfo* pCreateInfo->pMsState, is null pointer");
5472 return;
5473 }
5474 if(pCreateInfo->pMsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5475 pCreateInfo->pMsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5476 {
5477 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5478 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pMsState->sType, is unrecognized enumerator");
5479 return;
5480 }
5481 if(pCreateInfo->pMsState->pNext == nullptr)
5482 {
5483 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5484 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pMsState->pNext, is null pointer");
5485 return;
5486 }
5487 if(pCreateInfo->pDsState == nullptr)
5488 {
5489 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5490 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineDsStateCreateInfo* pCreateInfo->pDsState, is null pointer");
5491 return;
5492 }
5493 if(pCreateInfo->pDsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5494 pCreateInfo->pDsState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5495 {
5496 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5497 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pDsState->sType, is unrecognized enumerator");
5498 return;
5499 }
5500 if(pCreateInfo->pDsState->pNext == nullptr)
5501 {
5502 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5503 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pDsState->pNext, is null pointer");
5504 return;
5505 }
5506 if(pCreateInfo->pDsState->format < VK_FORMAT_BEGIN_RANGE ||
5507 pCreateInfo->pDsState->format > VK_FORMAT_END_RANGE)
5508 {
5509 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5510 "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pDsState->format, is unrecognized enumerator");
5511 return;
5512 }
5513 if(pCreateInfo->pDsState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5514 pCreateInfo->pDsState->depthCompareOp > VK_COMPARE_OP_END_RANGE)
5515 {
5516 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5517 "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->depthCompareOp, is unrecognized enumerator");
5518 return;
5519 }
5520 if(pCreateInfo->pDsState->front.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5521 pCreateInfo->pDsState->front.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5522 {
5523 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5524 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilFailOp, is unrecognized enumerator");
5525 return;
5526 }
5527 if(pCreateInfo->pDsState->front.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5528 pCreateInfo->pDsState->front.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5529 {
5530 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5531 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilPassOp, is unrecognized enumerator");
5532 return;
5533 }
5534 if(pCreateInfo->pDsState->front.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5535 pCreateInfo->pDsState->front.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5536 {
5537 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5538 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilDepthFailOp, is unrecognized enumerator");
5539 return;
5540 }
5541 if(pCreateInfo->pDsState->front.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5542 pCreateInfo->pDsState->front.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5543 {
5544 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5545 "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->front.stencilCompareOp, is unrecognized enumerator");
5546 return;
5547 }
5548 if(pCreateInfo->pDsState->back.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5549 pCreateInfo->pDsState->back.stencilFailOp > VK_STENCIL_OP_END_RANGE)
5550 {
5551 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5552 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilFailOp, is unrecognized enumerator");
5553 return;
5554 }
5555 if(pCreateInfo->pDsState->back.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
5556 pCreateInfo->pDsState->back.stencilPassOp > VK_STENCIL_OP_END_RANGE)
5557 {
5558 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5559 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilPassOp, is unrecognized enumerator");
5560 return;
5561 }
5562 if(pCreateInfo->pDsState->back.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
5563 pCreateInfo->pDsState->back.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
5564 {
5565 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5566 "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilDepthFailOp, is unrecognized enumerator");
5567 return;
5568 }
5569 if(pCreateInfo->pDsState->back.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
5570 pCreateInfo->pDsState->back.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
5571 {
5572 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5573 "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->back.stencilCompareOp, is unrecognized enumerator");
5574 return;
5575 }
5576 if(pCreateInfo->pCbState == nullptr)
5577 {
5578 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5579 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineCbStateCreateInfo* pCreateInfo->pCbState, is null pointer");
5580 return;
5581 }
5582 if(pCreateInfo->pCbState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5583 pCreateInfo->pCbState->sType > VK_STRUCTURE_TYPE_END_RANGE)
5584 {
5585 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5586 "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pCbState->sType, is unrecognized enumerator");
5587 return;
5588 }
5589 if(pCreateInfo->pCbState->pNext == nullptr)
5590 {
5591 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5592 "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pCbState->pNext, is null pointer");
5593 return;
5594 }
5595 if(pCreateInfo->pCbState->logicOp < VK_LOGIC_OP_BEGIN_RANGE ||
5596 pCreateInfo->pCbState->logicOp > VK_LOGIC_OP_END_RANGE)
5597 {
5598 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5599 "vkCreateGraphicsPipelineDerivative parameter, VkLogicOp pCreateInfo->pCbState->logicOp, is unrecognized enumerator");
5600 return;
5601 }
5602 if(pCreateInfo->pCbState->pAttachments == nullptr)
5603 {
5604 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5605 "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineCbAttachmentState* pCreateInfo->pCbState->pAttachments, is null pointer");
5606 return;
5607 }
5608 if(pCreateInfo->pCbState->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
5609 pCreateInfo->pCbState->pAttachments->format > VK_FORMAT_END_RANGE)
5610 {
5611 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5612 "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pCbState->pAttachments->format, is unrecognized enumerator");
5613 return;
5614 }
5615 if(pCreateInfo->pCbState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE ||
5616 pCreateInfo->pCbState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE)
5617 {
5618 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5619 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendColor, is unrecognized enumerator");
5620 return;
5621 }
5622 if(pCreateInfo->pCbState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE ||
5623 pCreateInfo->pCbState->pAttachments->destBlendColor > VK_BLEND_END_RANGE)
5624 {
5625 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5626 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendColor, is unrecognized enumerator");
5627 return;
5628 }
5629 if(pCreateInfo->pCbState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
5630 pCreateInfo->pCbState->pAttachments->blendOpColor > VK_BLEND_OP_END_RANGE)
5631 {
5632 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5633 "vkCreateGraphicsPipelineDerivative parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpColor, is unrecognized enumerator");
5634 return;
5635 }
5636 if(pCreateInfo->pCbState->pAttachments->srcBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5637 pCreateInfo->pCbState->pAttachments->srcBlendAlpha > VK_BLEND_END_RANGE)
5638 {
5639 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5640 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendAlpha, is unrecognized enumerator");
5641 return;
5642 }
5643 if(pCreateInfo->pCbState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE ||
5644 pCreateInfo->pCbState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE)
5645 {
5646 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5647 "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendAlpha, is unrecognized enumerator");
5648 return;
5649 }
5650 if(pCreateInfo->pCbState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
5651 pCreateInfo->pCbState->pAttachments->blendOpAlpha > VK_BLEND_OP_END_RANGE)
5652 {
5653 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5654 "vkCreateGraphicsPipelineDerivative parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpAlpha, is unrecognized enumerator");
5655 return;
5656 }
5657 if(!ValidateEnumerator((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask))
5658 {
5659 std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkChannelFlags pCreateInfo->pCbState->pAttachments->channelWriteMask, is " + EnumeratorString((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask);
5660 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5661 return;
5662 }
5663 if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags))
5664 {
5665 std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags);
5666 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5667 return;
5668 }
5669 if(pCreateInfo->layout == nullptr)
5670 {
5671 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5672 "vkCreateGraphicsPipelineDerivative parameter, VkPipelineLayout pCreateInfo->layout, is null pointer");
5673 return;
5674 }
5675}
5676
5677void PostCreateGraphicsPipelineDerivative(
5678 VkDevice device,
5679 VkPipeline basePipeline,
5680 VkPipeline* pPipeline,
5681 VkResult result)
5682{
5683 if(device == nullptr)
5684 {
5685 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5686 "vkCreateGraphicsPipelineDerivative parameter, VkDevice device, is null pointer");
5687 return;
5688 }
5689
5690 if(basePipeline == nullptr)
5691 {
5692 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5693 "vkCreateGraphicsPipelineDerivative parameter, VkPipeline basePipeline, is null pointer");
5694 return;
5695 }
5696
5697 if(pPipeline == nullptr)
5698 {
5699 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5700 "vkCreateGraphicsPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
5701 return;
5702 }
5703 if((*pPipeline) == nullptr)
5704 {
5705 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5706 "vkCreateGraphicsPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
5707 return;
5708 }
5709
5710 if(result != VK_SUCCESS)
5711 {
5712 std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkResult result, is " + EnumeratorString(result);
5713 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5714 return;
5715 }
5716}
5717
5718VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(
5719 VkDevice device,
5720 const VkGraphicsPipelineCreateInfo* pCreateInfo,
5721 VkPipeline basePipeline,
5722 VkPipeline* pPipeline)
5723{
5724 PreCreateGraphicsPipelineDerivative(device, pCreateInfo);
5725 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
5726
5727 PostCreateGraphicsPipelineDerivative(device, basePipeline, pPipeline, result);
5728
5729 return result;
5730}
5731
5732void PreCreateComputePipeline(
5733 VkDevice device,
5734 const VkComputePipelineCreateInfo* pCreateInfo)
5735{
5736 if(device == nullptr)
5737 {
5738 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5739 "vkCreateComputePipeline parameter, VkDevice device, is null pointer");
5740 return;
5741 }
5742
5743 if(pCreateInfo == nullptr)
5744 {
5745 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5746 "vkCreateComputePipeline parameter, const VkComputePipelineCreateInfo* pCreateInfo, is null pointer");
5747 return;
5748 }
5749 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5750 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
5751 {
5752 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5753 "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
5754 return;
5755 }
5756 if(pCreateInfo->cs.sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
5757 pCreateInfo->cs.sType > VK_STRUCTURE_TYPE_END_RANGE)
5758 {
5759 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5760 "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->cs.sType, is unrecognized enumerator");
5761 return;
5762 }
5763 if(pCreateInfo->cs.pNext == nullptr)
5764 {
5765 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5766 "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pNext, is null pointer");
5767 return;
5768 }
5769 if(pCreateInfo->cs.stage < VK_SHADER_STAGE_BEGIN_RANGE ||
5770 pCreateInfo->cs.stage > VK_SHADER_STAGE_END_RANGE)
5771 {
5772 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5773 "vkCreateComputePipeline parameter, VkShaderStage pCreateInfo->cs.stage, is unrecognized enumerator");
5774 return;
5775 }
5776 if(pCreateInfo->cs.shader == nullptr)
5777 {
5778 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5779 "vkCreateComputePipeline parameter, VkShader pCreateInfo->cs.shader, is null pointer");
5780 return;
5781 }
5782 if(pCreateInfo->cs.pLinkConstBufferInfo == nullptr)
5783 {
5784 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5785 "vkCreateComputePipeline parameter, const VkLinkConstBuffer* pCreateInfo->cs.pLinkConstBufferInfo, is null pointer");
5786 return;
5787 }
5788 if(pCreateInfo->cs.pLinkConstBufferInfo->pBufferData == nullptr)
5789 {
5790 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5791 "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pLinkConstBufferInfo->pBufferData, is null pointer");
5792 return;
5793 }
5794 if(pCreateInfo->cs.pSpecializationInfo == nullptr)
5795 {
5796 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5797 "vkCreateComputePipeline parameter, const VkSpecializationInfo* pCreateInfo->cs.pSpecializationInfo, is null pointer");
5798 return;
5799 }
5800 if(pCreateInfo->cs.pSpecializationInfo->pMap == nullptr)
5801 {
5802 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5803 "vkCreateComputePipeline parameter, const VkSpecializationMapEntry* pCreateInfo->cs.pSpecializationInfo->pMap, is null pointer");
5804 return;
5805 }
5806 if(pCreateInfo->cs.pSpecializationInfo->pData == nullptr)
5807 {
5808 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5809 "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pSpecializationInfo->pData, is null pointer");
5810 return;
5811 }
5812 if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags))
5813 {
5814 std::string reason = "vkCreateComputePipeline parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags);
5815 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5816 return;
5817 }
5818 if(pCreateInfo->layout == nullptr)
5819 {
5820 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5821 "vkCreateComputePipeline parameter, VkPipelineLayout pCreateInfo->layout, is null pointer");
5822 return;
5823 }
5824}
5825
5826void PostCreateComputePipeline(
5827 VkDevice device,
5828 VkPipeline* pPipeline,
5829 VkResult result)
5830{
5831 if(device == nullptr)
5832 {
5833 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5834 "vkCreateComputePipeline parameter, VkDevice device, is null pointer");
5835 return;
5836 }
5837
5838 if(pPipeline == nullptr)
5839 {
5840 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5841 "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer");
5842 return;
5843 }
5844 if((*pPipeline) == nullptr)
5845 {
5846 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5847 "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer");
5848 return;
5849 }
5850
5851 if(result != VK_SUCCESS)
5852 {
5853 std::string reason = "vkCreateComputePipeline parameter, VkResult result, is " + EnumeratorString(result);
5854 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5855 return;
5856 }
5857}
5858
5859VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(
5860 VkDevice device,
5861 const VkComputePipelineCreateInfo* pCreateInfo,
5862 VkPipeline* pPipeline)
5863{
5864 PreCreateComputePipeline(device, pCreateInfo);
5865 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipeline(device, pCreateInfo, pPipeline);
5866
5867 PostCreateComputePipeline(device, pPipeline, result);
5868
5869 return result;
5870}
5871
5872void PreStorePipeline(
5873 VkDevice device)
5874{
5875 if(device == nullptr)
5876 {
5877 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5878 "vkStorePipeline parameter, VkDevice device, is null pointer");
5879 return;
5880 }
5881}
5882
5883void PostStorePipeline(
5884 VkDevice device,
5885 VkPipeline pipeline,
5886 size_t* pDataSize,
5887 void* pData,
5888 VkResult result)
5889{
5890 if(device == nullptr)
5891 {
5892 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5893 "vkStorePipeline parameter, VkDevice device, is null pointer");
5894 return;
5895 }
5896
5897 if(pipeline == nullptr)
5898 {
5899 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5900 "vkStorePipeline parameter, VkPipeline pipeline, is null pointer");
5901 return;
5902 }
5903
5904 if(pDataSize == nullptr)
5905 {
5906 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5907 "vkStorePipeline parameter, size_t* pDataSize, is null pointer");
5908 return;
5909 }
5910
5911 if(pData == nullptr)
5912 {
5913 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5914 "vkStorePipeline parameter, void* pData, is null pointer");
5915 return;
5916 }
5917
5918 if(result != VK_SUCCESS)
5919 {
5920 std::string reason = "vkStorePipeline parameter, VkResult result, is " + EnumeratorString(result);
5921 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5922 return;
5923 }
5924}
5925
5926VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(
5927 VkDevice device,
5928 VkPipeline pipeline,
5929 size_t* pDataSize,
5930 void* pData)
5931{
5932 PreStorePipeline(device);
5933 VkResult result = get_dispatch_table(pc_device_table_map, device)->StorePipeline(device, pipeline, pDataSize, pData);
5934
5935 PostStorePipeline(device, pipeline, pDataSize, pData, result);
5936
5937 return result;
5938}
5939
5940void PreLoadPipeline(
5941 VkDevice device,
5942 const void* pData)
5943{
5944 if(device == nullptr)
5945 {
5946 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5947 "vkLoadPipeline parameter, VkDevice device, is null pointer");
5948 return;
5949 }
5950
5951 if(pData == nullptr)
5952 {
5953 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5954 "vkLoadPipeline parameter, const void* pData, is null pointer");
5955 return;
5956 }
5957}
5958
5959void PostLoadPipeline(
5960 VkDevice device,
5961 size_t dataSize,
5962 VkPipeline* pPipeline,
5963 VkResult result)
5964{
5965 if(device == nullptr)
5966 {
5967 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5968 "vkLoadPipeline parameter, VkDevice device, is null pointer");
5969 return;
5970 }
5971
5972
5973 if(pPipeline == nullptr)
5974 {
5975 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5976 "vkLoadPipeline parameter, VkPipeline* pPipeline, is null pointer");
5977 return;
5978 }
5979 if((*pPipeline) == nullptr)
5980 {
5981 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
5982 "vkLoadPipeline parameter, VkPipeline* pPipeline, is null pointer");
5983 return;
5984 }
5985
5986 if(result != VK_SUCCESS)
5987 {
5988 std::string reason = "vkLoadPipeline parameter, VkResult result, is " + EnumeratorString(result);
5989 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
5990 return;
5991 }
5992}
5993
5994VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline(
5995 VkDevice device,
5996 size_t dataSize,
5997 const void* pData,
5998 VkPipeline* pPipeline)
5999{
6000 PreLoadPipeline(device, pData);
6001 VkResult result = get_dispatch_table(pc_device_table_map, device)->LoadPipeline(device, dataSize, pData, pPipeline);
6002
6003 PostLoadPipeline(device, dataSize, pPipeline, result);
6004
6005 return result;
6006}
6007
6008void PreLoadPipelineDerivative(
6009 VkDevice device,
6010 const void* pData)
6011{
6012 if(device == nullptr)
6013 {
6014 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6015 "vkLoadPipelineDerivative parameter, VkDevice device, is null pointer");
6016 return;
6017 }
6018
6019 if(pData == nullptr)
6020 {
6021 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6022 "vkLoadPipelineDerivative parameter, const void* pData, is null pointer");
6023 return;
6024 }
6025}
6026
6027void PostLoadPipelineDerivative(
6028 VkDevice device,
6029 size_t dataSize,
6030 VkPipeline basePipeline,
6031 VkPipeline* pPipeline,
6032 VkResult result)
6033{
6034 if(device == nullptr)
6035 {
6036 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6037 "vkLoadPipelineDerivative parameter, VkDevice device, is null pointer");
6038 return;
6039 }
6040
6041
6042 if(basePipeline == nullptr)
6043 {
6044 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6045 "vkLoadPipelineDerivative parameter, VkPipeline basePipeline, is null pointer");
6046 return;
6047 }
6048
6049 if(pPipeline == nullptr)
6050 {
6051 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6052 "vkLoadPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
6053 return;
6054 }
6055 if((*pPipeline) == nullptr)
6056 {
6057 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6058 "vkLoadPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer");
6059 return;
6060 }
6061
6062 if(result != VK_SUCCESS)
6063 {
6064 std::string reason = "vkLoadPipelineDerivative parameter, VkResult result, is " + EnumeratorString(result);
6065 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6066 return;
6067 }
6068}
6069
6070VK_LAYER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(
6071 VkDevice device,
6072 size_t dataSize,
6073 const void* pData,
6074 VkPipeline basePipeline,
6075 VkPipeline* pPipeline)
6076{
6077 PreLoadPipelineDerivative(device, pData);
6078 VkResult result = get_dispatch_table(pc_device_table_map, device)->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
6079
6080 PostLoadPipelineDerivative(device, dataSize, basePipeline, pPipeline, result);
6081
6082 return result;
6083}
6084
6085void PreCreatePipelineLayout(
6086 VkDevice device,
6087 const VkPipelineLayoutCreateInfo* pCreateInfo)
6088{
6089 if(device == nullptr)
6090 {
6091 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6092 "vkCreatePipelineLayout parameter, VkDevice device, is null pointer");
6093 return;
6094 }
6095
6096 if(pCreateInfo == nullptr)
6097 {
6098 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6099 "vkCreatePipelineLayout parameter, const VkPipelineLayoutCreateInfo* pCreateInfo, is null pointer");
6100 return;
6101 }
6102 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6103 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6104 {
6105 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6106 "vkCreatePipelineLayout parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6107 return;
6108 }
6109 if(pCreateInfo->pSetLayouts == nullptr)
6110 {
6111 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6112 "vkCreatePipelineLayout parameter, const VkDescriptorSetLayout* pCreateInfo->pSetLayouts, is null pointer");
6113 return;
6114 }
6115 if((*pCreateInfo->pSetLayouts) == nullptr)
6116 {
6117 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6118 "vkCreatePipelineLayout parameter, const VkDescriptorSetLayout* pCreateInfo->pSetLayouts, is null pointer");
6119 return;
6120 }
6121}
6122
6123void PostCreatePipelineLayout(
6124 VkDevice device,
6125 VkPipelineLayout* pPipelineLayout,
6126 VkResult result)
6127{
6128 if(device == nullptr)
6129 {
6130 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6131 "vkCreatePipelineLayout parameter, VkDevice device, is null pointer");
6132 return;
6133 }
6134
6135 if(pPipelineLayout == nullptr)
6136 {
6137 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6138 "vkCreatePipelineLayout parameter, VkPipelineLayout* pPipelineLayout, is null pointer");
6139 return;
6140 }
6141 if((*pPipelineLayout) == nullptr)
6142 {
6143 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6144 "vkCreatePipelineLayout parameter, VkPipelineLayout* pPipelineLayout, is null pointer");
6145 return;
6146 }
6147
6148 if(result != VK_SUCCESS)
6149 {
6150 std::string reason = "vkCreatePipelineLayout parameter, VkResult result, is " + EnumeratorString(result);
6151 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6152 return;
6153 }
6154}
6155
6156VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
6157 VkDevice device,
6158 const VkPipelineLayoutCreateInfo* pCreateInfo,
6159 VkPipelineLayout* pPipelineLayout)
6160{
6161 PreCreatePipelineLayout(device, pCreateInfo);
6162 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
6163
6164 PostCreatePipelineLayout(device, pPipelineLayout, result);
6165
6166 return result;
6167}
6168
6169void PreCreateSampler(
6170 VkDevice device,
6171 const VkSamplerCreateInfo* pCreateInfo)
6172{
6173 if(device == nullptr)
6174 {
6175 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6176 "vkCreateSampler parameter, VkDevice device, is null pointer");
6177 return;
6178 }
6179
6180 if(pCreateInfo == nullptr)
6181 {
6182 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6183 "vkCreateSampler parameter, const VkSamplerCreateInfo* pCreateInfo, is null pointer");
6184 return;
6185 }
6186 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6187 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6188 {
6189 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6190 "vkCreateSampler parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6191 return;
6192 }
6193 if(pCreateInfo->magFilter < VK_TEX_FILTER_BEGIN_RANGE ||
6194 pCreateInfo->magFilter > VK_TEX_FILTER_END_RANGE)
6195 {
6196 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6197 "vkCreateSampler parameter, VkTexFilter pCreateInfo->magFilter, is unrecognized enumerator");
6198 return;
6199 }
6200 if(pCreateInfo->minFilter < VK_TEX_FILTER_BEGIN_RANGE ||
6201 pCreateInfo->minFilter > VK_TEX_FILTER_END_RANGE)
6202 {
6203 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6204 "vkCreateSampler parameter, VkTexFilter pCreateInfo->minFilter, is unrecognized enumerator");
6205 return;
6206 }
6207 if(pCreateInfo->mipMode < VK_TEX_MIPMAP_MODE_BEGIN_RANGE ||
6208 pCreateInfo->mipMode > VK_TEX_MIPMAP_MODE_END_RANGE)
6209 {
6210 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6211 "vkCreateSampler parameter, VkTexMipmapMode pCreateInfo->mipMode, is unrecognized enumerator");
6212 return;
6213 }
6214 if(pCreateInfo->addressU < VK_TEX_ADDRESS_BEGIN_RANGE ||
6215 pCreateInfo->addressU > VK_TEX_ADDRESS_END_RANGE)
6216 {
6217 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6218 "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressU, is unrecognized enumerator");
6219 return;
6220 }
6221 if(pCreateInfo->addressV < VK_TEX_ADDRESS_BEGIN_RANGE ||
6222 pCreateInfo->addressV > VK_TEX_ADDRESS_END_RANGE)
6223 {
6224 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6225 "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressV, is unrecognized enumerator");
6226 return;
6227 }
6228 if(pCreateInfo->addressW < VK_TEX_ADDRESS_BEGIN_RANGE ||
6229 pCreateInfo->addressW > VK_TEX_ADDRESS_END_RANGE)
6230 {
6231 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6232 "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressW, is unrecognized enumerator");
6233 return;
6234 }
6235 if(pCreateInfo->compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
6236 pCreateInfo->compareOp > VK_COMPARE_OP_END_RANGE)
6237 {
6238 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6239 "vkCreateSampler parameter, VkCompareOp pCreateInfo->compareOp, is unrecognized enumerator");
6240 return;
6241 }
6242 if(pCreateInfo->borderColor < VK_BORDER_COLOR_BEGIN_RANGE ||
6243 pCreateInfo->borderColor > VK_BORDER_COLOR_END_RANGE)
6244 {
6245 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6246 "vkCreateSampler parameter, VkBorderColor pCreateInfo->borderColor, is unrecognized enumerator");
6247 return;
6248 }
6249}
6250
6251void PostCreateSampler(
6252 VkDevice device,
6253 VkSampler* pSampler,
6254 VkResult result)
6255{
6256 if(device == nullptr)
6257 {
6258 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6259 "vkCreateSampler parameter, VkDevice device, is null pointer");
6260 return;
6261 }
6262
6263 if(pSampler == nullptr)
6264 {
6265 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6266 "vkCreateSampler parameter, VkSampler* pSampler, is null pointer");
6267 return;
6268 }
6269 if((*pSampler) == nullptr)
6270 {
6271 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6272 "vkCreateSampler parameter, VkSampler* pSampler, is null pointer");
6273 return;
6274 }
6275
6276 if(result != VK_SUCCESS)
6277 {
6278 std::string reason = "vkCreateSampler parameter, VkResult result, is " + EnumeratorString(result);
6279 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6280 return;
6281 }
6282}
6283
6284VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
6285 VkDevice device,
6286 const VkSamplerCreateInfo* pCreateInfo,
6287 VkSampler* pSampler)
6288{
6289 PreCreateSampler(device, pCreateInfo);
6290 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
6291
6292 PostCreateSampler(device, pSampler, result);
6293
6294 return result;
6295}
6296
6297void PreCreateDescriptorSetLayout(
6298 VkDevice device,
6299 const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
6300{
6301 if(device == nullptr)
6302 {
6303 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6304 "vkCreateDescriptorSetLayout parameter, VkDevice device, is null pointer");
6305 return;
6306 }
6307
6308 if(pCreateInfo == nullptr)
6309 {
6310 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6311 "vkCreateDescriptorSetLayout parameter, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, is null pointer");
6312 return;
6313 }
6314 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6315 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6316 {
6317 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6318 "vkCreateDescriptorSetLayout parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6319 return;
6320 }
6321 if(pCreateInfo->pBinding == nullptr)
6322 {
6323 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6324 "vkCreateDescriptorSetLayout parameter, const VkDescriptorSetLayoutBinding* pCreateInfo->pBinding, is null pointer");
6325 return;
6326 }
6327 if(pCreateInfo->pBinding->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
6328 pCreateInfo->pBinding->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
6329 {
6330 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6331 "vkCreateDescriptorSetLayout parameter, VkDescriptorType pCreateInfo->pBinding->descriptorType, is unrecognized enumerator");
6332 return;
6333 }
6334 if(!ValidateEnumerator((VkShaderStageFlagBits)pCreateInfo->pBinding->stageFlags))
6335 {
6336 std::string reason = "vkCreateDescriptorSetLayout parameter, VkShaderStageFlags pCreateInfo->pBinding->stageFlags, is " + EnumeratorString((VkShaderStageFlagBits)pCreateInfo->pBinding->stageFlags);
6337 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6338 return;
6339 }
6340 if(pCreateInfo->pBinding->pImmutableSamplers == nullptr)
6341 {
6342 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6343 "vkCreateDescriptorSetLayout parameter, const VkSampler* pCreateInfo->pBinding->pImmutableSamplers, is null pointer");
6344 return;
6345 }
6346 if((*pCreateInfo->pBinding->pImmutableSamplers) == nullptr)
6347 {
6348 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6349 "vkCreateDescriptorSetLayout parameter, const VkSampler* pCreateInfo->pBinding->pImmutableSamplers, is null pointer");
6350 return;
6351 }
6352}
6353
6354void PostCreateDescriptorSetLayout(
6355 VkDevice device,
6356 VkDescriptorSetLayout* pSetLayout,
6357 VkResult result)
6358{
6359 if(device == nullptr)
6360 {
6361 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6362 "vkCreateDescriptorSetLayout parameter, VkDevice device, is null pointer");
6363 return;
6364 }
6365
6366 if(pSetLayout == nullptr)
6367 {
6368 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6369 "vkCreateDescriptorSetLayout parameter, VkDescriptorSetLayout* pSetLayout, is null pointer");
6370 return;
6371 }
6372 if((*pSetLayout) == nullptr)
6373 {
6374 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6375 "vkCreateDescriptorSetLayout parameter, VkDescriptorSetLayout* pSetLayout, is null pointer");
6376 return;
6377 }
6378
6379 if(result != VK_SUCCESS)
6380 {
6381 std::string reason = "vkCreateDescriptorSetLayout parameter, VkResult result, is " + EnumeratorString(result);
6382 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6383 return;
6384 }
6385}
6386
6387VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
6388 VkDevice device,
6389 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
6390 VkDescriptorSetLayout* pSetLayout)
6391{
6392 PreCreateDescriptorSetLayout(device, pCreateInfo);
6393 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
6394
6395 PostCreateDescriptorSetLayout(device, pSetLayout, result);
6396
6397 return result;
6398}
6399
6400void PreCreateDescriptorPool(
6401 VkDevice device,
6402 const VkDescriptorPoolCreateInfo* pCreateInfo)
6403{
6404 if(device == nullptr)
6405 {
6406 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6407 "vkCreateDescriptorPool parameter, VkDevice device, is null pointer");
6408 return;
6409 }
6410
6411 if(pCreateInfo == nullptr)
6412 {
6413 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6414 "vkCreateDescriptorPool parameter, const VkDescriptorPoolCreateInfo* pCreateInfo, is null pointer");
6415 return;
6416 }
6417 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6418 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6419 {
6420 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6421 "vkCreateDescriptorPool parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6422 return;
6423 }
6424 if(pCreateInfo->pTypeCount == nullptr)
6425 {
6426 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6427 "vkCreateDescriptorPool parameter, const VkDescriptorTypeCount* pCreateInfo->pTypeCount, is null pointer");
6428 return;
6429 }
6430 if(pCreateInfo->pTypeCount->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
6431 pCreateInfo->pTypeCount->type > VK_DESCRIPTOR_TYPE_END_RANGE)
6432 {
6433 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6434 "vkCreateDescriptorPool parameter, VkDescriptorType pCreateInfo->pTypeCount->type, is unrecognized enumerator");
6435 return;
6436 }
6437}
6438
6439void PostCreateDescriptorPool(
6440 VkDevice device,
6441 VkDescriptorPoolUsage poolUsage,
6442 uint32_t maxSets,
6443 VkDescriptorPool* pDescriptorPool,
6444 VkResult result)
6445{
6446 if(device == nullptr)
6447 {
6448 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6449 "vkCreateDescriptorPool parameter, VkDevice device, is null pointer");
6450 return;
6451 }
6452
6453 if(poolUsage < VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE ||
6454 poolUsage > VK_DESCRIPTOR_POOL_USAGE_END_RANGE)
6455 {
6456 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6457 "vkCreateDescriptorPool parameter, VkDescriptorPoolUsage poolUsage, is unrecognized enumerator");
6458 return;
6459 }
6460
6461
6462 if(pDescriptorPool == nullptr)
6463 {
6464 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6465 "vkCreateDescriptorPool parameter, VkDescriptorPool* pDescriptorPool, is null pointer");
6466 return;
6467 }
6468 if((*pDescriptorPool) == nullptr)
6469 {
6470 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6471 "vkCreateDescriptorPool parameter, VkDescriptorPool* pDescriptorPool, is null pointer");
6472 return;
6473 }
6474
6475 if(result != VK_SUCCESS)
6476 {
6477 std::string reason = "vkCreateDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
6478 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6479 return;
6480 }
6481}
6482
6483VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
6484 VkDevice device,
6485 VkDescriptorPoolUsage poolUsage,
6486 uint32_t maxSets,
6487 const VkDescriptorPoolCreateInfo* pCreateInfo,
6488 VkDescriptorPool* pDescriptorPool)
6489{
6490 PreCreateDescriptorPool(device, pCreateInfo);
6491 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
6492
6493 PostCreateDescriptorPool(device, poolUsage, maxSets, pDescriptorPool, result);
6494
6495 return result;
6496}
6497
6498void PreResetDescriptorPool(
6499 VkDevice device)
6500{
6501 if(device == nullptr)
6502 {
6503 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6504 "vkResetDescriptorPool parameter, VkDevice device, is null pointer");
6505 return;
6506 }
6507}
6508
6509void PostResetDescriptorPool(
6510 VkDevice device,
6511 VkDescriptorPool descriptorPool,
6512 VkResult result)
6513{
6514 if(device == nullptr)
6515 {
6516 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6517 "vkResetDescriptorPool parameter, VkDevice device, is null pointer");
6518 return;
6519 }
6520
6521 if(descriptorPool == nullptr)
6522 {
6523 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6524 "vkResetDescriptorPool parameter, VkDescriptorPool descriptorPool, is null pointer");
6525 return;
6526 }
6527
6528 if(result != VK_SUCCESS)
6529 {
6530 std::string reason = "vkResetDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
6531 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6532 return;
6533 }
6534}
6535
6536VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(
6537 VkDevice device,
6538 VkDescriptorPool descriptorPool)
6539{
6540 PreResetDescriptorPool(device);
6541 VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetDescriptorPool(device, descriptorPool);
6542
6543 PostResetDescriptorPool(device, descriptorPool, result);
6544
6545 return result;
6546}
6547
6548void PreAllocDescriptorSets(
6549 VkDevice device,
6550 const VkDescriptorSetLayout* pSetLayouts)
6551{
6552 if(device == nullptr)
6553 {
6554 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6555 "vkAllocDescriptorSets parameter, VkDevice device, is null pointer");
6556 return;
6557 }
6558
6559 if(pSetLayouts == nullptr)
6560 {
6561 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6562 "vkAllocDescriptorSets parameter, const VkDescriptorSetLayout* pSetLayouts, is null pointer");
6563 return;
6564 }
6565 if((*pSetLayouts) == nullptr)
6566 {
6567 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6568 "vkAllocDescriptorSets parameter, const VkDescriptorSetLayout* pSetLayouts, is null pointer");
6569 return;
6570 }
6571}
6572
6573void PostAllocDescriptorSets(
6574 VkDevice device,
6575 VkDescriptorPool descriptorPool,
6576 VkDescriptorSetUsage setUsage,
6577 uint32_t count,
6578 VkDescriptorSet* pDescriptorSets,
6579 uint32_t* pCount,
6580 VkResult result)
6581{
6582 if(device == nullptr)
6583 {
6584 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6585 "vkAllocDescriptorSets parameter, VkDevice device, is null pointer");
6586 return;
6587 }
6588
6589 if(descriptorPool == nullptr)
6590 {
6591 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6592 "vkAllocDescriptorSets parameter, VkDescriptorPool descriptorPool, is null pointer");
6593 return;
6594 }
6595
6596 if(setUsage < VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE ||
6597 setUsage > VK_DESCRIPTOR_SET_USAGE_END_RANGE)
6598 {
6599 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6600 "vkAllocDescriptorSets parameter, VkDescriptorSetUsage setUsage, is unrecognized enumerator");
6601 return;
6602 }
6603
6604
6605 if(pDescriptorSets == nullptr)
6606 {
6607 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6608 "vkAllocDescriptorSets parameter, VkDescriptorSet* pDescriptorSets, is null pointer");
6609 return;
6610 }
6611 if((*pDescriptorSets) == nullptr)
6612 {
6613 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6614 "vkAllocDescriptorSets parameter, VkDescriptorSet* pDescriptorSets, is null pointer");
6615 return;
6616 }
6617
6618 if(pCount == nullptr)
6619 {
6620 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6621 "vkAllocDescriptorSets parameter, uint32_t* pCount, is null pointer");
6622 return;
6623 }
6624
6625 if(result != VK_SUCCESS)
6626 {
6627 std::string reason = "vkAllocDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
6628 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6629 return;
6630 }
6631}
6632
6633VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(
6634 VkDevice device,
6635 VkDescriptorPool descriptorPool,
6636 VkDescriptorSetUsage setUsage,
6637 uint32_t count,
6638 const VkDescriptorSetLayout* pSetLayouts,
6639 VkDescriptorSet* pDescriptorSets,
6640 uint32_t* pCount)
6641{
6642 PreAllocDescriptorSets(device, pSetLayouts);
6643 VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
6644
6645 PostAllocDescriptorSets(device, descriptorPool, setUsage, count, pDescriptorSets, pCount, result);
6646
6647 return result;
6648}
6649
6650void PreUpdateDescriptorSets(
6651 VkDevice device,
6652 const VkWriteDescriptorSet* pDescriptorWrites,
6653 const VkCopyDescriptorSet* pDescriptorCopies)
6654{
6655 if(device == nullptr)
6656 {
6657 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6658 "vkUpdateDescriptorSets parameter, VkDevice device, is null pointer");
6659 return;
6660 }
6661
6662 if(pDescriptorWrites == nullptr)
6663 {
6664 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6665 "vkUpdateDescriptorSets parameter, const VkWriteDescriptorSet* pDescriptorWrites, is null pointer");
6666 return;
6667 }
6668 if(pDescriptorWrites->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6669 pDescriptorWrites->sType > VK_STRUCTURE_TYPE_END_RANGE)
6670 {
6671 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6672 "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorWrites->sType, is unrecognized enumerator");
6673 return;
6674 }
6675 if(pDescriptorWrites->pNext == nullptr)
6676 {
6677 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6678 "vkUpdateDescriptorSets parameter, const void* pDescriptorWrites->pNext, is null pointer");
6679 return;
6680 }
6681 if(pDescriptorWrites->destSet == nullptr)
6682 {
6683 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6684 "vkUpdateDescriptorSets parameter, VkDescriptorSet pDescriptorWrites->destSet, is null pointer");
6685 return;
6686 }
6687 if(pDescriptorWrites->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
6688 pDescriptorWrites->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
6689 {
6690 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6691 "vkUpdateDescriptorSets parameter, VkDescriptorType pDescriptorWrites->descriptorType, is unrecognized enumerator");
6692 return;
6693 }
6694 if(pDescriptorWrites->pDescriptors == nullptr)
6695 {
6696 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6697 "vkUpdateDescriptorSets parameter, const VkDescriptorInfo* pDescriptorWrites->pDescriptors, is null pointer");
6698 return;
6699 }
6700 if(pDescriptorWrites->pDescriptors->bufferView == nullptr)
6701 {
6702 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6703 "vkUpdateDescriptorSets parameter, VkBufferView pDescriptorWrites->pDescriptors->bufferView, is null pointer");
6704 return;
6705 }
6706 if(pDescriptorWrites->pDescriptors->sampler == nullptr)
6707 {
6708 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6709 "vkUpdateDescriptorSets parameter, VkSampler pDescriptorWrites->pDescriptors->sampler, is null pointer");
6710 return;
6711 }
6712 if(pDescriptorWrites->pDescriptors->imageView == nullptr)
6713 {
6714 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6715 "vkUpdateDescriptorSets parameter, VkImageView pDescriptorWrites->pDescriptors->imageView, is null pointer");
6716 return;
6717 }
6718 if(pDescriptorWrites->pDescriptors->imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
6719 pDescriptorWrites->pDescriptors->imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
6720 {
6721 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6722 "vkUpdateDescriptorSets parameter, VkImageLayout pDescriptorWrites->pDescriptors->imageLayout, is unrecognized enumerator");
6723 return;
6724 }
6725
6726 if(pDescriptorCopies == nullptr)
6727 {
6728 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6729 "vkUpdateDescriptorSets parameter, const VkCopyDescriptorSet* pDescriptorCopies, is null pointer");
6730 return;
6731 }
6732 if(pDescriptorCopies->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6733 pDescriptorCopies->sType > VK_STRUCTURE_TYPE_END_RANGE)
6734 {
6735 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6736 "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorCopies->sType, is unrecognized enumerator");
6737 return;
6738 }
6739 if(pDescriptorCopies->pNext == nullptr)
6740 {
6741 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6742 "vkUpdateDescriptorSets parameter, const void* pDescriptorCopies->pNext, is null pointer");
6743 return;
6744 }
6745 if(pDescriptorCopies->srcSet == nullptr)
6746 {
6747 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6748 "vkUpdateDescriptorSets parameter, VkDescriptorSet pDescriptorCopies->srcSet, is null pointer");
6749 return;
6750 }
6751 if(pDescriptorCopies->destSet == nullptr)
6752 {
6753 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6754 "vkUpdateDescriptorSets parameter, VkDescriptorSet pDescriptorCopies->destSet, is null pointer");
6755 return;
6756 }
6757}
6758
6759void PostUpdateDescriptorSets(
6760 VkDevice device,
6761 uint32_t writeCount,
6762 uint32_t copyCount,
6763 VkResult result)
6764{
6765 if(device == nullptr)
6766 {
6767 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6768 "vkUpdateDescriptorSets parameter, VkDevice device, is null pointer");
6769 return;
6770 }
6771
6772
6773
6774 if(result != VK_SUCCESS)
6775 {
6776 std::string reason = "vkUpdateDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
6777 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6778 return;
6779 }
6780}
6781
6782VK_LAYER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(
6783 VkDevice device,
6784 uint32_t writeCount,
6785 const VkWriteDescriptorSet* pDescriptorWrites,
6786 uint32_t copyCount,
6787 const VkCopyDescriptorSet* pDescriptorCopies)
6788{
6789 PreUpdateDescriptorSets(device, pDescriptorWrites, pDescriptorCopies);
6790 VkResult result = get_dispatch_table(pc_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
6791
6792 PostUpdateDescriptorSets(device, writeCount, copyCount, result);
6793
6794 return result;
6795}
6796
6797void PreCreateDynamicViewportState(
6798 VkDevice device,
6799 const VkDynamicVpStateCreateInfo* pCreateInfo)
6800{
6801 if(device == nullptr)
6802 {
6803 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6804 "vkCreateDynamicViewportState parameter, VkDevice device, is null pointer");
6805 return;
6806 }
6807
6808 if(pCreateInfo == nullptr)
6809 {
6810 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6811 "vkCreateDynamicViewportState parameter, const VkDynamicVpStateCreateInfo* pCreateInfo, is null pointer");
6812 return;
6813 }
6814 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6815 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6816 {
6817 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6818 "vkCreateDynamicViewportState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6819 return;
6820 }
6821 if(pCreateInfo->pViewports == nullptr)
6822 {
6823 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6824 "vkCreateDynamicViewportState parameter, const VkViewport* pCreateInfo->pViewports, is null pointer");
6825 return;
6826 }
6827 if(pCreateInfo->pScissors == nullptr)
6828 {
6829 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6830 "vkCreateDynamicViewportState parameter, const VkRect* pCreateInfo->pScissors, is null pointer");
6831 return;
6832 }
6833}
6834
6835void PostCreateDynamicViewportState(
6836 VkDevice device,
6837 VkDynamicVpState* pState,
6838 VkResult result)
6839{
6840 if(device == nullptr)
6841 {
6842 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6843 "vkCreateDynamicViewportState parameter, VkDevice device, is null pointer");
6844 return;
6845 }
6846
6847 if(pState == nullptr)
6848 {
6849 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6850 "vkCreateDynamicViewportState parameter, VkDynamicVpState* pState, is null pointer");
6851 return;
6852 }
6853 if((*pState) == nullptr)
6854 {
6855 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6856 "vkCreateDynamicViewportState parameter, VkDynamicVpState* pState, is null pointer");
6857 return;
6858 }
6859
6860 if(result != VK_SUCCESS)
6861 {
6862 std::string reason = "vkCreateDynamicViewportState parameter, VkResult result, is " + EnumeratorString(result);
6863 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6864 return;
6865 }
6866}
6867
6868VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(
6869 VkDevice device,
6870 const VkDynamicVpStateCreateInfo* pCreateInfo,
6871 VkDynamicVpState* pState)
6872{
6873 PreCreateDynamicViewportState(device, pCreateInfo);
6874 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicViewportState(device, pCreateInfo, pState);
6875
6876 PostCreateDynamicViewportState(device, pState, result);
6877
6878 return result;
6879}
6880
6881void PreCreateDynamicRasterState(
6882 VkDevice device,
6883 const VkDynamicRsStateCreateInfo* pCreateInfo)
6884{
6885 if(device == nullptr)
6886 {
6887 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6888 "vkCreateDynamicRasterState parameter, VkDevice device, is null pointer");
6889 return;
6890 }
6891
6892 if(pCreateInfo == nullptr)
6893 {
6894 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6895 "vkCreateDynamicRasterState parameter, const VkDynamicRsStateCreateInfo* pCreateInfo, is null pointer");
6896 return;
6897 }
6898 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6899 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6900 {
6901 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6902 "vkCreateDynamicRasterState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6903 return;
6904 }
6905}
6906
6907void PostCreateDynamicRasterState(
6908 VkDevice device,
6909 VkDynamicRsState* pState,
6910 VkResult result)
6911{
6912 if(device == nullptr)
6913 {
6914 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6915 "vkCreateDynamicRasterState parameter, VkDevice device, is null pointer");
6916 return;
6917 }
6918
6919 if(pState == nullptr)
6920 {
6921 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6922 "vkCreateDynamicRasterState parameter, VkDynamicRsState* pState, is null pointer");
6923 return;
6924 }
6925 if((*pState) == nullptr)
6926 {
6927 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6928 "vkCreateDynamicRasterState parameter, VkDynamicRsState* pState, is null pointer");
6929 return;
6930 }
6931
6932 if(result != VK_SUCCESS)
6933 {
6934 std::string reason = "vkCreateDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result);
6935 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
6936 return;
6937 }
6938}
6939
6940VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
6941 VkDevice device,
6942 const VkDynamicRsStateCreateInfo* pCreateInfo,
6943 VkDynamicRsState* pState)
6944{
6945 PreCreateDynamicRasterState(device, pCreateInfo);
6946 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
6947
6948 PostCreateDynamicRasterState(device, pState, result);
6949
6950 return result;
6951}
6952
6953void PreCreateDynamicColorBlendState(
6954 VkDevice device,
6955 const VkDynamicCbStateCreateInfo* pCreateInfo)
6956{
6957 if(device == nullptr)
6958 {
6959 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6960 "vkCreateDynamicColorBlendState parameter, VkDevice device, is null pointer");
6961 return;
6962 }
6963
6964 if(pCreateInfo == nullptr)
6965 {
6966 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6967 "vkCreateDynamicColorBlendState parameter, const VkDynamicCbStateCreateInfo* pCreateInfo, is null pointer");
6968 return;
6969 }
6970 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
6971 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
6972 {
6973 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6974 "vkCreateDynamicColorBlendState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
6975 return;
6976 }
6977}
6978
6979void PostCreateDynamicColorBlendState(
6980 VkDevice device,
6981 VkDynamicCbState* pState,
6982 VkResult result)
6983{
6984 if(device == nullptr)
6985 {
6986 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6987 "vkCreateDynamicColorBlendState parameter, VkDevice device, is null pointer");
6988 return;
6989 }
6990
6991 if(pState == nullptr)
6992 {
6993 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
6994 "vkCreateDynamicColorBlendState parameter, VkDynamicCbState* pState, is null pointer");
6995 return;
6996 }
6997 if((*pState) == nullptr)
6998 {
6999 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7000 "vkCreateDynamicColorBlendState parameter, VkDynamicCbState* pState, is null pointer");
7001 return;
7002 }
7003
7004 if(result != VK_SUCCESS)
7005 {
7006 std::string reason = "vkCreateDynamicColorBlendState parameter, VkResult result, is " + EnumeratorString(result);
7007 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7008 return;
7009 }
7010}
7011
7012VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(
7013 VkDevice device,
7014 const VkDynamicCbStateCreateInfo* pCreateInfo,
7015 VkDynamicCbState* pState)
7016{
7017 PreCreateDynamicColorBlendState(device, pCreateInfo);
7018 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
7019
7020 PostCreateDynamicColorBlendState(device, pState, result);
7021
7022 return result;
7023}
7024
7025void PreCreateDynamicDepthStencilState(
7026 VkDevice device,
7027 const VkDynamicDsStateCreateInfo* pCreateInfo)
7028{
7029 if(device == nullptr)
7030 {
7031 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7032 "vkCreateDynamicDepthStencilState parameter, VkDevice device, is null pointer");
7033 return;
7034 }
7035
7036 if(pCreateInfo == nullptr)
7037 {
7038 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7039 "vkCreateDynamicDepthStencilState parameter, const VkDynamicDsStateCreateInfo* pCreateInfo, is null pointer");
7040 return;
7041 }
7042 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
7043 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
7044 {
7045 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7046 "vkCreateDynamicDepthStencilState parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
7047 return;
7048 }
7049}
7050
7051void PostCreateDynamicDepthStencilState(
7052 VkDevice device,
7053 VkDynamicDsState* pState,
7054 VkResult result)
7055{
7056 if(device == nullptr)
7057 {
7058 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7059 "vkCreateDynamicDepthStencilState parameter, VkDevice device, is null pointer");
7060 return;
7061 }
7062
7063 if(pState == nullptr)
7064 {
7065 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7066 "vkCreateDynamicDepthStencilState parameter, VkDynamicDsState* pState, is null pointer");
7067 return;
7068 }
7069 if((*pState) == nullptr)
7070 {
7071 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7072 "vkCreateDynamicDepthStencilState parameter, VkDynamicDsState* pState, is null pointer");
7073 return;
7074 }
7075
7076 if(result != VK_SUCCESS)
7077 {
7078 std::string reason = "vkCreateDynamicDepthStencilState parameter, VkResult result, is " + EnumeratorString(result);
7079 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7080 return;
7081 }
7082}
7083
7084VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(
7085 VkDevice device,
7086 const VkDynamicDsStateCreateInfo* pCreateInfo,
7087 VkDynamicDsState* pState)
7088{
7089 PreCreateDynamicDepthStencilState(device, pCreateInfo);
7090 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
7091
7092 PostCreateDynamicDepthStencilState(device, pState, result);
7093
7094 return result;
7095}
7096
7097void PreCreateCommandBuffer(
7098 VkDevice device,
7099 const VkCmdBufferCreateInfo* pCreateInfo,
7100 VkCmdBuffer* pCmdBuffer)
7101{
7102 if(device == nullptr)
7103 {
7104 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7105 "vkCreateCommandBuffer parameter, VkDevice device, is null pointer");
7106 return;
7107 }
7108
7109 if(pCreateInfo == nullptr)
7110 {
7111 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7112 "vkCreateCommandBuffer parameter, const VkCmdBufferCreateInfo* pCreateInfo, is null pointer");
7113 return;
7114 }
7115 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
7116 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
7117 {
7118 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7119 "vkCreateCommandBuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7120 return;
7121 }
7122
7123 if(pCmdBuffer == nullptr)
7124 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7125 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7126 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
7127 return;
7128 }
7129 if((*pCmdBuffer) == nullptr)
7130 {
7131 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7132 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7133 return;
7134 }
7135}
7136
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7137void PostCreateCommandBuffer(
7138 VkDevice device,
7139 VkCmdBuffer* pCmdBuffer,
7140 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7141{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7142 if(device == nullptr)
7143 {
7144 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7145 "vkCreateCommandBuffer parameter, VkDevice device, is null pointer");
7146 return;
7147 }
7148
7149 if(pCmdBuffer == nullptr)
7150 {
7151 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7152 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
7153 return;
7154 }
7155 if((*pCmdBuffer) == nullptr)
7156 {
7157 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7158 "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is null pointer");
7159 return;
7160 }
7161
7162 if(result != VK_SUCCESS)
7163 {
7164 std::string reason = "vkCreateCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7165 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7166 return;
7167 }
7168}
7169
7170VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(
7171 VkDevice device,
7172 const VkCmdBufferCreateInfo* pCreateInfo,
7173 VkCmdBuffer* pCmdBuffer)
7174{
7175 PreCreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
7176 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
7177
7178 PostCreateCommandBuffer(device, pCmdBuffer, result);
7179
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7180 return result;
7181}
7182
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7183void PreBeginCommandBuffer(
7184 VkCmdBuffer cmdBuffer,
7185 const VkCmdBufferBeginInfo* pBeginInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7186{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7187 if(cmdBuffer == nullptr)
7188 {
7189 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7190 "vkBeginCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7191 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7192 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7193
7194 if(pBeginInfo == nullptr)
7195 {
7196 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7197 "vkBeginCommandBuffer parameter, const VkCmdBufferBeginInfo* pBeginInfo, is null pointer");
7198 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7199 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7200 if(pBeginInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
7201 pBeginInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
7202 {
7203 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7204 "vkBeginCommandBuffer parameter, VkStructureType pBeginInfo->sType, is unrecognized enumerator");
7205 return;
7206 }
7207 if(!ValidateEnumerator((VkCmdBufferOptimizeFlagBits)pBeginInfo->flags))
7208 {
7209 std::string reason = "vkBeginCommandBuffer parameter, VkCmdBufferOptimizeFlags pBeginInfo->flags, is " + EnumeratorString((VkCmdBufferOptimizeFlagBits)pBeginInfo->flags);
7210 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7211 return;
7212 }
7213}
7214
7215void PostBeginCommandBuffer(
7216 VkCmdBuffer cmdBuffer,
7217 VkResult result)
7218{
7219 if(cmdBuffer == nullptr)
7220 {
7221 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7222 "vkBeginCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7223 return;
7224 }
7225
7226 if(result != VK_SUCCESS)
7227 {
7228 std::string reason = "vkBeginCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7229 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7230 return;
7231 }
7232}
7233
7234VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
7235 VkCmdBuffer cmdBuffer,
7236 const VkCmdBufferBeginInfo* pBeginInfo)
7237{
7238 PreBeginCommandBuffer(cmdBuffer, pBeginInfo);
7239 VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
7240
7241 PostBeginCommandBuffer(cmdBuffer, result);
7242
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7243 return result;
7244}
7245
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7246void PreEndCommandBuffer(
7247 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7248{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7249 if(cmdBuffer == nullptr)
7250 {
7251 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7252 "vkEndCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7253 return;
7254 }
7255}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7256
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7257void PostEndCommandBuffer(
7258 VkCmdBuffer cmdBuffer,
7259 VkResult result)
7260{
7261 if(cmdBuffer == nullptr)
7262 {
7263 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7264 "vkEndCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7265 return;
7266 }
7267
7268 if(result != VK_SUCCESS)
7269 {
7270 std::string reason = "vkEndCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7271 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7272 return;
7273 }
7274}
7275
7276VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
7277 VkCmdBuffer cmdBuffer)
7278{
7279 PreEndCommandBuffer(cmdBuffer);
7280 VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
7281
7282 PostEndCommandBuffer(cmdBuffer, result);
7283
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7284 return result;
7285}
7286
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7287void PreResetCommandBuffer(
7288 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7289{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7290 if(cmdBuffer == nullptr)
7291 {
7292 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7293 "vkResetCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7294 return;
7295 }
7296}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7297
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7298void PostResetCommandBuffer(
7299 VkCmdBuffer cmdBuffer,
7300 VkResult result)
7301{
7302 if(cmdBuffer == nullptr)
7303 {
7304 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7305 "vkResetCommandBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7306 return;
7307 }
7308
7309 if(result != VK_SUCCESS)
7310 {
7311 std::string reason = "vkResetCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
7312 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
7313 return;
7314 }
7315}
7316
7317VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
7318 VkCmdBuffer cmdBuffer)
7319{
7320 PreResetCommandBuffer(cmdBuffer);
7321 VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer);
7322
7323 PostResetCommandBuffer(cmdBuffer, result);
7324
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7325 return result;
7326}
7327
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7328void PreCmdBindPipeline(
7329 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7330{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7331 if(cmdBuffer == nullptr)
7332 {
7333 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7334 "vkCmdBindPipeline parameter, VkCmdBuffer cmdBuffer, is null pointer");
7335 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7336 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7337}
7338
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7339void PostCmdBindPipeline(
7340 VkCmdBuffer cmdBuffer,
7341 VkPipelineBindPoint pipelineBindPoint,
7342 VkPipeline pipeline)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7343{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7344 if(cmdBuffer == nullptr)
7345 {
7346 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7347 "vkCmdBindPipeline parameter, VkCmdBuffer cmdBuffer, is null pointer");
7348 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7349 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7350
7351 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
7352 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
7353 {
7354 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7355 "vkCmdBindPipeline parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
7356 return;
7357 }
7358
7359 if(pipeline == nullptr)
7360 {
7361 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7362 "vkCmdBindPipeline parameter, VkPipeline pipeline, is null pointer");
7363 return;
7364 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7365}
7366
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7367VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
7368 VkCmdBuffer cmdBuffer,
7369 VkPipelineBindPoint pipelineBindPoint,
7370 VkPipeline pipeline)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7371{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7372 PreCmdBindPipeline(cmdBuffer);
7373 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
7374
7375 PostCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
7376}
7377
7378void PreCmdBindDynamicStateObject(
7379 VkCmdBuffer cmdBuffer)
7380{
7381 if(cmdBuffer == nullptr)
7382 {
7383 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7384 "vkCmdBindDynamicStateObject parameter, VkCmdBuffer cmdBuffer, is null pointer");
7385 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7386 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7387}
7388
7389void PostCmdBindDynamicStateObject(
7390 VkCmdBuffer cmdBuffer,
7391 VkStateBindPoint stateBindPoint,
7392 VkDynamicStateObject dynamicState)
7393{
7394 if(cmdBuffer == nullptr)
7395 {
7396 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7397 "vkCmdBindDynamicStateObject parameter, VkCmdBuffer cmdBuffer, is null pointer");
7398 return;
7399 }
7400
7401 if(stateBindPoint < VK_STATE_BIND_POINT_BEGIN_RANGE ||
7402 stateBindPoint > VK_STATE_BIND_POINT_END_RANGE)
7403 {
7404 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7405 "vkCmdBindDynamicStateObject parameter, VkStateBindPoint stateBindPoint, is unrecognized enumerator");
7406 return;
7407 }
7408
7409 if(dynamicState == nullptr)
7410 {
7411 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7412 "vkCmdBindDynamicStateObject parameter, VkDynamicStateObject dynamicState, is null pointer");
7413 return;
7414 }
7415}
7416
7417VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(
7418 VkCmdBuffer cmdBuffer,
7419 VkStateBindPoint stateBindPoint,
7420 VkDynamicStateObject dynamicState)
7421{
7422 PreCmdBindDynamicStateObject(cmdBuffer);
7423 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, dynamicState);
7424
7425 PostCmdBindDynamicStateObject(cmdBuffer, stateBindPoint, dynamicState);
7426}
7427
7428void PreCmdBindDescriptorSets(
7429 VkCmdBuffer cmdBuffer,
7430 const VkDescriptorSet* pDescriptorSets,
7431 const uint32_t* pDynamicOffsets)
7432{
7433 if(cmdBuffer == nullptr)
7434 {
7435 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7436 "vkCmdBindDescriptorSets parameter, VkCmdBuffer cmdBuffer, is null pointer");
7437 return;
7438 }
7439
7440 if(pDescriptorSets == nullptr)
7441 {
7442 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7443 "vkCmdBindDescriptorSets parameter, const VkDescriptorSet* pDescriptorSets, is null pointer");
7444 return;
7445 }
7446 if((*pDescriptorSets) == nullptr)
7447 {
7448 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7449 "vkCmdBindDescriptorSets parameter, const VkDescriptorSet* pDescriptorSets, is null pointer");
7450 return;
7451 }
7452
7453 if(pDynamicOffsets == nullptr)
7454 {
7455 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7456 "vkCmdBindDescriptorSets parameter, const uint32_t* pDynamicOffsets, is null pointer");
7457 return;
7458 }
7459}
7460
7461void PostCmdBindDescriptorSets(
7462 VkCmdBuffer cmdBuffer,
7463 VkPipelineBindPoint pipelineBindPoint,
7464 VkPipelineLayout layout,
7465 uint32_t firstSet,
7466 uint32_t setCount,
7467 uint32_t dynamicOffsetCount)
7468{
7469 if(cmdBuffer == nullptr)
7470 {
7471 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7472 "vkCmdBindDescriptorSets parameter, VkCmdBuffer cmdBuffer, is null pointer");
7473 return;
7474 }
7475
7476 if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
7477 pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
7478 {
7479 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7480 "vkCmdBindDescriptorSets parameter, VkPipelineBindPoint pipelineBindPoint, is unrecognized enumerator");
7481 return;
7482 }
7483
7484 if(layout == nullptr)
7485 {
7486 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7487 "vkCmdBindDescriptorSets parameter, VkPipelineLayout layout, is null pointer");
7488 return;
7489 }
7490
7491
7492
7493}
7494
7495VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
7496 VkCmdBuffer cmdBuffer,
7497 VkPipelineBindPoint pipelineBindPoint,
7498 VkPipelineLayout layout,
7499 uint32_t firstSet,
7500 uint32_t setCount,
7501 const VkDescriptorSet* pDescriptorSets,
7502 uint32_t dynamicOffsetCount,
7503 const uint32_t* pDynamicOffsets)
7504{
7505 PreCmdBindDescriptorSets(cmdBuffer, pDescriptorSets, pDynamicOffsets);
7506 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
7507
7508 PostCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
7509}
7510
7511void PreCmdBindIndexBuffer(
7512 VkCmdBuffer cmdBuffer)
7513{
7514 if(cmdBuffer == nullptr)
7515 {
7516 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7517 "vkCmdBindIndexBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7518 return;
7519 }
7520}
7521
7522void PostCmdBindIndexBuffer(
7523 VkCmdBuffer cmdBuffer,
7524 VkBuffer buffer,
7525 VkDeviceSize offset,
7526 VkIndexType indexType)
7527{
7528 if(cmdBuffer == nullptr)
7529 {
7530 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7531 "vkCmdBindIndexBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7532 return;
7533 }
7534
7535 if(buffer == nullptr)
7536 {
7537 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7538 "vkCmdBindIndexBuffer parameter, VkBuffer buffer, is null pointer");
7539 return;
7540 }
7541
7542
7543 if(indexType < VK_INDEX_TYPE_BEGIN_RANGE ||
7544 indexType > VK_INDEX_TYPE_END_RANGE)
7545 {
7546 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7547 "vkCmdBindIndexBuffer parameter, VkIndexType indexType, is unrecognized enumerator");
7548 return;
7549 }
7550}
7551
7552VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
7553 VkCmdBuffer cmdBuffer,
7554 VkBuffer buffer,
7555 VkDeviceSize offset,
7556 VkIndexType indexType)
7557{
7558 PreCmdBindIndexBuffer(cmdBuffer);
7559 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
7560
7561 PostCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
7562}
7563
7564void PreCmdBindVertexBuffers(
7565 VkCmdBuffer cmdBuffer,
7566 const VkBuffer* pBuffers,
7567 const VkDeviceSize* pOffsets)
7568{
7569 if(cmdBuffer == nullptr)
7570 {
7571 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7572 "vkCmdBindVertexBuffers parameter, VkCmdBuffer cmdBuffer, is null pointer");
7573 return;
7574 }
7575
7576 if(pBuffers == nullptr)
7577 {
7578 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7579 "vkCmdBindVertexBuffers parameter, const VkBuffer* pBuffers, is null pointer");
7580 return;
7581 }
7582 if((*pBuffers) == nullptr)
7583 {
7584 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7585 "vkCmdBindVertexBuffers parameter, const VkBuffer* pBuffers, is null pointer");
7586 return;
7587 }
7588
7589 if(pOffsets == nullptr)
7590 {
7591 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7592 "vkCmdBindVertexBuffers parameter, const VkDeviceSize* pOffsets, is null pointer");
7593 return;
7594 }
7595}
7596
7597void PostCmdBindVertexBuffers(
7598 VkCmdBuffer cmdBuffer,
7599 uint32_t startBinding,
7600 uint32_t bindingCount)
7601{
7602 if(cmdBuffer == nullptr)
7603 {
7604 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7605 "vkCmdBindVertexBuffers parameter, VkCmdBuffer cmdBuffer, is null pointer");
7606 return;
7607 }
7608
7609
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7610}
7611
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -0600[diff] [blame]7612VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7613 VkCmdBuffer cmdBuffer,
7614 uint32_t startBinding,
7615 uint32_t bindingCount,
7616 const VkBuffer* pBuffers,
7617 const VkDeviceSize* pOffsets)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7618{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7619 PreCmdBindVertexBuffers(cmdBuffer, pBuffers, pOffsets);
7620 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
7621
7622 PostCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7623}
7624
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7625void PreCmdDraw(
7626 VkCmdBuffer cmdBuffer)
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 Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7634}
7635
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7636void PostCmdDraw(
7637 VkCmdBuffer cmdBuffer,
7638 uint32_t firstVertex,
7639 uint32_t vertexCount,
7640 uint32_t firstInstance,
7641 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7642{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7643 if(cmdBuffer == nullptr)
7644 {
7645 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7646 "vkCmdDraw parameter, VkCmdBuffer cmdBuffer, is null pointer");
7647 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7648 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7649
7650
7651
7652
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7653}
7654
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7655VK_LAYER_EXPORT void VKAPI vkCmdDraw(
7656 VkCmdBuffer cmdBuffer,
7657 uint32_t firstVertex,
7658 uint32_t vertexCount,
7659 uint32_t firstInstance,
7660 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7661{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7662 PreCmdDraw(cmdBuffer);
7663 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
7664
7665 PostCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7666}
7667
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7668void PreCmdDrawIndexed(
7669 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7670{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7671 if(cmdBuffer == nullptr)
7672 {
7673 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7674 "vkCmdDrawIndexed parameter, VkCmdBuffer cmdBuffer, is null pointer");
7675 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7676 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7677}
7678
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7679void PostCmdDrawIndexed(
7680 VkCmdBuffer cmdBuffer,
7681 uint32_t firstIndex,
7682 uint32_t indexCount,
7683 int32_t vertexOffset,
7684 uint32_t firstInstance,
7685 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7686{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7687 if(cmdBuffer == nullptr)
7688 {
7689 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7690 "vkCmdDrawIndexed parameter, VkCmdBuffer cmdBuffer, is null pointer");
7691 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7692 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7693
7694
7695
7696
7697
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7698}
7699
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7700VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(
7701 VkCmdBuffer cmdBuffer,
7702 uint32_t firstIndex,
7703 uint32_t indexCount,
7704 int32_t vertexOffset,
7705 uint32_t firstInstance,
7706 uint32_t instanceCount)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7707{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7708 PreCmdDrawIndexed(cmdBuffer);
7709 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
7710
7711 PostCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
7712}
7713
7714void PreCmdDrawIndirect(
7715 VkCmdBuffer cmdBuffer)
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 Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7723}
7724
7725void PostCmdDrawIndirect(
7726 VkCmdBuffer cmdBuffer,
7727 VkBuffer buffer,
7728 VkDeviceSize offset,
7729 uint32_t count,
7730 uint32_t stride)
7731{
7732 if(cmdBuffer == nullptr)
7733 {
7734 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7735 "vkCmdDrawIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7736 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7737 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7738
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7739 if(buffer == nullptr)
7740 {
7741 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7742 "vkCmdDrawIndirect parameter, VkBuffer buffer, is null pointer");
7743 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7744 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7745
7746
7747
7748}
7749
7750VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
7751 VkCmdBuffer cmdBuffer,
7752 VkBuffer buffer,
7753 VkDeviceSize offset,
7754 uint32_t count,
7755 uint32_t stride)
7756{
7757 PreCmdDrawIndirect(cmdBuffer);
7758 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
7759
7760 PostCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
7761}
7762
7763void PreCmdDrawIndexedIndirect(
7764 VkCmdBuffer cmdBuffer)
7765{
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 Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7772}
7773
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7774void PostCmdDrawIndexedIndirect(
7775 VkCmdBuffer cmdBuffer,
7776 VkBuffer buffer,
7777 VkDeviceSize offset,
7778 uint32_t count,
7779 uint32_t stride)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7780{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7781 if(cmdBuffer == nullptr)
7782 {
7783 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7784 "vkCmdDrawIndexedIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7785 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7786 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7787
7788 if(buffer == nullptr)
7789 {
7790 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7791 "vkCmdDrawIndexedIndirect parameter, VkBuffer buffer, is null pointer");
7792 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7793 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7794
7795
7796
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7797}
7798
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7799VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
7800 VkCmdBuffer cmdBuffer,
7801 VkBuffer buffer,
7802 VkDeviceSize offset,
7803 uint32_t count,
7804 uint32_t stride)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7805{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7806 PreCmdDrawIndexedIndirect(cmdBuffer);
7807 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
7808
7809 PostCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
7810}
7811
7812void PreCmdDispatch(
7813 VkCmdBuffer cmdBuffer)
7814{
7815 if(cmdBuffer == nullptr)
7816 {
7817 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7818 "vkCmdDispatch parameter, VkCmdBuffer cmdBuffer, is null pointer");
7819 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7820 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7821}
7822
7823void PostCmdDispatch(
7824 VkCmdBuffer cmdBuffer,
7825 uint32_t x,
7826 uint32_t y,
7827 uint32_t z)
7828{
7829 if(cmdBuffer == nullptr)
7830 {
7831 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7832 "vkCmdDispatch parameter, VkCmdBuffer cmdBuffer, is null pointer");
7833 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7834 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7835
7836
7837
7838}
7839
7840VK_LAYER_EXPORT void VKAPI vkCmdDispatch(
7841 VkCmdBuffer cmdBuffer,
7842 uint32_t x,
7843 uint32_t y,
7844 uint32_t z)
7845{
7846 PreCmdDispatch(cmdBuffer);
7847 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
7848
7849 PostCmdDispatch(cmdBuffer, x, y, z);
7850}
7851
7852void PreCmdDispatchIndirect(
7853 VkCmdBuffer cmdBuffer)
7854{
7855 if(cmdBuffer == nullptr)
7856 {
7857 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7858 "vkCmdDispatchIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7859 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7860 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7861}
7862
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7863void PostCmdDispatchIndirect(
7864 VkCmdBuffer cmdBuffer,
7865 VkBuffer buffer,
7866 VkDeviceSize offset)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7867{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7868 if(cmdBuffer == nullptr)
7869 {
7870 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7871 "vkCmdDispatchIndirect parameter, VkCmdBuffer cmdBuffer, is null pointer");
7872 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7873 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7874
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7875 if(buffer == nullptr)
7876 {
7877 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7878 "vkCmdDispatchIndirect parameter, VkBuffer buffer, is null pointer");
7879 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7880 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7881
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7882}
7883
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7884VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
7885 VkCmdBuffer cmdBuffer,
7886 VkBuffer buffer,
7887 VkDeviceSize offset)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7888{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7889 PreCmdDispatchIndirect(cmdBuffer);
7890 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
7891
7892 PostCmdDispatchIndirect(cmdBuffer, buffer, offset);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7893}
7894
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7895void PreCmdCopyBuffer(
7896 VkCmdBuffer cmdBuffer,
7897 const VkBufferCopy* pRegions)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7898{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7899 if(cmdBuffer == nullptr)
7900 {
7901 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7902 "vkCmdCopyBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7903 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]7904 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]7905
7906 if(pRegions == nullptr)
7907 {
7908 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7909 "vkCmdCopyBuffer parameter, const VkBufferCopy* pRegions, is null pointer");
7910 return;
7911 }
7912}
7913
7914void PostCmdCopyBuffer(
7915 VkCmdBuffer cmdBuffer,
7916 VkBuffer srcBuffer,
7917 VkBuffer destBuffer,
7918 uint32_t regionCount)
7919{
7920 if(cmdBuffer == nullptr)
7921 {
7922 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7923 "vkCmdCopyBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
7924 return;
7925 }
7926
7927 if(srcBuffer == nullptr)
7928 {
7929 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7930 "vkCmdCopyBuffer parameter, VkBuffer srcBuffer, is null pointer");
7931 return;
7932 }
7933
7934 if(destBuffer == nullptr)
7935 {
7936 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7937 "vkCmdCopyBuffer parameter, VkBuffer destBuffer, is null pointer");
7938 return;
7939 }
7940
7941}
7942
7943VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
7944 VkCmdBuffer cmdBuffer,
7945 VkBuffer srcBuffer,
7946 VkBuffer destBuffer,
7947 uint32_t regionCount,
7948 const VkBufferCopy* pRegions)
7949{
7950 PreCmdCopyBuffer(cmdBuffer, pRegions);
7951 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
7952
7953 PostCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount);
7954}
7955
7956void PreCmdCopyImage(
7957 VkCmdBuffer cmdBuffer,
7958 const VkImageCopy* pRegions)
7959{
7960 if(cmdBuffer == nullptr)
7961 {
7962 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7963 "vkCmdCopyImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
7964 return;
7965 }
7966
7967 if(pRegions == nullptr)
7968 {
7969 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7970 "vkCmdCopyImage parameter, const VkImageCopy* pRegions, is null pointer");
7971 return;
7972 }
7973 if(pRegions->srcSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
7974 pRegions->srcSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
7975 {
7976 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7977 "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is unrecognized enumerator");
7978 return;
7979 }
7980 if(pRegions->destSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
7981 pRegions->destSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
7982 {
7983 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
7984 "vkCmdCopyImage parameter, VkImageAspect pRegions->destSubresource.aspect, is unrecognized enumerator");
7985 return;
7986 }
7987}
7988
7989void PostCmdCopyImage(
7990 VkCmdBuffer cmdBuffer,
7991 VkImage srcImage,
7992 VkImageLayout srcImageLayout,
7993 VkImage destImage,
7994 VkImageLayout destImageLayout,
7995 uint32_t regionCount)
7996{
7997 if(cmdBuffer == nullptr)
7998 {
7999 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8000 "vkCmdCopyImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8001 return;
8002 }
8003
8004 if(srcImage == nullptr)
8005 {
8006 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8007 "vkCmdCopyImage parameter, VkImage srcImage, is null pointer");
8008 return;
8009 }
8010
8011 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8012 srcImageLayout > 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 srcImageLayout, is unrecognized enumerator");
8016 return;
8017 }
8018
8019 if(destImage == nullptr)
8020 {
8021 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8022 "vkCmdCopyImage parameter, VkImage destImage, is null pointer");
8023 return;
8024 }
8025
8026 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8027 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8028 {
8029 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8030 "vkCmdCopyImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8031 return;
8032 }
8033
8034}
8035
8036VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
8037 VkCmdBuffer cmdBuffer,
8038 VkImage srcImage,
8039 VkImageLayout srcImageLayout,
8040 VkImage destImage,
8041 VkImageLayout destImageLayout,
8042 uint32_t regionCount,
8043 const VkImageCopy* pRegions)
8044{
8045 PreCmdCopyImage(cmdBuffer, pRegions);
8046 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
8047
8048 PostCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
8049}
8050
8051void PreCmdBlitImage(
8052 VkCmdBuffer cmdBuffer,
8053 const VkImageBlit* pRegions)
8054{
8055 if(cmdBuffer == nullptr)
8056 {
8057 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8058 "vkCmdBlitImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8059 return;
8060 }
8061
8062 if(pRegions == nullptr)
8063 {
8064 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8065 "vkCmdBlitImage parameter, const VkImageBlit* pRegions, is null pointer");
8066 return;
8067 }
8068 if(pRegions->srcSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8069 pRegions->srcSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8070 {
8071 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8072 "vkCmdBlitImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is unrecognized enumerator");
8073 return;
8074 }
8075 if(pRegions->destSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8076 pRegions->destSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8077 {
8078 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8079 "vkCmdBlitImage parameter, VkImageAspect pRegions->destSubresource.aspect, is unrecognized enumerator");
8080 return;
8081 }
8082}
8083
8084void PostCmdBlitImage(
8085 VkCmdBuffer cmdBuffer,
8086 VkImage srcImage,
8087 VkImageLayout srcImageLayout,
8088 VkImage destImage,
8089 VkImageLayout destImageLayout,
8090 uint32_t regionCount,
8091 VkTexFilter filter)
8092{
8093 if(cmdBuffer == nullptr)
8094 {
8095 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8096 "vkCmdBlitImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8097 return;
8098 }
8099
8100 if(srcImage == nullptr)
8101 {
8102 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8103 "vkCmdBlitImage parameter, VkImage srcImage, is null pointer");
8104 return;
8105 }
8106
8107 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8108 srcImageLayout > 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 srcImageLayout, is unrecognized enumerator");
8112 return;
8113 }
8114
8115 if(destImage == nullptr)
8116 {
8117 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8118 "vkCmdBlitImage parameter, VkImage destImage, is null pointer");
8119 return;
8120 }
8121
8122 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8123 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8124 {
8125 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8126 "vkCmdBlitImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8127 return;
8128 }
8129
8130
8131 if(filter < VK_TEX_FILTER_BEGIN_RANGE ||
8132 filter > VK_TEX_FILTER_END_RANGE)
8133 {
8134 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8135 "vkCmdBlitImage parameter, VkTexFilter filter, is unrecognized enumerator");
8136 return;
8137 }
8138}
8139
8140VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
8141 VkCmdBuffer cmdBuffer,
8142 VkImage srcImage,
8143 VkImageLayout srcImageLayout,
8144 VkImage destImage,
8145 VkImageLayout destImageLayout,
8146 uint32_t regionCount,
8147 const VkImageBlit* pRegions,
8148 VkTexFilter filter)
8149{
8150 PreCmdBlitImage(cmdBuffer, pRegions);
8151 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
8152
8153 PostCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, filter);
8154}
8155
8156void PreCmdCopyBufferToImage(
8157 VkCmdBuffer cmdBuffer,
8158 const VkBufferImageCopy* pRegions)
8159{
8160 if(cmdBuffer == nullptr)
8161 {
8162 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8163 "vkCmdCopyBufferToImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8164 return;
8165 }
8166
8167 if(pRegions == nullptr)
8168 {
8169 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8170 "vkCmdCopyBufferToImage parameter, const VkBufferImageCopy* pRegions, is null pointer");
8171 return;
8172 }
8173 if(pRegions->imageSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8174 pRegions->imageSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8175 {
8176 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8177 "vkCmdCopyBufferToImage parameter, VkImageAspect pRegions->imageSubresource.aspect, is unrecognized enumerator");
8178 return;
8179 }
8180}
8181
8182void PostCmdCopyBufferToImage(
8183 VkCmdBuffer cmdBuffer,
8184 VkBuffer srcBuffer,
8185 VkImage destImage,
8186 VkImageLayout destImageLayout,
8187 uint32_t regionCount)
8188{
8189 if(cmdBuffer == nullptr)
8190 {
8191 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8192 "vkCmdCopyBufferToImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8193 return;
8194 }
8195
8196 if(srcBuffer == nullptr)
8197 {
8198 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8199 "vkCmdCopyBufferToImage parameter, VkBuffer srcBuffer, is null pointer");
8200 return;
8201 }
8202
8203 if(destImage == nullptr)
8204 {
8205 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8206 "vkCmdCopyBufferToImage parameter, VkImage destImage, is null pointer");
8207 return;
8208 }
8209
8210 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8211 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8212 {
8213 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8214 "vkCmdCopyBufferToImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8215 return;
8216 }
8217
8218}
8219
8220VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
8221 VkCmdBuffer cmdBuffer,
8222 VkBuffer srcBuffer,
8223 VkImage destImage,
8224 VkImageLayout destImageLayout,
8225 uint32_t regionCount,
8226 const VkBufferImageCopy* pRegions)
8227{
8228 PreCmdCopyBufferToImage(cmdBuffer, pRegions);
8229 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
8230
8231 PostCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount);
8232}
8233
8234void PreCmdCopyImageToBuffer(
8235 VkCmdBuffer cmdBuffer,
8236 const VkBufferImageCopy* pRegions)
8237{
8238 if(cmdBuffer == nullptr)
8239 {
8240 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8241 "vkCmdCopyImageToBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8242 return;
8243 }
8244
8245 if(pRegions == nullptr)
8246 {
8247 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8248 "vkCmdCopyImageToBuffer parameter, const VkBufferImageCopy* pRegions, is null pointer");
8249 return;
8250 }
8251 if(pRegions->imageSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8252 pRegions->imageSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8253 {
8254 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8255 "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspect, is unrecognized enumerator");
8256 return;
8257 }
8258}
8259
8260void PostCmdCopyImageToBuffer(
8261 VkCmdBuffer cmdBuffer,
8262 VkImage srcImage,
8263 VkImageLayout srcImageLayout,
8264 VkBuffer destBuffer,
8265 uint32_t regionCount)
8266{
8267 if(cmdBuffer == nullptr)
8268 {
8269 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8270 "vkCmdCopyImageToBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8271 return;
8272 }
8273
8274 if(srcImage == nullptr)
8275 {
8276 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8277 "vkCmdCopyImageToBuffer parameter, VkImage srcImage, is null pointer");
8278 return;
8279 }
8280
8281 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8282 srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8283 {
8284 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8285 "vkCmdCopyImageToBuffer parameter, VkImageLayout srcImageLayout, is unrecognized enumerator");
8286 return;
8287 }
8288
8289 if(destBuffer == nullptr)
8290 {
8291 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8292 "vkCmdCopyImageToBuffer parameter, VkBuffer destBuffer, is null pointer");
8293 return;
8294 }
8295
8296}
8297
8298VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
8299 VkCmdBuffer cmdBuffer,
8300 VkImage srcImage,
8301 VkImageLayout srcImageLayout,
8302 VkBuffer destBuffer,
8303 uint32_t regionCount,
8304 const VkBufferImageCopy* pRegions)
8305{
8306 PreCmdCopyImageToBuffer(cmdBuffer, pRegions);
8307 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
8308
8309 PostCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount);
8310}
8311
8312void PreCmdUpdateBuffer(
8313 VkCmdBuffer cmdBuffer,
8314 const uint32_t* pData)
8315{
8316 if(cmdBuffer == nullptr)
8317 {
8318 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8319 "vkCmdUpdateBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8320 return;
8321 }
8322
8323 if(pData == nullptr)
8324 {
8325 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8326 "vkCmdUpdateBuffer parameter, const uint32_t* pData, is null pointer");
8327 return;
8328 }
8329}
8330
8331void PostCmdUpdateBuffer(
8332 VkCmdBuffer cmdBuffer,
8333 VkBuffer destBuffer,
8334 VkDeviceSize destOffset,
8335 VkDeviceSize dataSize)
8336{
8337 if(cmdBuffer == nullptr)
8338 {
8339 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8340 "vkCmdUpdateBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8341 return;
8342 }
8343
8344 if(destBuffer == nullptr)
8345 {
8346 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8347 "vkCmdUpdateBuffer parameter, VkBuffer destBuffer, is null pointer");
8348 return;
8349 }
8350
8351
8352}
8353
8354VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
8355 VkCmdBuffer cmdBuffer,
8356 VkBuffer destBuffer,
8357 VkDeviceSize destOffset,
8358 VkDeviceSize dataSize,
8359 const uint32_t* pData)
8360{
8361 PreCmdUpdateBuffer(cmdBuffer, pData);
8362 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
8363
8364 PostCmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize);
8365}
8366
8367void PreCmdFillBuffer(
8368 VkCmdBuffer cmdBuffer)
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
8378void PostCmdFillBuffer(
8379 VkCmdBuffer cmdBuffer,
8380 VkBuffer destBuffer,
8381 VkDeviceSize destOffset,
8382 VkDeviceSize fillSize,
8383 uint32_t data)
8384{
8385 if(cmdBuffer == nullptr)
8386 {
8387 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8388 "vkCmdFillBuffer parameter, VkCmdBuffer cmdBuffer, is null pointer");
8389 return;
8390 }
8391
8392 if(destBuffer == nullptr)
8393 {
8394 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8395 "vkCmdFillBuffer parameter, VkBuffer destBuffer, is null pointer");
8396 return;
8397 }
8398
8399
8400
8401}
8402
8403VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
8404 VkCmdBuffer cmdBuffer,
8405 VkBuffer destBuffer,
8406 VkDeviceSize destOffset,
8407 VkDeviceSize fillSize,
8408 uint32_t data)
8409{
8410 PreCmdFillBuffer(cmdBuffer);
8411 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
8412
8413 PostCmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
8414}
8415
8416void PreCmdClearColorImage(
8417 VkCmdBuffer cmdBuffer,
8418 const VkClearColor* pColor,
8419 const VkImageSubresourceRange* pRanges)
8420{
8421 if(cmdBuffer == nullptr)
8422 {
8423 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8424 "vkCmdClearColorImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8425 return;
8426 }
8427
8428 if(pColor == nullptr)
8429 {
8430 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8431 "vkCmdClearColorImage parameter, const VkClearColor* pColor, is null pointer");
8432 return;
8433 }
8434
8435 if(pRanges == nullptr)
8436 {
8437 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8438 "vkCmdClearColorImage parameter, const VkImageSubresourceRange* pRanges, is null pointer");
8439 return;
8440 }
8441 if(pRanges->aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8442 pRanges->aspect > VK_IMAGE_ASPECT_END_RANGE)
8443 {
8444 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8445 "vkCmdClearColorImage parameter, VkImageAspect pRanges->aspect, is unrecognized enumerator");
8446 return;
8447 }
8448}
8449
8450void PostCmdClearColorImage(
8451 VkCmdBuffer cmdBuffer,
8452 VkImage image,
8453 VkImageLayout imageLayout,
8454 uint32_t rangeCount)
8455{
8456 if(cmdBuffer == nullptr)
8457 {
8458 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8459 "vkCmdClearColorImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8460 return;
8461 }
8462
8463 if(image == nullptr)
8464 {
8465 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8466 "vkCmdClearColorImage parameter, VkImage image, is null pointer");
8467 return;
8468 }
8469
8470 if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8471 imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8472 {
8473 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8474 "vkCmdClearColorImage parameter, VkImageLayout imageLayout, is unrecognized enumerator");
8475 return;
8476 }
8477
8478}
8479
8480VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
8481 VkCmdBuffer cmdBuffer,
8482 VkImage image,
8483 VkImageLayout imageLayout,
8484 const VkClearColor* pColor,
8485 uint32_t rangeCount,
8486 const VkImageSubresourceRange* pRanges)
8487{
8488 PreCmdClearColorImage(cmdBuffer, pColor, pRanges);
8489 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
8490
8491 PostCmdClearColorImage(cmdBuffer, image, imageLayout, rangeCount);
8492}
8493
Chris Forbes2951d7d2015-06-22 17:21:59 +1200[diff] [blame^]8494void PreCmdClearDepthStencilImage(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8495 VkCmdBuffer cmdBuffer,
8496 const VkImageSubresourceRange* pRanges)
8497{
8498 if(cmdBuffer == nullptr)
8499 {
8500 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8501 "vkCmdClearDepthStencil parameter, VkCmdBuffer cmdBuffer, is null pointer");
8502 return;
8503 }
8504
8505 if(pRanges == nullptr)
8506 {
8507 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8508 "vkCmdClearDepthStencil parameter, const VkImageSubresourceRange* pRanges, is null pointer");
8509 return;
8510 }
8511 if(pRanges->aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8512 pRanges->aspect > VK_IMAGE_ASPECT_END_RANGE)
8513 {
8514 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8515 "vkCmdClearDepthStencil parameter, VkImageAspect pRanges->aspect, is unrecognized enumerator");
8516 return;
8517 }
8518}
8519
Chris Forbes2951d7d2015-06-22 17:21:59 +1200[diff] [blame^]8520void PostCmdClearDepthStencilImage(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8521 VkCmdBuffer cmdBuffer,
8522 VkImage image,
8523 VkImageLayout imageLayout,
8524 float depth,
8525 uint32_t stencil,
8526 uint32_t rangeCount)
8527{
8528 if(cmdBuffer == nullptr)
8529 {
8530 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8531 "vkCmdClearDepthStencil parameter, VkCmdBuffer cmdBuffer, is null pointer");
8532 return;
8533 }
8534
8535 if(image == nullptr)
8536 {
8537 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8538 "vkCmdClearDepthStencil parameter, VkImage image, is null pointer");
8539 return;
8540 }
8541
8542 if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8543 imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8544 {
8545 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8546 "vkCmdClearDepthStencil parameter, VkImageLayout imageLayout, is unrecognized enumerator");
8547 return;
8548 }
8549
8550
8551
8552}
8553
Chris Forbes2951d7d2015-06-22 17:21:59 +1200[diff] [blame^]8554VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8555 VkCmdBuffer cmdBuffer,
8556 VkImage image,
8557 VkImageLayout imageLayout,
8558 float depth,
8559 uint32_t stencil,
8560 uint32_t rangeCount,
8561 const VkImageSubresourceRange* pRanges)
8562{
Chris Forbes2951d7d2015-06-22 17:21:59 +1200[diff] [blame^]8563 PreCmdClearDepthStencilImage(cmdBuffer, pRanges);
8564 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]8565
Chris Forbes2951d7d2015-06-22 17:21:59 +1200[diff] [blame^]8566 PostCmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8567}
8568
8569void PreCmdResolveImage(
8570 VkCmdBuffer cmdBuffer,
8571 const VkImageResolve* pRegions)
8572{
8573 if(cmdBuffer == nullptr)
8574 {
8575 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8576 "vkCmdResolveImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8577 return;
8578 }
8579
8580 if(pRegions == nullptr)
8581 {
8582 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8583 "vkCmdResolveImage parameter, const VkImageResolve* pRegions, is null pointer");
8584 return;
8585 }
8586 if(pRegions->srcSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8587 pRegions->srcSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8588 {
8589 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8590 "vkCmdResolveImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is unrecognized enumerator");
8591 return;
8592 }
8593 if(pRegions->destSubresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
8594 pRegions->destSubresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
8595 {
8596 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8597 "vkCmdResolveImage parameter, VkImageAspect pRegions->destSubresource.aspect, is unrecognized enumerator");
8598 return;
8599 }
8600}
8601
8602void PostCmdResolveImage(
8603 VkCmdBuffer cmdBuffer,
8604 VkImage srcImage,
8605 VkImageLayout srcImageLayout,
8606 VkImage destImage,
8607 VkImageLayout destImageLayout,
8608 uint32_t regionCount)
8609{
8610 if(cmdBuffer == nullptr)
8611 {
8612 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8613 "vkCmdResolveImage parameter, VkCmdBuffer cmdBuffer, is null pointer");
8614 return;
8615 }
8616
8617 if(srcImage == nullptr)
8618 {
8619 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8620 "vkCmdResolveImage parameter, VkImage srcImage, is null pointer");
8621 return;
8622 }
8623
8624 if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8625 srcImageLayout > 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 srcImageLayout, is unrecognized enumerator");
8629 return;
8630 }
8631
8632 if(destImage == nullptr)
8633 {
8634 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8635 "vkCmdResolveImage parameter, VkImage destImage, is null pointer");
8636 return;
8637 }
8638
8639 if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
8640 destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
8641 {
8642 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8643 "vkCmdResolveImage parameter, VkImageLayout destImageLayout, is unrecognized enumerator");
8644 return;
8645 }
8646
8647}
8648
8649VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
8650 VkCmdBuffer cmdBuffer,
8651 VkImage srcImage,
8652 VkImageLayout srcImageLayout,
8653 VkImage destImage,
8654 VkImageLayout destImageLayout,
8655 uint32_t regionCount,
8656 const VkImageResolve* pRegions)
8657{
8658 PreCmdResolveImage(cmdBuffer, pRegions);
8659 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
8660
8661 PostCmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
8662}
8663
8664void PreCmdSetEvent(
8665 VkCmdBuffer cmdBuffer)
8666{
8667 if(cmdBuffer == nullptr)
8668 {
8669 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8670 "vkCmdSetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8671 return;
8672 }
8673}
8674
8675void PostCmdSetEvent(
8676 VkCmdBuffer cmdBuffer,
8677 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8678 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8679{
8680 if(cmdBuffer == nullptr)
8681 {
8682 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8683 "vkCmdSetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8684 return;
8685 }
8686
8687 if(event == nullptr)
8688 {
8689 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8690 "vkCmdSetEvent parameter, VkEvent event, is null pointer");
8691 return;
8692 }
8693
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8694}
8695
8696VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(
8697 VkCmdBuffer cmdBuffer,
8698 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8699 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8700{
8701 PreCmdSetEvent(cmdBuffer);
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8702 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8703
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8704 PostCmdSetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8705}
8706
8707void PreCmdResetEvent(
8708 VkCmdBuffer cmdBuffer)
8709{
8710 if(cmdBuffer == nullptr)
8711 {
8712 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8713 "vkCmdResetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8714 return;
8715 }
8716}
8717
8718void PostCmdResetEvent(
8719 VkCmdBuffer cmdBuffer,
8720 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8721 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8722{
8723 if(cmdBuffer == nullptr)
8724 {
8725 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8726 "vkCmdResetEvent parameter, VkCmdBuffer cmdBuffer, is null pointer");
8727 return;
8728 }
8729
8730 if(event == nullptr)
8731 {
8732 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8733 "vkCmdResetEvent parameter, VkEvent event, is null pointer");
8734 return;
8735 }
8736
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8737}
8738
8739VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(
8740 VkCmdBuffer cmdBuffer,
8741 VkEvent event,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8742 VkPipelineStageFlags stageMask)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8743{
8744 PreCmdResetEvent(cmdBuffer);
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8745 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8746
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8747 PostCmdResetEvent(cmdBuffer, event, stageMask);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8748}
8749
8750void PreCmdWaitEvents(
8751 VkCmdBuffer cmdBuffer,
8752 const VkEvent* pEvents,
8753 const void** ppMemBarriers)
8754{
8755 if(cmdBuffer == nullptr)
8756 {
8757 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8758 "vkCmdWaitEvents parameter, VkCmdBuffer cmdBuffer, is null pointer");
8759 return;
8760 }
8761
8762 if(pEvents == nullptr)
8763 {
8764 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8765 "vkCmdWaitEvents parameter, const VkEvent* pEvents, is null pointer");
8766 return;
8767 }
8768 if((*pEvents) == nullptr)
8769 {
8770 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8771 "vkCmdWaitEvents parameter, const VkEvent* pEvents, is null pointer");
8772 return;
8773 }
8774
8775 if(ppMemBarriers == nullptr)
8776 {
8777 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8778 "vkCmdWaitEvents parameter, const void** ppMemBarriers, is null pointer");
8779 return;
8780 }
8781}
8782
8783void PostCmdWaitEvents(
8784 VkCmdBuffer cmdBuffer,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8785 uint32_t eventCount,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8786 VkPipelineStageFlags sourceStageMask,
8787 VkPipelineStageFlags destStageMask,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8788 uint32_t memBarrierCount)
8789{
8790 if(cmdBuffer == nullptr)
8791 {
8792 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8793 "vkCmdWaitEvents parameter, VkCmdBuffer cmdBuffer, is null pointer");
8794 return;
8795 }
8796
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8797
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8798
8799
8800}
8801
8802VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(
8803 VkCmdBuffer cmdBuffer,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8804 uint32_t eventCount,
8805 const VkEvent* pEvents,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8806 VkPipelineStageFlags sourceStageMask,
8807 VkPipelineStageFlags destStageMask,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8808 uint32_t memBarrierCount,
8809 const void** ppMemBarriers)
8810{
8811 PreCmdWaitEvents(cmdBuffer, pEvents, ppMemBarriers);
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8812 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]8813
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8814 PostCmdWaitEvents(cmdBuffer, eventCount, sourceStageMask, destStageMask, memBarrierCount);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8815}
8816
8817void PreCmdPipelineBarrier(
8818 VkCmdBuffer cmdBuffer,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8819 const void** ppMemBarriers)
8820{
8821 if(cmdBuffer == nullptr)
8822 {
8823 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8824 "vkCmdPipelineBarrier parameter, VkCmdBuffer cmdBuffer, is null pointer");
8825 return;
8826 }
8827
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8828 if(ppMemBarriers == nullptr)
8829 {
8830 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8831 "vkCmdPipelineBarrier parameter, const void** ppMemBarriers, is null pointer");
8832 return;
8833 }
8834}
8835
8836void PostCmdPipelineBarrier(
8837 VkCmdBuffer cmdBuffer,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8838 VkPipelineStageFlags sourceStageMask,
8839 VkPipelineStageFlags destStageMask,
8840 bool32_t byRegion,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8841 uint32_t memBarrierCount)
8842{
8843 if(cmdBuffer == nullptr)
8844 {
8845 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8846 "vkCmdPipelineBarrier parameter, VkCmdBuffer cmdBuffer, is null pointer");
8847 return;
8848 }
8849
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8850
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8851
8852
8853}
8854
8855VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(
8856 VkCmdBuffer cmdBuffer,
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8857 VkPipelineStageFlags sourceStageMask,
8858 VkPipelineStageFlags destStageMask,
8859 bool32_t byRegion,
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8860 uint32_t memBarrierCount,
8861 const void** ppMemBarriers)
8862{
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8863 PreCmdPipelineBarrier(cmdBuffer, ppMemBarriers);
8864 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]8865
Tony Barbourc2e987e2015-06-29 16:20:35 -0600[diff] [blame]8866 PostCmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8867}
8868
8869void PreCmdBeginQuery(
8870 VkCmdBuffer cmdBuffer)
8871{
8872 if(cmdBuffer == nullptr)
8873 {
8874 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8875 "vkCmdBeginQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8876 return;
8877 }
8878}
8879
8880void PostCmdBeginQuery(
8881 VkCmdBuffer cmdBuffer,
8882 VkQueryPool queryPool,
8883 uint32_t slot,
8884 VkQueryControlFlags flags)
8885{
8886 if(cmdBuffer == nullptr)
8887 {
8888 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8889 "vkCmdBeginQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8890 return;
8891 }
8892
8893 if(queryPool == nullptr)
8894 {
8895 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8896 "vkCmdBeginQuery parameter, VkQueryPool queryPool, is null pointer");
8897 return;
8898 }
8899
8900
8901 if(!ValidateEnumerator((VkQueryControlFlagBits)flags))
8902 {
8903 std::string reason = "vkCmdBeginQuery parameter, VkQueryControlFlags flags, is " + EnumeratorString((VkQueryControlFlagBits)flags);
8904 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
8905 return;
8906 }
8907}
8908
8909VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
8910 VkCmdBuffer cmdBuffer,
8911 VkQueryPool queryPool,
8912 uint32_t slot,
8913 VkQueryControlFlags flags)
8914{
8915 PreCmdBeginQuery(cmdBuffer);
8916 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
8917
8918 PostCmdBeginQuery(cmdBuffer, queryPool, slot, flags);
8919}
8920
8921void PreCmdEndQuery(
8922 VkCmdBuffer cmdBuffer)
8923{
8924 if(cmdBuffer == nullptr)
8925 {
8926 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8927 "vkCmdEndQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8928 return;
8929 }
8930}
8931
8932void PostCmdEndQuery(
8933 VkCmdBuffer cmdBuffer,
8934 VkQueryPool queryPool,
8935 uint32_t slot)
8936{
8937 if(cmdBuffer == nullptr)
8938 {
8939 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8940 "vkCmdEndQuery parameter, VkCmdBuffer cmdBuffer, is null pointer");
8941 return;
8942 }
8943
8944 if(queryPool == nullptr)
8945 {
8946 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8947 "vkCmdEndQuery parameter, VkQueryPool queryPool, is null pointer");
8948 return;
8949 }
8950
8951}
8952
8953VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
8954 VkCmdBuffer cmdBuffer,
8955 VkQueryPool queryPool,
8956 uint32_t slot)
8957{
8958 PreCmdEndQuery(cmdBuffer);
8959 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
8960
8961 PostCmdEndQuery(cmdBuffer, queryPool, slot);
8962}
8963
8964void PreCmdResetQueryPool(
8965 VkCmdBuffer cmdBuffer)
8966{
8967 if(cmdBuffer == nullptr)
8968 {
8969 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8970 "vkCmdResetQueryPool parameter, VkCmdBuffer cmdBuffer, is null pointer");
8971 return;
8972 }
8973}
8974
8975void PostCmdResetQueryPool(
8976 VkCmdBuffer cmdBuffer,
8977 VkQueryPool queryPool,
8978 uint32_t startQuery,
8979 uint32_t queryCount)
8980{
8981 if(cmdBuffer == nullptr)
8982 {
8983 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8984 "vkCmdResetQueryPool parameter, VkCmdBuffer cmdBuffer, is null pointer");
8985 return;
8986 }
8987
8988 if(queryPool == nullptr)
8989 {
8990 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
8991 "vkCmdResetQueryPool parameter, VkQueryPool queryPool, is null pointer");
8992 return;
8993 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]8994}
8995
8996VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
8997 VkCmdBuffer cmdBuffer,
8998 VkQueryPool queryPool,
8999 uint32_t startQuery,
9000 uint32_t queryCount)
9001{
9002 PreCmdResetQueryPool(cmdBuffer);
9003 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
9004
9005 PostCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
9006}
9007
9008void PreCmdWriteTimestamp(
9009 VkCmdBuffer cmdBuffer)
9010{
9011 if(cmdBuffer == nullptr)
9012 {
9013 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9014 "vkCmdWriteTimestamp parameter, VkCmdBuffer cmdBuffer, is null pointer");
9015 return;
9016 }
9017}
9018
9019void PostCmdWriteTimestamp(
9020 VkCmdBuffer cmdBuffer,
9021 VkTimestampType timestampType,
9022 VkBuffer destBuffer,
9023 VkDeviceSize destOffset)
9024{
9025 if(cmdBuffer == nullptr)
9026 {
9027 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9028 "vkCmdWriteTimestamp parameter, VkCmdBuffer cmdBuffer, is null pointer");
9029 return;
9030 }
9031
9032 if(timestampType < VK_TIMESTAMP_TYPE_BEGIN_RANGE ||
9033 timestampType > VK_TIMESTAMP_TYPE_END_RANGE)
9034 {
9035 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9036 "vkCmdWriteTimestamp parameter, VkTimestampType timestampType, is unrecognized enumerator");
9037 return;
9038 }
9039
9040 if(destBuffer == nullptr)
9041 {
9042 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9043 "vkCmdWriteTimestamp parameter, VkBuffer destBuffer, is null pointer");
9044 return;
9045 }
9046
9047}
9048
9049VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(
9050 VkCmdBuffer cmdBuffer,
9051 VkTimestampType timestampType,
9052 VkBuffer destBuffer,
9053 VkDeviceSize destOffset)
9054{
9055 PreCmdWriteTimestamp(cmdBuffer);
9056 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
9057
9058 PostCmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
9059}
9060
9061void PreCmdCopyQueryPoolResults(
9062 VkCmdBuffer cmdBuffer)
9063{
9064 if(cmdBuffer == nullptr)
9065 {
9066 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9067 "vkCmdCopyQueryPoolResults parameter, VkCmdBuffer cmdBuffer, is null pointer");
9068 return;
9069 }
9070}
9071
9072void PostCmdCopyQueryPoolResults(
9073 VkCmdBuffer cmdBuffer,
9074 VkQueryPool queryPool,
9075 uint32_t startQuery,
9076 uint32_t queryCount,
9077 VkBuffer destBuffer,
9078 VkDeviceSize destOffset,
9079 VkDeviceSize destStride,
9080 VkQueryResultFlags flags)
9081{
9082 if(cmdBuffer == nullptr)
9083 {
9084 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9085 "vkCmdCopyQueryPoolResults parameter, VkCmdBuffer cmdBuffer, is null pointer");
9086 return;
9087 }
9088
9089 if(queryPool == nullptr)
9090 {
9091 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9092 "vkCmdCopyQueryPoolResults parameter, VkQueryPool queryPool, is null pointer");
9093 return;
9094 }
9095
9096
9097
9098 if(destBuffer == nullptr)
9099 {
9100 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9101 "vkCmdCopyQueryPoolResults parameter, VkBuffer destBuffer, is null pointer");
9102 return;
9103 }
9104
9105
9106
9107 if(!ValidateEnumerator((VkQueryResultFlagBits)flags))
9108 {
9109 std::string reason = "vkCmdCopyQueryPoolResults parameter, VkQueryResultFlags flags, is " + EnumeratorString((VkQueryResultFlagBits)flags);
9110 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
9111 return;
9112 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9113}
9114
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]9115VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9116 VkCmdBuffer cmdBuffer,
9117 VkQueryPool queryPool,
9118 uint32_t startQuery,
9119 uint32_t queryCount,
9120 VkBuffer destBuffer,
9121 VkDeviceSize destOffset,
9122 VkDeviceSize destStride,
9123 VkQueryResultFlags flags)
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]9124{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9125 PreCmdCopyQueryPoolResults(cmdBuffer);
9126 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
9127
9128 PostCmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
Jeremy Hayescf469132015-04-17 10:36:53 -0600[diff] [blame]9129}
9130
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9131void PreCreateFramebuffer(
9132 VkDevice device,
9133 const VkFramebufferCreateInfo* pCreateInfo)
9134{
9135 if(device == nullptr)
9136 {
9137 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9138 "vkCreateFramebuffer parameter, VkDevice device, is null pointer");
9139 return;
9140 }
9141
9142 if(pCreateInfo == nullptr)
9143 {
9144 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9145 "vkCreateFramebuffer parameter, const VkFramebufferCreateInfo* pCreateInfo, is null pointer");
9146 return;
9147 }
9148 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
9149 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
9150 {
9151 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9152 "vkCreateFramebuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
9153 return;
9154 }
9155 if(pCreateInfo->pColorAttachments == nullptr)
9156 {
9157 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9158 "vkCreateFramebuffer parameter, const VkColorAttachmentBindInfo* pCreateInfo->pColorAttachments, is null pointer");
9159 return;
9160 }
9161 if(pCreateInfo->pColorAttachments->view == nullptr)
9162 {
9163 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9164 "vkCreateFramebuffer parameter, VkColorAttachmentView pCreateInfo->pColorAttachments->view, is null pointer");
9165 return;
9166 }
9167 if(pCreateInfo->pColorAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9168 pCreateInfo->pColorAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE)
9169 {
9170 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9171 "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pColorAttachments->layout, is unrecognized enumerator");
9172 return;
9173 }
9174 if(pCreateInfo->pDepthStencilAttachment == nullptr)
9175 {
9176 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9177 "vkCreateFramebuffer parameter, const VkDepthStencilBindInfo* pCreateInfo->pDepthStencilAttachment, is null pointer");
9178 return;
9179 }
9180 if(pCreateInfo->pDepthStencilAttachment->view == nullptr)
9181 {
9182 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9183 "vkCreateFramebuffer parameter, VkDepthStencilView pCreateInfo->pDepthStencilAttachment->view, is null pointer");
9184 return;
9185 }
9186 if(pCreateInfo->pDepthStencilAttachment->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9187 pCreateInfo->pDepthStencilAttachment->layout > VK_IMAGE_LAYOUT_END_RANGE)
9188 {
9189 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9190 "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pDepthStencilAttachment->layout, is unrecognized enumerator");
9191 return;
9192 }
9193}
9194
9195void PostCreateFramebuffer(
9196 VkDevice device,
9197 VkFramebuffer* pFramebuffer,
9198 VkResult result)
9199{
9200 if(device == nullptr)
9201 {
9202 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9203 "vkCreateFramebuffer parameter, VkDevice device, is null pointer");
9204 return;
9205 }
9206
9207 if(pFramebuffer == nullptr)
9208 {
9209 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9210 "vkCreateFramebuffer parameter, VkFramebuffer* pFramebuffer, is null pointer");
9211 return;
9212 }
9213 if((*pFramebuffer) == nullptr)
9214 {
9215 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9216 "vkCreateFramebuffer parameter, VkFramebuffer* pFramebuffer, is null pointer");
9217 return;
9218 }
9219
9220 if(result != VK_SUCCESS)
9221 {
9222 std::string reason = "vkCreateFramebuffer parameter, VkResult result, is " + EnumeratorString(result);
9223 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
9224 return;
9225 }
9226}
9227
9228VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(
9229 VkDevice device,
9230 const VkFramebufferCreateInfo* pCreateInfo,
9231 VkFramebuffer* pFramebuffer)
9232{
9233 PreCreateFramebuffer(device, pCreateInfo);
9234 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
9235
9236 PostCreateFramebuffer(device, pFramebuffer, result);
9237
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9238 return result;
9239}
9240
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9241void PreCreateRenderPass(
9242 VkDevice device,
9243 const VkRenderPassCreateInfo* pCreateInfo)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9244{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9245 if(device == nullptr)
9246 {
9247 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9248 "vkCreateRenderPass parameter, VkDevice device, is null pointer");
9249 return;
9250 }
9251
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9252 if(pCreateInfo == nullptr)
9253 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9254 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9255 "vkCreateRenderPass parameter, const VkRenderPassCreateInfo* pCreateInfo, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9256 return;
9257 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9258 if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
9259 pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9260 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9261 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9262 "vkCreateRenderPass parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9263 return;
9264 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9265 if(pCreateInfo->pColorFormats == nullptr)
9266 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9267 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9268 "vkCreateRenderPass parameter, const VkFormat* pCreateInfo->pColorFormats, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9269 return;
9270 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9271 if((*pCreateInfo->pColorFormats) < VK_FORMAT_BEGIN_RANGE ||
9272 (*pCreateInfo->pColorFormats) > VK_FORMAT_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9273 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9274 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9275 "vkCreateRenderPass parameter, const VkFormat* pCreateInfo->pColorFormats, is unrecognized enumerator");
9276 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9277 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9278 if(pCreateInfo->pColorLayouts == nullptr)
9279 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9280 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9281 "vkCreateRenderPass parameter, const VkImageLayout* pCreateInfo->pColorLayouts, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9282 return;
9283 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9284 if((*pCreateInfo->pColorLayouts) < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9285 (*pCreateInfo->pColorLayouts) > VK_IMAGE_LAYOUT_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9286 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9287 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9288 "vkCreateRenderPass parameter, const VkImageLayout* pCreateInfo->pColorLayouts, is unrecognized enumerator");
9289 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9290 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9291 if(pCreateInfo->pColorLoadOps == nullptr)
9292 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9293 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9294 "vkCreateRenderPass parameter, const VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9295 return;
9296 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9297 if((*pCreateInfo->pColorLoadOps) < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
9298 (*pCreateInfo->pColorLoadOps) > VK_ATTACHMENT_LOAD_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9299 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9300 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9301 "vkCreateRenderPass parameter, const VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, is unrecognized enumerator");
9302 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9303 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9304 if(pCreateInfo->pColorStoreOps == nullptr)
9305 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9306 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9307 "vkCreateRenderPass parameter, const VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9308 return;
9309 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9310 if((*pCreateInfo->pColorStoreOps) < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
9311 (*pCreateInfo->pColorStoreOps) > VK_ATTACHMENT_STORE_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9312 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9313 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9314 "vkCreateRenderPass parameter, const VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, is unrecognized enumerator");
9315 return;
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9316 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9317 if(pCreateInfo->pColorLoadClearValues == nullptr)
9318 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9319 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9320 "vkCreateRenderPass parameter, const VkClearColor* pCreateInfo->pColorLoadClearValues, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9321 return;
9322 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9323 if(pCreateInfo->depthStencilFormat < VK_FORMAT_BEGIN_RANGE ||
9324 pCreateInfo->depthStencilFormat > VK_FORMAT_END_RANGE)
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9325 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9326 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9327 "vkCreateRenderPass parameter, VkFormat pCreateInfo->depthStencilFormat, is unrecognized enumerator");
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9328 return;
9329 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9330 if(pCreateInfo->depthStencilLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
9331 pCreateInfo->depthStencilLayout > VK_IMAGE_LAYOUT_END_RANGE)
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9332 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9333 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9334 "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->depthStencilLayout, is unrecognized enumerator");
Jeremy Hayes6b7060b2015-04-07 09:49:05 -0600[diff] [blame]9335 return;
9336 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9337 if(pCreateInfo->depthLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
9338 pCreateInfo->depthLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9339 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9340 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9341 "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->depthLoadOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9342 return;
9343 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9344 if(pCreateInfo->depthStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
9345 pCreateInfo->depthStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9346 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9347 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9348 "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->depthStoreOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9349 return;
9350 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9351 if(pCreateInfo->stencilLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
9352 pCreateInfo->stencilLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9353 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9354 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9355 "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->stencilLoadOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9356 return;
9357 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9358 if(pCreateInfo->stencilStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
9359 pCreateInfo->stencilStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9360 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9361 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9362 "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->stencilStoreOp, is unrecognized enumerator");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9363 return;
9364 }
9365}
9366
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9367void PostCreateRenderPass(
9368 VkDevice device,
9369 VkRenderPass* pRenderPass,
9370 VkResult result)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9371{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9372 if(device == nullptr)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9373 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9374 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9375 "vkCreateRenderPass parameter, VkDevice device, is null pointer");
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9376 return;
9377 }
9378
9379 if(pRenderPass == nullptr)
9380 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9381 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9382 "vkCreateRenderPass parameter, VkRenderPass* pRenderPass, is null pointer");
9383 return;
9384 }
9385 if((*pRenderPass) == nullptr)
9386 {
9387 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9388 "vkCreateRenderPass parameter, VkRenderPass* pRenderPass, is null pointer");
9389 return;
9390 }
9391
9392 if(result != VK_SUCCESS)
9393 {
9394 std::string reason = "vkCreateRenderPass parameter, VkResult result, is " + EnumeratorString(result);
9395 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]9396 return;
9397 }
9398}
9399
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9400VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
9401 VkDevice device,
9402 const VkRenderPassCreateInfo* pCreateInfo,
9403 VkRenderPass* pRenderPass)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9404{
9405 PreCreateRenderPass(device, pCreateInfo);
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9406 VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
9407
9408 PostCreateRenderPass(device, pRenderPass, result);
9409
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9410 return result;
9411}
9412
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9413void PreCmdBeginRenderPass(
9414 VkCmdBuffer cmdBuffer,
9415 const VkRenderPassBegin* pRenderPassBegin)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9416{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9417 if(cmdBuffer == nullptr)
9418 {
9419 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9420 "vkCmdBeginRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9421 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9422 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9423
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9424 if(pRenderPassBegin == nullptr)
9425 {
9426 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9427 "vkCmdBeginRenderPass parameter, const VkRenderPassBegin* pRenderPassBegin, is null pointer");
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9428 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9429 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9430 if(pRenderPassBegin->renderPass == nullptr)
9431 {
9432 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9433 "vkCmdBeginRenderPass parameter, VkRenderPass pRenderPassBegin->renderPass, is null pointer");
9434 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9435 }
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9436 if(pRenderPassBegin->framebuffer == nullptr)
9437 {
9438 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9439 "vkCmdBeginRenderPass parameter, VkFramebuffer pRenderPassBegin->framebuffer, is null pointer");
9440 return;
Jon Ashburnf0615e22015-05-25 14:11:37 -0600[diff] [blame]9441 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9442}
9443
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9444void PostCmdBeginRenderPass(
9445 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9446{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9447 if(cmdBuffer == nullptr)
9448 {
9449 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9450 "vkCmdBeginRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
9451 return;
9452 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9453}
9454
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9455VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(
9456 VkCmdBuffer cmdBuffer,
9457 const VkRenderPassBegin* pRenderPassBegin)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9458{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9459 PreCmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
9460 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
9461
9462 PostCmdBeginRenderPass(cmdBuffer);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9463}
9464
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9465void PreCmdEndRenderPass(
9466 VkCmdBuffer cmdBuffer)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9467{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9468 if(cmdBuffer == nullptr)
9469 {
9470 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9471 "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
9472 return;
9473 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9474}
9475
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9476void PostCmdEndRenderPass(
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9477 VkCmdBuffer cmdBuffer)
Chia-I Wu5b66aa52015-04-16 22:02:10 +0800[diff] [blame]9478{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9479 if(cmdBuffer == nullptr)
9480 {
9481 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9482 "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
9483 return;
9484 }
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9485}
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9486
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9487void PreCmdExecuteCommands(
9488 VkCmdBuffer cmdBuffer)
9489{
9490 if(cmdBuffer == nullptr)
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9491 {
9492 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]9493 "vkCmdExecuteCommands parameter, VkCmdBuffer cmdBuffer, is null pointer");
9494 return;
9495 }
9496}
9497
9498void PostCmdExecuteCommands(
9499 VkCmdBuffer cmdBuffer)
9500{
9501 if(cmdBuffer == nullptr)
9502 {
9503 log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
9504 "vkCmdExecuteCommands parameter, VkCmdBuffer cmdBuffer, is null pointer");
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9505 return;
9506 }
Chia-I Wu5b66aa52015-04-16 22:02:10 +0800[diff] [blame]9507}
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9508
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9509VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9510 VkCmdBuffer cmdBuffer)
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9511{
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9512 PreCmdEndRenderPass(cmdBuffer);
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9513 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer);
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9514
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9515 PostCmdEndRenderPass(cmdBuffer);
9516}
9517
9518VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(
9519 VkCmdBuffer cmdBuffer,
9520 uint32_t cmdBuffersCount,
9521 const VkCmdBuffer* pCmdBuffers)
9522{
9523 PreCmdExecuteCommands(cmdBuffer);
9524 get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
9525
9526 PostCmdExecuteCommands(cmdBuffer);
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9527}
9528
Jon Ashburn1245cec2015-05-18 13:20:15 -0600[diff] [blame]9529VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9530{
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9531 if (device == NULL) {
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9532 return NULL;
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9533 }
9534
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9535 /* loader uses this to force layer initialization; device object is wrapped */
9536 if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9537 initDeviceTable(pc_device_table_map, (const VkBaseLayerObject *) device);
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9538 return (void*) vkGetDeviceProcAddr;
9539 }
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9540
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600[diff] [blame]9541 if (!strcmp(funcName, "vkCreateDevice"))
9542 return (void*) vkCreateDevice;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9543 if (!strcmp(funcName, "vkDestroyDevice"))
9544 return (void*) vkDestroyDevice;
9545 if (!strcmp(funcName, "vkGetDeviceQueue"))
9546 return (void*) vkGetDeviceQueue;
9547 if (!strcmp(funcName, "vkQueueSubmit"))
9548 return (void*) vkQueueSubmit;
9549 if (!strcmp(funcName, "vkQueueWaitIdle"))
9550 return (void*) vkQueueWaitIdle;
9551 if (!strcmp(funcName, "vkDeviceWaitIdle"))
9552 return (void*) vkDeviceWaitIdle;
9553 if (!strcmp(funcName, "vkAllocMemory"))
9554 return (void*) vkAllocMemory;
9555 if (!strcmp(funcName, "vkFreeMemory"))
9556 return (void*) vkFreeMemory;
9557 if (!strcmp(funcName, "vkMapMemory"))
9558 return (void*) vkMapMemory;
9559 if (!strcmp(funcName, "vkUnmapMemory"))
9560 return (void*) vkUnmapMemory;
9561 if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
9562 return (void*) vkFlushMappedMemoryRanges;
9563 if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges"))
9564 return (void*) vkInvalidateMappedMemoryRanges;
9565 if (!strcmp(funcName, "vkDestroyObject"))
9566 return (void*) vkDestroyObject;
9567 if (!strcmp(funcName, "vkGetObjectMemoryRequirements"))
9568 return (void*) vkGetObjectMemoryRequirements;
9569 if (!strcmp(funcName, "vkCreateFence"))
9570 return (void*) vkCreateFence;
9571 if (!strcmp(funcName, "vkResetFences"))
9572 return (void*) vkResetFences;
9573 if (!strcmp(funcName, "vkGetFenceStatus"))
9574 return (void*) vkGetFenceStatus;
9575 if (!strcmp(funcName, "vkWaitForFences"))
9576 return (void*) vkWaitForFences;
9577 if (!strcmp(funcName, "vkCreateSemaphore"))
9578 return (void*) vkCreateSemaphore;
9579 if (!strcmp(funcName, "vkQueueSignalSemaphore"))
9580 return (void*) vkQueueSignalSemaphore;
9581 if (!strcmp(funcName, "vkQueueWaitSemaphore"))
9582 return (void*) vkQueueWaitSemaphore;
9583 if (!strcmp(funcName, "vkCreateEvent"))
9584 return (void*) vkCreateEvent;
9585 if (!strcmp(funcName, "vkGetEventStatus"))
9586 return (void*) vkGetEventStatus;
9587 if (!strcmp(funcName, "vkSetEvent"))
9588 return (void*) vkSetEvent;
9589 if (!strcmp(funcName, "vkResetEvent"))
9590 return (void*) vkResetEvent;
9591 if (!strcmp(funcName, "vkCreateQueryPool"))
9592 return (void*) vkCreateQueryPool;
9593 if (!strcmp(funcName, "vkGetQueryPoolResults"))
9594 return (void*) vkGetQueryPoolResults;
9595 if (!strcmp(funcName, "vkCreateBuffer"))
9596 return (void*) vkCreateBuffer;
9597 if (!strcmp(funcName, "vkCreateBufferView"))
9598 return (void*) vkCreateBufferView;
9599 if (!strcmp(funcName, "vkCreateImage"))
9600 return (void*) vkCreateImage;
9601 if (!strcmp(funcName, "vkGetImageSubresourceLayout"))
9602 return (void*) vkGetImageSubresourceLayout;
9603 if (!strcmp(funcName, "vkCreateImageView"))
9604 return (void*) vkCreateImageView;
9605 if (!strcmp(funcName, "vkCreateColorAttachmentView"))
9606 return (void*) vkCreateColorAttachmentView;
9607 if (!strcmp(funcName, "vkCreateDepthStencilView"))
9608 return (void*) vkCreateDepthStencilView;
9609 if (!strcmp(funcName, "vkCreateShader"))
9610 return (void*) vkCreateShader;
9611 if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
9612 return (void*) vkCreateGraphicsPipeline;
9613 if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
9614 return (void*) vkCreateGraphicsPipelineDerivative;
9615 if (!strcmp(funcName, "vkCreateComputePipeline"))
9616 return (void*) vkCreateComputePipeline;
9617 if (!strcmp(funcName, "vkStorePipeline"))
9618 return (void*) vkStorePipeline;
9619 if (!strcmp(funcName, "vkLoadPipeline"))
9620 return (void*) vkLoadPipeline;
9621 if (!strcmp(funcName, "vkLoadPipelineDerivative"))
9622 return (void*) vkLoadPipelineDerivative;
9623 if (!strcmp(funcName, "vkCreatePipelineLayout"))
9624 return (void*) vkCreatePipelineLayout;
9625 if (!strcmp(funcName, "vkCreateSampler"))
9626 return (void*) vkCreateSampler;
9627 if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
9628 return (void*) vkCreateDescriptorSetLayout;
9629 if (!strcmp(funcName, "vkCreateDescriptorPool"))
9630 return (void*) vkCreateDescriptorPool;
9631 if (!strcmp(funcName, "vkResetDescriptorPool"))
9632 return (void*) vkResetDescriptorPool;
9633 if (!strcmp(funcName, "vkAllocDescriptorSets"))
9634 return (void*) vkAllocDescriptorSets;
9635 if (!strcmp(funcName, "vkCreateDynamicViewportState"))
9636 return (void*) vkCreateDynamicViewportState;
9637 if (!strcmp(funcName, "vkCreateDynamicRasterState"))
9638 return (void*) vkCreateDynamicRasterState;
9639 if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
9640 return (void*) vkCreateDynamicColorBlendState;
9641 if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
9642 return (void*) vkCreateDynamicDepthStencilState;
9643 if (!strcmp(funcName, "vkCreateCommandBuffer"))
9644 return (void*) vkCreateCommandBuffer;
9645 if (!strcmp(funcName, "vkBeginCommandBuffer"))
9646 return (void*) vkBeginCommandBuffer;
9647 if (!strcmp(funcName, "vkEndCommandBuffer"))
9648 return (void*) vkEndCommandBuffer;
9649 if (!strcmp(funcName, "vkResetCommandBuffer"))
9650 return (void*) vkResetCommandBuffer;
9651 if (!strcmp(funcName, "vkCmdBindPipeline"))
9652 return (void*) vkCmdBindPipeline;
9653 if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
9654 return (void*) vkCmdBindDynamicStateObject;
9655 if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
9656 return (void*) vkCmdBindDescriptorSets;
9657 if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
9658 return (void*) vkCmdBindVertexBuffers;
9659 if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
9660 return (void*) vkCmdBindIndexBuffer;
9661 if (!strcmp(funcName, "vkCmdDraw"))
9662 return (void*) vkCmdDraw;
9663 if (!strcmp(funcName, "vkCmdDrawIndexed"))
9664 return (void*) vkCmdDrawIndexed;
9665 if (!strcmp(funcName, "vkCmdDrawIndirect"))
9666 return (void*) vkCmdDrawIndirect;
9667 if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
9668 return (void*) vkCmdDrawIndexedIndirect;
9669 if (!strcmp(funcName, "vkCmdDispatch"))
9670 return (void*) vkCmdDispatch;
9671 if (!strcmp(funcName, "vkCmdDispatchIndirect"))
9672 return (void*) vkCmdDispatchIndirect;
9673 if (!strcmp(funcName, "vkCmdCopyBuffer"))
9674 return (void*) vkCmdCopyBuffer;
9675 if (!strcmp(funcName, "vkCmdCopyImage"))
9676 return (void*) vkCmdCopyImage;
9677 if (!strcmp(funcName, "vkCmdBlitImage"))
9678 return (void*) vkCmdBlitImage;
9679 if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
9680 return (void*) vkCmdCopyBufferToImage;
9681 if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
9682 return (void*) vkCmdCopyImageToBuffer;
9683 if (!strcmp(funcName, "vkCmdUpdateBuffer"))
9684 return (void*) vkCmdUpdateBuffer;
9685 if (!strcmp(funcName, "vkCmdFillBuffer"))
9686 return (void*) vkCmdFillBuffer;
9687 if (!strcmp(funcName, "vkCmdClearColorImage"))
9688 return (void*) vkCmdClearColorImage;
Chris Forbes2951d7d2015-06-22 17:21:59 +1200[diff] [blame^]9689 if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
9690 return (void*) vkCmdClearDepthStencilImage;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9691 if (!strcmp(funcName, "vkCmdResolveImage"))
9692 return (void*) vkCmdResolveImage;
9693 if (!strcmp(funcName, "vkCmdSetEvent"))
9694 return (void*) vkCmdSetEvent;
9695 if (!strcmp(funcName, "vkCmdResetEvent"))
9696 return (void*) vkCmdResetEvent;
9697 if (!strcmp(funcName, "vkCmdWaitEvents"))
9698 return (void*) vkCmdWaitEvents;
9699 if (!strcmp(funcName, "vkCmdPipelineBarrier"))
9700 return (void*) vkCmdPipelineBarrier;
9701 if (!strcmp(funcName, "vkCmdBeginQuery"))
9702 return (void*) vkCmdBeginQuery;
9703 if (!strcmp(funcName, "vkCmdEndQuery"))
9704 return (void*) vkCmdEndQuery;
9705 if (!strcmp(funcName, "vkCmdResetQueryPool"))
9706 return (void*) vkCmdResetQueryPool;
9707 if (!strcmp(funcName, "vkCmdWriteTimestamp"))
9708 return (void*) vkCmdWriteTimestamp;
9709 if (!strcmp(funcName, "vkCmdCopyQueryPoolResults"))
9710 return (void*) vkCmdCopyQueryPoolResults;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9711 if (!strcmp(funcName, "vkCreateFramebuffer"))
9712 return (void*) vkCreateFramebuffer;
9713 if (!strcmp(funcName, "vkCreateRenderPass"))
9714 return (void*) vkCreateRenderPass;
9715 if (!strcmp(funcName, "vkCmdBeginRenderPass"))
9716 return (void*) vkCmdBeginRenderPass;
9717 if (!strcmp(funcName, "vkCmdEndRenderPass"))
9718 return (void*) vkCmdEndRenderPass;
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]9719 if (!strcmp(funcName, "vkCmdExecuteCommands"))
9720 return (void*) vkCmdExecuteCommands;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9721 if (!strcmp(funcName, "vkGetGlobalExtensionCount"))
9722 return (void*) vkGetGlobalExtensionCount;
9723 if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
9724 return (void*) vkGetGlobalExtensionProperties;
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9725
Jon Ashburn6f8cd632015-06-01 09:37:38 -0600[diff] [blame]9726 {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9727 if (get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr == NULL)
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9728 return NULL;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9729 return get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr(device, funcName);
Jeremy Hayesc6cfa572015-04-06 13:46:11 -0600[diff] [blame]9730 }
9731}
9732
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9733VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9734{
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9735 if (instance == NULL) {
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9736 return NULL;
Mark Lobodzinski3723c512015-05-26 10:58:40 -0500[diff] [blame]9737 }
9738
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9739 /* loader uses this to force layer initialization; instance object is wrapped */
9740 if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9741 initInstanceTable(pc_instance_table_map, (const VkBaseLayerObject *) instance);
9742 return (void *) vkGetInstanceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600[diff] [blame]9743 }
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9744
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9745 if (!strcmp(funcName, "vkCreateInstance"))
9746 return (void*) vkCreateInstance;
9747 if (!strcmp(funcName, "vkDestroyInstance"))
9748 return (void*) vkDestroyInstance;
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9749 if (!strcmp(funcName, "vkEnumeratePhysicalDevices"))
9750 return (void*) vkEnumeratePhysicalDevices;
9751 if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionCount"))
9752 return (void*) vkGetPhysicalDeviceExtensionCount;
9753 if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
9754 return (void*) vkGetPhysicalDeviceExtensionProperties;
9755 if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
9756 return (void*) vkGetPhysicalDeviceProperties;
9757 if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures"))
9758 return (void*) vkGetPhysicalDeviceFeatures;
9759 if (!strcmp(funcName, "vkGetPhysicalDeviceFormatInfo"))
9760 return (void*) vkGetPhysicalDeviceFormatInfo;
9761 if (!strcmp(funcName, "vkGetPhysicalDeviceLimits"))
9762 return (void*) vkGetPhysicalDeviceLimits;
Courtney Goeltzenleuchter09f85042015-06-01 14:45:27 -0600[diff] [blame]9763
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9764 layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
9765 void* fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
9766 if(fptr)
Courtney Goeltzenleuchter09f85042015-06-01 14:45:27 -0600[diff] [blame]9767 return fptr;
9768
Jeremy Hayesea53d6f2015-06-26 12:48:09 -0600[diff] [blame]9769 {
9770 if (get_dispatch_table(pc_instance_table_map, instance)->GetInstanceProcAddr == NULL)
9771 return NULL;
9772 return get_dispatch_table(pc_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);
9773 }
Jon Ashburn79b78ac2015-05-05 14:22:52 -0600[diff] [blame]9774}