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