1
2 // This file is ***GENERATED***. Do Not Edit.
3 // See thread_safety_generator.py for modifications.
4
5 /* Copyright (c) 2015-2019 The Khronos Group Inc.
6 * Copyright (c) 2015-2019 Valve Corporation
7 * Copyright (c) 2015-2019 LunarG, Inc.
8 * Copyright (c) 2015-2019 Google Inc.
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 *
22 * Author: Mark Lobodzinski <mark@lunarg.com>
23 */
24
25 #pragma once
26
27 #include <chrono>
28 #include <thread>
29 #include <mutex>
30 #include <vector>
31 #include <unordered_set>
32 #include <string>
33
34 VK_DEFINE_NON_DISPATCHABLE_HANDLE(DISTINCT_NONDISPATCHABLE_PHONY_HANDLE)
35 // The following line must match the vulkan_core.h condition guarding VK_DEFINE_NON_DISPATCHABLE_HANDLE
36 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
37 // If pointers are 64-bit, then there can be separate counters for each
38 // NONDISPATCHABLE_HANDLE type. Otherwise they are all typedef uint64_t.
39 #define DISTINCT_NONDISPATCHABLE_HANDLES
40 // Make sure we catch any disagreement between us and the vulkan definition
41 static_assert(std::is_pointer<DISTINCT_NONDISPATCHABLE_PHONY_HANDLE>::value,
42 "Mismatched non-dispatchable handle handle, expected pointer type.");
43 #else
44 // Make sure we catch any disagreement between us and the vulkan definition
45 static_assert(std::is_same<uint64_t, DISTINCT_NONDISPATCHABLE_PHONY_HANDLE>::value,
46 "Mismatched non-dispatchable handle handle, expected uint64_t.");
47 #endif
48
49 // Suppress unused warning on Linux
50 #if defined(__GNUC__)
51 #define DECORATE_UNUSED __attribute__((unused))
52 #else
53 #define DECORATE_UNUSED
54 #endif
55
56 // clang-format off
57 static const char DECORATE_UNUSED *kVUID_Threading_Info = "UNASSIGNED-Threading-Info";
58 static const char DECORATE_UNUSED *kVUID_Threading_MultipleThreads = "UNASSIGNED-Threading-MultipleThreads";
59 static const char DECORATE_UNUSED *kVUID_Threading_SingleThreadReuse = "UNASSIGNED-Threading-SingleThreadReuse";
60 // clang-format on
61
62 #undef DECORATE_UNUSED
63
64 struct object_use_data {
65 loader_platform_thread_id thread;
66 int reader_count;
67 int writer_count;
68 };
69
70 // This is a wrapper around unordered_map that optimizes for the common case
71 // of only containing a single element. The "first" element's use is stored
72 // inline in the class and doesn't require hashing or memory (de)allocation.
73 // TODO: Consider generalizing this from one element to N elements (where N
74 // is a template parameter).
75 template <typename Key, typename T>
76 class small_unordered_map {
77
78 bool first_data_allocated;
79 Key first_data_key;
80 T first_data;
81
82 std::unordered_map<Key, T> uses;
83
84 public:
small_unordered_map()85 small_unordered_map() : first_data_allocated(false) {}
86
contains(const Key & object)87 bool contains(const Key& object) const {
88 if (first_data_allocated && object == first_data_key) {
89 return true;
90 // check size() first to avoid hashing object unnecessarily.
91 } else if (uses.size() == 0) {
92 return false;
93 } else {
94 return uses.find(object) != uses.end();
95 }
96 }
97
98 T& operator[](const Key& object) {
99 if (first_data_allocated && first_data_key == object) {
100 return first_data;
101 } else if (!first_data_allocated && uses.size() == 0) {
102 first_data_allocated = true;
103 first_data_key = object;
104 return first_data;
105 } else {
106 return uses[object];
107 }
108 }
109
erase(const Key & object)110 typename std::unordered_map<Key, T>::size_type erase(const Key& object) {
111 if (first_data_allocated && first_data_key == object) {
112 first_data_allocated = false;
113 return 1;
114 } else {
115 return uses.erase(object);
116 }
117 }
118 };
119
120 #define THREAD_SAFETY_BUCKETS_LOG2 6
121 #define THREAD_SAFETY_BUCKETS (1 << THREAD_SAFETY_BUCKETS_LOG2)
122
ThreadSafetyHashObject(T object)123 template <typename T> inline uint32_t ThreadSafetyHashObject(T object)
124 {
125 uint64_t u64 = (uint64_t)(uintptr_t)object;
126 uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
127 hash ^= (hash >> THREAD_SAFETY_BUCKETS_LOG2) ^ (hash >> (2*THREAD_SAFETY_BUCKETS_LOG2));
128 hash &= (THREAD_SAFETY_BUCKETS-1);
129 return hash;
130 }
131
132 template <typename T>
133 class counter {
134 public:
135 const char *typeName;
136 VkDebugReportObjectTypeEXT objectType;
137 debug_report_data **report_data;
138
139 // Per-bucket locking, to reduce contention.
140 struct CounterBucket {
141 small_unordered_map<T, object_use_data> uses;
142 std::mutex counter_lock;
143 };
144
145 CounterBucket buckets[THREAD_SAFETY_BUCKETS];
GetBucket(T object)146 CounterBucket &GetBucket(T object)
147 {
148 return buckets[ThreadSafetyHashObject(object)];
149 }
150
StartWrite(T object)151 void StartWrite(T object) {
152 if (object == VK_NULL_HANDLE) {
153 return;
154 }
155 auto &bucket = GetBucket(object);
156 bool skip = false;
157 loader_platform_thread_id tid = loader_platform_get_thread_id();
158 std::unique_lock<std::mutex> lock(bucket.counter_lock);
159 if (!bucket.uses.contains(object)) {
160 // There is no current use of the object. Record writer thread.
161 struct object_use_data *use_data = &bucket.uses[object];
162 use_data->reader_count = 0;
163 use_data->writer_count = 1;
164 use_data->thread = tid;
165 } else {
166 struct object_use_data *use_data = &bucket.uses[object];
167 if (use_data->reader_count == 0) {
168 // There are no readers. Two writers just collided.
169 if (use_data->thread != tid) {
170 skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
171 kVUID_Threading_MultipleThreads,
172 "THREADING ERROR : object of type %s is simultaneously used in "
173 "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
174 typeName, (uint64_t)use_data->thread, (uint64_t)tid);
175 if (skip) {
176 WaitForObjectIdle(bucket, object, lock);
177 // There is now no current use of the object. Record writer thread.
178 struct object_use_data *new_use_data = &bucket.uses[object];
179 new_use_data->thread = tid;
180 new_use_data->reader_count = 0;
181 new_use_data->writer_count = 1;
182 } else {
183 // Continue with an unsafe use of the object.
184 use_data->thread = tid;
185 use_data->writer_count += 1;
186 }
187 } else {
188 // This is either safe multiple use in one call, or recursive use.
189 // There is no way to make recursion safe. Just forge ahead.
190 use_data->writer_count += 1;
191 }
192 } else {
193 // There are readers. This writer collided with them.
194 if (use_data->thread != tid) {
195 skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
196 kVUID_Threading_MultipleThreads,
197 "THREADING ERROR : object of type %s is simultaneously used in "
198 "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
199 typeName, (uint64_t)use_data->thread, (uint64_t)tid);
200 if (skip) {
201 WaitForObjectIdle(bucket, object, lock);
202 // There is now no current use of the object. Record writer thread.
203 struct object_use_data *new_use_data = &bucket.uses[object];
204 new_use_data->thread = tid;
205 new_use_data->reader_count = 0;
206 new_use_data->writer_count = 1;
207 } else {
208 // Continue with an unsafe use of the object.
209 use_data->thread = tid;
210 use_data->writer_count += 1;
211 }
212 } else {
213 // This is either safe multiple use in one call, or recursive use.
214 // There is no way to make recursion safe. Just forge ahead.
215 use_data->writer_count += 1;
216 }
217 }
218 }
219 }
220
FinishWrite(T object)221 void FinishWrite(T object) {
222 if (object == VK_NULL_HANDLE) {
223 return;
224 }
225 auto &bucket = GetBucket(object);
226 // Object is no longer in use
227 std::unique_lock<std::mutex> lock(bucket.counter_lock);
228 struct object_use_data *use_data = &bucket.uses[object];
229 use_data->writer_count -= 1;
230 if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
231 bucket.uses.erase(object);
232 }
233 }
234
StartRead(T object)235 void StartRead(T object) {
236 if (object == VK_NULL_HANDLE) {
237 return;
238 }
239 auto &bucket = GetBucket(object);
240 bool skip = false;
241 loader_platform_thread_id tid = loader_platform_get_thread_id();
242 std::unique_lock<std::mutex> lock(bucket.counter_lock);
243 if (!bucket.uses.contains(object)) {
244 // There is no current use of the object. Record reader count
245 struct object_use_data *use_data = &bucket.uses[object];
246 use_data->reader_count = 1;
247 use_data->writer_count = 0;
248 use_data->thread = tid;
249 } else if (bucket.uses[object].writer_count > 0 && bucket.uses[object].thread != tid) {
250 // There is a writer of the object.
251 skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
252 kVUID_Threading_MultipleThreads,
253 "THREADING ERROR : object of type %s is simultaneously used in "
254 "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
255 typeName, (uint64_t)bucket.uses[object].thread, (uint64_t)tid);
256 if (skip) {
257 WaitForObjectIdle(bucket, object, lock);
258 // There is no current use of the object. Record reader count
259 struct object_use_data *use_data = &bucket.uses[object];
260 use_data->reader_count = 1;
261 use_data->writer_count = 0;
262 use_data->thread = tid;
263 } else {
264 bucket.uses[object].reader_count += 1;
265 }
266 } else {
267 // There are other readers of the object. Increase reader count
268 bucket.uses[object].reader_count += 1;
269 }
270 }
FinishRead(T object)271 void FinishRead(T object) {
272 if (object == VK_NULL_HANDLE) {
273 return;
274 }
275 auto &bucket = GetBucket(object);
276 std::unique_lock<std::mutex> lock(bucket.counter_lock);
277 struct object_use_data *use_data = &bucket.uses[object];
278 use_data->reader_count -= 1;
279 if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
280 bucket.uses.erase(object);
281 }
282 }
283 counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, debug_report_data **rep_data = nullptr) {
284 typeName = name;
285 objectType = type;
286 report_data = rep_data;
287 }
288
289 private:
WaitForObjectIdle(CounterBucket & bucket,T object,std::unique_lock<std::mutex> & lock)290 void WaitForObjectIdle(CounterBucket &bucket, T object, std::unique_lock<std::mutex> &lock) {
291 // Wait for thread-safe access to object instead of skipping call.
292 // Don't use condition_variable to wait because it should be extremely
293 // rare to have collisions, but signaling would be very frequent.
294 while (bucket.uses.contains(object)) {
295 lock.unlock();
296 std::this_thread::sleep_for(std::chrono::microseconds(1));
297 lock.lock();
298 }
299 }
300 };
301
302
303
304 class ThreadSafety : public ValidationObject {
305 public:
306
307 // Override chassis read/write locks for this validation object
308 // This override takes a deferred lock. i.e. it is not acquired.
write_lock()309 std::unique_lock<std::mutex> write_lock() {
310 return std::unique_lock<std::mutex>(validation_object_mutex, std::defer_lock);
311 }
312
313 // Per-bucket locking, to reduce contention.
314 struct CommandBufferBucket {
315 std::mutex command_pool_lock;
316 small_unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
317 };
318
319 CommandBufferBucket buckets[THREAD_SAFETY_BUCKETS];
GetBucket(VkCommandBuffer object)320 CommandBufferBucket &GetBucket(VkCommandBuffer object)
321 {
322 return buckets[ThreadSafetyHashObject(object)];
323 }
324
325 counter<VkCommandBuffer> c_VkCommandBuffer;
326 counter<VkDevice> c_VkDevice;
327 counter<VkInstance> c_VkInstance;
328 counter<VkQueue> c_VkQueue;
329 #ifdef DISTINCT_NONDISPATCHABLE_HANDLES
330
331 // Special entry to allow tracking of command pool Reset and Destroy
332 counter<VkCommandPool> c_VkCommandPoolContents;
333 counter<VkAccelerationStructureNV> c_VkAccelerationStructureNV;
334 counter<VkBuffer> c_VkBuffer;
335 counter<VkBufferView> c_VkBufferView;
336 counter<VkCommandPool> c_VkCommandPool;
337 counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT;
338 counter<VkDebugUtilsMessengerEXT> c_VkDebugUtilsMessengerEXT;
339 counter<VkDescriptorPool> c_VkDescriptorPool;
340 counter<VkDescriptorSet> c_VkDescriptorSet;
341 counter<VkDescriptorSetLayout> c_VkDescriptorSetLayout;
342 counter<VkDescriptorUpdateTemplate> c_VkDescriptorUpdateTemplate;
343 counter<VkDeviceMemory> c_VkDeviceMemory;
344 counter<VkDisplayKHR> c_VkDisplayKHR;
345 counter<VkDisplayModeKHR> c_VkDisplayModeKHR;
346 counter<VkEvent> c_VkEvent;
347 counter<VkFence> c_VkFence;
348 counter<VkFramebuffer> c_VkFramebuffer;
349 counter<VkImage> c_VkImage;
350 counter<VkImageView> c_VkImageView;
351 counter<VkIndirectCommandsLayoutNVX> c_VkIndirectCommandsLayoutNVX;
352 counter<VkObjectTableNVX> c_VkObjectTableNVX;
353 counter<VkPerformanceConfigurationINTEL> c_VkPerformanceConfigurationINTEL;
354 counter<VkPipeline> c_VkPipeline;
355 counter<VkPipelineCache> c_VkPipelineCache;
356 counter<VkPipelineLayout> c_VkPipelineLayout;
357 counter<VkQueryPool> c_VkQueryPool;
358 counter<VkRenderPass> c_VkRenderPass;
359 counter<VkSampler> c_VkSampler;
360 counter<VkSamplerYcbcrConversion> c_VkSamplerYcbcrConversion;
361 counter<VkSemaphore> c_VkSemaphore;
362 counter<VkShaderModule> c_VkShaderModule;
363 counter<VkSurfaceKHR> c_VkSurfaceKHR;
364 counter<VkSwapchainKHR> c_VkSwapchainKHR;
365 counter<VkValidationCacheEXT> c_VkValidationCacheEXT;
366
367
368 #else // DISTINCT_NONDISPATCHABLE_HANDLES
369 // Special entry to allow tracking of command pool Reset and Destroy
370 counter<uint64_t> c_VkCommandPoolContents;
371
372 counter<uint64_t> c_uint64_t;
373 #endif // DISTINCT_NONDISPATCHABLE_HANDLES
374
ThreadSafety()375 ThreadSafety()
376 : c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, &report_data),
377 c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, &report_data),
378 c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, &report_data),
379 c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, &report_data),
380 c_VkCommandPoolContents("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, &report_data),
381
382 #ifdef DISTINCT_NONDISPATCHABLE_HANDLES
383 c_VkAccelerationStructureNV("VkAccelerationStructureNV", VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, &report_data),
384 c_VkBuffer("VkBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &report_data),
385 c_VkBufferView("VkBufferView", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, &report_data),
386 c_VkCommandPool("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, &report_data),
387 c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, &report_data),
388 c_VkDebugUtilsMessengerEXT("VkDebugUtilsMessengerEXT", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data),
389 c_VkDescriptorPool("VkDescriptorPool", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, &report_data),
390 c_VkDescriptorSet("VkDescriptorSet", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, &report_data),
391 c_VkDescriptorSetLayout("VkDescriptorSetLayout", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, &report_data),
392 c_VkDescriptorUpdateTemplate("VkDescriptorUpdateTemplate", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, &report_data),
393 c_VkDeviceMemory("VkDeviceMemory", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, &report_data),
394 c_VkDisplayKHR("VkDisplayKHR", VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, &report_data),
395 c_VkDisplayModeKHR("VkDisplayModeKHR", VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, &report_data),
396 c_VkEvent("VkEvent", VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, &report_data),
397 c_VkFence("VkFence", VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, &report_data),
398 c_VkFramebuffer("VkFramebuffer", VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, &report_data),
399 c_VkImage("VkImage", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &report_data),
400 c_VkImageView("VkImageView", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, &report_data),
401 c_VkIndirectCommandsLayoutNVX("VkIndirectCommandsLayoutNVX", VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, &report_data),
402 c_VkObjectTableNVX("VkObjectTableNVX", VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, &report_data),
403 c_VkPerformanceConfigurationINTEL("VkPerformanceConfigurationINTEL", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data),
404 c_VkPipeline("VkPipeline", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, &report_data),
405 c_VkPipelineCache("VkPipelineCache", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, &report_data),
406 c_VkPipelineLayout("VkPipelineLayout", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, &report_data),
407 c_VkQueryPool("VkQueryPool", VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, &report_data),
408 c_VkRenderPass("VkRenderPass", VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, &report_data),
409 c_VkSampler("VkSampler", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, &report_data),
410 c_VkSamplerYcbcrConversion("VkSamplerYcbcrConversion", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, &report_data),
411 c_VkSemaphore("VkSemaphore", VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, &report_data),
412 c_VkShaderModule("VkShaderModule", VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, &report_data),
413 c_VkSurfaceKHR("VkSurfaceKHR", VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, &report_data),
414 c_VkSwapchainKHR("VkSwapchainKHR", VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, &report_data),
415 c_VkValidationCacheEXT("VkValidationCacheEXT", VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, &report_data)
416
417
418 #else // DISTINCT_NONDISPATCHABLE_HANDLES
419 c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data)
420 #endif // DISTINCT_NONDISPATCHABLE_HANDLES
421 {};
422
423 #define WRAPPER(type) void StartWriteObject(type object) { c_##type.StartWrite(object); } void FinishWriteObject(type object) { c_##type.FinishWrite(object); } void StartReadObject(type object) { c_##type.StartRead(object); } void FinishReadObject(type object) { c_##type.FinishRead(object); }
424
425 WRAPPER(VkDevice)
WRAPPER(VkInstance)426 WRAPPER(VkInstance)
427 WRAPPER(VkQueue)
428 #ifdef DISTINCT_NONDISPATCHABLE_HANDLES
429 WRAPPER(VkAccelerationStructureNV)
430 WRAPPER(VkBuffer)
431 WRAPPER(VkBufferView)
432 WRAPPER(VkCommandPool)
433 WRAPPER(VkDebugReportCallbackEXT)
434 WRAPPER(VkDebugUtilsMessengerEXT)
435 WRAPPER(VkDescriptorPool)
436 WRAPPER(VkDescriptorSet)
437 WRAPPER(VkDescriptorSetLayout)
438 WRAPPER(VkDescriptorUpdateTemplate)
439 WRAPPER(VkDeviceMemory)
440 WRAPPER(VkDisplayKHR)
441 WRAPPER(VkDisplayModeKHR)
442 WRAPPER(VkEvent)
443 WRAPPER(VkFence)
444 WRAPPER(VkFramebuffer)
445 WRAPPER(VkImage)
446 WRAPPER(VkImageView)
447 WRAPPER(VkIndirectCommandsLayoutNVX)
448 WRAPPER(VkObjectTableNVX)
449 WRAPPER(VkPerformanceConfigurationINTEL)
450 WRAPPER(VkPipeline)
451 WRAPPER(VkPipelineCache)
452 WRAPPER(VkPipelineLayout)
453 WRAPPER(VkQueryPool)
454 WRAPPER(VkRenderPass)
455 WRAPPER(VkSampler)
456 WRAPPER(VkSamplerYcbcrConversion)
457 WRAPPER(VkSemaphore)
458 WRAPPER(VkShaderModule)
459 WRAPPER(VkSurfaceKHR)
460 WRAPPER(VkSwapchainKHR)
461 WRAPPER(VkValidationCacheEXT)
462
463
464 #else // DISTINCT_NONDISPATCHABLE_HANDLES
465 WRAPPER(uint64_t)
466 #endif // DISTINCT_NONDISPATCHABLE_HANDLES
467
468 // VkCommandBuffer needs check for implicit use of command pool
469 void StartWriteObject(VkCommandBuffer object, bool lockPool = true) {
470 if (lockPool) {
471 auto &bucket = GetBucket(object);
472 std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
473 VkCommandPool pool = bucket.command_pool_map[object];
474 lock.unlock();
475 StartWriteObject(pool);
476 }
477 c_VkCommandBuffer.StartWrite(object);
478 }
479 void FinishWriteObject(VkCommandBuffer object, bool lockPool = true) {
480 c_VkCommandBuffer.FinishWrite(object);
481 if (lockPool) {
482 auto &bucket = GetBucket(object);
483 std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
484 VkCommandPool pool = bucket.command_pool_map[object];
485 lock.unlock();
486 FinishWriteObject(pool);
487 }
488 }
StartReadObject(VkCommandBuffer object)489 void StartReadObject(VkCommandBuffer object) {
490 auto &bucket = GetBucket(object);
491 std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
492 VkCommandPool pool = bucket.command_pool_map[object];
493 lock.unlock();
494 // We set up a read guard against the "Contents" counter to catch conflict vs. vkResetCommandPool and vkDestroyCommandPool
495 // while *not* establishing a read guard against the command pool counter itself to avoid false postives for
496 // non-externally sync'd command buffers
497 c_VkCommandPoolContents.StartRead(pool);
498 c_VkCommandBuffer.StartRead(object);
499 }
FinishReadObject(VkCommandBuffer object)500 void FinishReadObject(VkCommandBuffer object) {
501 auto &bucket = GetBucket(object);
502 c_VkCommandBuffer.FinishRead(object);
503 std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
504 VkCommandPool pool = bucket.command_pool_map[object];
505 lock.unlock();
506 c_VkCommandPoolContents.FinishRead(pool);
507 }
508
509 void PreCallRecordDestroyInstance(
510 VkInstance instance,
511 const VkAllocationCallbacks* pAllocator);
512
513 void PostCallRecordDestroyInstance(
514 VkInstance instance,
515 const VkAllocationCallbacks* pAllocator);
516
517 void PreCallRecordEnumeratePhysicalDevices(
518 VkInstance instance,
519 uint32_t* pPhysicalDeviceCount,
520 VkPhysicalDevice* pPhysicalDevices);
521
522 void PostCallRecordEnumeratePhysicalDevices(
523 VkInstance instance,
524 uint32_t* pPhysicalDeviceCount,
525 VkPhysicalDevice* pPhysicalDevices,
526 VkResult result);
527
528 void PreCallRecordGetInstanceProcAddr(
529 VkInstance instance,
530 const char* pName);
531
532 void PostCallRecordGetInstanceProcAddr(
533 VkInstance instance,
534 const char* pName);
535
536 void PreCallRecordGetDeviceProcAddr(
537 VkDevice device,
538 const char* pName);
539
540 void PostCallRecordGetDeviceProcAddr(
541 VkDevice device,
542 const char* pName);
543
544 void PreCallRecordDestroyDevice(
545 VkDevice device,
546 const VkAllocationCallbacks* pAllocator);
547
548 void PostCallRecordDestroyDevice(
549 VkDevice device,
550 const VkAllocationCallbacks* pAllocator);
551
552 void PreCallRecordGetDeviceQueue(
553 VkDevice device,
554 uint32_t queueFamilyIndex,
555 uint32_t queueIndex,
556 VkQueue* pQueue);
557
558 void PostCallRecordGetDeviceQueue(
559 VkDevice device,
560 uint32_t queueFamilyIndex,
561 uint32_t queueIndex,
562 VkQueue* pQueue);
563
564 void PreCallRecordQueueSubmit(
565 VkQueue queue,
566 uint32_t submitCount,
567 const VkSubmitInfo* pSubmits,
568 VkFence fence);
569
570 void PostCallRecordQueueSubmit(
571 VkQueue queue,
572 uint32_t submitCount,
573 const VkSubmitInfo* pSubmits,
574 VkFence fence,
575 VkResult result);
576
577 void PreCallRecordQueueWaitIdle(
578 VkQueue queue);
579
580 void PostCallRecordQueueWaitIdle(
581 VkQueue queue,
582 VkResult result);
583
584 void PreCallRecordDeviceWaitIdle(
585 VkDevice device);
586
587 void PostCallRecordDeviceWaitIdle(
588 VkDevice device,
589 VkResult result);
590
591 void PreCallRecordAllocateMemory(
592 VkDevice device,
593 const VkMemoryAllocateInfo* pAllocateInfo,
594 const VkAllocationCallbacks* pAllocator,
595 VkDeviceMemory* pMemory);
596
597 void PostCallRecordAllocateMemory(
598 VkDevice device,
599 const VkMemoryAllocateInfo* pAllocateInfo,
600 const VkAllocationCallbacks* pAllocator,
601 VkDeviceMemory* pMemory,
602 VkResult result);
603
604 void PreCallRecordFreeMemory(
605 VkDevice device,
606 VkDeviceMemory memory,
607 const VkAllocationCallbacks* pAllocator);
608
609 void PostCallRecordFreeMemory(
610 VkDevice device,
611 VkDeviceMemory memory,
612 const VkAllocationCallbacks* pAllocator);
613
614 void PreCallRecordMapMemory(
615 VkDevice device,
616 VkDeviceMemory memory,
617 VkDeviceSize offset,
618 VkDeviceSize size,
619 VkMemoryMapFlags flags,
620 void** ppData);
621
622 void PostCallRecordMapMemory(
623 VkDevice device,
624 VkDeviceMemory memory,
625 VkDeviceSize offset,
626 VkDeviceSize size,
627 VkMemoryMapFlags flags,
628 void** ppData,
629 VkResult result);
630
631 void PreCallRecordUnmapMemory(
632 VkDevice device,
633 VkDeviceMemory memory);
634
635 void PostCallRecordUnmapMemory(
636 VkDevice device,
637 VkDeviceMemory memory);
638
639 void PreCallRecordFlushMappedMemoryRanges(
640 VkDevice device,
641 uint32_t memoryRangeCount,
642 const VkMappedMemoryRange* pMemoryRanges);
643
644 void PostCallRecordFlushMappedMemoryRanges(
645 VkDevice device,
646 uint32_t memoryRangeCount,
647 const VkMappedMemoryRange* pMemoryRanges,
648 VkResult result);
649
650 void PreCallRecordInvalidateMappedMemoryRanges(
651 VkDevice device,
652 uint32_t memoryRangeCount,
653 const VkMappedMemoryRange* pMemoryRanges);
654
655 void PostCallRecordInvalidateMappedMemoryRanges(
656 VkDevice device,
657 uint32_t memoryRangeCount,
658 const VkMappedMemoryRange* pMemoryRanges,
659 VkResult result);
660
661 void PreCallRecordGetDeviceMemoryCommitment(
662 VkDevice device,
663 VkDeviceMemory memory,
664 VkDeviceSize* pCommittedMemoryInBytes);
665
666 void PostCallRecordGetDeviceMemoryCommitment(
667 VkDevice device,
668 VkDeviceMemory memory,
669 VkDeviceSize* pCommittedMemoryInBytes);
670
671 void PreCallRecordBindBufferMemory(
672 VkDevice device,
673 VkBuffer buffer,
674 VkDeviceMemory memory,
675 VkDeviceSize memoryOffset);
676
677 void PostCallRecordBindBufferMemory(
678 VkDevice device,
679 VkBuffer buffer,
680 VkDeviceMemory memory,
681 VkDeviceSize memoryOffset,
682 VkResult result);
683
684 void PreCallRecordBindImageMemory(
685 VkDevice device,
686 VkImage image,
687 VkDeviceMemory memory,
688 VkDeviceSize memoryOffset);
689
690 void PostCallRecordBindImageMemory(
691 VkDevice device,
692 VkImage image,
693 VkDeviceMemory memory,
694 VkDeviceSize memoryOffset,
695 VkResult result);
696
697 void PreCallRecordGetBufferMemoryRequirements(
698 VkDevice device,
699 VkBuffer buffer,
700 VkMemoryRequirements* pMemoryRequirements);
701
702 void PostCallRecordGetBufferMemoryRequirements(
703 VkDevice device,
704 VkBuffer buffer,
705 VkMemoryRequirements* pMemoryRequirements);
706
707 void PreCallRecordGetImageMemoryRequirements(
708 VkDevice device,
709 VkImage image,
710 VkMemoryRequirements* pMemoryRequirements);
711
712 void PostCallRecordGetImageMemoryRequirements(
713 VkDevice device,
714 VkImage image,
715 VkMemoryRequirements* pMemoryRequirements);
716
717 void PreCallRecordGetImageSparseMemoryRequirements(
718 VkDevice device,
719 VkImage image,
720 uint32_t* pSparseMemoryRequirementCount,
721 VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
722
723 void PostCallRecordGetImageSparseMemoryRequirements(
724 VkDevice device,
725 VkImage image,
726 uint32_t* pSparseMemoryRequirementCount,
727 VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
728
729 void PreCallRecordQueueBindSparse(
730 VkQueue queue,
731 uint32_t bindInfoCount,
732 const VkBindSparseInfo* pBindInfo,
733 VkFence fence);
734
735 void PostCallRecordQueueBindSparse(
736 VkQueue queue,
737 uint32_t bindInfoCount,
738 const VkBindSparseInfo* pBindInfo,
739 VkFence fence,
740 VkResult result);
741
742 void PreCallRecordCreateFence(
743 VkDevice device,
744 const VkFenceCreateInfo* pCreateInfo,
745 const VkAllocationCallbacks* pAllocator,
746 VkFence* pFence);
747
748 void PostCallRecordCreateFence(
749 VkDevice device,
750 const VkFenceCreateInfo* pCreateInfo,
751 const VkAllocationCallbacks* pAllocator,
752 VkFence* pFence,
753 VkResult result);
754
755 void PreCallRecordDestroyFence(
756 VkDevice device,
757 VkFence fence,
758 const VkAllocationCallbacks* pAllocator);
759
760 void PostCallRecordDestroyFence(
761 VkDevice device,
762 VkFence fence,
763 const VkAllocationCallbacks* pAllocator);
764
765 void PreCallRecordResetFences(
766 VkDevice device,
767 uint32_t fenceCount,
768 const VkFence* pFences);
769
770 void PostCallRecordResetFences(
771 VkDevice device,
772 uint32_t fenceCount,
773 const VkFence* pFences,
774 VkResult result);
775
776 void PreCallRecordGetFenceStatus(
777 VkDevice device,
778 VkFence fence);
779
780 void PostCallRecordGetFenceStatus(
781 VkDevice device,
782 VkFence fence,
783 VkResult result);
784
785 void PreCallRecordWaitForFences(
786 VkDevice device,
787 uint32_t fenceCount,
788 const VkFence* pFences,
789 VkBool32 waitAll,
790 uint64_t timeout);
791
792 void PostCallRecordWaitForFences(
793 VkDevice device,
794 uint32_t fenceCount,
795 const VkFence* pFences,
796 VkBool32 waitAll,
797 uint64_t timeout,
798 VkResult result);
799
800 void PreCallRecordCreateSemaphore(
801 VkDevice device,
802 const VkSemaphoreCreateInfo* pCreateInfo,
803 const VkAllocationCallbacks* pAllocator,
804 VkSemaphore* pSemaphore);
805
806 void PostCallRecordCreateSemaphore(
807 VkDevice device,
808 const VkSemaphoreCreateInfo* pCreateInfo,
809 const VkAllocationCallbacks* pAllocator,
810 VkSemaphore* pSemaphore,
811 VkResult result);
812
813 void PreCallRecordDestroySemaphore(
814 VkDevice device,
815 VkSemaphore semaphore,
816 const VkAllocationCallbacks* pAllocator);
817
818 void PostCallRecordDestroySemaphore(
819 VkDevice device,
820 VkSemaphore semaphore,
821 const VkAllocationCallbacks* pAllocator);
822
823 void PreCallRecordCreateEvent(
824 VkDevice device,
825 const VkEventCreateInfo* pCreateInfo,
826 const VkAllocationCallbacks* pAllocator,
827 VkEvent* pEvent);
828
829 void PostCallRecordCreateEvent(
830 VkDevice device,
831 const VkEventCreateInfo* pCreateInfo,
832 const VkAllocationCallbacks* pAllocator,
833 VkEvent* pEvent,
834 VkResult result);
835
836 void PreCallRecordDestroyEvent(
837 VkDevice device,
838 VkEvent event,
839 const VkAllocationCallbacks* pAllocator);
840
841 void PostCallRecordDestroyEvent(
842 VkDevice device,
843 VkEvent event,
844 const VkAllocationCallbacks* pAllocator);
845
846 void PreCallRecordGetEventStatus(
847 VkDevice device,
848 VkEvent event);
849
850 void PostCallRecordGetEventStatus(
851 VkDevice device,
852 VkEvent event,
853 VkResult result);
854
855 void PreCallRecordSetEvent(
856 VkDevice device,
857 VkEvent event);
858
859 void PostCallRecordSetEvent(
860 VkDevice device,
861 VkEvent event,
862 VkResult result);
863
864 void PreCallRecordResetEvent(
865 VkDevice device,
866 VkEvent event);
867
868 void PostCallRecordResetEvent(
869 VkDevice device,
870 VkEvent event,
871 VkResult result);
872
873 void PreCallRecordCreateQueryPool(
874 VkDevice device,
875 const VkQueryPoolCreateInfo* pCreateInfo,
876 const VkAllocationCallbacks* pAllocator,
877 VkQueryPool* pQueryPool);
878
879 void PostCallRecordCreateQueryPool(
880 VkDevice device,
881 const VkQueryPoolCreateInfo* pCreateInfo,
882 const VkAllocationCallbacks* pAllocator,
883 VkQueryPool* pQueryPool,
884 VkResult result);
885
886 void PreCallRecordDestroyQueryPool(
887 VkDevice device,
888 VkQueryPool queryPool,
889 const VkAllocationCallbacks* pAllocator);
890
891 void PostCallRecordDestroyQueryPool(
892 VkDevice device,
893 VkQueryPool queryPool,
894 const VkAllocationCallbacks* pAllocator);
895
896 void PreCallRecordGetQueryPoolResults(
897 VkDevice device,
898 VkQueryPool queryPool,
899 uint32_t firstQuery,
900 uint32_t queryCount,
901 size_t dataSize,
902 void* pData,
903 VkDeviceSize stride,
904 VkQueryResultFlags flags);
905
906 void PostCallRecordGetQueryPoolResults(
907 VkDevice device,
908 VkQueryPool queryPool,
909 uint32_t firstQuery,
910 uint32_t queryCount,
911 size_t dataSize,
912 void* pData,
913 VkDeviceSize stride,
914 VkQueryResultFlags flags,
915 VkResult result);
916
917 void PreCallRecordCreateBuffer(
918 VkDevice device,
919 const VkBufferCreateInfo* pCreateInfo,
920 const VkAllocationCallbacks* pAllocator,
921 VkBuffer* pBuffer);
922
923 void PostCallRecordCreateBuffer(
924 VkDevice device,
925 const VkBufferCreateInfo* pCreateInfo,
926 const VkAllocationCallbacks* pAllocator,
927 VkBuffer* pBuffer,
928 VkResult result);
929
930 void PreCallRecordDestroyBuffer(
931 VkDevice device,
932 VkBuffer buffer,
933 const VkAllocationCallbacks* pAllocator);
934
935 void PostCallRecordDestroyBuffer(
936 VkDevice device,
937 VkBuffer buffer,
938 const VkAllocationCallbacks* pAllocator);
939
940 void PreCallRecordCreateBufferView(
941 VkDevice device,
942 const VkBufferViewCreateInfo* pCreateInfo,
943 const VkAllocationCallbacks* pAllocator,
944 VkBufferView* pView);
945
946 void PostCallRecordCreateBufferView(
947 VkDevice device,
948 const VkBufferViewCreateInfo* pCreateInfo,
949 const VkAllocationCallbacks* pAllocator,
950 VkBufferView* pView,
951 VkResult result);
952
953 void PreCallRecordDestroyBufferView(
954 VkDevice device,
955 VkBufferView bufferView,
956 const VkAllocationCallbacks* pAllocator);
957
958 void PostCallRecordDestroyBufferView(
959 VkDevice device,
960 VkBufferView bufferView,
961 const VkAllocationCallbacks* pAllocator);
962
963 void PreCallRecordCreateImage(
964 VkDevice device,
965 const VkImageCreateInfo* pCreateInfo,
966 const VkAllocationCallbacks* pAllocator,
967 VkImage* pImage);
968
969 void PostCallRecordCreateImage(
970 VkDevice device,
971 const VkImageCreateInfo* pCreateInfo,
972 const VkAllocationCallbacks* pAllocator,
973 VkImage* pImage,
974 VkResult result);
975
976 void PreCallRecordDestroyImage(
977 VkDevice device,
978 VkImage image,
979 const VkAllocationCallbacks* pAllocator);
980
981 void PostCallRecordDestroyImage(
982 VkDevice device,
983 VkImage image,
984 const VkAllocationCallbacks* pAllocator);
985
986 void PreCallRecordGetImageSubresourceLayout(
987 VkDevice device,
988 VkImage image,
989 const VkImageSubresource* pSubresource,
990 VkSubresourceLayout* pLayout);
991
992 void PostCallRecordGetImageSubresourceLayout(
993 VkDevice device,
994 VkImage image,
995 const VkImageSubresource* pSubresource,
996 VkSubresourceLayout* pLayout);
997
998 void PreCallRecordCreateImageView(
999 VkDevice device,
1000 const VkImageViewCreateInfo* pCreateInfo,
1001 const VkAllocationCallbacks* pAllocator,
1002 VkImageView* pView);
1003
1004 void PostCallRecordCreateImageView(
1005 VkDevice device,
1006 const VkImageViewCreateInfo* pCreateInfo,
1007 const VkAllocationCallbacks* pAllocator,
1008 VkImageView* pView,
1009 VkResult result);
1010
1011 void PreCallRecordDestroyImageView(
1012 VkDevice device,
1013 VkImageView imageView,
1014 const VkAllocationCallbacks* pAllocator);
1015
1016 void PostCallRecordDestroyImageView(
1017 VkDevice device,
1018 VkImageView imageView,
1019 const VkAllocationCallbacks* pAllocator);
1020
1021 void PreCallRecordCreateShaderModule(
1022 VkDevice device,
1023 const VkShaderModuleCreateInfo* pCreateInfo,
1024 const VkAllocationCallbacks* pAllocator,
1025 VkShaderModule* pShaderModule);
1026
1027 void PostCallRecordCreateShaderModule(
1028 VkDevice device,
1029 const VkShaderModuleCreateInfo* pCreateInfo,
1030 const VkAllocationCallbacks* pAllocator,
1031 VkShaderModule* pShaderModule,
1032 VkResult result);
1033
1034 void PreCallRecordDestroyShaderModule(
1035 VkDevice device,
1036 VkShaderModule shaderModule,
1037 const VkAllocationCallbacks* pAllocator);
1038
1039 void PostCallRecordDestroyShaderModule(
1040 VkDevice device,
1041 VkShaderModule shaderModule,
1042 const VkAllocationCallbacks* pAllocator);
1043
1044 void PreCallRecordCreatePipelineCache(
1045 VkDevice device,
1046 const VkPipelineCacheCreateInfo* pCreateInfo,
1047 const VkAllocationCallbacks* pAllocator,
1048 VkPipelineCache* pPipelineCache);
1049
1050 void PostCallRecordCreatePipelineCache(
1051 VkDevice device,
1052 const VkPipelineCacheCreateInfo* pCreateInfo,
1053 const VkAllocationCallbacks* pAllocator,
1054 VkPipelineCache* pPipelineCache,
1055 VkResult result);
1056
1057 void PreCallRecordDestroyPipelineCache(
1058 VkDevice device,
1059 VkPipelineCache pipelineCache,
1060 const VkAllocationCallbacks* pAllocator);
1061
1062 void PostCallRecordDestroyPipelineCache(
1063 VkDevice device,
1064 VkPipelineCache pipelineCache,
1065 const VkAllocationCallbacks* pAllocator);
1066
1067 void PreCallRecordGetPipelineCacheData(
1068 VkDevice device,
1069 VkPipelineCache pipelineCache,
1070 size_t* pDataSize,
1071 void* pData);
1072
1073 void PostCallRecordGetPipelineCacheData(
1074 VkDevice device,
1075 VkPipelineCache pipelineCache,
1076 size_t* pDataSize,
1077 void* pData,
1078 VkResult result);
1079
1080 void PreCallRecordMergePipelineCaches(
1081 VkDevice device,
1082 VkPipelineCache dstCache,
1083 uint32_t srcCacheCount,
1084 const VkPipelineCache* pSrcCaches);
1085
1086 void PostCallRecordMergePipelineCaches(
1087 VkDevice device,
1088 VkPipelineCache dstCache,
1089 uint32_t srcCacheCount,
1090 const VkPipelineCache* pSrcCaches,
1091 VkResult result);
1092
1093 void PreCallRecordCreateGraphicsPipelines(
1094 VkDevice device,
1095 VkPipelineCache pipelineCache,
1096 uint32_t createInfoCount,
1097 const VkGraphicsPipelineCreateInfo* pCreateInfos,
1098 const VkAllocationCallbacks* pAllocator,
1099 VkPipeline* pPipelines);
1100
1101 void PostCallRecordCreateGraphicsPipelines(
1102 VkDevice device,
1103 VkPipelineCache pipelineCache,
1104 uint32_t createInfoCount,
1105 const VkGraphicsPipelineCreateInfo* pCreateInfos,
1106 const VkAllocationCallbacks* pAllocator,
1107 VkPipeline* pPipelines,
1108 VkResult result);
1109
1110 void PreCallRecordCreateComputePipelines(
1111 VkDevice device,
1112 VkPipelineCache pipelineCache,
1113 uint32_t createInfoCount,
1114 const VkComputePipelineCreateInfo* pCreateInfos,
1115 const VkAllocationCallbacks* pAllocator,
1116 VkPipeline* pPipelines);
1117
1118 void PostCallRecordCreateComputePipelines(
1119 VkDevice device,
1120 VkPipelineCache pipelineCache,
1121 uint32_t createInfoCount,
1122 const VkComputePipelineCreateInfo* pCreateInfos,
1123 const VkAllocationCallbacks* pAllocator,
1124 VkPipeline* pPipelines,
1125 VkResult result);
1126
1127 void PreCallRecordDestroyPipeline(
1128 VkDevice device,
1129 VkPipeline pipeline,
1130 const VkAllocationCallbacks* pAllocator);
1131
1132 void PostCallRecordDestroyPipeline(
1133 VkDevice device,
1134 VkPipeline pipeline,
1135 const VkAllocationCallbacks* pAllocator);
1136
1137 void PreCallRecordCreatePipelineLayout(
1138 VkDevice device,
1139 const VkPipelineLayoutCreateInfo* pCreateInfo,
1140 const VkAllocationCallbacks* pAllocator,
1141 VkPipelineLayout* pPipelineLayout);
1142
1143 void PostCallRecordCreatePipelineLayout(
1144 VkDevice device,
1145 const VkPipelineLayoutCreateInfo* pCreateInfo,
1146 const VkAllocationCallbacks* pAllocator,
1147 VkPipelineLayout* pPipelineLayout,
1148 VkResult result);
1149
1150 void PreCallRecordDestroyPipelineLayout(
1151 VkDevice device,
1152 VkPipelineLayout pipelineLayout,
1153 const VkAllocationCallbacks* pAllocator);
1154
1155 void PostCallRecordDestroyPipelineLayout(
1156 VkDevice device,
1157 VkPipelineLayout pipelineLayout,
1158 const VkAllocationCallbacks* pAllocator);
1159
1160 void PreCallRecordCreateSampler(
1161 VkDevice device,
1162 const VkSamplerCreateInfo* pCreateInfo,
1163 const VkAllocationCallbacks* pAllocator,
1164 VkSampler* pSampler);
1165
1166 void PostCallRecordCreateSampler(
1167 VkDevice device,
1168 const VkSamplerCreateInfo* pCreateInfo,
1169 const VkAllocationCallbacks* pAllocator,
1170 VkSampler* pSampler,
1171 VkResult result);
1172
1173 void PreCallRecordDestroySampler(
1174 VkDevice device,
1175 VkSampler sampler,
1176 const VkAllocationCallbacks* pAllocator);
1177
1178 void PostCallRecordDestroySampler(
1179 VkDevice device,
1180 VkSampler sampler,
1181 const VkAllocationCallbacks* pAllocator);
1182
1183 void PreCallRecordCreateDescriptorSetLayout(
1184 VkDevice device,
1185 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1186 const VkAllocationCallbacks* pAllocator,
1187 VkDescriptorSetLayout* pSetLayout);
1188
1189 void PostCallRecordCreateDescriptorSetLayout(
1190 VkDevice device,
1191 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1192 const VkAllocationCallbacks* pAllocator,
1193 VkDescriptorSetLayout* pSetLayout,
1194 VkResult result);
1195
1196 void PreCallRecordDestroyDescriptorSetLayout(
1197 VkDevice device,
1198 VkDescriptorSetLayout descriptorSetLayout,
1199 const VkAllocationCallbacks* pAllocator);
1200
1201 void PostCallRecordDestroyDescriptorSetLayout(
1202 VkDevice device,
1203 VkDescriptorSetLayout descriptorSetLayout,
1204 const VkAllocationCallbacks* pAllocator);
1205
1206 void PreCallRecordCreateDescriptorPool(
1207 VkDevice device,
1208 const VkDescriptorPoolCreateInfo* pCreateInfo,
1209 const VkAllocationCallbacks* pAllocator,
1210 VkDescriptorPool* pDescriptorPool);
1211
1212 void PostCallRecordCreateDescriptorPool(
1213 VkDevice device,
1214 const VkDescriptorPoolCreateInfo* pCreateInfo,
1215 const VkAllocationCallbacks* pAllocator,
1216 VkDescriptorPool* pDescriptorPool,
1217 VkResult result);
1218
1219 void PreCallRecordDestroyDescriptorPool(
1220 VkDevice device,
1221 VkDescriptorPool descriptorPool,
1222 const VkAllocationCallbacks* pAllocator);
1223
1224 void PostCallRecordDestroyDescriptorPool(
1225 VkDevice device,
1226 VkDescriptorPool descriptorPool,
1227 const VkAllocationCallbacks* pAllocator);
1228
1229 void PreCallRecordResetDescriptorPool(
1230 VkDevice device,
1231 VkDescriptorPool descriptorPool,
1232 VkDescriptorPoolResetFlags flags);
1233
1234 void PostCallRecordResetDescriptorPool(
1235 VkDevice device,
1236 VkDescriptorPool descriptorPool,
1237 VkDescriptorPoolResetFlags flags,
1238 VkResult result);
1239
1240 void PreCallRecordAllocateDescriptorSets(
1241 VkDevice device,
1242 const VkDescriptorSetAllocateInfo* pAllocateInfo,
1243 VkDescriptorSet* pDescriptorSets);
1244
1245 void PostCallRecordAllocateDescriptorSets(
1246 VkDevice device,
1247 const VkDescriptorSetAllocateInfo* pAllocateInfo,
1248 VkDescriptorSet* pDescriptorSets,
1249 VkResult result);
1250
1251 void PreCallRecordFreeDescriptorSets(
1252 VkDevice device,
1253 VkDescriptorPool descriptorPool,
1254 uint32_t descriptorSetCount,
1255 const VkDescriptorSet* pDescriptorSets);
1256
1257 void PostCallRecordFreeDescriptorSets(
1258 VkDevice device,
1259 VkDescriptorPool descriptorPool,
1260 uint32_t descriptorSetCount,
1261 const VkDescriptorSet* pDescriptorSets,
1262 VkResult result);
1263
1264 void PreCallRecordUpdateDescriptorSets(
1265 VkDevice device,
1266 uint32_t descriptorWriteCount,
1267 const VkWriteDescriptorSet* pDescriptorWrites,
1268 uint32_t descriptorCopyCount,
1269 const VkCopyDescriptorSet* pDescriptorCopies);
1270
1271 void PostCallRecordUpdateDescriptorSets(
1272 VkDevice device,
1273 uint32_t descriptorWriteCount,
1274 const VkWriteDescriptorSet* pDescriptorWrites,
1275 uint32_t descriptorCopyCount,
1276 const VkCopyDescriptorSet* pDescriptorCopies);
1277
1278 void PreCallRecordCreateFramebuffer(
1279 VkDevice device,
1280 const VkFramebufferCreateInfo* pCreateInfo,
1281 const VkAllocationCallbacks* pAllocator,
1282 VkFramebuffer* pFramebuffer);
1283
1284 void PostCallRecordCreateFramebuffer(
1285 VkDevice device,
1286 const VkFramebufferCreateInfo* pCreateInfo,
1287 const VkAllocationCallbacks* pAllocator,
1288 VkFramebuffer* pFramebuffer,
1289 VkResult result);
1290
1291 void PreCallRecordDestroyFramebuffer(
1292 VkDevice device,
1293 VkFramebuffer framebuffer,
1294 const VkAllocationCallbacks* pAllocator);
1295
1296 void PostCallRecordDestroyFramebuffer(
1297 VkDevice device,
1298 VkFramebuffer framebuffer,
1299 const VkAllocationCallbacks* pAllocator);
1300
1301 void PreCallRecordCreateRenderPass(
1302 VkDevice device,
1303 const VkRenderPassCreateInfo* pCreateInfo,
1304 const VkAllocationCallbacks* pAllocator,
1305 VkRenderPass* pRenderPass);
1306
1307 void PostCallRecordCreateRenderPass(
1308 VkDevice device,
1309 const VkRenderPassCreateInfo* pCreateInfo,
1310 const VkAllocationCallbacks* pAllocator,
1311 VkRenderPass* pRenderPass,
1312 VkResult result);
1313
1314 void PreCallRecordDestroyRenderPass(
1315 VkDevice device,
1316 VkRenderPass renderPass,
1317 const VkAllocationCallbacks* pAllocator);
1318
1319 void PostCallRecordDestroyRenderPass(
1320 VkDevice device,
1321 VkRenderPass renderPass,
1322 const VkAllocationCallbacks* pAllocator);
1323
1324 void PreCallRecordGetRenderAreaGranularity(
1325 VkDevice device,
1326 VkRenderPass renderPass,
1327 VkExtent2D* pGranularity);
1328
1329 void PostCallRecordGetRenderAreaGranularity(
1330 VkDevice device,
1331 VkRenderPass renderPass,
1332 VkExtent2D* pGranularity);
1333
1334 void PreCallRecordCreateCommandPool(
1335 VkDevice device,
1336 const VkCommandPoolCreateInfo* pCreateInfo,
1337 const VkAllocationCallbacks* pAllocator,
1338 VkCommandPool* pCommandPool);
1339
1340 void PostCallRecordCreateCommandPool(
1341 VkDevice device,
1342 const VkCommandPoolCreateInfo* pCreateInfo,
1343 const VkAllocationCallbacks* pAllocator,
1344 VkCommandPool* pCommandPool,
1345 VkResult result);
1346
1347 void PreCallRecordDestroyCommandPool(
1348 VkDevice device,
1349 VkCommandPool commandPool,
1350 const VkAllocationCallbacks* pAllocator);
1351
1352 void PostCallRecordDestroyCommandPool(
1353 VkDevice device,
1354 VkCommandPool commandPool,
1355 const VkAllocationCallbacks* pAllocator);
1356
1357 void PreCallRecordResetCommandPool(
1358 VkDevice device,
1359 VkCommandPool commandPool,
1360 VkCommandPoolResetFlags flags);
1361
1362 void PostCallRecordResetCommandPool(
1363 VkDevice device,
1364 VkCommandPool commandPool,
1365 VkCommandPoolResetFlags flags,
1366 VkResult result);
1367
1368 void PreCallRecordAllocateCommandBuffers(
1369 VkDevice device,
1370 const VkCommandBufferAllocateInfo* pAllocateInfo,
1371 VkCommandBuffer* pCommandBuffers);
1372
1373 void PostCallRecordAllocateCommandBuffers(
1374 VkDevice device,
1375 const VkCommandBufferAllocateInfo* pAllocateInfo,
1376 VkCommandBuffer* pCommandBuffers,
1377 VkResult result);
1378
1379 void PreCallRecordFreeCommandBuffers(
1380 VkDevice device,
1381 VkCommandPool commandPool,
1382 uint32_t commandBufferCount,
1383 const VkCommandBuffer* pCommandBuffers);
1384
1385 void PostCallRecordFreeCommandBuffers(
1386 VkDevice device,
1387 VkCommandPool commandPool,
1388 uint32_t commandBufferCount,
1389 const VkCommandBuffer* pCommandBuffers);
1390
1391 void PreCallRecordBeginCommandBuffer(
1392 VkCommandBuffer commandBuffer,
1393 const VkCommandBufferBeginInfo* pBeginInfo);
1394
1395 void PostCallRecordBeginCommandBuffer(
1396 VkCommandBuffer commandBuffer,
1397 const VkCommandBufferBeginInfo* pBeginInfo,
1398 VkResult result);
1399
1400 void PreCallRecordEndCommandBuffer(
1401 VkCommandBuffer commandBuffer);
1402
1403 void PostCallRecordEndCommandBuffer(
1404 VkCommandBuffer commandBuffer,
1405 VkResult result);
1406
1407 void PreCallRecordResetCommandBuffer(
1408 VkCommandBuffer commandBuffer,
1409 VkCommandBufferResetFlags flags);
1410
1411 void PostCallRecordResetCommandBuffer(
1412 VkCommandBuffer commandBuffer,
1413 VkCommandBufferResetFlags flags,
1414 VkResult result);
1415
1416 void PreCallRecordCmdBindPipeline(
1417 VkCommandBuffer commandBuffer,
1418 VkPipelineBindPoint pipelineBindPoint,
1419 VkPipeline pipeline);
1420
1421 void PostCallRecordCmdBindPipeline(
1422 VkCommandBuffer commandBuffer,
1423 VkPipelineBindPoint pipelineBindPoint,
1424 VkPipeline pipeline);
1425
1426 void PreCallRecordCmdSetViewport(
1427 VkCommandBuffer commandBuffer,
1428 uint32_t firstViewport,
1429 uint32_t viewportCount,
1430 const VkViewport* pViewports);
1431
1432 void PostCallRecordCmdSetViewport(
1433 VkCommandBuffer commandBuffer,
1434 uint32_t firstViewport,
1435 uint32_t viewportCount,
1436 const VkViewport* pViewports);
1437
1438 void PreCallRecordCmdSetScissor(
1439 VkCommandBuffer commandBuffer,
1440 uint32_t firstScissor,
1441 uint32_t scissorCount,
1442 const VkRect2D* pScissors);
1443
1444 void PostCallRecordCmdSetScissor(
1445 VkCommandBuffer commandBuffer,
1446 uint32_t firstScissor,
1447 uint32_t scissorCount,
1448 const VkRect2D* pScissors);
1449
1450 void PreCallRecordCmdSetLineWidth(
1451 VkCommandBuffer commandBuffer,
1452 float lineWidth);
1453
1454 void PostCallRecordCmdSetLineWidth(
1455 VkCommandBuffer commandBuffer,
1456 float lineWidth);
1457
1458 void PreCallRecordCmdSetDepthBias(
1459 VkCommandBuffer commandBuffer,
1460 float depthBiasConstantFactor,
1461 float depthBiasClamp,
1462 float depthBiasSlopeFactor);
1463
1464 void PostCallRecordCmdSetDepthBias(
1465 VkCommandBuffer commandBuffer,
1466 float depthBiasConstantFactor,
1467 float depthBiasClamp,
1468 float depthBiasSlopeFactor);
1469
1470 void PreCallRecordCmdSetBlendConstants(
1471 VkCommandBuffer commandBuffer,
1472 const float blendConstants[4]);
1473
1474 void PostCallRecordCmdSetBlendConstants(
1475 VkCommandBuffer commandBuffer,
1476 const float blendConstants[4]);
1477
1478 void PreCallRecordCmdSetDepthBounds(
1479 VkCommandBuffer commandBuffer,
1480 float minDepthBounds,
1481 float maxDepthBounds);
1482
1483 void PostCallRecordCmdSetDepthBounds(
1484 VkCommandBuffer commandBuffer,
1485 float minDepthBounds,
1486 float maxDepthBounds);
1487
1488 void PreCallRecordCmdSetStencilCompareMask(
1489 VkCommandBuffer commandBuffer,
1490 VkStencilFaceFlags faceMask,
1491 uint32_t compareMask);
1492
1493 void PostCallRecordCmdSetStencilCompareMask(
1494 VkCommandBuffer commandBuffer,
1495 VkStencilFaceFlags faceMask,
1496 uint32_t compareMask);
1497
1498 void PreCallRecordCmdSetStencilWriteMask(
1499 VkCommandBuffer commandBuffer,
1500 VkStencilFaceFlags faceMask,
1501 uint32_t writeMask);
1502
1503 void PostCallRecordCmdSetStencilWriteMask(
1504 VkCommandBuffer commandBuffer,
1505 VkStencilFaceFlags faceMask,
1506 uint32_t writeMask);
1507
1508 void PreCallRecordCmdSetStencilReference(
1509 VkCommandBuffer commandBuffer,
1510 VkStencilFaceFlags faceMask,
1511 uint32_t reference);
1512
1513 void PostCallRecordCmdSetStencilReference(
1514 VkCommandBuffer commandBuffer,
1515 VkStencilFaceFlags faceMask,
1516 uint32_t reference);
1517
1518 void PreCallRecordCmdBindDescriptorSets(
1519 VkCommandBuffer commandBuffer,
1520 VkPipelineBindPoint pipelineBindPoint,
1521 VkPipelineLayout layout,
1522 uint32_t firstSet,
1523 uint32_t descriptorSetCount,
1524 const VkDescriptorSet* pDescriptorSets,
1525 uint32_t dynamicOffsetCount,
1526 const uint32_t* pDynamicOffsets);
1527
1528 void PostCallRecordCmdBindDescriptorSets(
1529 VkCommandBuffer commandBuffer,
1530 VkPipelineBindPoint pipelineBindPoint,
1531 VkPipelineLayout layout,
1532 uint32_t firstSet,
1533 uint32_t descriptorSetCount,
1534 const VkDescriptorSet* pDescriptorSets,
1535 uint32_t dynamicOffsetCount,
1536 const uint32_t* pDynamicOffsets);
1537
1538 void PreCallRecordCmdBindIndexBuffer(
1539 VkCommandBuffer commandBuffer,
1540 VkBuffer buffer,
1541 VkDeviceSize offset,
1542 VkIndexType indexType);
1543
1544 void PostCallRecordCmdBindIndexBuffer(
1545 VkCommandBuffer commandBuffer,
1546 VkBuffer buffer,
1547 VkDeviceSize offset,
1548 VkIndexType indexType);
1549
1550 void PreCallRecordCmdBindVertexBuffers(
1551 VkCommandBuffer commandBuffer,
1552 uint32_t firstBinding,
1553 uint32_t bindingCount,
1554 const VkBuffer* pBuffers,
1555 const VkDeviceSize* pOffsets);
1556
1557 void PostCallRecordCmdBindVertexBuffers(
1558 VkCommandBuffer commandBuffer,
1559 uint32_t firstBinding,
1560 uint32_t bindingCount,
1561 const VkBuffer* pBuffers,
1562 const VkDeviceSize* pOffsets);
1563
1564 void PreCallRecordCmdDraw(
1565 VkCommandBuffer commandBuffer,
1566 uint32_t vertexCount,
1567 uint32_t instanceCount,
1568 uint32_t firstVertex,
1569 uint32_t firstInstance);
1570
1571 void PostCallRecordCmdDraw(
1572 VkCommandBuffer commandBuffer,
1573 uint32_t vertexCount,
1574 uint32_t instanceCount,
1575 uint32_t firstVertex,
1576 uint32_t firstInstance);
1577
1578 void PreCallRecordCmdDrawIndexed(
1579 VkCommandBuffer commandBuffer,
1580 uint32_t indexCount,
1581 uint32_t instanceCount,
1582 uint32_t firstIndex,
1583 int32_t vertexOffset,
1584 uint32_t firstInstance);
1585
1586 void PostCallRecordCmdDrawIndexed(
1587 VkCommandBuffer commandBuffer,
1588 uint32_t indexCount,
1589 uint32_t instanceCount,
1590 uint32_t firstIndex,
1591 int32_t vertexOffset,
1592 uint32_t firstInstance);
1593
1594 void PreCallRecordCmdDrawIndirect(
1595 VkCommandBuffer commandBuffer,
1596 VkBuffer buffer,
1597 VkDeviceSize offset,
1598 uint32_t drawCount,
1599 uint32_t stride);
1600
1601 void PostCallRecordCmdDrawIndirect(
1602 VkCommandBuffer commandBuffer,
1603 VkBuffer buffer,
1604 VkDeviceSize offset,
1605 uint32_t drawCount,
1606 uint32_t stride);
1607
1608 void PreCallRecordCmdDrawIndexedIndirect(
1609 VkCommandBuffer commandBuffer,
1610 VkBuffer buffer,
1611 VkDeviceSize offset,
1612 uint32_t drawCount,
1613 uint32_t stride);
1614
1615 void PostCallRecordCmdDrawIndexedIndirect(
1616 VkCommandBuffer commandBuffer,
1617 VkBuffer buffer,
1618 VkDeviceSize offset,
1619 uint32_t drawCount,
1620 uint32_t stride);
1621
1622 void PreCallRecordCmdDispatch(
1623 VkCommandBuffer commandBuffer,
1624 uint32_t groupCountX,
1625 uint32_t groupCountY,
1626 uint32_t groupCountZ);
1627
1628 void PostCallRecordCmdDispatch(
1629 VkCommandBuffer commandBuffer,
1630 uint32_t groupCountX,
1631 uint32_t groupCountY,
1632 uint32_t groupCountZ);
1633
1634 void PreCallRecordCmdDispatchIndirect(
1635 VkCommandBuffer commandBuffer,
1636 VkBuffer buffer,
1637 VkDeviceSize offset);
1638
1639 void PostCallRecordCmdDispatchIndirect(
1640 VkCommandBuffer commandBuffer,
1641 VkBuffer buffer,
1642 VkDeviceSize offset);
1643
1644 void PreCallRecordCmdCopyBuffer(
1645 VkCommandBuffer commandBuffer,
1646 VkBuffer srcBuffer,
1647 VkBuffer dstBuffer,
1648 uint32_t regionCount,
1649 const VkBufferCopy* pRegions);
1650
1651 void PostCallRecordCmdCopyBuffer(
1652 VkCommandBuffer commandBuffer,
1653 VkBuffer srcBuffer,
1654 VkBuffer dstBuffer,
1655 uint32_t regionCount,
1656 const VkBufferCopy* pRegions);
1657
1658 void PreCallRecordCmdCopyImage(
1659 VkCommandBuffer commandBuffer,
1660 VkImage srcImage,
1661 VkImageLayout srcImageLayout,
1662 VkImage dstImage,
1663 VkImageLayout dstImageLayout,
1664 uint32_t regionCount,
1665 const VkImageCopy* pRegions);
1666
1667 void PostCallRecordCmdCopyImage(
1668 VkCommandBuffer commandBuffer,
1669 VkImage srcImage,
1670 VkImageLayout srcImageLayout,
1671 VkImage dstImage,
1672 VkImageLayout dstImageLayout,
1673 uint32_t regionCount,
1674 const VkImageCopy* pRegions);
1675
1676 void PreCallRecordCmdBlitImage(
1677 VkCommandBuffer commandBuffer,
1678 VkImage srcImage,
1679 VkImageLayout srcImageLayout,
1680 VkImage dstImage,
1681 VkImageLayout dstImageLayout,
1682 uint32_t regionCount,
1683 const VkImageBlit* pRegions,
1684 VkFilter filter);
1685
1686 void PostCallRecordCmdBlitImage(
1687 VkCommandBuffer commandBuffer,
1688 VkImage srcImage,
1689 VkImageLayout srcImageLayout,
1690 VkImage dstImage,
1691 VkImageLayout dstImageLayout,
1692 uint32_t regionCount,
1693 const VkImageBlit* pRegions,
1694 VkFilter filter);
1695
1696 void PreCallRecordCmdCopyBufferToImage(
1697 VkCommandBuffer commandBuffer,
1698 VkBuffer srcBuffer,
1699 VkImage dstImage,
1700 VkImageLayout dstImageLayout,
1701 uint32_t regionCount,
1702 const VkBufferImageCopy* pRegions);
1703
1704 void PostCallRecordCmdCopyBufferToImage(
1705 VkCommandBuffer commandBuffer,
1706 VkBuffer srcBuffer,
1707 VkImage dstImage,
1708 VkImageLayout dstImageLayout,
1709 uint32_t regionCount,
1710 const VkBufferImageCopy* pRegions);
1711
1712 void PreCallRecordCmdCopyImageToBuffer(
1713 VkCommandBuffer commandBuffer,
1714 VkImage srcImage,
1715 VkImageLayout srcImageLayout,
1716 VkBuffer dstBuffer,
1717 uint32_t regionCount,
1718 const VkBufferImageCopy* pRegions);
1719
1720 void PostCallRecordCmdCopyImageToBuffer(
1721 VkCommandBuffer commandBuffer,
1722 VkImage srcImage,
1723 VkImageLayout srcImageLayout,
1724 VkBuffer dstBuffer,
1725 uint32_t regionCount,
1726 const VkBufferImageCopy* pRegions);
1727
1728 void PreCallRecordCmdUpdateBuffer(
1729 VkCommandBuffer commandBuffer,
1730 VkBuffer dstBuffer,
1731 VkDeviceSize dstOffset,
1732 VkDeviceSize dataSize,
1733 const void* pData);
1734
1735 void PostCallRecordCmdUpdateBuffer(
1736 VkCommandBuffer commandBuffer,
1737 VkBuffer dstBuffer,
1738 VkDeviceSize dstOffset,
1739 VkDeviceSize dataSize,
1740 const void* pData);
1741
1742 void PreCallRecordCmdFillBuffer(
1743 VkCommandBuffer commandBuffer,
1744 VkBuffer dstBuffer,
1745 VkDeviceSize dstOffset,
1746 VkDeviceSize size,
1747 uint32_t data);
1748
1749 void PostCallRecordCmdFillBuffer(
1750 VkCommandBuffer commandBuffer,
1751 VkBuffer dstBuffer,
1752 VkDeviceSize dstOffset,
1753 VkDeviceSize size,
1754 uint32_t data);
1755
1756 void PreCallRecordCmdClearColorImage(
1757 VkCommandBuffer commandBuffer,
1758 VkImage image,
1759 VkImageLayout imageLayout,
1760 const VkClearColorValue* pColor,
1761 uint32_t rangeCount,
1762 const VkImageSubresourceRange* pRanges);
1763
1764 void PostCallRecordCmdClearColorImage(
1765 VkCommandBuffer commandBuffer,
1766 VkImage image,
1767 VkImageLayout imageLayout,
1768 const VkClearColorValue* pColor,
1769 uint32_t rangeCount,
1770 const VkImageSubresourceRange* pRanges);
1771
1772 void PreCallRecordCmdClearDepthStencilImage(
1773 VkCommandBuffer commandBuffer,
1774 VkImage image,
1775 VkImageLayout imageLayout,
1776 const VkClearDepthStencilValue* pDepthStencil,
1777 uint32_t rangeCount,
1778 const VkImageSubresourceRange* pRanges);
1779
1780 void PostCallRecordCmdClearDepthStencilImage(
1781 VkCommandBuffer commandBuffer,
1782 VkImage image,
1783 VkImageLayout imageLayout,
1784 const VkClearDepthStencilValue* pDepthStencil,
1785 uint32_t rangeCount,
1786 const VkImageSubresourceRange* pRanges);
1787
1788 void PreCallRecordCmdClearAttachments(
1789 VkCommandBuffer commandBuffer,
1790 uint32_t attachmentCount,
1791 const VkClearAttachment* pAttachments,
1792 uint32_t rectCount,
1793 const VkClearRect* pRects);
1794
1795 void PostCallRecordCmdClearAttachments(
1796 VkCommandBuffer commandBuffer,
1797 uint32_t attachmentCount,
1798 const VkClearAttachment* pAttachments,
1799 uint32_t rectCount,
1800 const VkClearRect* pRects);
1801
1802 void PreCallRecordCmdResolveImage(
1803 VkCommandBuffer commandBuffer,
1804 VkImage srcImage,
1805 VkImageLayout srcImageLayout,
1806 VkImage dstImage,
1807 VkImageLayout dstImageLayout,
1808 uint32_t regionCount,
1809 const VkImageResolve* pRegions);
1810
1811 void PostCallRecordCmdResolveImage(
1812 VkCommandBuffer commandBuffer,
1813 VkImage srcImage,
1814 VkImageLayout srcImageLayout,
1815 VkImage dstImage,
1816 VkImageLayout dstImageLayout,
1817 uint32_t regionCount,
1818 const VkImageResolve* pRegions);
1819
1820 void PreCallRecordCmdSetEvent(
1821 VkCommandBuffer commandBuffer,
1822 VkEvent event,
1823 VkPipelineStageFlags stageMask);
1824
1825 void PostCallRecordCmdSetEvent(
1826 VkCommandBuffer commandBuffer,
1827 VkEvent event,
1828 VkPipelineStageFlags stageMask);
1829
1830 void PreCallRecordCmdResetEvent(
1831 VkCommandBuffer commandBuffer,
1832 VkEvent event,
1833 VkPipelineStageFlags stageMask);
1834
1835 void PostCallRecordCmdResetEvent(
1836 VkCommandBuffer commandBuffer,
1837 VkEvent event,
1838 VkPipelineStageFlags stageMask);
1839
1840 void PreCallRecordCmdWaitEvents(
1841 VkCommandBuffer commandBuffer,
1842 uint32_t eventCount,
1843 const VkEvent* pEvents,
1844 VkPipelineStageFlags srcStageMask,
1845 VkPipelineStageFlags dstStageMask,
1846 uint32_t memoryBarrierCount,
1847 const VkMemoryBarrier* pMemoryBarriers,
1848 uint32_t bufferMemoryBarrierCount,
1849 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1850 uint32_t imageMemoryBarrierCount,
1851 const VkImageMemoryBarrier* pImageMemoryBarriers);
1852
1853 void PostCallRecordCmdWaitEvents(
1854 VkCommandBuffer commandBuffer,
1855 uint32_t eventCount,
1856 const VkEvent* pEvents,
1857 VkPipelineStageFlags srcStageMask,
1858 VkPipelineStageFlags dstStageMask,
1859 uint32_t memoryBarrierCount,
1860 const VkMemoryBarrier* pMemoryBarriers,
1861 uint32_t bufferMemoryBarrierCount,
1862 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1863 uint32_t imageMemoryBarrierCount,
1864 const VkImageMemoryBarrier* pImageMemoryBarriers);
1865
1866 void PreCallRecordCmdPipelineBarrier(
1867 VkCommandBuffer commandBuffer,
1868 VkPipelineStageFlags srcStageMask,
1869 VkPipelineStageFlags dstStageMask,
1870 VkDependencyFlags dependencyFlags,
1871 uint32_t memoryBarrierCount,
1872 const VkMemoryBarrier* pMemoryBarriers,
1873 uint32_t bufferMemoryBarrierCount,
1874 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1875 uint32_t imageMemoryBarrierCount,
1876 const VkImageMemoryBarrier* pImageMemoryBarriers);
1877
1878 void PostCallRecordCmdPipelineBarrier(
1879 VkCommandBuffer commandBuffer,
1880 VkPipelineStageFlags srcStageMask,
1881 VkPipelineStageFlags dstStageMask,
1882 VkDependencyFlags dependencyFlags,
1883 uint32_t memoryBarrierCount,
1884 const VkMemoryBarrier* pMemoryBarriers,
1885 uint32_t bufferMemoryBarrierCount,
1886 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1887 uint32_t imageMemoryBarrierCount,
1888 const VkImageMemoryBarrier* pImageMemoryBarriers);
1889
1890 void PreCallRecordCmdBeginQuery(
1891 VkCommandBuffer commandBuffer,
1892 VkQueryPool queryPool,
1893 uint32_t query,
1894 VkQueryControlFlags flags);
1895
1896 void PostCallRecordCmdBeginQuery(
1897 VkCommandBuffer commandBuffer,
1898 VkQueryPool queryPool,
1899 uint32_t query,
1900 VkQueryControlFlags flags);
1901
1902 void PreCallRecordCmdEndQuery(
1903 VkCommandBuffer commandBuffer,
1904 VkQueryPool queryPool,
1905 uint32_t query);
1906
1907 void PostCallRecordCmdEndQuery(
1908 VkCommandBuffer commandBuffer,
1909 VkQueryPool queryPool,
1910 uint32_t query);
1911
1912 void PreCallRecordCmdResetQueryPool(
1913 VkCommandBuffer commandBuffer,
1914 VkQueryPool queryPool,
1915 uint32_t firstQuery,
1916 uint32_t queryCount);
1917
1918 void PostCallRecordCmdResetQueryPool(
1919 VkCommandBuffer commandBuffer,
1920 VkQueryPool queryPool,
1921 uint32_t firstQuery,
1922 uint32_t queryCount);
1923
1924 void PreCallRecordCmdWriteTimestamp(
1925 VkCommandBuffer commandBuffer,
1926 VkPipelineStageFlagBits pipelineStage,
1927 VkQueryPool queryPool,
1928 uint32_t query);
1929
1930 void PostCallRecordCmdWriteTimestamp(
1931 VkCommandBuffer commandBuffer,
1932 VkPipelineStageFlagBits pipelineStage,
1933 VkQueryPool queryPool,
1934 uint32_t query);
1935
1936 void PreCallRecordCmdCopyQueryPoolResults(
1937 VkCommandBuffer commandBuffer,
1938 VkQueryPool queryPool,
1939 uint32_t firstQuery,
1940 uint32_t queryCount,
1941 VkBuffer dstBuffer,
1942 VkDeviceSize dstOffset,
1943 VkDeviceSize stride,
1944 VkQueryResultFlags flags);
1945
1946 void PostCallRecordCmdCopyQueryPoolResults(
1947 VkCommandBuffer commandBuffer,
1948 VkQueryPool queryPool,
1949 uint32_t firstQuery,
1950 uint32_t queryCount,
1951 VkBuffer dstBuffer,
1952 VkDeviceSize dstOffset,
1953 VkDeviceSize stride,
1954 VkQueryResultFlags flags);
1955
1956 void PreCallRecordCmdPushConstants(
1957 VkCommandBuffer commandBuffer,
1958 VkPipelineLayout layout,
1959 VkShaderStageFlags stageFlags,
1960 uint32_t offset,
1961 uint32_t size,
1962 const void* pValues);
1963
1964 void PostCallRecordCmdPushConstants(
1965 VkCommandBuffer commandBuffer,
1966 VkPipelineLayout layout,
1967 VkShaderStageFlags stageFlags,
1968 uint32_t offset,
1969 uint32_t size,
1970 const void* pValues);
1971
1972 void PreCallRecordCmdBeginRenderPass(
1973 VkCommandBuffer commandBuffer,
1974 const VkRenderPassBeginInfo* pRenderPassBegin,
1975 VkSubpassContents contents);
1976
1977 void PostCallRecordCmdBeginRenderPass(
1978 VkCommandBuffer commandBuffer,
1979 const VkRenderPassBeginInfo* pRenderPassBegin,
1980 VkSubpassContents contents);
1981
1982 void PreCallRecordCmdNextSubpass(
1983 VkCommandBuffer commandBuffer,
1984 VkSubpassContents contents);
1985
1986 void PostCallRecordCmdNextSubpass(
1987 VkCommandBuffer commandBuffer,
1988 VkSubpassContents contents);
1989
1990 void PreCallRecordCmdEndRenderPass(
1991 VkCommandBuffer commandBuffer);
1992
1993 void PostCallRecordCmdEndRenderPass(
1994 VkCommandBuffer commandBuffer);
1995
1996 void PreCallRecordCmdExecuteCommands(
1997 VkCommandBuffer commandBuffer,
1998 uint32_t commandBufferCount,
1999 const VkCommandBuffer* pCommandBuffers);
2000
2001 void PostCallRecordCmdExecuteCommands(
2002 VkCommandBuffer commandBuffer,
2003 uint32_t commandBufferCount,
2004 const VkCommandBuffer* pCommandBuffers);
2005
2006 void PreCallRecordBindBufferMemory2(
2007 VkDevice device,
2008 uint32_t bindInfoCount,
2009 const VkBindBufferMemoryInfo* pBindInfos);
2010
2011 void PostCallRecordBindBufferMemory2(
2012 VkDevice device,
2013 uint32_t bindInfoCount,
2014 const VkBindBufferMemoryInfo* pBindInfos,
2015 VkResult result);
2016
2017 void PreCallRecordBindImageMemory2(
2018 VkDevice device,
2019 uint32_t bindInfoCount,
2020 const VkBindImageMemoryInfo* pBindInfos);
2021
2022 void PostCallRecordBindImageMemory2(
2023 VkDevice device,
2024 uint32_t bindInfoCount,
2025 const VkBindImageMemoryInfo* pBindInfos,
2026 VkResult result);
2027
2028 void PreCallRecordGetDeviceGroupPeerMemoryFeatures(
2029 VkDevice device,
2030 uint32_t heapIndex,
2031 uint32_t localDeviceIndex,
2032 uint32_t remoteDeviceIndex,
2033 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
2034
2035 void PostCallRecordGetDeviceGroupPeerMemoryFeatures(
2036 VkDevice device,
2037 uint32_t heapIndex,
2038 uint32_t localDeviceIndex,
2039 uint32_t remoteDeviceIndex,
2040 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
2041
2042 void PreCallRecordCmdSetDeviceMask(
2043 VkCommandBuffer commandBuffer,
2044 uint32_t deviceMask);
2045
2046 void PostCallRecordCmdSetDeviceMask(
2047 VkCommandBuffer commandBuffer,
2048 uint32_t deviceMask);
2049
2050 void PreCallRecordCmdDispatchBase(
2051 VkCommandBuffer commandBuffer,
2052 uint32_t baseGroupX,
2053 uint32_t baseGroupY,
2054 uint32_t baseGroupZ,
2055 uint32_t groupCountX,
2056 uint32_t groupCountY,
2057 uint32_t groupCountZ);
2058
2059 void PostCallRecordCmdDispatchBase(
2060 VkCommandBuffer commandBuffer,
2061 uint32_t baseGroupX,
2062 uint32_t baseGroupY,
2063 uint32_t baseGroupZ,
2064 uint32_t groupCountX,
2065 uint32_t groupCountY,
2066 uint32_t groupCountZ);
2067
2068 void PreCallRecordEnumeratePhysicalDeviceGroups(
2069 VkInstance instance,
2070 uint32_t* pPhysicalDeviceGroupCount,
2071 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
2072
2073 void PostCallRecordEnumeratePhysicalDeviceGroups(
2074 VkInstance instance,
2075 uint32_t* pPhysicalDeviceGroupCount,
2076 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
2077 VkResult result);
2078
2079 void PreCallRecordGetImageMemoryRequirements2(
2080 VkDevice device,
2081 const VkImageMemoryRequirementsInfo2* pInfo,
2082 VkMemoryRequirements2* pMemoryRequirements);
2083
2084 void PostCallRecordGetImageMemoryRequirements2(
2085 VkDevice device,
2086 const VkImageMemoryRequirementsInfo2* pInfo,
2087 VkMemoryRequirements2* pMemoryRequirements);
2088
2089 void PreCallRecordGetBufferMemoryRequirements2(
2090 VkDevice device,
2091 const VkBufferMemoryRequirementsInfo2* pInfo,
2092 VkMemoryRequirements2* pMemoryRequirements);
2093
2094 void PostCallRecordGetBufferMemoryRequirements2(
2095 VkDevice device,
2096 const VkBufferMemoryRequirementsInfo2* pInfo,
2097 VkMemoryRequirements2* pMemoryRequirements);
2098
2099 void PreCallRecordGetImageSparseMemoryRequirements2(
2100 VkDevice device,
2101 const VkImageSparseMemoryRequirementsInfo2* pInfo,
2102 uint32_t* pSparseMemoryRequirementCount,
2103 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
2104
2105 void PostCallRecordGetImageSparseMemoryRequirements2(
2106 VkDevice device,
2107 const VkImageSparseMemoryRequirementsInfo2* pInfo,
2108 uint32_t* pSparseMemoryRequirementCount,
2109 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
2110
2111 void PreCallRecordTrimCommandPool(
2112 VkDevice device,
2113 VkCommandPool commandPool,
2114 VkCommandPoolTrimFlags flags);
2115
2116 void PostCallRecordTrimCommandPool(
2117 VkDevice device,
2118 VkCommandPool commandPool,
2119 VkCommandPoolTrimFlags flags);
2120
2121 void PreCallRecordGetDeviceQueue2(
2122 VkDevice device,
2123 const VkDeviceQueueInfo2* pQueueInfo,
2124 VkQueue* pQueue);
2125
2126 void PostCallRecordGetDeviceQueue2(
2127 VkDevice device,
2128 const VkDeviceQueueInfo2* pQueueInfo,
2129 VkQueue* pQueue);
2130
2131 void PreCallRecordCreateSamplerYcbcrConversion(
2132 VkDevice device,
2133 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
2134 const VkAllocationCallbacks* pAllocator,
2135 VkSamplerYcbcrConversion* pYcbcrConversion);
2136
2137 void PostCallRecordCreateSamplerYcbcrConversion(
2138 VkDevice device,
2139 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
2140 const VkAllocationCallbacks* pAllocator,
2141 VkSamplerYcbcrConversion* pYcbcrConversion,
2142 VkResult result);
2143
2144 void PreCallRecordDestroySamplerYcbcrConversion(
2145 VkDevice device,
2146 VkSamplerYcbcrConversion ycbcrConversion,
2147 const VkAllocationCallbacks* pAllocator);
2148
2149 void PostCallRecordDestroySamplerYcbcrConversion(
2150 VkDevice device,
2151 VkSamplerYcbcrConversion ycbcrConversion,
2152 const VkAllocationCallbacks* pAllocator);
2153
2154 void PreCallRecordCreateDescriptorUpdateTemplate(
2155 VkDevice device,
2156 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
2157 const VkAllocationCallbacks* pAllocator,
2158 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
2159
2160 void PostCallRecordCreateDescriptorUpdateTemplate(
2161 VkDevice device,
2162 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
2163 const VkAllocationCallbacks* pAllocator,
2164 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
2165 VkResult result);
2166
2167 void PreCallRecordDestroyDescriptorUpdateTemplate(
2168 VkDevice device,
2169 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2170 const VkAllocationCallbacks* pAllocator);
2171
2172 void PostCallRecordDestroyDescriptorUpdateTemplate(
2173 VkDevice device,
2174 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2175 const VkAllocationCallbacks* pAllocator);
2176
2177 void PreCallRecordUpdateDescriptorSetWithTemplate(
2178 VkDevice device,
2179 VkDescriptorSet descriptorSet,
2180 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2181 const void* pData);
2182
2183 void PostCallRecordUpdateDescriptorSetWithTemplate(
2184 VkDevice device,
2185 VkDescriptorSet descriptorSet,
2186 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2187 const void* pData);
2188
2189 void PreCallRecordGetDescriptorSetLayoutSupport(
2190 VkDevice device,
2191 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
2192 VkDescriptorSetLayoutSupport* pSupport);
2193
2194 void PostCallRecordGetDescriptorSetLayoutSupport(
2195 VkDevice device,
2196 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
2197 VkDescriptorSetLayoutSupport* pSupport);
2198
2199 void PreCallRecordDestroySurfaceKHR(
2200 VkInstance instance,
2201 VkSurfaceKHR surface,
2202 const VkAllocationCallbacks* pAllocator);
2203
2204 void PostCallRecordDestroySurfaceKHR(
2205 VkInstance instance,
2206 VkSurfaceKHR surface,
2207 const VkAllocationCallbacks* pAllocator);
2208
2209 void PreCallRecordGetPhysicalDeviceSurfaceSupportKHR(
2210 VkPhysicalDevice physicalDevice,
2211 uint32_t queueFamilyIndex,
2212 VkSurfaceKHR surface,
2213 VkBool32* pSupported);
2214
2215 void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(
2216 VkPhysicalDevice physicalDevice,
2217 uint32_t queueFamilyIndex,
2218 VkSurfaceKHR surface,
2219 VkBool32* pSupported,
2220 VkResult result);
2221
2222 void PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(
2223 VkPhysicalDevice physicalDevice,
2224 VkSurfaceKHR surface,
2225 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
2226
2227 void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(
2228 VkPhysicalDevice physicalDevice,
2229 VkSurfaceKHR surface,
2230 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities,
2231 VkResult result);
2232
2233 void PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR(
2234 VkPhysicalDevice physicalDevice,
2235 VkSurfaceKHR surface,
2236 uint32_t* pSurfaceFormatCount,
2237 VkSurfaceFormatKHR* pSurfaceFormats);
2238
2239 void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(
2240 VkPhysicalDevice physicalDevice,
2241 VkSurfaceKHR surface,
2242 uint32_t* pSurfaceFormatCount,
2243 VkSurfaceFormatKHR* pSurfaceFormats,
2244 VkResult result);
2245
2246 void PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR(
2247 VkPhysicalDevice physicalDevice,
2248 VkSurfaceKHR surface,
2249 uint32_t* pPresentModeCount,
2250 VkPresentModeKHR* pPresentModes);
2251
2252 void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(
2253 VkPhysicalDevice physicalDevice,
2254 VkSurfaceKHR surface,
2255 uint32_t* pPresentModeCount,
2256 VkPresentModeKHR* pPresentModes,
2257 VkResult result);
2258
2259 void PreCallRecordCreateSwapchainKHR(
2260 VkDevice device,
2261 const VkSwapchainCreateInfoKHR* pCreateInfo,
2262 const VkAllocationCallbacks* pAllocator,
2263 VkSwapchainKHR* pSwapchain);
2264
2265 void PostCallRecordCreateSwapchainKHR(
2266 VkDevice device,
2267 const VkSwapchainCreateInfoKHR* pCreateInfo,
2268 const VkAllocationCallbacks* pAllocator,
2269 VkSwapchainKHR* pSwapchain,
2270 VkResult result);
2271
2272 void PreCallRecordDestroySwapchainKHR(
2273 VkDevice device,
2274 VkSwapchainKHR swapchain,
2275 const VkAllocationCallbacks* pAllocator);
2276
2277 void PostCallRecordDestroySwapchainKHR(
2278 VkDevice device,
2279 VkSwapchainKHR swapchain,
2280 const VkAllocationCallbacks* pAllocator);
2281
2282 void PreCallRecordGetSwapchainImagesKHR(
2283 VkDevice device,
2284 VkSwapchainKHR swapchain,
2285 uint32_t* pSwapchainImageCount,
2286 VkImage* pSwapchainImages);
2287
2288 void PostCallRecordGetSwapchainImagesKHR(
2289 VkDevice device,
2290 VkSwapchainKHR swapchain,
2291 uint32_t* pSwapchainImageCount,
2292 VkImage* pSwapchainImages,
2293 VkResult result);
2294
2295 void PreCallRecordAcquireNextImageKHR(
2296 VkDevice device,
2297 VkSwapchainKHR swapchain,
2298 uint64_t timeout,
2299 VkSemaphore semaphore,
2300 VkFence fence,
2301 uint32_t* pImageIndex);
2302
2303 void PostCallRecordAcquireNextImageKHR(
2304 VkDevice device,
2305 VkSwapchainKHR swapchain,
2306 uint64_t timeout,
2307 VkSemaphore semaphore,
2308 VkFence fence,
2309 uint32_t* pImageIndex,
2310 VkResult result);
2311
2312 void PreCallRecordGetDeviceGroupPresentCapabilitiesKHR(
2313 VkDevice device,
2314 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
2315
2316 void PostCallRecordGetDeviceGroupPresentCapabilitiesKHR(
2317 VkDevice device,
2318 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities,
2319 VkResult result);
2320
2321 void PreCallRecordGetDeviceGroupSurfacePresentModesKHR(
2322 VkDevice device,
2323 VkSurfaceKHR surface,
2324 VkDeviceGroupPresentModeFlagsKHR* pModes);
2325
2326 void PostCallRecordGetDeviceGroupSurfacePresentModesKHR(
2327 VkDevice device,
2328 VkSurfaceKHR surface,
2329 VkDeviceGroupPresentModeFlagsKHR* pModes,
2330 VkResult result);
2331
2332 void PreCallRecordGetPhysicalDevicePresentRectanglesKHR(
2333 VkPhysicalDevice physicalDevice,
2334 VkSurfaceKHR surface,
2335 uint32_t* pRectCount,
2336 VkRect2D* pRects);
2337
2338 void PostCallRecordGetPhysicalDevicePresentRectanglesKHR(
2339 VkPhysicalDevice physicalDevice,
2340 VkSurfaceKHR surface,
2341 uint32_t* pRectCount,
2342 VkRect2D* pRects,
2343 VkResult result);
2344
2345 void PreCallRecordAcquireNextImage2KHR(
2346 VkDevice device,
2347 const VkAcquireNextImageInfoKHR* pAcquireInfo,
2348 uint32_t* pImageIndex);
2349
2350 void PostCallRecordAcquireNextImage2KHR(
2351 VkDevice device,
2352 const VkAcquireNextImageInfoKHR* pAcquireInfo,
2353 uint32_t* pImageIndex,
2354 VkResult result);
2355
2356 void PreCallRecordGetDisplayPlaneSupportedDisplaysKHR(
2357 VkPhysicalDevice physicalDevice,
2358 uint32_t planeIndex,
2359 uint32_t* pDisplayCount,
2360 VkDisplayKHR* pDisplays);
2361
2362 void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(
2363 VkPhysicalDevice physicalDevice,
2364 uint32_t planeIndex,
2365 uint32_t* pDisplayCount,
2366 VkDisplayKHR* pDisplays,
2367 VkResult result);
2368
2369 void PreCallRecordGetDisplayModePropertiesKHR(
2370 VkPhysicalDevice physicalDevice,
2371 VkDisplayKHR display,
2372 uint32_t* pPropertyCount,
2373 VkDisplayModePropertiesKHR* pProperties);
2374
2375 void PostCallRecordGetDisplayModePropertiesKHR(
2376 VkPhysicalDevice physicalDevice,
2377 VkDisplayKHR display,
2378 uint32_t* pPropertyCount,
2379 VkDisplayModePropertiesKHR* pProperties,
2380 VkResult result);
2381
2382 void PreCallRecordCreateDisplayModeKHR(
2383 VkPhysicalDevice physicalDevice,
2384 VkDisplayKHR display,
2385 const VkDisplayModeCreateInfoKHR* pCreateInfo,
2386 const VkAllocationCallbacks* pAllocator,
2387 VkDisplayModeKHR* pMode);
2388
2389 void PostCallRecordCreateDisplayModeKHR(
2390 VkPhysicalDevice physicalDevice,
2391 VkDisplayKHR display,
2392 const VkDisplayModeCreateInfoKHR* pCreateInfo,
2393 const VkAllocationCallbacks* pAllocator,
2394 VkDisplayModeKHR* pMode,
2395 VkResult result);
2396
2397 void PreCallRecordGetDisplayPlaneCapabilitiesKHR(
2398 VkPhysicalDevice physicalDevice,
2399 VkDisplayModeKHR mode,
2400 uint32_t planeIndex,
2401 VkDisplayPlaneCapabilitiesKHR* pCapabilities);
2402
2403 void PostCallRecordGetDisplayPlaneCapabilitiesKHR(
2404 VkPhysicalDevice physicalDevice,
2405 VkDisplayModeKHR mode,
2406 uint32_t planeIndex,
2407 VkDisplayPlaneCapabilitiesKHR* pCapabilities,
2408 VkResult result);
2409
2410 void PreCallRecordCreateDisplayPlaneSurfaceKHR(
2411 VkInstance instance,
2412 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
2413 const VkAllocationCallbacks* pAllocator,
2414 VkSurfaceKHR* pSurface);
2415
2416 void PostCallRecordCreateDisplayPlaneSurfaceKHR(
2417 VkInstance instance,
2418 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
2419 const VkAllocationCallbacks* pAllocator,
2420 VkSurfaceKHR* pSurface,
2421 VkResult result);
2422
2423 void PreCallRecordCreateSharedSwapchainsKHR(
2424 VkDevice device,
2425 uint32_t swapchainCount,
2426 const VkSwapchainCreateInfoKHR* pCreateInfos,
2427 const VkAllocationCallbacks* pAllocator,
2428 VkSwapchainKHR* pSwapchains);
2429
2430 void PostCallRecordCreateSharedSwapchainsKHR(
2431 VkDevice device,
2432 uint32_t swapchainCount,
2433 const VkSwapchainCreateInfoKHR* pCreateInfos,
2434 const VkAllocationCallbacks* pAllocator,
2435 VkSwapchainKHR* pSwapchains,
2436 VkResult result);
2437
2438 #ifdef VK_USE_PLATFORM_XLIB_KHR
2439
2440 void PreCallRecordCreateXlibSurfaceKHR(
2441 VkInstance instance,
2442 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
2443 const VkAllocationCallbacks* pAllocator,
2444 VkSurfaceKHR* pSurface);
2445
2446 void PostCallRecordCreateXlibSurfaceKHR(
2447 VkInstance instance,
2448 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
2449 const VkAllocationCallbacks* pAllocator,
2450 VkSurfaceKHR* pSurface,
2451 VkResult result);
2452 #endif // VK_USE_PLATFORM_XLIB_KHR
2453
2454 #ifdef VK_USE_PLATFORM_XCB_KHR
2455
2456 void PreCallRecordCreateXcbSurfaceKHR(
2457 VkInstance instance,
2458 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
2459 const VkAllocationCallbacks* pAllocator,
2460 VkSurfaceKHR* pSurface);
2461
2462 void PostCallRecordCreateXcbSurfaceKHR(
2463 VkInstance instance,
2464 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
2465 const VkAllocationCallbacks* pAllocator,
2466 VkSurfaceKHR* pSurface,
2467 VkResult result);
2468 #endif // VK_USE_PLATFORM_XCB_KHR
2469
2470 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
2471
2472 void PreCallRecordCreateWaylandSurfaceKHR(
2473 VkInstance instance,
2474 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
2475 const VkAllocationCallbacks* pAllocator,
2476 VkSurfaceKHR* pSurface);
2477
2478 void PostCallRecordCreateWaylandSurfaceKHR(
2479 VkInstance instance,
2480 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
2481 const VkAllocationCallbacks* pAllocator,
2482 VkSurfaceKHR* pSurface,
2483 VkResult result);
2484 #endif // VK_USE_PLATFORM_WAYLAND_KHR
2485
2486 #ifdef VK_USE_PLATFORM_ANDROID_KHR
2487
2488 void PreCallRecordCreateAndroidSurfaceKHR(
2489 VkInstance instance,
2490 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
2491 const VkAllocationCallbacks* pAllocator,
2492 VkSurfaceKHR* pSurface);
2493
2494 void PostCallRecordCreateAndroidSurfaceKHR(
2495 VkInstance instance,
2496 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
2497 const VkAllocationCallbacks* pAllocator,
2498 VkSurfaceKHR* pSurface,
2499 VkResult result);
2500 #endif // VK_USE_PLATFORM_ANDROID_KHR
2501
2502 #ifdef VK_USE_PLATFORM_WIN32_KHR
2503
2504 void PreCallRecordCreateWin32SurfaceKHR(
2505 VkInstance instance,
2506 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
2507 const VkAllocationCallbacks* pAllocator,
2508 VkSurfaceKHR* pSurface);
2509
2510 void PostCallRecordCreateWin32SurfaceKHR(
2511 VkInstance instance,
2512 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
2513 const VkAllocationCallbacks* pAllocator,
2514 VkSurfaceKHR* pSurface,
2515 VkResult result);
2516 #endif // VK_USE_PLATFORM_WIN32_KHR
2517
2518 void PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(
2519 VkDevice device,
2520 uint32_t heapIndex,
2521 uint32_t localDeviceIndex,
2522 uint32_t remoteDeviceIndex,
2523 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
2524
2525 void PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(
2526 VkDevice device,
2527 uint32_t heapIndex,
2528 uint32_t localDeviceIndex,
2529 uint32_t remoteDeviceIndex,
2530 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
2531
2532 void PreCallRecordCmdSetDeviceMaskKHR(
2533 VkCommandBuffer commandBuffer,
2534 uint32_t deviceMask);
2535
2536 void PostCallRecordCmdSetDeviceMaskKHR(
2537 VkCommandBuffer commandBuffer,
2538 uint32_t deviceMask);
2539
2540 void PreCallRecordCmdDispatchBaseKHR(
2541 VkCommandBuffer commandBuffer,
2542 uint32_t baseGroupX,
2543 uint32_t baseGroupY,
2544 uint32_t baseGroupZ,
2545 uint32_t groupCountX,
2546 uint32_t groupCountY,
2547 uint32_t groupCountZ);
2548
2549 void PostCallRecordCmdDispatchBaseKHR(
2550 VkCommandBuffer commandBuffer,
2551 uint32_t baseGroupX,
2552 uint32_t baseGroupY,
2553 uint32_t baseGroupZ,
2554 uint32_t groupCountX,
2555 uint32_t groupCountY,
2556 uint32_t groupCountZ);
2557
2558 void PreCallRecordTrimCommandPoolKHR(
2559 VkDevice device,
2560 VkCommandPool commandPool,
2561 VkCommandPoolTrimFlags flags);
2562
2563 void PostCallRecordTrimCommandPoolKHR(
2564 VkDevice device,
2565 VkCommandPool commandPool,
2566 VkCommandPoolTrimFlags flags);
2567
2568 void PreCallRecordEnumeratePhysicalDeviceGroupsKHR(
2569 VkInstance instance,
2570 uint32_t* pPhysicalDeviceGroupCount,
2571 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
2572
2573 void PostCallRecordEnumeratePhysicalDeviceGroupsKHR(
2574 VkInstance instance,
2575 uint32_t* pPhysicalDeviceGroupCount,
2576 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
2577 VkResult result);
2578
2579 #ifdef VK_USE_PLATFORM_WIN32_KHR
2580
2581 void PreCallRecordGetMemoryWin32HandleKHR(
2582 VkDevice device,
2583 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
2584 HANDLE* pHandle);
2585
2586 void PostCallRecordGetMemoryWin32HandleKHR(
2587 VkDevice device,
2588 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
2589 HANDLE* pHandle,
2590 VkResult result);
2591
2592 void PreCallRecordGetMemoryWin32HandlePropertiesKHR(
2593 VkDevice device,
2594 VkExternalMemoryHandleTypeFlagBits handleType,
2595 HANDLE handle,
2596 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
2597
2598 void PostCallRecordGetMemoryWin32HandlePropertiesKHR(
2599 VkDevice device,
2600 VkExternalMemoryHandleTypeFlagBits handleType,
2601 HANDLE handle,
2602 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties,
2603 VkResult result);
2604 #endif // VK_USE_PLATFORM_WIN32_KHR
2605
2606 void PreCallRecordGetMemoryFdKHR(
2607 VkDevice device,
2608 const VkMemoryGetFdInfoKHR* pGetFdInfo,
2609 int* pFd);
2610
2611 void PostCallRecordGetMemoryFdKHR(
2612 VkDevice device,
2613 const VkMemoryGetFdInfoKHR* pGetFdInfo,
2614 int* pFd,
2615 VkResult result);
2616
2617 void PreCallRecordGetMemoryFdPropertiesKHR(
2618 VkDevice device,
2619 VkExternalMemoryHandleTypeFlagBits handleType,
2620 int fd,
2621 VkMemoryFdPropertiesKHR* pMemoryFdProperties);
2622
2623 void PostCallRecordGetMemoryFdPropertiesKHR(
2624 VkDevice device,
2625 VkExternalMemoryHandleTypeFlagBits handleType,
2626 int fd,
2627 VkMemoryFdPropertiesKHR* pMemoryFdProperties,
2628 VkResult result);
2629
2630 #ifdef VK_USE_PLATFORM_WIN32_KHR
2631 #endif // VK_USE_PLATFORM_WIN32_KHR
2632
2633 #ifdef VK_USE_PLATFORM_WIN32_KHR
2634
2635 void PreCallRecordImportSemaphoreWin32HandleKHR(
2636 VkDevice device,
2637 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
2638
2639 void PostCallRecordImportSemaphoreWin32HandleKHR(
2640 VkDevice device,
2641 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo,
2642 VkResult result);
2643
2644 void PreCallRecordGetSemaphoreWin32HandleKHR(
2645 VkDevice device,
2646 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
2647 HANDLE* pHandle);
2648
2649 void PostCallRecordGetSemaphoreWin32HandleKHR(
2650 VkDevice device,
2651 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
2652 HANDLE* pHandle,
2653 VkResult result);
2654 #endif // VK_USE_PLATFORM_WIN32_KHR
2655
2656 void PreCallRecordImportSemaphoreFdKHR(
2657 VkDevice device,
2658 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
2659
2660 void PostCallRecordImportSemaphoreFdKHR(
2661 VkDevice device,
2662 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
2663 VkResult result);
2664
2665 void PreCallRecordGetSemaphoreFdKHR(
2666 VkDevice device,
2667 const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
2668 int* pFd);
2669
2670 void PostCallRecordGetSemaphoreFdKHR(
2671 VkDevice device,
2672 const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
2673 int* pFd,
2674 VkResult result);
2675
2676 void PreCallRecordCmdPushDescriptorSetKHR(
2677 VkCommandBuffer commandBuffer,
2678 VkPipelineBindPoint pipelineBindPoint,
2679 VkPipelineLayout layout,
2680 uint32_t set,
2681 uint32_t descriptorWriteCount,
2682 const VkWriteDescriptorSet* pDescriptorWrites);
2683
2684 void PostCallRecordCmdPushDescriptorSetKHR(
2685 VkCommandBuffer commandBuffer,
2686 VkPipelineBindPoint pipelineBindPoint,
2687 VkPipelineLayout layout,
2688 uint32_t set,
2689 uint32_t descriptorWriteCount,
2690 const VkWriteDescriptorSet* pDescriptorWrites);
2691
2692 void PreCallRecordCmdPushDescriptorSetWithTemplateKHR(
2693 VkCommandBuffer commandBuffer,
2694 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2695 VkPipelineLayout layout,
2696 uint32_t set,
2697 const void* pData);
2698
2699 void PostCallRecordCmdPushDescriptorSetWithTemplateKHR(
2700 VkCommandBuffer commandBuffer,
2701 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2702 VkPipelineLayout layout,
2703 uint32_t set,
2704 const void* pData);
2705
2706 void PreCallRecordCreateDescriptorUpdateTemplateKHR(
2707 VkDevice device,
2708 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
2709 const VkAllocationCallbacks* pAllocator,
2710 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
2711
2712 void PostCallRecordCreateDescriptorUpdateTemplateKHR(
2713 VkDevice device,
2714 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
2715 const VkAllocationCallbacks* pAllocator,
2716 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
2717 VkResult result);
2718
2719 void PreCallRecordDestroyDescriptorUpdateTemplateKHR(
2720 VkDevice device,
2721 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2722 const VkAllocationCallbacks* pAllocator);
2723
2724 void PostCallRecordDestroyDescriptorUpdateTemplateKHR(
2725 VkDevice device,
2726 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2727 const VkAllocationCallbacks* pAllocator);
2728
2729 void PreCallRecordUpdateDescriptorSetWithTemplateKHR(
2730 VkDevice device,
2731 VkDescriptorSet descriptorSet,
2732 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2733 const void* pData);
2734
2735 void PostCallRecordUpdateDescriptorSetWithTemplateKHR(
2736 VkDevice device,
2737 VkDescriptorSet descriptorSet,
2738 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2739 const void* pData);
2740
2741 void PreCallRecordCreateRenderPass2KHR(
2742 VkDevice device,
2743 const VkRenderPassCreateInfo2KHR* pCreateInfo,
2744 const VkAllocationCallbacks* pAllocator,
2745 VkRenderPass* pRenderPass);
2746
2747 void PostCallRecordCreateRenderPass2KHR(
2748 VkDevice device,
2749 const VkRenderPassCreateInfo2KHR* pCreateInfo,
2750 const VkAllocationCallbacks* pAllocator,
2751 VkRenderPass* pRenderPass,
2752 VkResult result);
2753
2754 void PreCallRecordCmdBeginRenderPass2KHR(
2755 VkCommandBuffer commandBuffer,
2756 const VkRenderPassBeginInfo* pRenderPassBegin,
2757 const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
2758
2759 void PostCallRecordCmdBeginRenderPass2KHR(
2760 VkCommandBuffer commandBuffer,
2761 const VkRenderPassBeginInfo* pRenderPassBegin,
2762 const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
2763
2764 void PreCallRecordCmdNextSubpass2KHR(
2765 VkCommandBuffer commandBuffer,
2766 const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
2767 const VkSubpassEndInfoKHR* pSubpassEndInfo);
2768
2769 void PostCallRecordCmdNextSubpass2KHR(
2770 VkCommandBuffer commandBuffer,
2771 const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
2772 const VkSubpassEndInfoKHR* pSubpassEndInfo);
2773
2774 void PreCallRecordCmdEndRenderPass2KHR(
2775 VkCommandBuffer commandBuffer,
2776 const VkSubpassEndInfoKHR* pSubpassEndInfo);
2777
2778 void PostCallRecordCmdEndRenderPass2KHR(
2779 VkCommandBuffer commandBuffer,
2780 const VkSubpassEndInfoKHR* pSubpassEndInfo);
2781
2782 void PreCallRecordGetSwapchainStatusKHR(
2783 VkDevice device,
2784 VkSwapchainKHR swapchain);
2785
2786 void PostCallRecordGetSwapchainStatusKHR(
2787 VkDevice device,
2788 VkSwapchainKHR swapchain,
2789 VkResult result);
2790
2791 #ifdef VK_USE_PLATFORM_WIN32_KHR
2792
2793 void PreCallRecordImportFenceWin32HandleKHR(
2794 VkDevice device,
2795 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
2796
2797 void PostCallRecordImportFenceWin32HandleKHR(
2798 VkDevice device,
2799 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo,
2800 VkResult result);
2801
2802 void PreCallRecordGetFenceWin32HandleKHR(
2803 VkDevice device,
2804 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
2805 HANDLE* pHandle);
2806
2807 void PostCallRecordGetFenceWin32HandleKHR(
2808 VkDevice device,
2809 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
2810 HANDLE* pHandle,
2811 VkResult result);
2812 #endif // VK_USE_PLATFORM_WIN32_KHR
2813
2814 void PreCallRecordImportFenceFdKHR(
2815 VkDevice device,
2816 const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
2817
2818 void PostCallRecordImportFenceFdKHR(
2819 VkDevice device,
2820 const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
2821 VkResult result);
2822
2823 void PreCallRecordGetFenceFdKHR(
2824 VkDevice device,
2825 const VkFenceGetFdInfoKHR* pGetFdInfo,
2826 int* pFd);
2827
2828 void PostCallRecordGetFenceFdKHR(
2829 VkDevice device,
2830 const VkFenceGetFdInfoKHR* pGetFdInfo,
2831 int* pFd,
2832 VkResult result);
2833
2834 void PreCallRecordGetDisplayModeProperties2KHR(
2835 VkPhysicalDevice physicalDevice,
2836 VkDisplayKHR display,
2837 uint32_t* pPropertyCount,
2838 VkDisplayModeProperties2KHR* pProperties);
2839
2840 void PostCallRecordGetDisplayModeProperties2KHR(
2841 VkPhysicalDevice physicalDevice,
2842 VkDisplayKHR display,
2843 uint32_t* pPropertyCount,
2844 VkDisplayModeProperties2KHR* pProperties,
2845 VkResult result);
2846
2847 void PreCallRecordGetImageMemoryRequirements2KHR(
2848 VkDevice device,
2849 const VkImageMemoryRequirementsInfo2* pInfo,
2850 VkMemoryRequirements2* pMemoryRequirements);
2851
2852 void PostCallRecordGetImageMemoryRequirements2KHR(
2853 VkDevice device,
2854 const VkImageMemoryRequirementsInfo2* pInfo,
2855 VkMemoryRequirements2* pMemoryRequirements);
2856
2857 void PreCallRecordGetBufferMemoryRequirements2KHR(
2858 VkDevice device,
2859 const VkBufferMemoryRequirementsInfo2* pInfo,
2860 VkMemoryRequirements2* pMemoryRequirements);
2861
2862 void PostCallRecordGetBufferMemoryRequirements2KHR(
2863 VkDevice device,
2864 const VkBufferMemoryRequirementsInfo2* pInfo,
2865 VkMemoryRequirements2* pMemoryRequirements);
2866
2867 void PreCallRecordGetImageSparseMemoryRequirements2KHR(
2868 VkDevice device,
2869 const VkImageSparseMemoryRequirementsInfo2* pInfo,
2870 uint32_t* pSparseMemoryRequirementCount,
2871 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
2872
2873 void PostCallRecordGetImageSparseMemoryRequirements2KHR(
2874 VkDevice device,
2875 const VkImageSparseMemoryRequirementsInfo2* pInfo,
2876 uint32_t* pSparseMemoryRequirementCount,
2877 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
2878
2879 void PreCallRecordCreateSamplerYcbcrConversionKHR(
2880 VkDevice device,
2881 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
2882 const VkAllocationCallbacks* pAllocator,
2883 VkSamplerYcbcrConversion* pYcbcrConversion);
2884
2885 void PostCallRecordCreateSamplerYcbcrConversionKHR(
2886 VkDevice device,
2887 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
2888 const VkAllocationCallbacks* pAllocator,
2889 VkSamplerYcbcrConversion* pYcbcrConversion,
2890 VkResult result);
2891
2892 void PreCallRecordDestroySamplerYcbcrConversionKHR(
2893 VkDevice device,
2894 VkSamplerYcbcrConversion ycbcrConversion,
2895 const VkAllocationCallbacks* pAllocator);
2896
2897 void PostCallRecordDestroySamplerYcbcrConversionKHR(
2898 VkDevice device,
2899 VkSamplerYcbcrConversion ycbcrConversion,
2900 const VkAllocationCallbacks* pAllocator);
2901
2902 void PreCallRecordBindBufferMemory2KHR(
2903 VkDevice device,
2904 uint32_t bindInfoCount,
2905 const VkBindBufferMemoryInfo* pBindInfos);
2906
2907 void PostCallRecordBindBufferMemory2KHR(
2908 VkDevice device,
2909 uint32_t bindInfoCount,
2910 const VkBindBufferMemoryInfo* pBindInfos,
2911 VkResult result);
2912
2913 void PreCallRecordBindImageMemory2KHR(
2914 VkDevice device,
2915 uint32_t bindInfoCount,
2916 const VkBindImageMemoryInfo* pBindInfos);
2917
2918 void PostCallRecordBindImageMemory2KHR(
2919 VkDevice device,
2920 uint32_t bindInfoCount,
2921 const VkBindImageMemoryInfo* pBindInfos,
2922 VkResult result);
2923
2924 void PreCallRecordGetDescriptorSetLayoutSupportKHR(
2925 VkDevice device,
2926 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
2927 VkDescriptorSetLayoutSupport* pSupport);
2928
2929 void PostCallRecordGetDescriptorSetLayoutSupportKHR(
2930 VkDevice device,
2931 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
2932 VkDescriptorSetLayoutSupport* pSupport);
2933
2934 void PreCallRecordCmdDrawIndirectCountKHR(
2935 VkCommandBuffer commandBuffer,
2936 VkBuffer buffer,
2937 VkDeviceSize offset,
2938 VkBuffer countBuffer,
2939 VkDeviceSize countBufferOffset,
2940 uint32_t maxDrawCount,
2941 uint32_t stride);
2942
2943 void PostCallRecordCmdDrawIndirectCountKHR(
2944 VkCommandBuffer commandBuffer,
2945 VkBuffer buffer,
2946 VkDeviceSize offset,
2947 VkBuffer countBuffer,
2948 VkDeviceSize countBufferOffset,
2949 uint32_t maxDrawCount,
2950 uint32_t stride);
2951
2952 void PreCallRecordCmdDrawIndexedIndirectCountKHR(
2953 VkCommandBuffer commandBuffer,
2954 VkBuffer buffer,
2955 VkDeviceSize offset,
2956 VkBuffer countBuffer,
2957 VkDeviceSize countBufferOffset,
2958 uint32_t maxDrawCount,
2959 uint32_t stride);
2960
2961 void PostCallRecordCmdDrawIndexedIndirectCountKHR(
2962 VkCommandBuffer commandBuffer,
2963 VkBuffer buffer,
2964 VkDeviceSize offset,
2965 VkBuffer countBuffer,
2966 VkDeviceSize countBufferOffset,
2967 uint32_t maxDrawCount,
2968 uint32_t stride);
2969
2970 void PreCallRecordGetPipelineExecutablePropertiesKHR(
2971 VkDevice device,
2972 const VkPipelineInfoKHR* pPipelineInfo,
2973 uint32_t* pExecutableCount,
2974 VkPipelineExecutablePropertiesKHR* pProperties);
2975
2976 void PostCallRecordGetPipelineExecutablePropertiesKHR(
2977 VkDevice device,
2978 const VkPipelineInfoKHR* pPipelineInfo,
2979 uint32_t* pExecutableCount,
2980 VkPipelineExecutablePropertiesKHR* pProperties,
2981 VkResult result);
2982
2983 void PreCallRecordGetPipelineExecutableStatisticsKHR(
2984 VkDevice device,
2985 const VkPipelineExecutableInfoKHR* pExecutableInfo,
2986 uint32_t* pStatisticCount,
2987 VkPipelineExecutableStatisticKHR* pStatistics);
2988
2989 void PostCallRecordGetPipelineExecutableStatisticsKHR(
2990 VkDevice device,
2991 const VkPipelineExecutableInfoKHR* pExecutableInfo,
2992 uint32_t* pStatisticCount,
2993 VkPipelineExecutableStatisticKHR* pStatistics,
2994 VkResult result);
2995
2996 void PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(
2997 VkDevice device,
2998 const VkPipelineExecutableInfoKHR* pExecutableInfo,
2999 uint32_t* pInternalRepresentationCount,
3000 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
3001
3002 void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(
3003 VkDevice device,
3004 const VkPipelineExecutableInfoKHR* pExecutableInfo,
3005 uint32_t* pInternalRepresentationCount,
3006 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
3007 VkResult result);
3008
3009 void PreCallRecordCreateDebugReportCallbackEXT(
3010 VkInstance instance,
3011 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
3012 const VkAllocationCallbacks* pAllocator,
3013 VkDebugReportCallbackEXT* pCallback);
3014
3015 void PostCallRecordCreateDebugReportCallbackEXT(
3016 VkInstance instance,
3017 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
3018 const VkAllocationCallbacks* pAllocator,
3019 VkDebugReportCallbackEXT* pCallback,
3020 VkResult result);
3021
3022 void PreCallRecordDestroyDebugReportCallbackEXT(
3023 VkInstance instance,
3024 VkDebugReportCallbackEXT callback,
3025 const VkAllocationCallbacks* pAllocator);
3026
3027 void PostCallRecordDestroyDebugReportCallbackEXT(
3028 VkInstance instance,
3029 VkDebugReportCallbackEXT callback,
3030 const VkAllocationCallbacks* pAllocator);
3031
3032 void PreCallRecordDebugReportMessageEXT(
3033 VkInstance instance,
3034 VkDebugReportFlagsEXT flags,
3035 VkDebugReportObjectTypeEXT objectType,
3036 uint64_t object,
3037 size_t location,
3038 int32_t messageCode,
3039 const char* pLayerPrefix,
3040 const char* pMessage);
3041
3042 void PostCallRecordDebugReportMessageEXT(
3043 VkInstance instance,
3044 VkDebugReportFlagsEXT flags,
3045 VkDebugReportObjectTypeEXT objectType,
3046 uint64_t object,
3047 size_t location,
3048 int32_t messageCode,
3049 const char* pLayerPrefix,
3050 const char* pMessage);
3051 // TODO - not wrapping EXT function vkDebugMarkerSetObjectTagEXT
3052 // TODO - not wrapping EXT function vkDebugMarkerSetObjectNameEXT
3053 // TODO - not wrapping EXT function vkCmdDebugMarkerBeginEXT
3054 // TODO - not wrapping EXT function vkCmdDebugMarkerEndEXT
3055 // TODO - not wrapping EXT function vkCmdDebugMarkerInsertEXT
3056
3057 void PreCallRecordCmdBindTransformFeedbackBuffersEXT(
3058 VkCommandBuffer commandBuffer,
3059 uint32_t firstBinding,
3060 uint32_t bindingCount,
3061 const VkBuffer* pBuffers,
3062 const VkDeviceSize* pOffsets,
3063 const VkDeviceSize* pSizes);
3064
3065 void PostCallRecordCmdBindTransformFeedbackBuffersEXT(
3066 VkCommandBuffer commandBuffer,
3067 uint32_t firstBinding,
3068 uint32_t bindingCount,
3069 const VkBuffer* pBuffers,
3070 const VkDeviceSize* pOffsets,
3071 const VkDeviceSize* pSizes);
3072
3073 void PreCallRecordCmdBeginTransformFeedbackEXT(
3074 VkCommandBuffer commandBuffer,
3075 uint32_t firstCounterBuffer,
3076 uint32_t counterBufferCount,
3077 const VkBuffer* pCounterBuffers,
3078 const VkDeviceSize* pCounterBufferOffsets);
3079
3080 void PostCallRecordCmdBeginTransformFeedbackEXT(
3081 VkCommandBuffer commandBuffer,
3082 uint32_t firstCounterBuffer,
3083 uint32_t counterBufferCount,
3084 const VkBuffer* pCounterBuffers,
3085 const VkDeviceSize* pCounterBufferOffsets);
3086
3087 void PreCallRecordCmdEndTransformFeedbackEXT(
3088 VkCommandBuffer commandBuffer,
3089 uint32_t firstCounterBuffer,
3090 uint32_t counterBufferCount,
3091 const VkBuffer* pCounterBuffers,
3092 const VkDeviceSize* pCounterBufferOffsets);
3093
3094 void PostCallRecordCmdEndTransformFeedbackEXT(
3095 VkCommandBuffer commandBuffer,
3096 uint32_t firstCounterBuffer,
3097 uint32_t counterBufferCount,
3098 const VkBuffer* pCounterBuffers,
3099 const VkDeviceSize* pCounterBufferOffsets);
3100
3101 void PreCallRecordCmdBeginQueryIndexedEXT(
3102 VkCommandBuffer commandBuffer,
3103 VkQueryPool queryPool,
3104 uint32_t query,
3105 VkQueryControlFlags flags,
3106 uint32_t index);
3107
3108 void PostCallRecordCmdBeginQueryIndexedEXT(
3109 VkCommandBuffer commandBuffer,
3110 VkQueryPool queryPool,
3111 uint32_t query,
3112 VkQueryControlFlags flags,
3113 uint32_t index);
3114
3115 void PreCallRecordCmdEndQueryIndexedEXT(
3116 VkCommandBuffer commandBuffer,
3117 VkQueryPool queryPool,
3118 uint32_t query,
3119 uint32_t index);
3120
3121 void PostCallRecordCmdEndQueryIndexedEXT(
3122 VkCommandBuffer commandBuffer,
3123 VkQueryPool queryPool,
3124 uint32_t query,
3125 uint32_t index);
3126
3127 void PreCallRecordCmdDrawIndirectByteCountEXT(
3128 VkCommandBuffer commandBuffer,
3129 uint32_t instanceCount,
3130 uint32_t firstInstance,
3131 VkBuffer counterBuffer,
3132 VkDeviceSize counterBufferOffset,
3133 uint32_t counterOffset,
3134 uint32_t vertexStride);
3135
3136 void PostCallRecordCmdDrawIndirectByteCountEXT(
3137 VkCommandBuffer commandBuffer,
3138 uint32_t instanceCount,
3139 uint32_t firstInstance,
3140 VkBuffer counterBuffer,
3141 VkDeviceSize counterBufferOffset,
3142 uint32_t counterOffset,
3143 uint32_t vertexStride);
3144
3145 void PreCallRecordGetImageViewHandleNVX(
3146 VkDevice device,
3147 const VkImageViewHandleInfoNVX* pInfo);
3148
3149 void PostCallRecordGetImageViewHandleNVX(
3150 VkDevice device,
3151 const VkImageViewHandleInfoNVX* pInfo);
3152
3153 void PreCallRecordCmdDrawIndirectCountAMD(
3154 VkCommandBuffer commandBuffer,
3155 VkBuffer buffer,
3156 VkDeviceSize offset,
3157 VkBuffer countBuffer,
3158 VkDeviceSize countBufferOffset,
3159 uint32_t maxDrawCount,
3160 uint32_t stride);
3161
3162 void PostCallRecordCmdDrawIndirectCountAMD(
3163 VkCommandBuffer commandBuffer,
3164 VkBuffer buffer,
3165 VkDeviceSize offset,
3166 VkBuffer countBuffer,
3167 VkDeviceSize countBufferOffset,
3168 uint32_t maxDrawCount,
3169 uint32_t stride);
3170
3171 void PreCallRecordCmdDrawIndexedIndirectCountAMD(
3172 VkCommandBuffer commandBuffer,
3173 VkBuffer buffer,
3174 VkDeviceSize offset,
3175 VkBuffer countBuffer,
3176 VkDeviceSize countBufferOffset,
3177 uint32_t maxDrawCount,
3178 uint32_t stride);
3179
3180 void PostCallRecordCmdDrawIndexedIndirectCountAMD(
3181 VkCommandBuffer commandBuffer,
3182 VkBuffer buffer,
3183 VkDeviceSize offset,
3184 VkBuffer countBuffer,
3185 VkDeviceSize countBufferOffset,
3186 uint32_t maxDrawCount,
3187 uint32_t stride);
3188
3189 void PreCallRecordGetShaderInfoAMD(
3190 VkDevice device,
3191 VkPipeline pipeline,
3192 VkShaderStageFlagBits shaderStage,
3193 VkShaderInfoTypeAMD infoType,
3194 size_t* pInfoSize,
3195 void* pInfo);
3196
3197 void PostCallRecordGetShaderInfoAMD(
3198 VkDevice device,
3199 VkPipeline pipeline,
3200 VkShaderStageFlagBits shaderStage,
3201 VkShaderInfoTypeAMD infoType,
3202 size_t* pInfoSize,
3203 void* pInfo,
3204 VkResult result);
3205
3206 #ifdef VK_USE_PLATFORM_GGP
3207
3208 void PreCallRecordCreateStreamDescriptorSurfaceGGP(
3209 VkInstance instance,
3210 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
3211 const VkAllocationCallbacks* pAllocator,
3212 VkSurfaceKHR* pSurface);
3213
3214 void PostCallRecordCreateStreamDescriptorSurfaceGGP(
3215 VkInstance instance,
3216 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
3217 const VkAllocationCallbacks* pAllocator,
3218 VkSurfaceKHR* pSurface,
3219 VkResult result);
3220 #endif // VK_USE_PLATFORM_GGP
3221
3222 #ifdef VK_USE_PLATFORM_WIN32_KHR
3223
3224 void PreCallRecordGetMemoryWin32HandleNV(
3225 VkDevice device,
3226 VkDeviceMemory memory,
3227 VkExternalMemoryHandleTypeFlagsNV handleType,
3228 HANDLE* pHandle);
3229
3230 void PostCallRecordGetMemoryWin32HandleNV(
3231 VkDevice device,
3232 VkDeviceMemory memory,
3233 VkExternalMemoryHandleTypeFlagsNV handleType,
3234 HANDLE* pHandle,
3235 VkResult result);
3236 #endif // VK_USE_PLATFORM_WIN32_KHR
3237
3238 #ifdef VK_USE_PLATFORM_WIN32_KHR
3239 #endif // VK_USE_PLATFORM_WIN32_KHR
3240
3241 #ifdef VK_USE_PLATFORM_VI_NN
3242
3243 void PreCallRecordCreateViSurfaceNN(
3244 VkInstance instance,
3245 const VkViSurfaceCreateInfoNN* pCreateInfo,
3246 const VkAllocationCallbacks* pAllocator,
3247 VkSurfaceKHR* pSurface);
3248
3249 void PostCallRecordCreateViSurfaceNN(
3250 VkInstance instance,
3251 const VkViSurfaceCreateInfoNN* pCreateInfo,
3252 const VkAllocationCallbacks* pAllocator,
3253 VkSurfaceKHR* pSurface,
3254 VkResult result);
3255 #endif // VK_USE_PLATFORM_VI_NN
3256
3257 void PreCallRecordCmdBeginConditionalRenderingEXT(
3258 VkCommandBuffer commandBuffer,
3259 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
3260
3261 void PostCallRecordCmdBeginConditionalRenderingEXT(
3262 VkCommandBuffer commandBuffer,
3263 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
3264
3265 void PreCallRecordCmdEndConditionalRenderingEXT(
3266 VkCommandBuffer commandBuffer);
3267
3268 void PostCallRecordCmdEndConditionalRenderingEXT(
3269 VkCommandBuffer commandBuffer);
3270
3271 void PreCallRecordCmdProcessCommandsNVX(
3272 VkCommandBuffer commandBuffer,
3273 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
3274
3275 void PostCallRecordCmdProcessCommandsNVX(
3276 VkCommandBuffer commandBuffer,
3277 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
3278
3279 void PreCallRecordCmdReserveSpaceForCommandsNVX(
3280 VkCommandBuffer commandBuffer,
3281 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
3282
3283 void PostCallRecordCmdReserveSpaceForCommandsNVX(
3284 VkCommandBuffer commandBuffer,
3285 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
3286
3287 void PreCallRecordCreateIndirectCommandsLayoutNVX(
3288 VkDevice device,
3289 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
3290 const VkAllocationCallbacks* pAllocator,
3291 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
3292
3293 void PostCallRecordCreateIndirectCommandsLayoutNVX(
3294 VkDevice device,
3295 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
3296 const VkAllocationCallbacks* pAllocator,
3297 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout,
3298 VkResult result);
3299
3300 void PreCallRecordDestroyIndirectCommandsLayoutNVX(
3301 VkDevice device,
3302 VkIndirectCommandsLayoutNVX indirectCommandsLayout,
3303 const VkAllocationCallbacks* pAllocator);
3304
3305 void PostCallRecordDestroyIndirectCommandsLayoutNVX(
3306 VkDevice device,
3307 VkIndirectCommandsLayoutNVX indirectCommandsLayout,
3308 const VkAllocationCallbacks* pAllocator);
3309
3310 void PreCallRecordCreateObjectTableNVX(
3311 VkDevice device,
3312 const VkObjectTableCreateInfoNVX* pCreateInfo,
3313 const VkAllocationCallbacks* pAllocator,
3314 VkObjectTableNVX* pObjectTable);
3315
3316 void PostCallRecordCreateObjectTableNVX(
3317 VkDevice device,
3318 const VkObjectTableCreateInfoNVX* pCreateInfo,
3319 const VkAllocationCallbacks* pAllocator,
3320 VkObjectTableNVX* pObjectTable,
3321 VkResult result);
3322
3323 void PreCallRecordDestroyObjectTableNVX(
3324 VkDevice device,
3325 VkObjectTableNVX objectTable,
3326 const VkAllocationCallbacks* pAllocator);
3327
3328 void PostCallRecordDestroyObjectTableNVX(
3329 VkDevice device,
3330 VkObjectTableNVX objectTable,
3331 const VkAllocationCallbacks* pAllocator);
3332
3333 void PreCallRecordRegisterObjectsNVX(
3334 VkDevice device,
3335 VkObjectTableNVX objectTable,
3336 uint32_t objectCount,
3337 const VkObjectTableEntryNVX* const* ppObjectTableEntries,
3338 const uint32_t* pObjectIndices);
3339
3340 void PostCallRecordRegisterObjectsNVX(
3341 VkDevice device,
3342 VkObjectTableNVX objectTable,
3343 uint32_t objectCount,
3344 const VkObjectTableEntryNVX* const* ppObjectTableEntries,
3345 const uint32_t* pObjectIndices,
3346 VkResult result);
3347
3348 void PreCallRecordUnregisterObjectsNVX(
3349 VkDevice device,
3350 VkObjectTableNVX objectTable,
3351 uint32_t objectCount,
3352 const VkObjectEntryTypeNVX* pObjectEntryTypes,
3353 const uint32_t* pObjectIndices);
3354
3355 void PostCallRecordUnregisterObjectsNVX(
3356 VkDevice device,
3357 VkObjectTableNVX objectTable,
3358 uint32_t objectCount,
3359 const VkObjectEntryTypeNVX* pObjectEntryTypes,
3360 const uint32_t* pObjectIndices,
3361 VkResult result);
3362
3363 void PreCallRecordCmdSetViewportWScalingNV(
3364 VkCommandBuffer commandBuffer,
3365 uint32_t firstViewport,
3366 uint32_t viewportCount,
3367 const VkViewportWScalingNV* pViewportWScalings);
3368
3369 void PostCallRecordCmdSetViewportWScalingNV(
3370 VkCommandBuffer commandBuffer,
3371 uint32_t firstViewport,
3372 uint32_t viewportCount,
3373 const VkViewportWScalingNV* pViewportWScalings);
3374
3375 void PreCallRecordReleaseDisplayEXT(
3376 VkPhysicalDevice physicalDevice,
3377 VkDisplayKHR display);
3378
3379 void PostCallRecordReleaseDisplayEXT(
3380 VkPhysicalDevice physicalDevice,
3381 VkDisplayKHR display,
3382 VkResult result);
3383
3384 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3385
3386 void PreCallRecordAcquireXlibDisplayEXT(
3387 VkPhysicalDevice physicalDevice,
3388 Display* dpy,
3389 VkDisplayKHR display);
3390
3391 void PostCallRecordAcquireXlibDisplayEXT(
3392 VkPhysicalDevice physicalDevice,
3393 Display* dpy,
3394 VkDisplayKHR display,
3395 VkResult result);
3396 #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
3397
3398 void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(
3399 VkPhysicalDevice physicalDevice,
3400 VkSurfaceKHR surface,
3401 VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
3402
3403 void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(
3404 VkPhysicalDevice physicalDevice,
3405 VkSurfaceKHR surface,
3406 VkSurfaceCapabilities2EXT* pSurfaceCapabilities,
3407 VkResult result);
3408
3409 void PreCallRecordDisplayPowerControlEXT(
3410 VkDevice device,
3411 VkDisplayKHR display,
3412 const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
3413
3414 void PostCallRecordDisplayPowerControlEXT(
3415 VkDevice device,
3416 VkDisplayKHR display,
3417 const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
3418 VkResult result);
3419
3420 void PreCallRecordRegisterDeviceEventEXT(
3421 VkDevice device,
3422 const VkDeviceEventInfoEXT* pDeviceEventInfo,
3423 const VkAllocationCallbacks* pAllocator,
3424 VkFence* pFence);
3425
3426 void PostCallRecordRegisterDeviceEventEXT(
3427 VkDevice device,
3428 const VkDeviceEventInfoEXT* pDeviceEventInfo,
3429 const VkAllocationCallbacks* pAllocator,
3430 VkFence* pFence,
3431 VkResult result);
3432
3433 void PreCallRecordRegisterDisplayEventEXT(
3434 VkDevice device,
3435 VkDisplayKHR display,
3436 const VkDisplayEventInfoEXT* pDisplayEventInfo,
3437 const VkAllocationCallbacks* pAllocator,
3438 VkFence* pFence);
3439
3440 void PostCallRecordRegisterDisplayEventEXT(
3441 VkDevice device,
3442 VkDisplayKHR display,
3443 const VkDisplayEventInfoEXT* pDisplayEventInfo,
3444 const VkAllocationCallbacks* pAllocator,
3445 VkFence* pFence,
3446 VkResult result);
3447
3448 void PreCallRecordGetSwapchainCounterEXT(
3449 VkDevice device,
3450 VkSwapchainKHR swapchain,
3451 VkSurfaceCounterFlagBitsEXT counter,
3452 uint64_t* pCounterValue);
3453
3454 void PostCallRecordGetSwapchainCounterEXT(
3455 VkDevice device,
3456 VkSwapchainKHR swapchain,
3457 VkSurfaceCounterFlagBitsEXT counter,
3458 uint64_t* pCounterValue,
3459 VkResult result);
3460
3461 void PreCallRecordGetRefreshCycleDurationGOOGLE(
3462 VkDevice device,
3463 VkSwapchainKHR swapchain,
3464 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
3465
3466 void PostCallRecordGetRefreshCycleDurationGOOGLE(
3467 VkDevice device,
3468 VkSwapchainKHR swapchain,
3469 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties,
3470 VkResult result);
3471
3472 void PreCallRecordGetPastPresentationTimingGOOGLE(
3473 VkDevice device,
3474 VkSwapchainKHR swapchain,
3475 uint32_t* pPresentationTimingCount,
3476 VkPastPresentationTimingGOOGLE* pPresentationTimings);
3477
3478 void PostCallRecordGetPastPresentationTimingGOOGLE(
3479 VkDevice device,
3480 VkSwapchainKHR swapchain,
3481 uint32_t* pPresentationTimingCount,
3482 VkPastPresentationTimingGOOGLE* pPresentationTimings,
3483 VkResult result);
3484
3485 void PreCallRecordCmdSetDiscardRectangleEXT(
3486 VkCommandBuffer commandBuffer,
3487 uint32_t firstDiscardRectangle,
3488 uint32_t discardRectangleCount,
3489 const VkRect2D* pDiscardRectangles);
3490
3491 void PostCallRecordCmdSetDiscardRectangleEXT(
3492 VkCommandBuffer commandBuffer,
3493 uint32_t firstDiscardRectangle,
3494 uint32_t discardRectangleCount,
3495 const VkRect2D* pDiscardRectangles);
3496
3497 void PreCallRecordSetHdrMetadataEXT(
3498 VkDevice device,
3499 uint32_t swapchainCount,
3500 const VkSwapchainKHR* pSwapchains,
3501 const VkHdrMetadataEXT* pMetadata);
3502
3503 void PostCallRecordSetHdrMetadataEXT(
3504 VkDevice device,
3505 uint32_t swapchainCount,
3506 const VkSwapchainKHR* pSwapchains,
3507 const VkHdrMetadataEXT* pMetadata);
3508
3509 #ifdef VK_USE_PLATFORM_IOS_MVK
3510
3511 void PreCallRecordCreateIOSSurfaceMVK(
3512 VkInstance instance,
3513 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
3514 const VkAllocationCallbacks* pAllocator,
3515 VkSurfaceKHR* pSurface);
3516
3517 void PostCallRecordCreateIOSSurfaceMVK(
3518 VkInstance instance,
3519 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
3520 const VkAllocationCallbacks* pAllocator,
3521 VkSurfaceKHR* pSurface,
3522 VkResult result);
3523 #endif // VK_USE_PLATFORM_IOS_MVK
3524
3525 #ifdef VK_USE_PLATFORM_MACOS_MVK
3526
3527 void PreCallRecordCreateMacOSSurfaceMVK(
3528 VkInstance instance,
3529 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
3530 const VkAllocationCallbacks* pAllocator,
3531 VkSurfaceKHR* pSurface);
3532
3533 void PostCallRecordCreateMacOSSurfaceMVK(
3534 VkInstance instance,
3535 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
3536 const VkAllocationCallbacks* pAllocator,
3537 VkSurfaceKHR* pSurface,
3538 VkResult result);
3539 #endif // VK_USE_PLATFORM_MACOS_MVK
3540 // TODO - not wrapping EXT function vkSetDebugUtilsObjectNameEXT
3541 // TODO - not wrapping EXT function vkSetDebugUtilsObjectTagEXT
3542
3543 void PreCallRecordQueueBeginDebugUtilsLabelEXT(
3544 VkQueue queue,
3545 const VkDebugUtilsLabelEXT* pLabelInfo);
3546
3547 void PostCallRecordQueueBeginDebugUtilsLabelEXT(
3548 VkQueue queue,
3549 const VkDebugUtilsLabelEXT* pLabelInfo);
3550
3551 void PreCallRecordQueueEndDebugUtilsLabelEXT(
3552 VkQueue queue);
3553
3554 void PostCallRecordQueueEndDebugUtilsLabelEXT(
3555 VkQueue queue);
3556
3557 void PreCallRecordQueueInsertDebugUtilsLabelEXT(
3558 VkQueue queue,
3559 const VkDebugUtilsLabelEXT* pLabelInfo);
3560
3561 void PostCallRecordQueueInsertDebugUtilsLabelEXT(
3562 VkQueue queue,
3563 const VkDebugUtilsLabelEXT* pLabelInfo);
3564
3565 void PreCallRecordCmdBeginDebugUtilsLabelEXT(
3566 VkCommandBuffer commandBuffer,
3567 const VkDebugUtilsLabelEXT* pLabelInfo);
3568
3569 void PostCallRecordCmdBeginDebugUtilsLabelEXT(
3570 VkCommandBuffer commandBuffer,
3571 const VkDebugUtilsLabelEXT* pLabelInfo);
3572
3573 void PreCallRecordCmdEndDebugUtilsLabelEXT(
3574 VkCommandBuffer commandBuffer);
3575
3576 void PostCallRecordCmdEndDebugUtilsLabelEXT(
3577 VkCommandBuffer commandBuffer);
3578
3579 void PreCallRecordCmdInsertDebugUtilsLabelEXT(
3580 VkCommandBuffer commandBuffer,
3581 const VkDebugUtilsLabelEXT* pLabelInfo);
3582
3583 void PostCallRecordCmdInsertDebugUtilsLabelEXT(
3584 VkCommandBuffer commandBuffer,
3585 const VkDebugUtilsLabelEXT* pLabelInfo);
3586
3587 void PreCallRecordCreateDebugUtilsMessengerEXT(
3588 VkInstance instance,
3589 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
3590 const VkAllocationCallbacks* pAllocator,
3591 VkDebugUtilsMessengerEXT* pMessenger);
3592
3593 void PostCallRecordCreateDebugUtilsMessengerEXT(
3594 VkInstance instance,
3595 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
3596 const VkAllocationCallbacks* pAllocator,
3597 VkDebugUtilsMessengerEXT* pMessenger,
3598 VkResult result);
3599
3600 void PreCallRecordDestroyDebugUtilsMessengerEXT(
3601 VkInstance instance,
3602 VkDebugUtilsMessengerEXT messenger,
3603 const VkAllocationCallbacks* pAllocator);
3604
3605 void PostCallRecordDestroyDebugUtilsMessengerEXT(
3606 VkInstance instance,
3607 VkDebugUtilsMessengerEXT messenger,
3608 const VkAllocationCallbacks* pAllocator);
3609
3610 void PreCallRecordSubmitDebugUtilsMessageEXT(
3611 VkInstance instance,
3612 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
3613 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
3614 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
3615
3616 void PostCallRecordSubmitDebugUtilsMessageEXT(
3617 VkInstance instance,
3618 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
3619 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
3620 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
3621
3622 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3623
3624 void PreCallRecordGetAndroidHardwareBufferPropertiesANDROID(
3625 VkDevice device,
3626 const struct AHardwareBuffer* buffer,
3627 VkAndroidHardwareBufferPropertiesANDROID* pProperties);
3628
3629 void PostCallRecordGetAndroidHardwareBufferPropertiesANDROID(
3630 VkDevice device,
3631 const struct AHardwareBuffer* buffer,
3632 VkAndroidHardwareBufferPropertiesANDROID* pProperties,
3633 VkResult result);
3634
3635 void PreCallRecordGetMemoryAndroidHardwareBufferANDROID(
3636 VkDevice device,
3637 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
3638 struct AHardwareBuffer** pBuffer);
3639
3640 void PostCallRecordGetMemoryAndroidHardwareBufferANDROID(
3641 VkDevice device,
3642 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
3643 struct AHardwareBuffer** pBuffer,
3644 VkResult result);
3645 #endif // VK_USE_PLATFORM_ANDROID_KHR
3646
3647 void PreCallRecordCmdSetSampleLocationsEXT(
3648 VkCommandBuffer commandBuffer,
3649 const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
3650
3651 void PostCallRecordCmdSetSampleLocationsEXT(
3652 VkCommandBuffer commandBuffer,
3653 const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
3654
3655 void PreCallRecordGetImageDrmFormatModifierPropertiesEXT(
3656 VkDevice device,
3657 VkImage image,
3658 VkImageDrmFormatModifierPropertiesEXT* pProperties);
3659
3660 void PostCallRecordGetImageDrmFormatModifierPropertiesEXT(
3661 VkDevice device,
3662 VkImage image,
3663 VkImageDrmFormatModifierPropertiesEXT* pProperties,
3664 VkResult result);
3665
3666 void PreCallRecordCreateValidationCacheEXT(
3667 VkDevice device,
3668 const VkValidationCacheCreateInfoEXT* pCreateInfo,
3669 const VkAllocationCallbacks* pAllocator,
3670 VkValidationCacheEXT* pValidationCache);
3671
3672 void PostCallRecordCreateValidationCacheEXT(
3673 VkDevice device,
3674 const VkValidationCacheCreateInfoEXT* pCreateInfo,
3675 const VkAllocationCallbacks* pAllocator,
3676 VkValidationCacheEXT* pValidationCache,
3677 VkResult result);
3678
3679 void PreCallRecordDestroyValidationCacheEXT(
3680 VkDevice device,
3681 VkValidationCacheEXT validationCache,
3682 const VkAllocationCallbacks* pAllocator);
3683
3684 void PostCallRecordDestroyValidationCacheEXT(
3685 VkDevice device,
3686 VkValidationCacheEXT validationCache,
3687 const VkAllocationCallbacks* pAllocator);
3688
3689 void PreCallRecordMergeValidationCachesEXT(
3690 VkDevice device,
3691 VkValidationCacheEXT dstCache,
3692 uint32_t srcCacheCount,
3693 const VkValidationCacheEXT* pSrcCaches);
3694
3695 void PostCallRecordMergeValidationCachesEXT(
3696 VkDevice device,
3697 VkValidationCacheEXT dstCache,
3698 uint32_t srcCacheCount,
3699 const VkValidationCacheEXT* pSrcCaches,
3700 VkResult result);
3701
3702 void PreCallRecordGetValidationCacheDataEXT(
3703 VkDevice device,
3704 VkValidationCacheEXT validationCache,
3705 size_t* pDataSize,
3706 void* pData);
3707
3708 void PostCallRecordGetValidationCacheDataEXT(
3709 VkDevice device,
3710 VkValidationCacheEXT validationCache,
3711 size_t* pDataSize,
3712 void* pData,
3713 VkResult result);
3714
3715 void PreCallRecordCmdBindShadingRateImageNV(
3716 VkCommandBuffer commandBuffer,
3717 VkImageView imageView,
3718 VkImageLayout imageLayout);
3719
3720 void PostCallRecordCmdBindShadingRateImageNV(
3721 VkCommandBuffer commandBuffer,
3722 VkImageView imageView,
3723 VkImageLayout imageLayout);
3724
3725 void PreCallRecordCmdSetViewportShadingRatePaletteNV(
3726 VkCommandBuffer commandBuffer,
3727 uint32_t firstViewport,
3728 uint32_t viewportCount,
3729 const VkShadingRatePaletteNV* pShadingRatePalettes);
3730
3731 void PostCallRecordCmdSetViewportShadingRatePaletteNV(
3732 VkCommandBuffer commandBuffer,
3733 uint32_t firstViewport,
3734 uint32_t viewportCount,
3735 const VkShadingRatePaletteNV* pShadingRatePalettes);
3736
3737 void PreCallRecordCmdSetCoarseSampleOrderNV(
3738 VkCommandBuffer commandBuffer,
3739 VkCoarseSampleOrderTypeNV sampleOrderType,
3740 uint32_t customSampleOrderCount,
3741 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
3742
3743 void PostCallRecordCmdSetCoarseSampleOrderNV(
3744 VkCommandBuffer commandBuffer,
3745 VkCoarseSampleOrderTypeNV sampleOrderType,
3746 uint32_t customSampleOrderCount,
3747 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
3748
3749 void PreCallRecordCreateAccelerationStructureNV(
3750 VkDevice device,
3751 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
3752 const VkAllocationCallbacks* pAllocator,
3753 VkAccelerationStructureNV* pAccelerationStructure);
3754
3755 void PostCallRecordCreateAccelerationStructureNV(
3756 VkDevice device,
3757 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
3758 const VkAllocationCallbacks* pAllocator,
3759 VkAccelerationStructureNV* pAccelerationStructure,
3760 VkResult result);
3761
3762 void PreCallRecordDestroyAccelerationStructureNV(
3763 VkDevice device,
3764 VkAccelerationStructureNV accelerationStructure,
3765 const VkAllocationCallbacks* pAllocator);
3766
3767 void PostCallRecordDestroyAccelerationStructureNV(
3768 VkDevice device,
3769 VkAccelerationStructureNV accelerationStructure,
3770 const VkAllocationCallbacks* pAllocator);
3771
3772 void PreCallRecordGetAccelerationStructureMemoryRequirementsNV(
3773 VkDevice device,
3774 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
3775 VkMemoryRequirements2KHR* pMemoryRequirements);
3776
3777 void PostCallRecordGetAccelerationStructureMemoryRequirementsNV(
3778 VkDevice device,
3779 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
3780 VkMemoryRequirements2KHR* pMemoryRequirements);
3781
3782 void PreCallRecordBindAccelerationStructureMemoryNV(
3783 VkDevice device,
3784 uint32_t bindInfoCount,
3785 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
3786
3787 void PostCallRecordBindAccelerationStructureMemoryNV(
3788 VkDevice device,
3789 uint32_t bindInfoCount,
3790 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
3791 VkResult result);
3792
3793 void PreCallRecordCmdBuildAccelerationStructureNV(
3794 VkCommandBuffer commandBuffer,
3795 const VkAccelerationStructureInfoNV* pInfo,
3796 VkBuffer instanceData,
3797 VkDeviceSize instanceOffset,
3798 VkBool32 update,
3799 VkAccelerationStructureNV dst,
3800 VkAccelerationStructureNV src,
3801 VkBuffer scratch,
3802 VkDeviceSize scratchOffset);
3803
3804 void PostCallRecordCmdBuildAccelerationStructureNV(
3805 VkCommandBuffer commandBuffer,
3806 const VkAccelerationStructureInfoNV* pInfo,
3807 VkBuffer instanceData,
3808 VkDeviceSize instanceOffset,
3809 VkBool32 update,
3810 VkAccelerationStructureNV dst,
3811 VkAccelerationStructureNV src,
3812 VkBuffer scratch,
3813 VkDeviceSize scratchOffset);
3814
3815 void PreCallRecordCmdCopyAccelerationStructureNV(
3816 VkCommandBuffer commandBuffer,
3817 VkAccelerationStructureNV dst,
3818 VkAccelerationStructureNV src,
3819 VkCopyAccelerationStructureModeNV mode);
3820
3821 void PostCallRecordCmdCopyAccelerationStructureNV(
3822 VkCommandBuffer commandBuffer,
3823 VkAccelerationStructureNV dst,
3824 VkAccelerationStructureNV src,
3825 VkCopyAccelerationStructureModeNV mode);
3826
3827 void PreCallRecordCmdTraceRaysNV(
3828 VkCommandBuffer commandBuffer,
3829 VkBuffer raygenShaderBindingTableBuffer,
3830 VkDeviceSize raygenShaderBindingOffset,
3831 VkBuffer missShaderBindingTableBuffer,
3832 VkDeviceSize missShaderBindingOffset,
3833 VkDeviceSize missShaderBindingStride,
3834 VkBuffer hitShaderBindingTableBuffer,
3835 VkDeviceSize hitShaderBindingOffset,
3836 VkDeviceSize hitShaderBindingStride,
3837 VkBuffer callableShaderBindingTableBuffer,
3838 VkDeviceSize callableShaderBindingOffset,
3839 VkDeviceSize callableShaderBindingStride,
3840 uint32_t width,
3841 uint32_t height,
3842 uint32_t depth);
3843
3844 void PostCallRecordCmdTraceRaysNV(
3845 VkCommandBuffer commandBuffer,
3846 VkBuffer raygenShaderBindingTableBuffer,
3847 VkDeviceSize raygenShaderBindingOffset,
3848 VkBuffer missShaderBindingTableBuffer,
3849 VkDeviceSize missShaderBindingOffset,
3850 VkDeviceSize missShaderBindingStride,
3851 VkBuffer hitShaderBindingTableBuffer,
3852 VkDeviceSize hitShaderBindingOffset,
3853 VkDeviceSize hitShaderBindingStride,
3854 VkBuffer callableShaderBindingTableBuffer,
3855 VkDeviceSize callableShaderBindingOffset,
3856 VkDeviceSize callableShaderBindingStride,
3857 uint32_t width,
3858 uint32_t height,
3859 uint32_t depth);
3860
3861 void PreCallRecordCreateRayTracingPipelinesNV(
3862 VkDevice device,
3863 VkPipelineCache pipelineCache,
3864 uint32_t createInfoCount,
3865 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
3866 const VkAllocationCallbacks* pAllocator,
3867 VkPipeline* pPipelines);
3868
3869 void PostCallRecordCreateRayTracingPipelinesNV(
3870 VkDevice device,
3871 VkPipelineCache pipelineCache,
3872 uint32_t createInfoCount,
3873 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
3874 const VkAllocationCallbacks* pAllocator,
3875 VkPipeline* pPipelines,
3876 VkResult result);
3877
3878 void PreCallRecordGetRayTracingShaderGroupHandlesNV(
3879 VkDevice device,
3880 VkPipeline pipeline,
3881 uint32_t firstGroup,
3882 uint32_t groupCount,
3883 size_t dataSize,
3884 void* pData);
3885
3886 void PostCallRecordGetRayTracingShaderGroupHandlesNV(
3887 VkDevice device,
3888 VkPipeline pipeline,
3889 uint32_t firstGroup,
3890 uint32_t groupCount,
3891 size_t dataSize,
3892 void* pData,
3893 VkResult result);
3894
3895 void PreCallRecordGetAccelerationStructureHandleNV(
3896 VkDevice device,
3897 VkAccelerationStructureNV accelerationStructure,
3898 size_t dataSize,
3899 void* pData);
3900
3901 void PostCallRecordGetAccelerationStructureHandleNV(
3902 VkDevice device,
3903 VkAccelerationStructureNV accelerationStructure,
3904 size_t dataSize,
3905 void* pData,
3906 VkResult result);
3907
3908 void PreCallRecordCmdWriteAccelerationStructuresPropertiesNV(
3909 VkCommandBuffer commandBuffer,
3910 uint32_t accelerationStructureCount,
3911 const VkAccelerationStructureNV* pAccelerationStructures,
3912 VkQueryType queryType,
3913 VkQueryPool queryPool,
3914 uint32_t firstQuery);
3915
3916 void PostCallRecordCmdWriteAccelerationStructuresPropertiesNV(
3917 VkCommandBuffer commandBuffer,
3918 uint32_t accelerationStructureCount,
3919 const VkAccelerationStructureNV* pAccelerationStructures,
3920 VkQueryType queryType,
3921 VkQueryPool queryPool,
3922 uint32_t firstQuery);
3923
3924 void PreCallRecordCompileDeferredNV(
3925 VkDevice device,
3926 VkPipeline pipeline,
3927 uint32_t shader);
3928
3929 void PostCallRecordCompileDeferredNV(
3930 VkDevice device,
3931 VkPipeline pipeline,
3932 uint32_t shader,
3933 VkResult result);
3934
3935 void PreCallRecordGetMemoryHostPointerPropertiesEXT(
3936 VkDevice device,
3937 VkExternalMemoryHandleTypeFlagBits handleType,
3938 const void* pHostPointer,
3939 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
3940
3941 void PostCallRecordGetMemoryHostPointerPropertiesEXT(
3942 VkDevice device,
3943 VkExternalMemoryHandleTypeFlagBits handleType,
3944 const void* pHostPointer,
3945 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties,
3946 VkResult result);
3947
3948 void PreCallRecordCmdWriteBufferMarkerAMD(
3949 VkCommandBuffer commandBuffer,
3950 VkPipelineStageFlagBits pipelineStage,
3951 VkBuffer dstBuffer,
3952 VkDeviceSize dstOffset,
3953 uint32_t marker);
3954
3955 void PostCallRecordCmdWriteBufferMarkerAMD(
3956 VkCommandBuffer commandBuffer,
3957 VkPipelineStageFlagBits pipelineStage,
3958 VkBuffer dstBuffer,
3959 VkDeviceSize dstOffset,
3960 uint32_t marker);
3961
3962 void PreCallRecordGetCalibratedTimestampsEXT(
3963 VkDevice device,
3964 uint32_t timestampCount,
3965 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
3966 uint64_t* pTimestamps,
3967 uint64_t* pMaxDeviation);
3968
3969 void PostCallRecordGetCalibratedTimestampsEXT(
3970 VkDevice device,
3971 uint32_t timestampCount,
3972 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
3973 uint64_t* pTimestamps,
3974 uint64_t* pMaxDeviation,
3975 VkResult result);
3976
3977 #ifdef VK_USE_PLATFORM_GGP
3978 #endif // VK_USE_PLATFORM_GGP
3979
3980 void PreCallRecordCmdDrawMeshTasksNV(
3981 VkCommandBuffer commandBuffer,
3982 uint32_t taskCount,
3983 uint32_t firstTask);
3984
3985 void PostCallRecordCmdDrawMeshTasksNV(
3986 VkCommandBuffer commandBuffer,
3987 uint32_t taskCount,
3988 uint32_t firstTask);
3989
3990 void PreCallRecordCmdDrawMeshTasksIndirectNV(
3991 VkCommandBuffer commandBuffer,
3992 VkBuffer buffer,
3993 VkDeviceSize offset,
3994 uint32_t drawCount,
3995 uint32_t stride);
3996
3997 void PostCallRecordCmdDrawMeshTasksIndirectNV(
3998 VkCommandBuffer commandBuffer,
3999 VkBuffer buffer,
4000 VkDeviceSize offset,
4001 uint32_t drawCount,
4002 uint32_t stride);
4003
4004 void PreCallRecordCmdDrawMeshTasksIndirectCountNV(
4005 VkCommandBuffer commandBuffer,
4006 VkBuffer buffer,
4007 VkDeviceSize offset,
4008 VkBuffer countBuffer,
4009 VkDeviceSize countBufferOffset,
4010 uint32_t maxDrawCount,
4011 uint32_t stride);
4012
4013 void PostCallRecordCmdDrawMeshTasksIndirectCountNV(
4014 VkCommandBuffer commandBuffer,
4015 VkBuffer buffer,
4016 VkDeviceSize offset,
4017 VkBuffer countBuffer,
4018 VkDeviceSize countBufferOffset,
4019 uint32_t maxDrawCount,
4020 uint32_t stride);
4021
4022 void PreCallRecordCmdSetExclusiveScissorNV(
4023 VkCommandBuffer commandBuffer,
4024 uint32_t firstExclusiveScissor,
4025 uint32_t exclusiveScissorCount,
4026 const VkRect2D* pExclusiveScissors);
4027
4028 void PostCallRecordCmdSetExclusiveScissorNV(
4029 VkCommandBuffer commandBuffer,
4030 uint32_t firstExclusiveScissor,
4031 uint32_t exclusiveScissorCount,
4032 const VkRect2D* pExclusiveScissors);
4033
4034 void PreCallRecordCmdSetCheckpointNV(
4035 VkCommandBuffer commandBuffer,
4036 const void* pCheckpointMarker);
4037
4038 void PostCallRecordCmdSetCheckpointNV(
4039 VkCommandBuffer commandBuffer,
4040 const void* pCheckpointMarker);
4041
4042 void PreCallRecordGetQueueCheckpointDataNV(
4043 VkQueue queue,
4044 uint32_t* pCheckpointDataCount,
4045 VkCheckpointDataNV* pCheckpointData);
4046
4047 void PostCallRecordGetQueueCheckpointDataNV(
4048 VkQueue queue,
4049 uint32_t* pCheckpointDataCount,
4050 VkCheckpointDataNV* pCheckpointData);
4051
4052 void PreCallRecordInitializePerformanceApiINTEL(
4053 VkDevice device,
4054 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
4055
4056 void PostCallRecordInitializePerformanceApiINTEL(
4057 VkDevice device,
4058 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo,
4059 VkResult result);
4060
4061 void PreCallRecordUninitializePerformanceApiINTEL(
4062 VkDevice device);
4063
4064 void PostCallRecordUninitializePerformanceApiINTEL(
4065 VkDevice device);
4066
4067 void PreCallRecordCmdSetPerformanceMarkerINTEL(
4068 VkCommandBuffer commandBuffer,
4069 const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
4070
4071 void PostCallRecordCmdSetPerformanceMarkerINTEL(
4072 VkCommandBuffer commandBuffer,
4073 const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
4074 VkResult result);
4075
4076 void PreCallRecordCmdSetPerformanceStreamMarkerINTEL(
4077 VkCommandBuffer commandBuffer,
4078 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
4079
4080 void PostCallRecordCmdSetPerformanceStreamMarkerINTEL(
4081 VkCommandBuffer commandBuffer,
4082 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
4083 VkResult result);
4084
4085 void PreCallRecordCmdSetPerformanceOverrideINTEL(
4086 VkCommandBuffer commandBuffer,
4087 const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
4088
4089 void PostCallRecordCmdSetPerformanceOverrideINTEL(
4090 VkCommandBuffer commandBuffer,
4091 const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
4092 VkResult result);
4093
4094 void PreCallRecordAcquirePerformanceConfigurationINTEL(
4095 VkDevice device,
4096 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
4097 VkPerformanceConfigurationINTEL* pConfiguration);
4098
4099 void PostCallRecordAcquirePerformanceConfigurationINTEL(
4100 VkDevice device,
4101 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
4102 VkPerformanceConfigurationINTEL* pConfiguration,
4103 VkResult result);
4104
4105 void PreCallRecordReleasePerformanceConfigurationINTEL(
4106 VkDevice device,
4107 VkPerformanceConfigurationINTEL configuration);
4108
4109 void PostCallRecordReleasePerformanceConfigurationINTEL(
4110 VkDevice device,
4111 VkPerformanceConfigurationINTEL configuration,
4112 VkResult result);
4113
4114 void PreCallRecordQueueSetPerformanceConfigurationINTEL(
4115 VkQueue queue,
4116 VkPerformanceConfigurationINTEL configuration);
4117
4118 void PostCallRecordQueueSetPerformanceConfigurationINTEL(
4119 VkQueue queue,
4120 VkPerformanceConfigurationINTEL configuration,
4121 VkResult result);
4122
4123 void PreCallRecordGetPerformanceParameterINTEL(
4124 VkDevice device,
4125 VkPerformanceParameterTypeINTEL parameter,
4126 VkPerformanceValueINTEL* pValue);
4127
4128 void PostCallRecordGetPerformanceParameterINTEL(
4129 VkDevice device,
4130 VkPerformanceParameterTypeINTEL parameter,
4131 VkPerformanceValueINTEL* pValue,
4132 VkResult result);
4133
4134 void PreCallRecordSetLocalDimmingAMD(
4135 VkDevice device,
4136 VkSwapchainKHR swapChain,
4137 VkBool32 localDimmingEnable);
4138
4139 void PostCallRecordSetLocalDimmingAMD(
4140 VkDevice device,
4141 VkSwapchainKHR swapChain,
4142 VkBool32 localDimmingEnable);
4143
4144 #ifdef VK_USE_PLATFORM_FUCHSIA
4145
4146 void PreCallRecordCreateImagePipeSurfaceFUCHSIA(
4147 VkInstance instance,
4148 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
4149 const VkAllocationCallbacks* pAllocator,
4150 VkSurfaceKHR* pSurface);
4151
4152 void PostCallRecordCreateImagePipeSurfaceFUCHSIA(
4153 VkInstance instance,
4154 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
4155 const VkAllocationCallbacks* pAllocator,
4156 VkSurfaceKHR* pSurface,
4157 VkResult result);
4158 #endif // VK_USE_PLATFORM_FUCHSIA
4159
4160 #ifdef VK_USE_PLATFORM_METAL_EXT
4161
4162 void PreCallRecordCreateMetalSurfaceEXT(
4163 VkInstance instance,
4164 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
4165 const VkAllocationCallbacks* pAllocator,
4166 VkSurfaceKHR* pSurface);
4167
4168 void PostCallRecordCreateMetalSurfaceEXT(
4169 VkInstance instance,
4170 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
4171 const VkAllocationCallbacks* pAllocator,
4172 VkSurfaceKHR* pSurface,
4173 VkResult result);
4174 #endif // VK_USE_PLATFORM_METAL_EXT
4175
4176 void PreCallRecordGetBufferDeviceAddressEXT(
4177 VkDevice device,
4178 const VkBufferDeviceAddressInfoEXT* pInfo);
4179
4180 void PostCallRecordGetBufferDeviceAddressEXT(
4181 VkDevice device,
4182 const VkBufferDeviceAddressInfoEXT* pInfo);
4183
4184 #ifdef VK_USE_PLATFORM_WIN32_KHR
4185
4186 void PreCallRecordAcquireFullScreenExclusiveModeEXT(
4187 VkDevice device,
4188 VkSwapchainKHR swapchain);
4189
4190 void PostCallRecordAcquireFullScreenExclusiveModeEXT(
4191 VkDevice device,
4192 VkSwapchainKHR swapchain,
4193 VkResult result);
4194
4195 void PreCallRecordReleaseFullScreenExclusiveModeEXT(
4196 VkDevice device,
4197 VkSwapchainKHR swapchain);
4198
4199 void PostCallRecordReleaseFullScreenExclusiveModeEXT(
4200 VkDevice device,
4201 VkSwapchainKHR swapchain,
4202 VkResult result);
4203
4204 void PreCallRecordGetDeviceGroupSurfacePresentModes2EXT(
4205 VkDevice device,
4206 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
4207 VkDeviceGroupPresentModeFlagsKHR* pModes);
4208
4209 void PostCallRecordGetDeviceGroupSurfacePresentModes2EXT(
4210 VkDevice device,
4211 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
4212 VkDeviceGroupPresentModeFlagsKHR* pModes,
4213 VkResult result);
4214 #endif // VK_USE_PLATFORM_WIN32_KHR
4215
4216 void PreCallRecordCreateHeadlessSurfaceEXT(
4217 VkInstance instance,
4218 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
4219 const VkAllocationCallbacks* pAllocator,
4220 VkSurfaceKHR* pSurface);
4221
4222 void PostCallRecordCreateHeadlessSurfaceEXT(
4223 VkInstance instance,
4224 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
4225 const VkAllocationCallbacks* pAllocator,
4226 VkSurfaceKHR* pSurface,
4227 VkResult result);
4228
4229 void PreCallRecordCmdSetLineStippleEXT(
4230 VkCommandBuffer commandBuffer,
4231 uint32_t lineStippleFactor,
4232 uint16_t lineStipplePattern);
4233
4234 void PostCallRecordCmdSetLineStippleEXT(
4235 VkCommandBuffer commandBuffer,
4236 uint32_t lineStippleFactor,
4237 uint16_t lineStipplePattern);
4238
4239 void PreCallRecordResetQueryPoolEXT(
4240 VkDevice device,
4241 VkQueryPool queryPool,
4242 uint32_t firstQuery,
4243 uint32_t queryCount);
4244
4245 void PostCallRecordResetQueryPoolEXT(
4246 VkDevice device,
4247 VkQueryPool queryPool,
4248 uint32_t firstQuery,
4249 uint32_t queryCount);
4250 };
4251