| |
| // This file is ***GENERATED***. Do Not Edit. |
| // See thread_safety_generator.py for modifications. |
| |
| /* Copyright (c) 2015-2019 The Khronos Group Inc. |
| * Copyright (c) 2015-2019 Valve Corporation |
| * Copyright (c) 2015-2019 LunarG, Inc. |
| * Copyright (c) 2015-2019 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * Author: Mark Lobodzinski <mark@lunarg.com> |
| */ |
| |
| #pragma once |
| |
| #include <chrono> |
| #include <thread> |
| #include <mutex> |
| #include <vector> |
| #include <unordered_set> |
| #include <string> |
| |
| VK_DEFINE_NON_DISPATCHABLE_HANDLE(DISTINCT_NONDISPATCHABLE_PHONY_HANDLE) |
| // The following line must match the vulkan_core.h condition guarding VK_DEFINE_NON_DISPATCHABLE_HANDLE |
| #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) |
| // If pointers are 64-bit, then there can be separate counters for each |
| // NONDISPATCHABLE_HANDLE type. Otherwise they are all typedef uint64_t. |
| #define DISTINCT_NONDISPATCHABLE_HANDLES |
| // Make sure we catch any disagreement between us and the vulkan definition |
| static_assert(std::is_pointer<DISTINCT_NONDISPATCHABLE_PHONY_HANDLE>::value, |
| "Mismatched non-dispatchable handle handle, expected pointer type."); |
| #else |
| // Make sure we catch any disagreement between us and the vulkan definition |
| static_assert(std::is_same<uint64_t, DISTINCT_NONDISPATCHABLE_PHONY_HANDLE>::value, |
| "Mismatched non-dispatchable handle handle, expected uint64_t."); |
| #endif |
| |
| // Suppress unused warning on Linux |
| #if defined(__GNUC__) |
| #define DECORATE_UNUSED __attribute__((unused)) |
| #else |
| #define DECORATE_UNUSED |
| #endif |
| |
| // clang-format off |
| static const char DECORATE_UNUSED *kVUID_Threading_Info = "UNASSIGNED-Threading-Info"; |
| static const char DECORATE_UNUSED *kVUID_Threading_MultipleThreads = "UNASSIGNED-Threading-MultipleThreads"; |
| static const char DECORATE_UNUSED *kVUID_Threading_SingleThreadReuse = "UNASSIGNED-Threading-SingleThreadReuse"; |
| // clang-format on |
| |
| #undef DECORATE_UNUSED |
| |
| struct object_use_data { |
| loader_platform_thread_id thread; |
| int reader_count; |
| int writer_count; |
| }; |
| |
| // This is a wrapper around unordered_map that optimizes for the common case |
| // of only containing a single element. The "first" element's use is stored |
| // inline in the class and doesn't require hashing or memory (de)allocation. |
| // TODO: Consider generalizing this from one element to N elements (where N |
| // is a template parameter). |
| template <typename Key, typename T> |
| class small_unordered_map { |
| |
| bool first_data_allocated; |
| Key first_data_key; |
| T first_data; |
| |
| std::unordered_map<Key, T> uses; |
| |
| public: |
| small_unordered_map() : first_data_allocated(false) {} |
| |
| bool contains(const Key& object) const { |
| if (first_data_allocated && object == first_data_key) { |
| return true; |
| // check size() first to avoid hashing object unnecessarily. |
| } else if (uses.size() == 0) { |
| return false; |
| } else { |
| return uses.find(object) != uses.end(); |
| } |
| } |
| |
| T& operator[](const Key& object) { |
| if (first_data_allocated && first_data_key == object) { |
| return first_data; |
| } else if (!first_data_allocated && uses.size() == 0) { |
| first_data_allocated = true; |
| first_data_key = object; |
| return first_data; |
| } else { |
| return uses[object]; |
| } |
| } |
| |
| typename std::unordered_map<Key, T>::size_type erase(const Key& object) { |
| if (first_data_allocated && first_data_key == object) { |
| first_data_allocated = false; |
| return 1; |
| } else { |
| return uses.erase(object); |
| } |
| } |
| }; |
| |
| #define THREAD_SAFETY_BUCKETS_LOG2 6 |
| #define THREAD_SAFETY_BUCKETS (1 << THREAD_SAFETY_BUCKETS_LOG2) |
| |
| template <typename T> inline uint32_t ThreadSafetyHashObject(T object) |
| { |
| uint64_t u64 = (uint64_t)(uintptr_t)object; |
| uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64; |
| hash ^= (hash >> THREAD_SAFETY_BUCKETS_LOG2) ^ (hash >> (2*THREAD_SAFETY_BUCKETS_LOG2)); |
| hash &= (THREAD_SAFETY_BUCKETS-1); |
| return hash; |
| } |
| |
| template <typename T> |
| class counter { |
| public: |
| const char *typeName; |
| VkDebugReportObjectTypeEXT objectType; |
| debug_report_data **report_data; |
| |
| // Per-bucket locking, to reduce contention. |
| struct CounterBucket { |
| small_unordered_map<T, object_use_data> uses; |
| std::mutex counter_lock; |
| }; |
| |
| CounterBucket buckets[THREAD_SAFETY_BUCKETS]; |
| CounterBucket &GetBucket(T object) |
| { |
| return buckets[ThreadSafetyHashObject(object)]; |
| } |
| |
| void StartWrite(T object) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| auto &bucket = GetBucket(object); |
| bool skip = false; |
| loader_platform_thread_id tid = loader_platform_get_thread_id(); |
| std::unique_lock<std::mutex> lock(bucket.counter_lock); |
| if (!bucket.uses.contains(object)) { |
| // There is no current use of the object. Record writer thread. |
| struct object_use_data *use_data = &bucket.uses[object]; |
| use_data->reader_count = 0; |
| use_data->writer_count = 1; |
| use_data->thread = tid; |
| } else { |
| struct object_use_data *use_data = &bucket.uses[object]; |
| if (use_data->reader_count == 0) { |
| // There are no readers. Two writers just collided. |
| if (use_data->thread != tid) { |
| skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), |
| kVUID_Threading_MultipleThreads, |
| "THREADING ERROR : object of type %s is simultaneously used in " |
| "thread 0x%" PRIx64 " and thread 0x%" PRIx64, |
| typeName, (uint64_t)use_data->thread, (uint64_t)tid); |
| if (skip) { |
| WaitForObjectIdle(bucket, object, lock); |
| // There is now no current use of the object. Record writer thread. |
| struct object_use_data *new_use_data = &bucket.uses[object]; |
| new_use_data->thread = tid; |
| new_use_data->reader_count = 0; |
| new_use_data->writer_count = 1; |
| } else { |
| // Continue with an unsafe use of the object. |
| use_data->thread = tid; |
| use_data->writer_count += 1; |
| } |
| } else { |
| // This is either safe multiple use in one call, or recursive use. |
| // There is no way to make recursion safe. Just forge ahead. |
| use_data->writer_count += 1; |
| } |
| } else { |
| // There are readers. This writer collided with them. |
| if (use_data->thread != tid) { |
| skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), |
| kVUID_Threading_MultipleThreads, |
| "THREADING ERROR : object of type %s is simultaneously used in " |
| "thread 0x%" PRIx64 " and thread 0x%" PRIx64, |
| typeName, (uint64_t)use_data->thread, (uint64_t)tid); |
| if (skip) { |
| WaitForObjectIdle(bucket, object, lock); |
| // There is now no current use of the object. Record writer thread. |
| struct object_use_data *new_use_data = &bucket.uses[object]; |
| new_use_data->thread = tid; |
| new_use_data->reader_count = 0; |
| new_use_data->writer_count = 1; |
| } else { |
| // Continue with an unsafe use of the object. |
| use_data->thread = tid; |
| use_data->writer_count += 1; |
| } |
| } else { |
| // This is either safe multiple use in one call, or recursive use. |
| // There is no way to make recursion safe. Just forge ahead. |
| use_data->writer_count += 1; |
| } |
| } |
| } |
| } |
| |
| void FinishWrite(T object) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| auto &bucket = GetBucket(object); |
| // Object is no longer in use |
| std::unique_lock<std::mutex> lock(bucket.counter_lock); |
| struct object_use_data *use_data = &bucket.uses[object]; |
| use_data->writer_count -= 1; |
| if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) { |
| bucket.uses.erase(object); |
| } |
| } |
| |
| void StartRead(T object) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| auto &bucket = GetBucket(object); |
| bool skip = false; |
| loader_platform_thread_id tid = loader_platform_get_thread_id(); |
| std::unique_lock<std::mutex> lock(bucket.counter_lock); |
| if (!bucket.uses.contains(object)) { |
| // There is no current use of the object. Record reader count |
| struct object_use_data *use_data = &bucket.uses[object]; |
| use_data->reader_count = 1; |
| use_data->writer_count = 0; |
| use_data->thread = tid; |
| } else if (bucket.uses[object].writer_count > 0 && bucket.uses[object].thread != tid) { |
| // There is a writer of the object. |
| skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), |
| kVUID_Threading_MultipleThreads, |
| "THREADING ERROR : object of type %s is simultaneously used in " |
| "thread 0x%" PRIx64 " and thread 0x%" PRIx64, |
| typeName, (uint64_t)bucket.uses[object].thread, (uint64_t)tid); |
| if (skip) { |
| WaitForObjectIdle(bucket, object, lock); |
| // There is no current use of the object. Record reader count |
| struct object_use_data *use_data = &bucket.uses[object]; |
| use_data->reader_count = 1; |
| use_data->writer_count = 0; |
| use_data->thread = tid; |
| } else { |
| bucket.uses[object].reader_count += 1; |
| } |
| } else { |
| // There are other readers of the object. Increase reader count |
| bucket.uses[object].reader_count += 1; |
| } |
| } |
| void FinishRead(T object) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| auto &bucket = GetBucket(object); |
| std::unique_lock<std::mutex> lock(bucket.counter_lock); |
| struct object_use_data *use_data = &bucket.uses[object]; |
| use_data->reader_count -= 1; |
| if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) { |
| bucket.uses.erase(object); |
| } |
| } |
| counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, debug_report_data **rep_data = nullptr) { |
| typeName = name; |
| objectType = type; |
| report_data = rep_data; |
| } |
| |
| private: |
| void WaitForObjectIdle(CounterBucket &bucket, T object, std::unique_lock<std::mutex> &lock) { |
| // Wait for thread-safe access to object instead of skipping call. |
| // Don't use condition_variable to wait because it should be extremely |
| // rare to have collisions, but signaling would be very frequent. |
| while (bucket.uses.contains(object)) { |
| lock.unlock(); |
| std::this_thread::sleep_for(std::chrono::microseconds(1)); |
| lock.lock(); |
| } |
| } |
| }; |
| |
| |
| |
| class ThreadSafety : public ValidationObject { |
| public: |
| |
| // Override chassis read/write locks for this validation object |
| // This override takes a deferred lock. i.e. it is not acquired. |
| std::unique_lock<std::mutex> write_lock() { |
| return std::unique_lock<std::mutex>(validation_object_mutex, std::defer_lock); |
| } |
| |
| // Per-bucket locking, to reduce contention. |
| struct CommandBufferBucket { |
| std::mutex command_pool_lock; |
| small_unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map; |
| }; |
| |
| CommandBufferBucket buckets[THREAD_SAFETY_BUCKETS]; |
| CommandBufferBucket &GetBucket(VkCommandBuffer object) |
| { |
| return buckets[ThreadSafetyHashObject(object)]; |
| } |
| |
| counter<VkCommandBuffer> c_VkCommandBuffer; |
| counter<VkDevice> c_VkDevice; |
| counter<VkInstance> c_VkInstance; |
| counter<VkQueue> c_VkQueue; |
| #ifdef DISTINCT_NONDISPATCHABLE_HANDLES |
| |
| // Special entry to allow tracking of command pool Reset and Destroy |
| counter<VkCommandPool> c_VkCommandPoolContents; |
| counter<VkAccelerationStructureNV> c_VkAccelerationStructureNV; |
| counter<VkBuffer> c_VkBuffer; |
| counter<VkBufferView> c_VkBufferView; |
| counter<VkCommandPool> c_VkCommandPool; |
| counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT; |
| counter<VkDebugUtilsMessengerEXT> c_VkDebugUtilsMessengerEXT; |
| counter<VkDescriptorPool> c_VkDescriptorPool; |
| counter<VkDescriptorSet> c_VkDescriptorSet; |
| counter<VkDescriptorSetLayout> c_VkDescriptorSetLayout; |
| counter<VkDescriptorUpdateTemplate> c_VkDescriptorUpdateTemplate; |
| counter<VkDeviceMemory> c_VkDeviceMemory; |
| counter<VkDisplayKHR> c_VkDisplayKHR; |
| counter<VkDisplayModeKHR> c_VkDisplayModeKHR; |
| counter<VkEvent> c_VkEvent; |
| counter<VkFence> c_VkFence; |
| counter<VkFramebuffer> c_VkFramebuffer; |
| counter<VkImage> c_VkImage; |
| counter<VkImageView> c_VkImageView; |
| counter<VkIndirectCommandsLayoutNVX> c_VkIndirectCommandsLayoutNVX; |
| counter<VkObjectTableNVX> c_VkObjectTableNVX; |
| counter<VkPerformanceConfigurationINTEL> c_VkPerformanceConfigurationINTEL; |
| counter<VkPipeline> c_VkPipeline; |
| counter<VkPipelineCache> c_VkPipelineCache; |
| counter<VkPipelineLayout> c_VkPipelineLayout; |
| counter<VkQueryPool> c_VkQueryPool; |
| counter<VkRenderPass> c_VkRenderPass; |
| counter<VkSampler> c_VkSampler; |
| counter<VkSamplerYcbcrConversion> c_VkSamplerYcbcrConversion; |
| counter<VkSemaphore> c_VkSemaphore; |
| counter<VkShaderModule> c_VkShaderModule; |
| counter<VkSurfaceKHR> c_VkSurfaceKHR; |
| counter<VkSwapchainKHR> c_VkSwapchainKHR; |
| counter<VkValidationCacheEXT> c_VkValidationCacheEXT; |
| |
| |
| #else // DISTINCT_NONDISPATCHABLE_HANDLES |
| // Special entry to allow tracking of command pool Reset and Destroy |
| counter<uint64_t> c_VkCommandPoolContents; |
| |
| counter<uint64_t> c_uint64_t; |
| #endif // DISTINCT_NONDISPATCHABLE_HANDLES |
| |
| ThreadSafety() |
| : c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, &report_data), |
| c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, &report_data), |
| c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, &report_data), |
| c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, &report_data), |
| c_VkCommandPoolContents("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, &report_data), |
| |
| #ifdef DISTINCT_NONDISPATCHABLE_HANDLES |
| c_VkAccelerationStructureNV("VkAccelerationStructureNV", VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, &report_data), |
| c_VkBuffer("VkBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &report_data), |
| c_VkBufferView("VkBufferView", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, &report_data), |
| c_VkCommandPool("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, &report_data), |
| c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, &report_data), |
| c_VkDebugUtilsMessengerEXT("VkDebugUtilsMessengerEXT", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data), |
| c_VkDescriptorPool("VkDescriptorPool", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, &report_data), |
| c_VkDescriptorSet("VkDescriptorSet", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, &report_data), |
| c_VkDescriptorSetLayout("VkDescriptorSetLayout", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, &report_data), |
| c_VkDescriptorUpdateTemplate("VkDescriptorUpdateTemplate", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, &report_data), |
| c_VkDeviceMemory("VkDeviceMemory", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, &report_data), |
| c_VkDisplayKHR("VkDisplayKHR", VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, &report_data), |
| c_VkDisplayModeKHR("VkDisplayModeKHR", VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, &report_data), |
| c_VkEvent("VkEvent", VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, &report_data), |
| c_VkFence("VkFence", VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, &report_data), |
| c_VkFramebuffer("VkFramebuffer", VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, &report_data), |
| c_VkImage("VkImage", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &report_data), |
| c_VkImageView("VkImageView", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, &report_data), |
| c_VkIndirectCommandsLayoutNVX("VkIndirectCommandsLayoutNVX", VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, &report_data), |
| c_VkObjectTableNVX("VkObjectTableNVX", VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, &report_data), |
| c_VkPerformanceConfigurationINTEL("VkPerformanceConfigurationINTEL", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data), |
| c_VkPipeline("VkPipeline", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, &report_data), |
| c_VkPipelineCache("VkPipelineCache", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, &report_data), |
| c_VkPipelineLayout("VkPipelineLayout", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, &report_data), |
| c_VkQueryPool("VkQueryPool", VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, &report_data), |
| c_VkRenderPass("VkRenderPass", VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, &report_data), |
| c_VkSampler("VkSampler", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, &report_data), |
| c_VkSamplerYcbcrConversion("VkSamplerYcbcrConversion", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, &report_data), |
| c_VkSemaphore("VkSemaphore", VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, &report_data), |
| c_VkShaderModule("VkShaderModule", VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, &report_data), |
| c_VkSurfaceKHR("VkSurfaceKHR", VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, &report_data), |
| c_VkSwapchainKHR("VkSwapchainKHR", VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, &report_data), |
| c_VkValidationCacheEXT("VkValidationCacheEXT", VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, &report_data) |
| |
| |
| #else // DISTINCT_NONDISPATCHABLE_HANDLES |
| c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data) |
| #endif // DISTINCT_NONDISPATCHABLE_HANDLES |
| {}; |
| |
| #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); } |
| |
| WRAPPER(VkDevice) |
| WRAPPER(VkInstance) |
| WRAPPER(VkQueue) |
| #ifdef DISTINCT_NONDISPATCHABLE_HANDLES |
| WRAPPER(VkAccelerationStructureNV) |
| WRAPPER(VkBuffer) |
| WRAPPER(VkBufferView) |
| WRAPPER(VkCommandPool) |
| WRAPPER(VkDebugReportCallbackEXT) |
| WRAPPER(VkDebugUtilsMessengerEXT) |
| WRAPPER(VkDescriptorPool) |
| WRAPPER(VkDescriptorSet) |
| WRAPPER(VkDescriptorSetLayout) |
| WRAPPER(VkDescriptorUpdateTemplate) |
| WRAPPER(VkDeviceMemory) |
| WRAPPER(VkDisplayKHR) |
| WRAPPER(VkDisplayModeKHR) |
| WRAPPER(VkEvent) |
| WRAPPER(VkFence) |
| WRAPPER(VkFramebuffer) |
| WRAPPER(VkImage) |
| WRAPPER(VkImageView) |
| WRAPPER(VkIndirectCommandsLayoutNVX) |
| WRAPPER(VkObjectTableNVX) |
| WRAPPER(VkPerformanceConfigurationINTEL) |
| WRAPPER(VkPipeline) |
| WRAPPER(VkPipelineCache) |
| WRAPPER(VkPipelineLayout) |
| WRAPPER(VkQueryPool) |
| WRAPPER(VkRenderPass) |
| WRAPPER(VkSampler) |
| WRAPPER(VkSamplerYcbcrConversion) |
| WRAPPER(VkSemaphore) |
| WRAPPER(VkShaderModule) |
| WRAPPER(VkSurfaceKHR) |
| WRAPPER(VkSwapchainKHR) |
| WRAPPER(VkValidationCacheEXT) |
| |
| |
| #else // DISTINCT_NONDISPATCHABLE_HANDLES |
| WRAPPER(uint64_t) |
| #endif // DISTINCT_NONDISPATCHABLE_HANDLES |
| |
| // VkCommandBuffer needs check for implicit use of command pool |
| void StartWriteObject(VkCommandBuffer object, bool lockPool = true) { |
| if (lockPool) { |
| auto &bucket = GetBucket(object); |
| std::unique_lock<std::mutex> lock(bucket.command_pool_lock); |
| VkCommandPool pool = bucket.command_pool_map[object]; |
| lock.unlock(); |
| StartWriteObject(pool); |
| } |
| c_VkCommandBuffer.StartWrite(object); |
| } |
| void FinishWriteObject(VkCommandBuffer object, bool lockPool = true) { |
| c_VkCommandBuffer.FinishWrite(object); |
| if (lockPool) { |
| auto &bucket = GetBucket(object); |
| std::unique_lock<std::mutex> lock(bucket.command_pool_lock); |
| VkCommandPool pool = bucket.command_pool_map[object]; |
| lock.unlock(); |
| FinishWriteObject(pool); |
| } |
| } |
| void StartReadObject(VkCommandBuffer object) { |
| auto &bucket = GetBucket(object); |
| std::unique_lock<std::mutex> lock(bucket.command_pool_lock); |
| VkCommandPool pool = bucket.command_pool_map[object]; |
| lock.unlock(); |
| // We set up a read guard against the "Contents" counter to catch conflict vs. vkResetCommandPool and vkDestroyCommandPool |
| // while *not* establishing a read guard against the command pool counter itself to avoid false postives for |
| // non-externally sync'd command buffers |
| c_VkCommandPoolContents.StartRead(pool); |
| c_VkCommandBuffer.StartRead(object); |
| } |
| void FinishReadObject(VkCommandBuffer object) { |
| auto &bucket = GetBucket(object); |
| c_VkCommandBuffer.FinishRead(object); |
| std::unique_lock<std::mutex> lock(bucket.command_pool_lock); |
| VkCommandPool pool = bucket.command_pool_map[object]; |
| lock.unlock(); |
| c_VkCommandPoolContents.FinishRead(pool); |
| } |
| |
| void PreCallRecordDestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordEnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices); |
| |
| void PostCallRecordEnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices, |
| VkResult result); |
| |
| void PreCallRecordGetInstanceProcAddr( |
| VkInstance instance, |
| const char* pName); |
| |
| void PostCallRecordGetInstanceProcAddr( |
| VkInstance instance, |
| const char* pName); |
| |
| void PreCallRecordGetDeviceProcAddr( |
| VkDevice device, |
| const char* pName); |
| |
| void PostCallRecordGetDeviceProcAddr( |
| VkDevice device, |
| const char* pName); |
| |
| void PreCallRecordDestroyDevice( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDevice( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetDeviceQueue( |
| VkDevice device, |
| uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VkQueue* pQueue); |
| |
| void PostCallRecordGetDeviceQueue( |
| VkDevice device, |
| uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VkQueue* pQueue); |
| |
| void PreCallRecordQueueSubmit( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence); |
| |
| void PostCallRecordQueueSubmit( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence, |
| VkResult result); |
| |
| void PreCallRecordQueueWaitIdle( |
| VkQueue queue); |
| |
| void PostCallRecordQueueWaitIdle( |
| VkQueue queue, |
| VkResult result); |
| |
| void PreCallRecordDeviceWaitIdle( |
| VkDevice device); |
| |
| void PostCallRecordDeviceWaitIdle( |
| VkDevice device, |
| VkResult result); |
| |
| void PreCallRecordAllocateMemory( |
| VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory); |
| |
| void PostCallRecordAllocateMemory( |
| VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory, |
| VkResult result); |
| |
| void PreCallRecordFreeMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordFreeMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordMapMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize offset, |
| VkDeviceSize size, |
| VkMemoryMapFlags flags, |
| void** ppData); |
| |
| void PostCallRecordMapMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize offset, |
| VkDeviceSize size, |
| VkMemoryMapFlags flags, |
| void** ppData, |
| VkResult result); |
| |
| void PreCallRecordUnmapMemory( |
| VkDevice device, |
| VkDeviceMemory memory); |
| |
| void PostCallRecordUnmapMemory( |
| VkDevice device, |
| VkDeviceMemory memory); |
| |
| void PreCallRecordFlushMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges); |
| |
| void PostCallRecordFlushMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges, |
| VkResult result); |
| |
| void PreCallRecordInvalidateMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges); |
| |
| void PostCallRecordInvalidateMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges, |
| VkResult result); |
| |
| void PreCallRecordGetDeviceMemoryCommitment( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes); |
| |
| void PostCallRecordGetDeviceMemoryCommitment( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes); |
| |
| void PreCallRecordBindBufferMemory( |
| VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset); |
| |
| void PostCallRecordBindBufferMemory( |
| VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset, |
| VkResult result); |
| |
| void PreCallRecordBindImageMemory( |
| VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset); |
| |
| void PostCallRecordBindImageMemory( |
| VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset, |
| VkResult result); |
| |
| void PreCallRecordGetBufferMemoryRequirements( |
| VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements); |
| |
| void PostCallRecordGetBufferMemoryRequirements( |
| VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements); |
| |
| void PreCallRecordGetImageMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements); |
| |
| void PostCallRecordGetImageMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements); |
| |
| void PreCallRecordGetImageSparseMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements); |
| |
| void PostCallRecordGetImageSparseMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements); |
| |
| void PreCallRecordQueueBindSparse( |
| VkQueue queue, |
| uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, |
| VkFence fence); |
| |
| void PostCallRecordQueueBindSparse( |
| VkQueue queue, |
| uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, |
| VkFence fence, |
| VkResult result); |
| |
| void PreCallRecordCreateFence( |
| VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence); |
| |
| void PostCallRecordCreateFence( |
| VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence, |
| VkResult result); |
| |
| void PreCallRecordDestroyFence( |
| VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyFence( |
| VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordResetFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences); |
| |
| void PostCallRecordResetFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkResult result); |
| |
| void PreCallRecordGetFenceStatus( |
| VkDevice device, |
| VkFence fence); |
| |
| void PostCallRecordGetFenceStatus( |
| VkDevice device, |
| VkFence fence, |
| VkResult result); |
| |
| void PreCallRecordWaitForFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkBool32 waitAll, |
| uint64_t timeout); |
| |
| void PostCallRecordWaitForFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkBool32 waitAll, |
| uint64_t timeout, |
| VkResult result); |
| |
| void PreCallRecordCreateSemaphore( |
| VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore); |
| |
| void PostCallRecordCreateSemaphore( |
| VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore, |
| VkResult result); |
| |
| void PreCallRecordDestroySemaphore( |
| VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroySemaphore( |
| VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateEvent( |
| VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkEvent* pEvent); |
| |
| void PostCallRecordCreateEvent( |
| VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkEvent* pEvent, |
| VkResult result); |
| |
| void PreCallRecordDestroyEvent( |
| VkDevice device, |
| VkEvent event, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyEvent( |
| VkDevice device, |
| VkEvent event, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetEventStatus( |
| VkDevice device, |
| VkEvent event); |
| |
| void PostCallRecordGetEventStatus( |
| VkDevice device, |
| VkEvent event, |
| VkResult result); |
| |
| void PreCallRecordSetEvent( |
| VkDevice device, |
| VkEvent event); |
| |
| void PostCallRecordSetEvent( |
| VkDevice device, |
| VkEvent event, |
| VkResult result); |
| |
| void PreCallRecordResetEvent( |
| VkDevice device, |
| VkEvent event); |
| |
| void PostCallRecordResetEvent( |
| VkDevice device, |
| VkEvent event, |
| VkResult result); |
| |
| void PreCallRecordCreateQueryPool( |
| VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool); |
| |
| void PostCallRecordCreateQueryPool( |
| VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool, |
| VkResult result); |
| |
| void PreCallRecordDestroyQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetQueryPoolResults( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags); |
| |
| void PostCallRecordGetQueryPoolResults( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags, |
| VkResult result); |
| |
| void PreCallRecordCreateBuffer( |
| VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer); |
| |
| void PostCallRecordCreateBuffer( |
| VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer, |
| VkResult result); |
| |
| void PreCallRecordDestroyBuffer( |
| VkDevice device, |
| VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyBuffer( |
| VkDevice device, |
| VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateBufferView( |
| VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView); |
| |
| void PostCallRecordCreateBufferView( |
| VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView, |
| VkResult result); |
| |
| void PreCallRecordDestroyBufferView( |
| VkDevice device, |
| VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyBufferView( |
| VkDevice device, |
| VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateImage( |
| VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage); |
| |
| void PostCallRecordCreateImage( |
| VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage, |
| VkResult result); |
| |
| void PreCallRecordDestroyImage( |
| VkDevice device, |
| VkImage image, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyImage( |
| VkDevice device, |
| VkImage image, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetImageSubresourceLayout( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout); |
| |
| void PostCallRecordGetImageSubresourceLayout( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout); |
| |
| void PreCallRecordCreateImageView( |
| VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView); |
| |
| void PostCallRecordCreateImageView( |
| VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView, |
| VkResult result); |
| |
| void PreCallRecordDestroyImageView( |
| VkDevice device, |
| VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyImageView( |
| VkDevice device, |
| VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateShaderModule( |
| VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule); |
| |
| void PostCallRecordCreateShaderModule( |
| VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule, |
| VkResult result); |
| |
| void PreCallRecordDestroyShaderModule( |
| VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyShaderModule( |
| VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreatePipelineCache( |
| VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache); |
| |
| void PostCallRecordCreatePipelineCache( |
| VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache, |
| VkResult result); |
| |
| void PreCallRecordDestroyPipelineCache( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyPipelineCache( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetPipelineCacheData( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| size_t* pDataSize, |
| void* pData); |
| |
| void PostCallRecordGetPipelineCacheData( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| size_t* pDataSize, |
| void* pData, |
| VkResult result); |
| |
| void PreCallRecordMergePipelineCaches( |
| VkDevice device, |
| VkPipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches); |
| |
| void PostCallRecordMergePipelineCaches( |
| VkDevice device, |
| VkPipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches, |
| VkResult result); |
| |
| void PreCallRecordCreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines); |
| |
| void PostCallRecordCreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result); |
| |
| void PreCallRecordCreateComputePipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines); |
| |
| void PostCallRecordCreateComputePipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result); |
| |
| void PreCallRecordDestroyPipeline( |
| VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyPipeline( |
| VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreatePipelineLayout( |
| VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout); |
| |
| void PostCallRecordCreatePipelineLayout( |
| VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout, |
| VkResult result); |
| |
| void PreCallRecordDestroyPipelineLayout( |
| VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyPipelineLayout( |
| VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateSampler( |
| VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler); |
| |
| void PostCallRecordCreateSampler( |
| VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler, |
| VkResult result); |
| |
| void PreCallRecordDestroySampler( |
| VkDevice device, |
| VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroySampler( |
| VkDevice device, |
| VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout); |
| |
| void PostCallRecordCreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout, |
| VkResult result); |
| |
| void PreCallRecordDestroyDescriptorSetLayout( |
| VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDescriptorSetLayout( |
| VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateDescriptorPool( |
| VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool); |
| |
| void PostCallRecordCreateDescriptorPool( |
| VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool, |
| VkResult result); |
| |
| void PreCallRecordDestroyDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordResetDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags); |
| |
| void PostCallRecordResetDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags, |
| VkResult result); |
| |
| void PreCallRecordAllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets); |
| |
| void PostCallRecordAllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets, |
| VkResult result); |
| |
| void PreCallRecordFreeDescriptorSets( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets); |
| |
| void PostCallRecordFreeDescriptorSets( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| VkResult result); |
| |
| void PreCallRecordUpdateDescriptorSets( |
| VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies); |
| |
| void PostCallRecordUpdateDescriptorSets( |
| VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies); |
| |
| void PreCallRecordCreateFramebuffer( |
| VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer); |
| |
| void PostCallRecordCreateFramebuffer( |
| VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer, |
| VkResult result); |
| |
| void PreCallRecordDestroyFramebuffer( |
| VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyFramebuffer( |
| VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateRenderPass( |
| VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass); |
| |
| void PostCallRecordCreateRenderPass( |
| VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass, |
| VkResult result); |
| |
| void PreCallRecordDestroyRenderPass( |
| VkDevice device, |
| VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyRenderPass( |
| VkDevice device, |
| VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetRenderAreaGranularity( |
| VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity); |
| |
| void PostCallRecordGetRenderAreaGranularity( |
| VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity); |
| |
| void PreCallRecordCreateCommandPool( |
| VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool); |
| |
| void PostCallRecordCreateCommandPool( |
| VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool, |
| VkResult result); |
| |
| void PreCallRecordDestroyCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordResetCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags); |
| |
| void PostCallRecordResetCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags, |
| VkResult result); |
| |
| void PreCallRecordAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers); |
| |
| void PostCallRecordAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers, |
| VkResult result); |
| |
| void PreCallRecordFreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers); |
| |
| void PostCallRecordFreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers); |
| |
| void PreCallRecordBeginCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo); |
| |
| void PostCallRecordBeginCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo, |
| VkResult result); |
| |
| void PreCallRecordEndCommandBuffer( |
| VkCommandBuffer commandBuffer); |
| |
| void PostCallRecordEndCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkResult result); |
| |
| void PreCallRecordResetCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags); |
| |
| void PostCallRecordResetCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags, |
| VkResult result); |
| |
| void PreCallRecordCmdBindPipeline( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline); |
| |
| void PostCallRecordCmdBindPipeline( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline); |
| |
| void PreCallRecordCmdSetViewport( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewport* pViewports); |
| |
| void PostCallRecordCmdSetViewport( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewport* pViewports); |
| |
| void PreCallRecordCmdSetScissor( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors); |
| |
| void PostCallRecordCmdSetScissor( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors); |
| |
| void PreCallRecordCmdSetLineWidth( |
| VkCommandBuffer commandBuffer, |
| float lineWidth); |
| |
| void PostCallRecordCmdSetLineWidth( |
| VkCommandBuffer commandBuffer, |
| float lineWidth); |
| |
| void PreCallRecordCmdSetDepthBias( |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, |
| float depthBiasClamp, |
| float depthBiasSlopeFactor); |
| |
| void PostCallRecordCmdSetDepthBias( |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, |
| float depthBiasClamp, |
| float depthBiasSlopeFactor); |
| |
| void PreCallRecordCmdSetBlendConstants( |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]); |
| |
| void PostCallRecordCmdSetBlendConstants( |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]); |
| |
| void PreCallRecordCmdSetDepthBounds( |
| VkCommandBuffer commandBuffer, |
| float minDepthBounds, |
| float maxDepthBounds); |
| |
| void PostCallRecordCmdSetDepthBounds( |
| VkCommandBuffer commandBuffer, |
| float minDepthBounds, |
| float maxDepthBounds); |
| |
| void PreCallRecordCmdSetStencilCompareMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t compareMask); |
| |
| void PostCallRecordCmdSetStencilCompareMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t compareMask); |
| |
| void PreCallRecordCmdSetStencilWriteMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t writeMask); |
| |
| void PostCallRecordCmdSetStencilWriteMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t writeMask); |
| |
| void PreCallRecordCmdSetStencilReference( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t reference); |
| |
| void PostCallRecordCmdSetStencilReference( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t reference); |
| |
| void PreCallRecordCmdBindDescriptorSets( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t* pDynamicOffsets); |
| |
| void PostCallRecordCmdBindDescriptorSets( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t* pDynamicOffsets); |
| |
| void PreCallRecordCmdBindIndexBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkIndexType indexType); |
| |
| void PostCallRecordCmdBindIndexBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkIndexType indexType); |
| |
| void PreCallRecordCmdBindVertexBuffers( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets); |
| |
| void PostCallRecordCmdBindVertexBuffers( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets); |
| |
| void PreCallRecordCmdDraw( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexCount, |
| uint32_t instanceCount, |
| uint32_t firstVertex, |
| uint32_t firstInstance); |
| |
| void PostCallRecordCmdDraw( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexCount, |
| uint32_t instanceCount, |
| uint32_t firstVertex, |
| uint32_t firstInstance); |
| |
| void PreCallRecordCmdDrawIndexed( |
| VkCommandBuffer commandBuffer, |
| uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance); |
| |
| void PostCallRecordCmdDrawIndexed( |
| VkCommandBuffer commandBuffer, |
| uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance); |
| |
| void PreCallRecordCmdDrawIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void PreCallRecordCmdDrawIndexedIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawIndexedIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void PreCallRecordCmdDispatch( |
| VkCommandBuffer commandBuffer, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ); |
| |
| void PostCallRecordCmdDispatch( |
| VkCommandBuffer commandBuffer, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ); |
| |
| void PreCallRecordCmdDispatchIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset); |
| |
| void PostCallRecordCmdDispatchIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset); |
| |
| void PreCallRecordCmdCopyBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferCopy* pRegions); |
| |
| void PostCallRecordCmdCopyBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferCopy* pRegions); |
| |
| void PreCallRecordCmdCopyImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageCopy* pRegions); |
| |
| void PostCallRecordCmdCopyImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageCopy* pRegions); |
| |
| void PreCallRecordCmdBlitImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageBlit* pRegions, |
| VkFilter filter); |
| |
| void PostCallRecordCmdBlitImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageBlit* pRegions, |
| VkFilter filter); |
| |
| void PreCallRecordCmdCopyBufferToImage( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions); |
| |
| void PostCallRecordCmdCopyBufferToImage( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions); |
| |
| void PreCallRecordCmdCopyImageToBuffer( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions); |
| |
| void PostCallRecordCmdCopyImageToBuffer( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions); |
| |
| void PreCallRecordCmdUpdateBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize dataSize, |
| const void* pData); |
| |
| void PostCallRecordCmdUpdateBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize dataSize, |
| const void* pData); |
| |
| void PreCallRecordCmdFillBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize size, |
| uint32_t data); |
| |
| void PostCallRecordCmdFillBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize size, |
| uint32_t data); |
| |
| void PreCallRecordCmdClearColorImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges); |
| |
| void PostCallRecordCmdClearColorImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges); |
| |
| void PreCallRecordCmdClearDepthStencilImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges); |
| |
| void PostCallRecordCmdClearDepthStencilImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges); |
| |
| void PreCallRecordCmdClearAttachments( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkClearAttachment* pAttachments, |
| uint32_t rectCount, |
| const VkClearRect* pRects); |
| |
| void PostCallRecordCmdClearAttachments( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkClearAttachment* pAttachments, |
| uint32_t rectCount, |
| const VkClearRect* pRects); |
| |
| void PreCallRecordCmdResolveImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageResolve* pRegions); |
| |
| void PostCallRecordCmdResolveImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageResolve* pRegions); |
| |
| void PreCallRecordCmdSetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask); |
| |
| void PostCallRecordCmdSetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask); |
| |
| void PreCallRecordCmdResetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask); |
| |
| void PostCallRecordCmdResetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask); |
| |
| void PreCallRecordCmdWaitEvents( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers); |
| |
| void PostCallRecordCmdWaitEvents( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers); |
| |
| void PreCallRecordCmdPipelineBarrier( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| VkDependencyFlags dependencyFlags, |
| uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers); |
| |
| void PostCallRecordCmdPipelineBarrier( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| VkDependencyFlags dependencyFlags, |
| uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers); |
| |
| void PreCallRecordCmdBeginQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags); |
| |
| void PostCallRecordCmdBeginQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags); |
| |
| void PreCallRecordCmdEndQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query); |
| |
| void PostCallRecordCmdEndQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query); |
| |
| void PreCallRecordCmdResetQueryPool( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount); |
| |
| void PostCallRecordCmdResetQueryPool( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount); |
| |
| void PreCallRecordCmdWriteTimestamp( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, |
| uint32_t query); |
| |
| void PostCallRecordCmdWriteTimestamp( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, |
| uint32_t query); |
| |
| void PreCallRecordCmdCopyQueryPoolResults( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags); |
| |
| void PostCallRecordCmdCopyQueryPoolResults( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags); |
| |
| void PreCallRecordCmdPushConstants( |
| VkCommandBuffer commandBuffer, |
| VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void* pValues); |
| |
| void PostCallRecordCmdPushConstants( |
| VkCommandBuffer commandBuffer, |
| VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void* pValues); |
| |
| void PreCallRecordCmdBeginRenderPass( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents); |
| |
| void PostCallRecordCmdBeginRenderPass( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents); |
| |
| void PreCallRecordCmdNextSubpass( |
| VkCommandBuffer commandBuffer, |
| VkSubpassContents contents); |
| |
| void PostCallRecordCmdNextSubpass( |
| VkCommandBuffer commandBuffer, |
| VkSubpassContents contents); |
| |
| void PreCallRecordCmdEndRenderPass( |
| VkCommandBuffer commandBuffer); |
| |
| void PostCallRecordCmdEndRenderPass( |
| VkCommandBuffer commandBuffer); |
| |
| void PreCallRecordCmdExecuteCommands( |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers); |
| |
| void PostCallRecordCmdExecuteCommands( |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers); |
| |
| void PreCallRecordBindBufferMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos); |
| |
| void PostCallRecordBindBufferMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos, |
| VkResult result); |
| |
| void PreCallRecordBindImageMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos); |
| |
| void PostCallRecordBindImageMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos, |
| VkResult result); |
| |
| void PreCallRecordGetDeviceGroupPeerMemoryFeatures( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); |
| |
| void PostCallRecordGetDeviceGroupPeerMemoryFeatures( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); |
| |
| void PreCallRecordCmdSetDeviceMask( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask); |
| |
| void PostCallRecordCmdSetDeviceMask( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask); |
| |
| void PreCallRecordCmdDispatchBase( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ); |
| |
| void PostCallRecordCmdDispatchBase( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ); |
| |
| void PreCallRecordEnumeratePhysicalDeviceGroups( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); |
| |
| void PostCallRecordEnumeratePhysicalDeviceGroups( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, |
| VkResult result); |
| |
| void PreCallRecordGetImageMemoryRequirements2( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PostCallRecordGetImageMemoryRequirements2( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PreCallRecordGetBufferMemoryRequirements2( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PostCallRecordGetBufferMemoryRequirements2( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PreCallRecordGetImageSparseMemoryRequirements2( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); |
| |
| void PostCallRecordGetImageSparseMemoryRequirements2( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); |
| |
| void PreCallRecordTrimCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags); |
| |
| void PostCallRecordTrimCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags); |
| |
| void PreCallRecordGetDeviceQueue2( |
| VkDevice device, |
| const VkDeviceQueueInfo2* pQueueInfo, |
| VkQueue* pQueue); |
| |
| void PostCallRecordGetDeviceQueue2( |
| VkDevice device, |
| const VkDeviceQueueInfo2* pQueueInfo, |
| VkQueue* pQueue); |
| |
| void PreCallRecordCreateSamplerYcbcrConversion( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion); |
| |
| void PostCallRecordCreateSamplerYcbcrConversion( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion, |
| VkResult result); |
| |
| void PreCallRecordDestroySamplerYcbcrConversion( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroySamplerYcbcrConversion( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateDescriptorUpdateTemplate( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); |
| |
| void PostCallRecordCreateDescriptorUpdateTemplate( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, |
| VkResult result); |
| |
| void PreCallRecordDestroyDescriptorUpdateTemplate( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDescriptorUpdateTemplate( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordUpdateDescriptorSetWithTemplate( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData); |
| |
| void PostCallRecordUpdateDescriptorSetWithTemplate( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData); |
| |
| void PreCallRecordGetDescriptorSetLayoutSupport( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport); |
| |
| void PostCallRecordGetDescriptorSetLayoutSupport( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport); |
| |
| void PreCallRecordDestroySurfaceKHR( |
| VkInstance instance, |
| VkSurfaceKHR surface, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroySurfaceKHR( |
| VkInstance instance, |
| VkSurfaceKHR surface, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| VkSurfaceKHR surface, |
| VkBool32* pSupported); |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| VkSurfaceKHR surface, |
| VkBool32* pSupported, |
| VkResult result); |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, |
| VkResult result); |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pSurfaceFormatCount, |
| VkSurfaceFormatKHR* pSurfaceFormats); |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pSurfaceFormatCount, |
| VkSurfaceFormatKHR* pSurfaceFormats, |
| VkResult result); |
| |
| void PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pPresentModeCount, |
| VkPresentModeKHR* pPresentModes); |
| |
| void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pPresentModeCount, |
| VkPresentModeKHR* pPresentModes, |
| VkResult result); |
| |
| void PreCallRecordCreateSwapchainKHR( |
| VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain); |
| |
| void PostCallRecordCreateSwapchainKHR( |
| VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain, |
| VkResult result); |
| |
| void PreCallRecordDestroySwapchainKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroySwapchainKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetSwapchainImagesKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, |
| VkImage* pSwapchainImages); |
| |
| void PostCallRecordGetSwapchainImagesKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, |
| VkImage* pSwapchainImages, |
| VkResult result); |
| |
| void PreCallRecordAcquireNextImageKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t timeout, |
| VkSemaphore semaphore, |
| VkFence fence, |
| uint32_t* pImageIndex); |
| |
| void PostCallRecordAcquireNextImageKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t timeout, |
| VkSemaphore semaphore, |
| VkFence fence, |
| uint32_t* pImageIndex, |
| VkResult result); |
| |
| void PreCallRecordGetDeviceGroupPresentCapabilitiesKHR( |
| VkDevice device, |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); |
| |
| void PostCallRecordGetDeviceGroupPresentCapabilitiesKHR( |
| VkDevice device, |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, |
| VkResult result); |
| |
| void PreCallRecordGetDeviceGroupSurfacePresentModesKHR( |
| VkDevice device, |
| VkSurfaceKHR surface, |
| VkDeviceGroupPresentModeFlagsKHR* pModes); |
| |
| void PostCallRecordGetDeviceGroupSurfacePresentModesKHR( |
| VkDevice device, |
| VkSurfaceKHR surface, |
| VkDeviceGroupPresentModeFlagsKHR* pModes, |
| VkResult result); |
| |
| void PreCallRecordGetPhysicalDevicePresentRectanglesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pRectCount, |
| VkRect2D* pRects); |
| |
| void PostCallRecordGetPhysicalDevicePresentRectanglesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pRectCount, |
| VkRect2D* pRects, |
| VkResult result); |
| |
| void PreCallRecordAcquireNextImage2KHR( |
| VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, |
| uint32_t* pImageIndex); |
| |
| void PostCallRecordAcquireNextImage2KHR( |
| VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, |
| uint32_t* pImageIndex, |
| VkResult result); |
| |
| void PreCallRecordGetDisplayPlaneSupportedDisplaysKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t planeIndex, |
| uint32_t* pDisplayCount, |
| VkDisplayKHR* pDisplays); |
| |
| void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t planeIndex, |
| uint32_t* pDisplayCount, |
| VkDisplayKHR* pDisplays, |
| VkResult result); |
| |
| void PreCallRecordGetDisplayModePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModePropertiesKHR* pProperties); |
| |
| void PostCallRecordGetDisplayModePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModePropertiesKHR* pProperties, |
| VkResult result); |
| |
| void PreCallRecordCreateDisplayModeKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDisplayModeKHR* pMode); |
| |
| void PostCallRecordCreateDisplayModeKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDisplayModeKHR* pMode, |
| VkResult result); |
| |
| void PreCallRecordGetDisplayPlaneCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayModeKHR mode, |
| uint32_t planeIndex, |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities); |
| |
| void PostCallRecordGetDisplayPlaneCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayModeKHR mode, |
| uint32_t planeIndex, |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities, |
| VkResult result); |
| |
| void PreCallRecordCreateDisplayPlaneSurfaceKHR( |
| VkInstance instance, |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateDisplayPlaneSurfaceKHR( |
| VkInstance instance, |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| |
| void PreCallRecordCreateSharedSwapchainsKHR( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchains); |
| |
| void PostCallRecordCreateSharedSwapchainsKHR( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchains, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| |
| void PreCallRecordCreateXlibSurfaceKHR( |
| VkInstance instance, |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateXlibSurfaceKHR( |
| VkInstance instance, |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_XLIB_KHR |
| |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| |
| void PreCallRecordCreateXcbSurfaceKHR( |
| VkInstance instance, |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateXcbSurfaceKHR( |
| VkInstance instance, |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_XCB_KHR |
| |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| |
| void PreCallRecordCreateWaylandSurfaceKHR( |
| VkInstance instance, |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateWaylandSurfaceKHR( |
| VkInstance instance, |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| void PreCallRecordCreateAndroidSurfaceKHR( |
| VkInstance instance, |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateAndroidSurfaceKHR( |
| VkInstance instance, |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordCreateWin32SurfaceKHR( |
| VkInstance instance, |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateWin32SurfaceKHR( |
| VkInstance instance, |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); |
| |
| void PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); |
| |
| void PreCallRecordCmdSetDeviceMaskKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask); |
| |
| void PostCallRecordCmdSetDeviceMaskKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask); |
| |
| void PreCallRecordCmdDispatchBaseKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ); |
| |
| void PostCallRecordCmdDispatchBaseKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ); |
| |
| void PreCallRecordTrimCommandPoolKHR( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags); |
| |
| void PostCallRecordTrimCommandPoolKHR( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags); |
| |
| void PreCallRecordEnumeratePhysicalDeviceGroupsKHR( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); |
| |
| void PostCallRecordEnumeratePhysicalDeviceGroupsKHR( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetMemoryWin32HandleKHR( |
| VkDevice device, |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle); |
| |
| void PostCallRecordGetMemoryWin32HandleKHR( |
| VkDevice device, |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle, |
| VkResult result); |
| |
| void PreCallRecordGetMemoryWin32HandlePropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| HANDLE handle, |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); |
| |
| void PostCallRecordGetMemoryWin32HandlePropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| HANDLE handle, |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetMemoryFdKHR( |
| VkDevice device, |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, |
| int* pFd); |
| |
| void PostCallRecordGetMemoryFdKHR( |
| VkDevice device, |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, |
| int* pFd, |
| VkResult result); |
| |
| void PreCallRecordGetMemoryFdPropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| int fd, |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties); |
| |
| void PostCallRecordGetMemoryFdPropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| int fd, |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); |
| |
| void PostCallRecordImportSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, |
| VkResult result); |
| |
| void PreCallRecordGetSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle); |
| |
| void PostCallRecordGetSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportSemaphoreFdKHR( |
| VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); |
| |
| void PostCallRecordImportSemaphoreFdKHR( |
| VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, |
| VkResult result); |
| |
| void PreCallRecordGetSemaphoreFdKHR( |
| VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, |
| int* pFd); |
| |
| void PostCallRecordGetSemaphoreFdKHR( |
| VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, |
| int* pFd, |
| VkResult result); |
| |
| void PreCallRecordCmdPushDescriptorSetKHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t set, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites); |
| |
| void PostCallRecordCmdPushDescriptorSetKHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t set, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites); |
| |
| void PreCallRecordCmdPushDescriptorSetWithTemplateKHR( |
| VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VkPipelineLayout layout, |
| uint32_t set, |
| const void* pData); |
| |
| void PostCallRecordCmdPushDescriptorSetWithTemplateKHR( |
| VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VkPipelineLayout layout, |
| uint32_t set, |
| const void* pData); |
| |
| void PreCallRecordCreateDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); |
| |
| void PostCallRecordCreateDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, |
| VkResult result); |
| |
| void PreCallRecordDestroyDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordUpdateDescriptorSetWithTemplateKHR( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData); |
| |
| void PostCallRecordUpdateDescriptorSetWithTemplateKHR( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData); |
| |
| void PreCallRecordCreateRenderPass2KHR( |
| VkDevice device, |
| const VkRenderPassCreateInfo2KHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass); |
| |
| void PostCallRecordCreateRenderPass2KHR( |
| VkDevice device, |
| const VkRenderPassCreateInfo2KHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass, |
| VkResult result); |
| |
| void PreCallRecordCmdBeginRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfoKHR* pSubpassBeginInfo); |
| |
| void PostCallRecordCmdBeginRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfoKHR* pSubpassBeginInfo); |
| |
| void PreCallRecordCmdNextSubpass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfoKHR* pSubpassBeginInfo, |
| const VkSubpassEndInfoKHR* pSubpassEndInfo); |
| |
| void PostCallRecordCmdNextSubpass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfoKHR* pSubpassBeginInfo, |
| const VkSubpassEndInfoKHR* pSubpassEndInfo); |
| |
| void PreCallRecordCmdEndRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfoKHR* pSubpassEndInfo); |
| |
| void PostCallRecordCmdEndRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfoKHR* pSubpassEndInfo); |
| |
| void PreCallRecordGetSwapchainStatusKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain); |
| |
| void PostCallRecordGetSwapchainStatusKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportFenceWin32HandleKHR( |
| VkDevice device, |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); |
| |
| void PostCallRecordImportFenceWin32HandleKHR( |
| VkDevice device, |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, |
| VkResult result); |
| |
| void PreCallRecordGetFenceWin32HandleKHR( |
| VkDevice device, |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle); |
| |
| void PostCallRecordGetFenceWin32HandleKHR( |
| VkDevice device, |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportFenceFdKHR( |
| VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo); |
| |
| void PostCallRecordImportFenceFdKHR( |
| VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo, |
| VkResult result); |
| |
| void PreCallRecordGetFenceFdKHR( |
| VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, |
| int* pFd); |
| |
| void PostCallRecordGetFenceFdKHR( |
| VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, |
| int* pFd, |
| VkResult result); |
| |
| void PreCallRecordGetDisplayModeProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModeProperties2KHR* pProperties); |
| |
| void PostCallRecordGetDisplayModeProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModeProperties2KHR* pProperties, |
| VkResult result); |
| |
| void PreCallRecordGetImageMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PostCallRecordGetImageMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PreCallRecordGetBufferMemoryRequirements2KHR( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PostCallRecordGetBufferMemoryRequirements2KHR( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements); |
| |
| void PreCallRecordGetImageSparseMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); |
| |
| void PostCallRecordGetImageSparseMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); |
| |
| void PreCallRecordCreateSamplerYcbcrConversionKHR( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion); |
| |
| void PostCallRecordCreateSamplerYcbcrConversionKHR( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion, |
| VkResult result); |
| |
| void PreCallRecordDestroySamplerYcbcrConversionKHR( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroySamplerYcbcrConversionKHR( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordBindBufferMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos); |
| |
| void PostCallRecordBindBufferMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos, |
| VkResult result); |
| |
| void PreCallRecordBindImageMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos); |
| |
| void PostCallRecordBindImageMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos, |
| VkResult result); |
| |
| void PreCallRecordGetDescriptorSetLayoutSupportKHR( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport); |
| |
| void PostCallRecordGetDescriptorSetLayoutSupportKHR( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport); |
| |
| void PreCallRecordCmdDrawIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PreCallRecordCmdDrawIndexedIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawIndexedIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PreCallRecordGetPipelineExecutablePropertiesKHR( |
| VkDevice device, |
| const VkPipelineInfoKHR* pPipelineInfo, |
| uint32_t* pExecutableCount, |
| VkPipelineExecutablePropertiesKHR* pProperties); |
| |
| void PostCallRecordGetPipelineExecutablePropertiesKHR( |
| VkDevice device, |
| const VkPipelineInfoKHR* pPipelineInfo, |
| uint32_t* pExecutableCount, |
| VkPipelineExecutablePropertiesKHR* pProperties, |
| VkResult result); |
| |
| void PreCallRecordGetPipelineExecutableStatisticsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pStatisticCount, |
| VkPipelineExecutableStatisticKHR* pStatistics); |
| |
| void PostCallRecordGetPipelineExecutableStatisticsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pStatisticCount, |
| VkPipelineExecutableStatisticKHR* pStatistics, |
| VkResult result); |
| |
| void PreCallRecordGetPipelineExecutableInternalRepresentationsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pInternalRepresentationCount, |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); |
| |
| void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pInternalRepresentationCount, |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, |
| VkResult result); |
| |
| void PreCallRecordCreateDebugReportCallbackEXT( |
| VkInstance instance, |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugReportCallbackEXT* pCallback); |
| |
| void PostCallRecordCreateDebugReportCallbackEXT( |
| VkInstance instance, |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugReportCallbackEXT* pCallback, |
| VkResult result); |
| |
| void PreCallRecordDestroyDebugReportCallbackEXT( |
| VkInstance instance, |
| VkDebugReportCallbackEXT callback, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDebugReportCallbackEXT( |
| VkInstance instance, |
| VkDebugReportCallbackEXT callback, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordDebugReportMessageEXT( |
| VkInstance instance, |
| VkDebugReportFlagsEXT flags, |
| VkDebugReportObjectTypeEXT objectType, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const char* pLayerPrefix, |
| const char* pMessage); |
| |
| void PostCallRecordDebugReportMessageEXT( |
| VkInstance instance, |
| VkDebugReportFlagsEXT flags, |
| VkDebugReportObjectTypeEXT objectType, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const char* pLayerPrefix, |
| const char* pMessage); |
| // TODO - not wrapping EXT function vkDebugMarkerSetObjectTagEXT |
| // TODO - not wrapping EXT function vkDebugMarkerSetObjectNameEXT |
| // TODO - not wrapping EXT function vkCmdDebugMarkerBeginEXT |
| // TODO - not wrapping EXT function vkCmdDebugMarkerEndEXT |
| // TODO - not wrapping EXT function vkCmdDebugMarkerInsertEXT |
| |
| void PreCallRecordCmdBindTransformFeedbackBuffersEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes); |
| |
| void PostCallRecordCmdBindTransformFeedbackBuffersEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes); |
| |
| void PreCallRecordCmdBeginTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets); |
| |
| void PostCallRecordCmdBeginTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets); |
| |
| void PreCallRecordCmdEndTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets); |
| |
| void PostCallRecordCmdEndTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets); |
| |
| void PreCallRecordCmdBeginQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags, |
| uint32_t index); |
| |
| void PostCallRecordCmdBeginQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags, |
| uint32_t index); |
| |
| void PreCallRecordCmdEndQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| uint32_t index); |
| |
| void PostCallRecordCmdEndQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| uint32_t index); |
| |
| void PreCallRecordCmdDrawIndirectByteCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| VkBuffer counterBuffer, |
| VkDeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride); |
| |
| void PostCallRecordCmdDrawIndirectByteCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| VkBuffer counterBuffer, |
| VkDeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride); |
| |
| void PreCallRecordGetImageViewHandleNVX( |
| VkDevice device, |
| const VkImageViewHandleInfoNVX* pInfo); |
| |
| void PostCallRecordGetImageViewHandleNVX( |
| VkDevice device, |
| const VkImageViewHandleInfoNVX* pInfo); |
| |
| void PreCallRecordCmdDrawIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PreCallRecordCmdDrawIndexedIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawIndexedIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PreCallRecordGetShaderInfoAMD( |
| VkDevice device, |
| VkPipeline pipeline, |
| VkShaderStageFlagBits shaderStage, |
| VkShaderInfoTypeAMD infoType, |
| size_t* pInfoSize, |
| void* pInfo); |
| |
| void PostCallRecordGetShaderInfoAMD( |
| VkDevice device, |
| VkPipeline pipeline, |
| VkShaderStageFlagBits shaderStage, |
| VkShaderInfoTypeAMD infoType, |
| size_t* pInfoSize, |
| void* pInfo, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_GGP |
| |
| void PreCallRecordCreateStreamDescriptorSurfaceGGP( |
| VkInstance instance, |
| const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateStreamDescriptorSurfaceGGP( |
| VkInstance instance, |
| const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_GGP |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetMemoryWin32HandleNV( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, |
| HANDLE* pHandle); |
| |
| void PostCallRecordGetMemoryWin32HandleNV( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, |
| HANDLE* pHandle, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_VI_NN |
| |
| void PreCallRecordCreateViSurfaceNN( |
| VkInstance instance, |
| const VkViSurfaceCreateInfoNN* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateViSurfaceNN( |
| VkInstance instance, |
| const VkViSurfaceCreateInfoNN* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_VI_NN |
| |
| void PreCallRecordCmdBeginConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer, |
| const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); |
| |
| void PostCallRecordCmdBeginConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer, |
| const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); |
| |
| void PreCallRecordCmdEndConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer); |
| |
| void PostCallRecordCmdEndConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer); |
| |
| void PreCallRecordCmdProcessCommandsNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); |
| |
| void PostCallRecordCmdProcessCommandsNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); |
| |
| void PreCallRecordCmdReserveSpaceForCommandsNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); |
| |
| void PostCallRecordCmdReserveSpaceForCommandsNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); |
| |
| void PreCallRecordCreateIndirectCommandsLayoutNVX( |
| VkDevice device, |
| const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); |
| |
| void PostCallRecordCreateIndirectCommandsLayoutNVX( |
| VkDevice device, |
| const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout, |
| VkResult result); |
| |
| void PreCallRecordDestroyIndirectCommandsLayoutNVX( |
| VkDevice device, |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyIndirectCommandsLayoutNVX( |
| VkDevice device, |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordCreateObjectTableNVX( |
| VkDevice device, |
| const VkObjectTableCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkObjectTableNVX* pObjectTable); |
| |
| void PostCallRecordCreateObjectTableNVX( |
| VkDevice device, |
| const VkObjectTableCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkObjectTableNVX* pObjectTable, |
| VkResult result); |
| |
| void PreCallRecordDestroyObjectTableNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyObjectTableNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordRegisterObjectsNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| uint32_t objectCount, |
| const VkObjectTableEntryNVX* const* ppObjectTableEntries, |
| const uint32_t* pObjectIndices); |
| |
| void PostCallRecordRegisterObjectsNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| uint32_t objectCount, |
| const VkObjectTableEntryNVX* const* ppObjectTableEntries, |
| const uint32_t* pObjectIndices, |
| VkResult result); |
| |
| void PreCallRecordUnregisterObjectsNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| uint32_t objectCount, |
| const VkObjectEntryTypeNVX* pObjectEntryTypes, |
| const uint32_t* pObjectIndices); |
| |
| void PostCallRecordUnregisterObjectsNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| uint32_t objectCount, |
| const VkObjectEntryTypeNVX* pObjectEntryTypes, |
| const uint32_t* pObjectIndices, |
| VkResult result); |
| |
| void PreCallRecordCmdSetViewportWScalingNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewportWScalingNV* pViewportWScalings); |
| |
| void PostCallRecordCmdSetViewportWScalingNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewportWScalingNV* pViewportWScalings); |
| |
| void PreCallRecordReleaseDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display); |
| |
| void PostCallRecordReleaseDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| void PreCallRecordAcquireXlibDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| VkDisplayKHR display); |
| |
| void PostCallRecordAcquireXlibDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| VkDisplayKHR display, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities); |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities, |
| VkResult result); |
| |
| void PreCallRecordDisplayPowerControlEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo); |
| |
| void PostCallRecordDisplayPowerControlEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo, |
| VkResult result); |
| |
| void PreCallRecordRegisterDeviceEventEXT( |
| VkDevice device, |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence); |
| |
| void PostCallRecordRegisterDeviceEventEXT( |
| VkDevice device, |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence, |
| VkResult result); |
| |
| void PreCallRecordRegisterDisplayEventEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence); |
| |
| void PostCallRecordRegisterDisplayEventEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence, |
| VkResult result); |
| |
| void PreCallRecordGetSwapchainCounterEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkSurfaceCounterFlagBitsEXT counter, |
| uint64_t* pCounterValue); |
| |
| void PostCallRecordGetSwapchainCounterEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkSurfaceCounterFlagBitsEXT counter, |
| uint64_t* pCounterValue, |
| VkResult result); |
| |
| void PreCallRecordGetRefreshCycleDurationGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); |
| |
| void PostCallRecordGetRefreshCycleDurationGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, |
| VkResult result); |
| |
| void PreCallRecordGetPastPresentationTimingGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pPresentationTimingCount, |
| VkPastPresentationTimingGOOGLE* pPresentationTimings); |
| |
| void PostCallRecordGetPastPresentationTimingGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pPresentationTimingCount, |
| VkPastPresentationTimingGOOGLE* pPresentationTimings, |
| VkResult result); |
| |
| void PreCallRecordCmdSetDiscardRectangleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstDiscardRectangle, |
| uint32_t discardRectangleCount, |
| const VkRect2D* pDiscardRectangles); |
| |
| void PostCallRecordCmdSetDiscardRectangleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstDiscardRectangle, |
| uint32_t discardRectangleCount, |
| const VkRect2D* pDiscardRectangles); |
| |
| void PreCallRecordSetHdrMetadataEXT( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainKHR* pSwapchains, |
| const VkHdrMetadataEXT* pMetadata); |
| |
| void PostCallRecordSetHdrMetadataEXT( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainKHR* pSwapchains, |
| const VkHdrMetadataEXT* pMetadata); |
| |
| #ifdef VK_USE_PLATFORM_IOS_MVK |
| |
| void PreCallRecordCreateIOSSurfaceMVK( |
| VkInstance instance, |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateIOSSurfaceMVK( |
| VkInstance instance, |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_IOS_MVK |
| |
| #ifdef VK_USE_PLATFORM_MACOS_MVK |
| |
| void PreCallRecordCreateMacOSSurfaceMVK( |
| VkInstance instance, |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateMacOSSurfaceMVK( |
| VkInstance instance, |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_MACOS_MVK |
| // TODO - not wrapping EXT function vkSetDebugUtilsObjectNameEXT |
| // TODO - not wrapping EXT function vkSetDebugUtilsObjectTagEXT |
| |
| void PreCallRecordQueueBeginDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PostCallRecordQueueBeginDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PreCallRecordQueueEndDebugUtilsLabelEXT( |
| VkQueue queue); |
| |
| void PostCallRecordQueueEndDebugUtilsLabelEXT( |
| VkQueue queue); |
| |
| void PreCallRecordQueueInsertDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PostCallRecordQueueInsertDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PreCallRecordCmdBeginDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PostCallRecordCmdBeginDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PreCallRecordCmdEndDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer); |
| |
| void PostCallRecordCmdEndDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer); |
| |
| void PreCallRecordCmdInsertDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PostCallRecordCmdInsertDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| void PreCallRecordCreateDebugUtilsMessengerEXT( |
| VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger); |
| |
| void PostCallRecordCreateDebugUtilsMessengerEXT( |
| VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger, |
| VkResult result); |
| |
| void PreCallRecordDestroyDebugUtilsMessengerEXT( |
| VkInstance instance, |
| VkDebugUtilsMessengerEXT messenger, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyDebugUtilsMessengerEXT( |
| VkInstance instance, |
| VkDebugUtilsMessengerEXT messenger, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordSubmitDebugUtilsMessageEXT( |
| VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); |
| |
| void PostCallRecordSubmitDebugUtilsMessageEXT( |
| VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| void PreCallRecordGetAndroidHardwareBufferPropertiesANDROID( |
| VkDevice device, |
| const struct AHardwareBuffer* buffer, |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties); |
| |
| void PostCallRecordGetAndroidHardwareBufferPropertiesANDROID( |
| VkDevice device, |
| const struct AHardwareBuffer* buffer, |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties, |
| VkResult result); |
| |
| void PreCallRecordGetMemoryAndroidHardwareBufferANDROID( |
| VkDevice device, |
| const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, |
| struct AHardwareBuffer** pBuffer); |
| |
| void PostCallRecordGetMemoryAndroidHardwareBufferANDROID( |
| VkDevice device, |
| const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, |
| struct AHardwareBuffer** pBuffer, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| void PreCallRecordCmdSetSampleLocationsEXT( |
| VkCommandBuffer commandBuffer, |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo); |
| |
| void PostCallRecordCmdSetSampleLocationsEXT( |
| VkCommandBuffer commandBuffer, |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo); |
| |
| void PreCallRecordGetImageDrmFormatModifierPropertiesEXT( |
| VkDevice device, |
| VkImage image, |
| VkImageDrmFormatModifierPropertiesEXT* pProperties); |
| |
| void PostCallRecordGetImageDrmFormatModifierPropertiesEXT( |
| VkDevice device, |
| VkImage image, |
| VkImageDrmFormatModifierPropertiesEXT* pProperties, |
| VkResult result); |
| |
| void PreCallRecordCreateValidationCacheEXT( |
| VkDevice device, |
| const VkValidationCacheCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkValidationCacheEXT* pValidationCache); |
| |
| void PostCallRecordCreateValidationCacheEXT( |
| VkDevice device, |
| const VkValidationCacheCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkValidationCacheEXT* pValidationCache, |
| VkResult result); |
| |
| void PreCallRecordDestroyValidationCacheEXT( |
| VkDevice device, |
| VkValidationCacheEXT validationCache, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyValidationCacheEXT( |
| VkDevice device, |
| VkValidationCacheEXT validationCache, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordMergeValidationCachesEXT( |
| VkDevice device, |
| VkValidationCacheEXT dstCache, |
| uint32_t srcCacheCount, |
| const VkValidationCacheEXT* pSrcCaches); |
| |
| void PostCallRecordMergeValidationCachesEXT( |
| VkDevice device, |
| VkValidationCacheEXT dstCache, |
| uint32_t srcCacheCount, |
| const VkValidationCacheEXT* pSrcCaches, |
| VkResult result); |
| |
| void PreCallRecordGetValidationCacheDataEXT( |
| VkDevice device, |
| VkValidationCacheEXT validationCache, |
| size_t* pDataSize, |
| void* pData); |
| |
| void PostCallRecordGetValidationCacheDataEXT( |
| VkDevice device, |
| VkValidationCacheEXT validationCache, |
| size_t* pDataSize, |
| void* pData, |
| VkResult result); |
| |
| void PreCallRecordCmdBindShadingRateImageNV( |
| VkCommandBuffer commandBuffer, |
| VkImageView imageView, |
| VkImageLayout imageLayout); |
| |
| void PostCallRecordCmdBindShadingRateImageNV( |
| VkCommandBuffer commandBuffer, |
| VkImageView imageView, |
| VkImageLayout imageLayout); |
| |
| void PreCallRecordCmdSetViewportShadingRatePaletteNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkShadingRatePaletteNV* pShadingRatePalettes); |
| |
| void PostCallRecordCmdSetViewportShadingRatePaletteNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkShadingRatePaletteNV* pShadingRatePalettes); |
| |
| void PreCallRecordCmdSetCoarseSampleOrderNV( |
| VkCommandBuffer commandBuffer, |
| VkCoarseSampleOrderTypeNV sampleOrderType, |
| uint32_t customSampleOrderCount, |
| const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); |
| |
| void PostCallRecordCmdSetCoarseSampleOrderNV( |
| VkCommandBuffer commandBuffer, |
| VkCoarseSampleOrderTypeNV sampleOrderType, |
| uint32_t customSampleOrderCount, |
| const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); |
| |
| void PreCallRecordCreateAccelerationStructureNV( |
| VkDevice device, |
| const VkAccelerationStructureCreateInfoNV* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkAccelerationStructureNV* pAccelerationStructure); |
| |
| void PostCallRecordCreateAccelerationStructureNV( |
| VkDevice device, |
| const VkAccelerationStructureCreateInfoNV* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkAccelerationStructureNV* pAccelerationStructure, |
| VkResult result); |
| |
| void PreCallRecordDestroyAccelerationStructureNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PostCallRecordDestroyAccelerationStructureNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| const VkAllocationCallbacks* pAllocator); |
| |
| void PreCallRecordGetAccelerationStructureMemoryRequirementsNV( |
| VkDevice device, |
| const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, |
| VkMemoryRequirements2KHR* pMemoryRequirements); |
| |
| void PostCallRecordGetAccelerationStructureMemoryRequirementsNV( |
| VkDevice device, |
| const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, |
| VkMemoryRequirements2KHR* pMemoryRequirements); |
| |
| void PreCallRecordBindAccelerationStructureMemoryNV( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); |
| |
| void PostCallRecordBindAccelerationStructureMemoryNV( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, |
| VkResult result); |
| |
| void PreCallRecordCmdBuildAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| const VkAccelerationStructureInfoNV* pInfo, |
| VkBuffer instanceData, |
| VkDeviceSize instanceOffset, |
| VkBool32 update, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkBuffer scratch, |
| VkDeviceSize scratchOffset); |
| |
| void PostCallRecordCmdBuildAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| const VkAccelerationStructureInfoNV* pInfo, |
| VkBuffer instanceData, |
| VkDeviceSize instanceOffset, |
| VkBool32 update, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkBuffer scratch, |
| VkDeviceSize scratchOffset); |
| |
| void PreCallRecordCmdCopyAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkCopyAccelerationStructureModeNV mode); |
| |
| void PostCallRecordCmdCopyAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkCopyAccelerationStructureModeNV mode); |
| |
| void PreCallRecordCmdTraceRaysNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer raygenShaderBindingTableBuffer, |
| VkDeviceSize raygenShaderBindingOffset, |
| VkBuffer missShaderBindingTableBuffer, |
| VkDeviceSize missShaderBindingOffset, |
| VkDeviceSize missShaderBindingStride, |
| VkBuffer hitShaderBindingTableBuffer, |
| VkDeviceSize hitShaderBindingOffset, |
| VkDeviceSize hitShaderBindingStride, |
| VkBuffer callableShaderBindingTableBuffer, |
| VkDeviceSize callableShaderBindingOffset, |
| VkDeviceSize callableShaderBindingStride, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth); |
| |
| void PostCallRecordCmdTraceRaysNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer raygenShaderBindingTableBuffer, |
| VkDeviceSize raygenShaderBindingOffset, |
| VkBuffer missShaderBindingTableBuffer, |
| VkDeviceSize missShaderBindingOffset, |
| VkDeviceSize missShaderBindingStride, |
| VkBuffer hitShaderBindingTableBuffer, |
| VkDeviceSize hitShaderBindingOffset, |
| VkDeviceSize hitShaderBindingStride, |
| VkBuffer callableShaderBindingTableBuffer, |
| VkDeviceSize callableShaderBindingOffset, |
| VkDeviceSize callableShaderBindingStride, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth); |
| |
| void PreCallRecordCreateRayTracingPipelinesNV( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkRayTracingPipelineCreateInfoNV* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines); |
| |
| void PostCallRecordCreateRayTracingPipelinesNV( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkRayTracingPipelineCreateInfoNV* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result); |
| |
| void PreCallRecordGetRayTracingShaderGroupHandlesNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData); |
| |
| void PostCallRecordGetRayTracingShaderGroupHandlesNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData, |
| VkResult result); |
| |
| void PreCallRecordGetAccelerationStructureHandleNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| size_t dataSize, |
| void* pData); |
| |
| void PostCallRecordGetAccelerationStructureHandleNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| size_t dataSize, |
| void* pData, |
| VkResult result); |
| |
| void PreCallRecordCmdWriteAccelerationStructuresPropertiesNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureNV* pAccelerationStructures, |
| VkQueryType queryType, |
| VkQueryPool queryPool, |
| uint32_t firstQuery); |
| |
| void PostCallRecordCmdWriteAccelerationStructuresPropertiesNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureNV* pAccelerationStructures, |
| VkQueryType queryType, |
| VkQueryPool queryPool, |
| uint32_t firstQuery); |
| |
| void PreCallRecordCompileDeferredNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t shader); |
| |
| void PostCallRecordCompileDeferredNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t shader, |
| VkResult result); |
| |
| void PreCallRecordGetMemoryHostPointerPropertiesEXT( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); |
| |
| void PostCallRecordGetMemoryHostPointerPropertiesEXT( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, |
| VkResult result); |
| |
| void PreCallRecordCmdWriteBufferMarkerAMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker); |
| |
| void PostCallRecordCmdWriteBufferMarkerAMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker); |
| |
| void PreCallRecordGetCalibratedTimestampsEXT( |
| VkDevice device, |
| uint32_t timestampCount, |
| const VkCalibratedTimestampInfoEXT* pTimestampInfos, |
| uint64_t* pTimestamps, |
| uint64_t* pMaxDeviation); |
| |
| void PostCallRecordGetCalibratedTimestampsEXT( |
| VkDevice device, |
| uint32_t timestampCount, |
| const VkCalibratedTimestampInfoEXT* pTimestampInfos, |
| uint64_t* pTimestamps, |
| uint64_t* pMaxDeviation, |
| VkResult result); |
| |
| #ifdef VK_USE_PLATFORM_GGP |
| #endif // VK_USE_PLATFORM_GGP |
| |
| void PreCallRecordCmdDrawMeshTasksNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t taskCount, |
| uint32_t firstTask); |
| |
| void PostCallRecordCmdDrawMeshTasksNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t taskCount, |
| uint32_t firstTask); |
| |
| void PreCallRecordCmdDrawMeshTasksIndirectNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawMeshTasksIndirectNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride); |
| |
| void PreCallRecordCmdDrawMeshTasksIndirectCountNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PostCallRecordCmdDrawMeshTasksIndirectCountNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride); |
| |
| void PreCallRecordCmdSetExclusiveScissorNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstExclusiveScissor, |
| uint32_t exclusiveScissorCount, |
| const VkRect2D* pExclusiveScissors); |
| |
| void PostCallRecordCmdSetExclusiveScissorNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstExclusiveScissor, |
| uint32_t exclusiveScissorCount, |
| const VkRect2D* pExclusiveScissors); |
| |
| void PreCallRecordCmdSetCheckpointNV( |
| VkCommandBuffer commandBuffer, |
| const void* pCheckpointMarker); |
| |
| void PostCallRecordCmdSetCheckpointNV( |
| VkCommandBuffer commandBuffer, |
| const void* pCheckpointMarker); |
| |
| void PreCallRecordGetQueueCheckpointDataNV( |
| VkQueue queue, |
| uint32_t* pCheckpointDataCount, |
| VkCheckpointDataNV* pCheckpointData); |
| |
| void PostCallRecordGetQueueCheckpointDataNV( |
| VkQueue queue, |
| uint32_t* pCheckpointDataCount, |
| VkCheckpointDataNV* pCheckpointData); |
| |
| void PreCallRecordInitializePerformanceApiINTEL( |
| VkDevice device, |
| const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); |
| |
| void PostCallRecordInitializePerformanceApiINTEL( |
| VkDevice device, |
| const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, |
| VkResult result); |
| |
| void PreCallRecordUninitializePerformanceApiINTEL( |
| VkDevice device); |
| |
| void PostCallRecordUninitializePerformanceApiINTEL( |
| VkDevice device); |
| |
| void PreCallRecordCmdSetPerformanceMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceMarkerInfoINTEL* pMarkerInfo); |
| |
| void PostCallRecordCmdSetPerformanceMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceMarkerInfoINTEL* pMarkerInfo, |
| VkResult result); |
| |
| void PreCallRecordCmdSetPerformanceStreamMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); |
| |
| void PostCallRecordCmdSetPerformanceStreamMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, |
| VkResult result); |
| |
| void PreCallRecordCmdSetPerformanceOverrideINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceOverrideInfoINTEL* pOverrideInfo); |
| |
| void PostCallRecordCmdSetPerformanceOverrideINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceOverrideInfoINTEL* pOverrideInfo, |
| VkResult result); |
| |
| void PreCallRecordAcquirePerformanceConfigurationINTEL( |
| VkDevice device, |
| const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, |
| VkPerformanceConfigurationINTEL* pConfiguration); |
| |
| void PostCallRecordAcquirePerformanceConfigurationINTEL( |
| VkDevice device, |
| const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, |
| VkPerformanceConfigurationINTEL* pConfiguration, |
| VkResult result); |
| |
| void PreCallRecordReleasePerformanceConfigurationINTEL( |
| VkDevice device, |
| VkPerformanceConfigurationINTEL configuration); |
| |
| void PostCallRecordReleasePerformanceConfigurationINTEL( |
| VkDevice device, |
| VkPerformanceConfigurationINTEL configuration, |
| VkResult result); |
| |
| void PreCallRecordQueueSetPerformanceConfigurationINTEL( |
| VkQueue queue, |
| VkPerformanceConfigurationINTEL configuration); |
| |
| void PostCallRecordQueueSetPerformanceConfigurationINTEL( |
| VkQueue queue, |
| VkPerformanceConfigurationINTEL configuration, |
| VkResult result); |
| |
| void PreCallRecordGetPerformanceParameterINTEL( |
| VkDevice device, |
| VkPerformanceParameterTypeINTEL parameter, |
| VkPerformanceValueINTEL* pValue); |
| |
| void PostCallRecordGetPerformanceParameterINTEL( |
| VkDevice device, |
| VkPerformanceParameterTypeINTEL parameter, |
| VkPerformanceValueINTEL* pValue, |
| VkResult result); |
| |
| void PreCallRecordSetLocalDimmingAMD( |
| VkDevice device, |
| VkSwapchainKHR swapChain, |
| VkBool32 localDimmingEnable); |
| |
| void PostCallRecordSetLocalDimmingAMD( |
| VkDevice device, |
| VkSwapchainKHR swapChain, |
| VkBool32 localDimmingEnable); |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| void PreCallRecordCreateImagePipeSurfaceFUCHSIA( |
| VkInstance instance, |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateImagePipeSurfaceFUCHSIA( |
| VkInstance instance, |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_METAL_EXT |
| |
| void PreCallRecordCreateMetalSurfaceEXT( |
| VkInstance instance, |
| const VkMetalSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateMetalSurfaceEXT( |
| VkInstance instance, |
| const VkMetalSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_METAL_EXT |
| |
| void PreCallRecordGetBufferDeviceAddressEXT( |
| VkDevice device, |
| const VkBufferDeviceAddressInfoEXT* pInfo); |
| |
| void PostCallRecordGetBufferDeviceAddressEXT( |
| VkDevice device, |
| const VkBufferDeviceAddressInfoEXT* pInfo); |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordAcquireFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain); |
| |
| void PostCallRecordAcquireFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkResult result); |
| |
| void PreCallRecordReleaseFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain); |
| |
| void PostCallRecordReleaseFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkResult result); |
| |
| void PreCallRecordGetDeviceGroupSurfacePresentModes2EXT( |
| VkDevice device, |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, |
| VkDeviceGroupPresentModeFlagsKHR* pModes); |
| |
| void PostCallRecordGetDeviceGroupSurfacePresentModes2EXT( |
| VkDevice device, |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, |
| VkDeviceGroupPresentModeFlagsKHR* pModes, |
| VkResult result); |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordCreateHeadlessSurfaceEXT( |
| VkInstance instance, |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface); |
| |
| void PostCallRecordCreateHeadlessSurfaceEXT( |
| VkInstance instance, |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result); |
| |
| void PreCallRecordCmdSetLineStippleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, |
| uint16_t lineStipplePattern); |
| |
| void PostCallRecordCmdSetLineStippleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, |
| uint16_t lineStipplePattern); |
| |
| void PreCallRecordResetQueryPoolEXT( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount); |
| |
| void PostCallRecordResetQueryPoolEXT( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount); |
| }; |
