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