| |
| // This file is ***GENERATED***. Do Not Edit. |
| // See thread_safety_generator.py for modifications. |
| |
| /* Copyright (c) 2015-2022 The Khronos Group Inc. |
| * Copyright (c) 2015-2022 Valve Corporation |
| * Copyright (c) 2015-2022 LunarG, Inc. |
| * Copyright (c) 2015-2022 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 <atomic> |
| #include <chrono> |
| #include <mutex> |
| #include <string> |
| #include <thread> |
| #include <vector> |
| |
| 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 |
| |
| class ObjectUseData |
| { |
| public: |
| class WriteReadCount |
| { |
| public: |
| WriteReadCount(int64_t v) : count(v) {} |
| |
| int32_t GetReadCount() const { return (int32_t)(count & 0xFFFFFFFF); } |
| int32_t GetWriteCount() const { return (int32_t)(count >> 32); } |
| |
| private: |
| int64_t count; |
| }; |
| |
| ObjectUseData() : thread(0), writer_reader_count(0) { |
| // silence -Wunused-private-field warning |
| padding[0] = 0; |
| } |
| |
| WriteReadCount AddWriter() { |
| int64_t prev = writer_reader_count.fetch_add(1ULL << 32); |
| return WriteReadCount(prev); |
| } |
| WriteReadCount AddReader() { |
| int64_t prev = writer_reader_count.fetch_add(1ULL); |
| return WriteReadCount(prev); |
| } |
| WriteReadCount RemoveWriter() { |
| int64_t prev = writer_reader_count.fetch_add(-(1LL << 32)); |
| return WriteReadCount(prev); |
| } |
| WriteReadCount RemoveReader() { |
| int64_t prev = writer_reader_count.fetch_add(-1LL); |
| return WriteReadCount(prev); |
| } |
| WriteReadCount GetCount() { |
| return WriteReadCount(writer_reader_count); |
| } |
| |
| void WaitForObjectIdle(bool is_writer) { |
| // Wait for thread-safe access to object instead of skipping call. |
| while (GetCount().GetReadCount() > (int)(!is_writer) || GetCount().GetWriteCount() > (int)is_writer) { |
| std::this_thread::sleep_for(std::chrono::microseconds(1)); |
| } |
| } |
| |
| std::atomic<loader_platform_thread_id> thread; |
| |
| private: |
| // need to update write and read counts atomically. Writer in high |
| // 32 bits, reader in low 32 bits. |
| std::atomic<int64_t> writer_reader_count; |
| |
| // Put each lock on its own cache line to avoid false cache line sharing. |
| char padding[(-int(sizeof(std::atomic<loader_platform_thread_id>) + sizeof(std::atomic<int64_t>))) & 63]; |
| }; |
| |
| |
| template <typename T> |
| class counter { |
| public: |
| const char *typeName; |
| VulkanObjectType object_type; |
| ValidationObject *object_data; |
| |
| vl_concurrent_unordered_map<T, std::shared_ptr<ObjectUseData>, 6> object_table; |
| |
| void CreateObject(T object) { |
| object_table.insert(object, std::make_shared<ObjectUseData>()); |
| } |
| |
| void DestroyObject(T object) { |
| if (object) { |
| object_table.erase(object); |
| } |
| } |
| |
| std::shared_ptr<ObjectUseData> FindObject(T object) { |
| assert(object_table.contains(object)); |
| auto iter = std::move(object_table.find(object)); |
| if (iter != object_table.end()) { |
| return std::move(iter->second); |
| } else { |
| object_data->LogError(object, kVUID_Threading_Info, |
| "Couldn't find %s Object 0x%" PRIxLEAST64 |
| ". This should not happen and may indicate a bug in the application.", |
| object_string[object_type], (uint64_t)(object)); |
| return nullptr; |
| } |
| } |
| |
| void StartWrite(T object, const char *api_name) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| bool skip = false; |
| loader_platform_thread_id tid = loader_platform_get_thread_id(); |
| |
| auto use_data = FindObject(object); |
| if (!use_data) { |
| return; |
| } |
| const ObjectUseData::WriteReadCount prevCount = use_data->AddWriter(); |
| |
| if (prevCount.GetReadCount() == 0 && prevCount.GetWriteCount() == 0) { |
| // There is no current use of the object. Record writer thread. |
| use_data->thread = tid; |
| } else { |
| if (prevCount.GetReadCount() == 0) { |
| assert(prevCount.GetWriteCount() != 0); |
| // There are no readers. Two writers just collided. |
| if (use_data->thread != tid) { |
| skip |= object_data->LogError(object, kVUID_Threading_MultipleThreads, |
| "THREADING ERROR : %s(): object of type %s is simultaneously used in " |
| "thread 0x%" PRIx64 " and thread 0x%" PRIx64, api_name, |
| typeName, (uint64_t)use_data->thread.load(std::memory_order_relaxed), (uint64_t)tid); |
| if (skip) { |
| // Wait for thread-safe access to object instead of skipping call. |
| use_data->WaitForObjectIdle(true); |
| // There is now no current use of the object. Record writer thread. |
| use_data->thread = tid; |
| } else { |
| // There is now no current use of the object. Record writer thread. |
| use_data->thread = tid; |
| } |
| } else { |
| // This is either safe multiple use in one call, or recursive use. |
| // There is no way to make recursion safe. Just forge ahead. |
| } |
| } else { |
| // There are readers. This writer collided with them. |
| if (use_data->thread != tid) { |
| skip |= object_data->LogError(object, kVUID_Threading_MultipleThreads, |
| "THREADING ERROR : %s(): object of type %s is simultaneously used in " |
| "thread 0x%" PRIx64 " and thread 0x%" PRIx64, api_name, |
| typeName, (uint64_t)use_data->thread.load(std::memory_order_relaxed), (uint64_t)tid); |
| if (skip) { |
| // Wait for thread-safe access to object instead of skipping call. |
| use_data->WaitForObjectIdle(true); |
| // There is now no current use of the object. Record writer thread. |
| use_data->thread = tid; |
| } else { |
| // Continue with an unsafe use of the object. |
| use_data->thread = tid; |
| } |
| } else { |
| // This is either safe multiple use in one call, or recursive use. |
| // There is no way to make recursion safe. Just forge ahead. |
| } |
| } |
| } |
| } |
| |
| void FinishWrite(T object, const char *api_name) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| // Object is no longer in use |
| auto use_data = FindObject(object); |
| if (!use_data) { |
| return; |
| } |
| use_data->RemoveWriter(); |
| } |
| |
| void StartRead(T object, const char *api_name) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| bool skip = false; |
| loader_platform_thread_id tid = loader_platform_get_thread_id(); |
| |
| auto use_data = FindObject(object); |
| if (!use_data) { |
| return; |
| } |
| const ObjectUseData::WriteReadCount prevCount = use_data->AddReader(); |
| |
| if (prevCount.GetReadCount() == 0 && prevCount.GetWriteCount() == 0) { |
| // There is no current use of the object. |
| use_data->thread = tid; |
| } else if (prevCount.GetWriteCount() > 0 && use_data->thread != tid) { |
| // There is a writer of the object. |
| skip |= object_data->LogError(object, kVUID_Threading_MultipleThreads, |
| "THREADING ERROR : %s(): object of type %s is simultaneously used in " |
| "thread 0x%" PRIx64 " and thread 0x%" PRIx64, api_name, |
| typeName, (uint64_t)use_data->thread.load(std::memory_order_relaxed), (uint64_t)tid); |
| if (skip) { |
| // Wait for thread-safe access to object instead of skipping call. |
| use_data->WaitForObjectIdle(false); |
| use_data->thread = tid; |
| } |
| } else { |
| // There are other readers of the object. |
| } |
| } |
| void FinishRead(T object, const char *api_name) { |
| if (object == VK_NULL_HANDLE) { |
| return; |
| } |
| |
| auto use_data = FindObject(object); |
| if (!use_data) { |
| return; |
| } |
| use_data->RemoveReader(); |
| } |
| counter(const char *name = "", VulkanObjectType type = kVulkanObjectTypeUnknown, ValidationObject *val_obj = nullptr) { |
| typeName = name; |
| object_type = type; |
| object_data = val_obj; |
| } |
| |
| private: |
| }; |
| |
| class ThreadSafety : public ValidationObject { |
| public: |
| |
| ReadWriteLock thread_safety_lock; |
| |
| // Override chassis read/write locks for this validation object |
| // This override takes a deferred lock. i.e. it is not acquired. |
| ReadLockGuard ReadLock() override; |
| WriteLockGuard WriteLock() override; |
| |
| vl_concurrent_unordered_map<VkCommandBuffer, VkCommandPool, 6> command_pool_map; |
| layer_data::unordered_map<VkCommandPool, layer_data::unordered_set<VkCommandBuffer>> pool_command_buffers_map; |
| layer_data::unordered_map<VkDevice, layer_data::unordered_set<VkQueue>> device_queues_map; |
| |
| // Track per-descriptorsetlayout and per-descriptorset whether UPDATE_AFTER_BIND is used. |
| // This is used to (sloppily) implement the relaxed externsync rules for UPDATE_AFTER_BIND |
| // descriptors. We model updates of UPDATE_AFTER_BIND descriptors as if they were reads |
| // rather than writes, because they only conflict with the set being freed or reset. |
| // |
| // We don't track the UPDATE_AFTER_BIND state per-binding for a couple reasons: |
| // (1) We only have one counter per object, and if we treated non-UAB as writes |
| // and UAB as reads then they'd appear to conflict with each other. |
| // (2) Avoid additional tracking of descriptor binding state in the descriptor set |
| // layout, and tracking of which bindings are accessed by a VkDescriptorUpdateTemplate. |
| vl_concurrent_unordered_map<VkDescriptorSetLayout, bool, 4> dsl_update_after_bind_map; |
| vl_concurrent_unordered_map<VkDescriptorSet, bool, 6> ds_update_after_bind_map; |
| bool DsUpdateAfterBind(VkDescriptorSet) const; |
| |
| 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<VkAccelerationStructureKHR> c_VkAccelerationStructureKHR; |
| counter<VkAccelerationStructureNV> c_VkAccelerationStructureNV; |
| counter<VkBuffer> c_VkBuffer; |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| counter<VkBufferCollectionFUCHSIA> c_VkBufferCollectionFUCHSIA; |
| #endif |
| counter<VkBufferView> c_VkBufferView; |
| counter<VkCommandPool> c_VkCommandPool; |
| counter<VkCuFunctionNVX> c_VkCuFunctionNVX; |
| counter<VkCuModuleNVX> c_VkCuModuleNVX; |
| counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT; |
| counter<VkDebugUtilsMessengerEXT> c_VkDebugUtilsMessengerEXT; |
| counter<VkDeferredOperationKHR> c_VkDeferredOperationKHR; |
| 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<VkIndirectCommandsLayoutNV> c_VkIndirectCommandsLayoutNV; |
| counter<VkPerformanceConfigurationINTEL> c_VkPerformanceConfigurationINTEL; |
| counter<VkPipeline> c_VkPipeline; |
| counter<VkPipelineCache> c_VkPipelineCache; |
| counter<VkPipelineLayout> c_VkPipelineLayout; |
| counter<VkPrivateDataSlot> c_VkPrivateDataSlot; |
| 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; |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| counter<VkVideoSessionKHR> c_VkVideoSessionKHR; |
| #endif |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| counter<VkVideoSessionParametersKHR> c_VkVideoSessionParametersKHR; |
| #endif |
| |
| |
| #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 |
| |
| // If this ThreadSafety is for a VkDevice, then parent_instance points to the |
| // ThreadSafety object of its parent VkInstance. This is used to get to the counters |
| // for objects created with the instance as parent. |
| ThreadSafety *parent_instance; |
| |
| ThreadSafety(ThreadSafety *parent) |
| : c_VkCommandBuffer("VkCommandBuffer", kVulkanObjectTypeCommandBuffer, this), |
| c_VkDevice("VkDevice", kVulkanObjectTypeDevice, this), |
| c_VkInstance("VkInstance", kVulkanObjectTypeInstance, this), |
| c_VkQueue("VkQueue", kVulkanObjectTypeQueue, this), |
| c_VkCommandPoolContents("VkCommandPool", kVulkanObjectTypeCommandPool, this), |
| |
| #ifdef DISTINCT_NONDISPATCHABLE_HANDLES |
| c_VkAccelerationStructureKHR("VkAccelerationStructureKHR", kVulkanObjectTypeAccelerationStructureKHR, this), |
| c_VkAccelerationStructureNV("VkAccelerationStructureNV", kVulkanObjectTypeAccelerationStructureNV, this), |
| c_VkBuffer("VkBuffer", kVulkanObjectTypeBuffer, this), |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| c_VkBufferCollectionFUCHSIA("VkBufferCollectionFUCHSIA", kVulkanObjectTypeBufferCollectionFUCHSIA, this), |
| #endif |
| c_VkBufferView("VkBufferView", kVulkanObjectTypeBufferView, this), |
| c_VkCommandPool("VkCommandPool", kVulkanObjectTypeCommandPool, this), |
| c_VkCuFunctionNVX("VkCuFunctionNVX", kVulkanObjectTypeCuFunctionNVX, this), |
| c_VkCuModuleNVX("VkCuModuleNVX", kVulkanObjectTypeCuModuleNVX, this), |
| c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", kVulkanObjectTypeDebugReportCallbackEXT, this), |
| c_VkDebugUtilsMessengerEXT("VkDebugUtilsMessengerEXT", kVulkanObjectTypeDebugUtilsMessengerEXT, this), |
| c_VkDeferredOperationKHR("VkDeferredOperationKHR", kVulkanObjectTypeDeferredOperationKHR, this), |
| c_VkDescriptorPool("VkDescriptorPool", kVulkanObjectTypeDescriptorPool, this), |
| c_VkDescriptorSet("VkDescriptorSet", kVulkanObjectTypeDescriptorSet, this), |
| c_VkDescriptorSetLayout("VkDescriptorSetLayout", kVulkanObjectTypeDescriptorSetLayout, this), |
| c_VkDescriptorUpdateTemplate("VkDescriptorUpdateTemplate", kVulkanObjectTypeDescriptorUpdateTemplate, this), |
| c_VkDeviceMemory("VkDeviceMemory", kVulkanObjectTypeDeviceMemory, this), |
| c_VkDisplayKHR("VkDisplayKHR", kVulkanObjectTypeDisplayKHR, this), |
| c_VkDisplayModeKHR("VkDisplayModeKHR", kVulkanObjectTypeDisplayModeKHR, this), |
| c_VkEvent("VkEvent", kVulkanObjectTypeEvent, this), |
| c_VkFence("VkFence", kVulkanObjectTypeFence, this), |
| c_VkFramebuffer("VkFramebuffer", kVulkanObjectTypeFramebuffer, this), |
| c_VkImage("VkImage", kVulkanObjectTypeImage, this), |
| c_VkImageView("VkImageView", kVulkanObjectTypeImageView, this), |
| c_VkIndirectCommandsLayoutNV("VkIndirectCommandsLayoutNV", kVulkanObjectTypeIndirectCommandsLayoutNV, this), |
| c_VkPerformanceConfigurationINTEL("VkPerformanceConfigurationINTEL", kVulkanObjectTypePerformanceConfigurationINTEL, this), |
| c_VkPipeline("VkPipeline", kVulkanObjectTypePipeline, this), |
| c_VkPipelineCache("VkPipelineCache", kVulkanObjectTypePipelineCache, this), |
| c_VkPipelineLayout("VkPipelineLayout", kVulkanObjectTypePipelineLayout, this), |
| c_VkPrivateDataSlot("VkPrivateDataSlot", kVulkanObjectTypePrivateDataSlot, this), |
| c_VkQueryPool("VkQueryPool", kVulkanObjectTypeQueryPool, this), |
| c_VkRenderPass("VkRenderPass", kVulkanObjectTypeRenderPass, this), |
| c_VkSampler("VkSampler", kVulkanObjectTypeSampler, this), |
| c_VkSamplerYcbcrConversion("VkSamplerYcbcrConversion", kVulkanObjectTypeSamplerYcbcrConversion, this), |
| c_VkSemaphore("VkSemaphore", kVulkanObjectTypeSemaphore, this), |
| c_VkShaderModule("VkShaderModule", kVulkanObjectTypeShaderModule, this), |
| c_VkSurfaceKHR("VkSurfaceKHR", kVulkanObjectTypeSurfaceKHR, this), |
| c_VkSwapchainKHR("VkSwapchainKHR", kVulkanObjectTypeSwapchainKHR, this), |
| c_VkValidationCacheEXT("VkValidationCacheEXT", kVulkanObjectTypeValidationCacheEXT, this), |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| c_VkVideoSessionKHR("VkVideoSessionKHR", kVulkanObjectTypeVideoSessionKHR, this), |
| #endif |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| c_VkVideoSessionParametersKHR("VkVideoSessionParametersKHR", kVulkanObjectTypeVideoSessionParametersKHR, this), |
| #endif |
| |
| |
| |
| #else // DISTINCT_NONDISPATCHABLE_HANDLES |
| c_uint64_t("NON_DISPATCHABLE_HANDLE", kVulkanObjectTypeUnknown, this), |
| #endif // DISTINCT_NONDISPATCHABLE_HANDLES |
| parent_instance(parent) |
| { |
| container_type = LayerObjectTypeThreading; |
| }; |
| |
| #define WRAPPER(type) \ |
| void StartWriteObject(type object, const char *api_name) { \ |
| c_##type.StartWrite(object, api_name); \ |
| } \ |
| void FinishWriteObject(type object, const char *api_name) { \ |
| c_##type.FinishWrite(object, api_name); \ |
| } \ |
| void StartReadObject(type object, const char *api_name) { \ |
| c_##type.StartRead(object, api_name); \ |
| } \ |
| void FinishReadObject(type object, const char *api_name) { \ |
| c_##type.FinishRead(object, api_name); \ |
| } \ |
| void CreateObject(type object) { \ |
| c_##type.CreateObject(object); \ |
| } \ |
| void DestroyObject(type object) { \ |
| c_##type.DestroyObject(object); \ |
| c_##type.DestroyObject(object); \ |
| } |
| |
| #define WRAPPER_PARENT_INSTANCE(type) \ |
| void StartWriteObjectParentInstance(type object, const char *api_name) { \ |
| (parent_instance ? parent_instance : this)->c_##type.StartWrite(object, api_name); \ |
| } \ |
| void FinishWriteObjectParentInstance(type object, const char *api_name) { \ |
| (parent_instance ? parent_instance : this)->c_##type.FinishWrite(object, api_name); \ |
| } \ |
| void StartReadObjectParentInstance(type object, const char *api_name) { \ |
| (parent_instance ? parent_instance : this)->c_##type.StartRead(object, api_name); \ |
| } \ |
| void FinishReadObjectParentInstance(type object, const char *api_name) { \ |
| (parent_instance ? parent_instance : this)->c_##type.FinishRead(object, api_name); \ |
| } \ |
| void CreateObjectParentInstance(type object) { \ |
| (parent_instance ? parent_instance : this)->c_##type.CreateObject(object); \ |
| } \ |
| void DestroyObjectParentInstance(type object) { \ |
| (parent_instance ? parent_instance : this)->c_##type.DestroyObject(object); \ |
| } |
| |
| WRAPPER_PARENT_INSTANCE(VkDevice) |
| WRAPPER_PARENT_INSTANCE(VkInstance) |
| WRAPPER(VkQueue) |
| #ifdef DISTINCT_NONDISPATCHABLE_HANDLES |
| WRAPPER(VkAccelerationStructureKHR) |
| WRAPPER(VkAccelerationStructureNV) |
| WRAPPER(VkBuffer) |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| WRAPPER(VkBufferCollectionFUCHSIA) |
| #endif |
| WRAPPER(VkBufferView) |
| WRAPPER(VkCommandPool) |
| WRAPPER(VkCuFunctionNVX) |
| WRAPPER(VkCuModuleNVX) |
| WRAPPER_PARENT_INSTANCE(VkDebugReportCallbackEXT) |
| WRAPPER_PARENT_INSTANCE(VkDebugUtilsMessengerEXT) |
| WRAPPER(VkDeferredOperationKHR) |
| WRAPPER(VkDescriptorPool) |
| WRAPPER(VkDescriptorSet) |
| WRAPPER(VkDescriptorSetLayout) |
| WRAPPER(VkDescriptorUpdateTemplate) |
| WRAPPER(VkDeviceMemory) |
| WRAPPER_PARENT_INSTANCE(VkDisplayKHR) |
| WRAPPER(VkDisplayModeKHR) |
| WRAPPER(VkEvent) |
| WRAPPER(VkFence) |
| WRAPPER(VkFramebuffer) |
| WRAPPER(VkImage) |
| WRAPPER(VkImageView) |
| WRAPPER(VkIndirectCommandsLayoutNV) |
| WRAPPER(VkPerformanceConfigurationINTEL) |
| WRAPPER(VkPipeline) |
| WRAPPER(VkPipelineCache) |
| WRAPPER(VkPipelineLayout) |
| WRAPPER(VkPrivateDataSlot) |
| WRAPPER(VkQueryPool) |
| WRAPPER(VkRenderPass) |
| WRAPPER(VkSampler) |
| WRAPPER(VkSamplerYcbcrConversion) |
| WRAPPER(VkSemaphore) |
| WRAPPER(VkShaderModule) |
| WRAPPER_PARENT_INSTANCE(VkSurfaceKHR) |
| WRAPPER_PARENT_INSTANCE(VkSwapchainKHR) |
| WRAPPER(VkValidationCacheEXT) |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| WRAPPER(VkVideoSessionKHR) |
| #endif |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| WRAPPER(VkVideoSessionParametersKHR) |
| #endif |
| |
| |
| #else // DISTINCT_NONDISPATCHABLE_HANDLES |
| WRAPPER(uint64_t) |
| WRAPPER_PARENT_INSTANCE(uint64_t) |
| #endif // DISTINCT_NONDISPATCHABLE_HANDLES |
| |
| void CreateObject(VkCommandBuffer object) { |
| c_VkCommandBuffer.CreateObject(object); |
| } |
| void DestroyObject(VkCommandBuffer object) { |
| c_VkCommandBuffer.DestroyObject(object); |
| } |
| |
| // VkCommandBuffer needs check for implicit use of command pool |
| void StartWriteObject(VkCommandBuffer object, const char *api_name, bool lockPool = true) { |
| if (lockPool) { |
| auto iter = command_pool_map.find(object); |
| if (iter != command_pool_map.end()) { |
| VkCommandPool pool = iter->second; |
| StartWriteObject(pool, api_name); |
| } |
| } |
| c_VkCommandBuffer.StartWrite(object, api_name); |
| } |
| void FinishWriteObject(VkCommandBuffer object, const char *api_name, bool lockPool = true) { |
| c_VkCommandBuffer.FinishWrite(object, api_name); |
| if (lockPool) { |
| auto iter = command_pool_map.find(object); |
| if (iter != command_pool_map.end()) { |
| VkCommandPool pool = iter->second; |
| FinishWriteObject(pool, api_name); |
| } |
| } |
| } |
| void StartReadObject(VkCommandBuffer object, const char *api_name) { |
| auto iter = command_pool_map.find(object); |
| if (iter != command_pool_map.end()) { |
| VkCommandPool pool = iter->second; |
| // 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 positive for |
| // non-externally sync'd command buffers |
| c_VkCommandPoolContents.StartRead(pool, api_name); |
| } |
| c_VkCommandBuffer.StartRead(object, api_name); |
| } |
| void FinishReadObject(VkCommandBuffer object, const char *api_name) { |
| c_VkCommandBuffer.FinishRead(object, api_name); |
| auto iter = command_pool_map.find(object); |
| if (iter != command_pool_map.end()) { |
| VkCommandPool pool = iter->second; |
| c_VkCommandPoolContents.FinishRead(pool, api_name); |
| } |
| } |
| |
| void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkDisplayPlanePropertiesKHR* pProperties, |
| VkResult result) override; |
| |
| void PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkDisplayPlaneProperties2KHR* pProperties, |
| VkResult result) override; |
| |
| void PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkDisplayPropertiesKHR* pProperties, |
| VkResult result) override; |
| |
| void PostCallRecordGetPhysicalDeviceDisplayProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkDisplayProperties2KHR* pProperties, |
| VkResult result) override; |
| |
| void PreCallRecordGetDisplayPlaneCapabilities2KHR( |
| VkPhysicalDevice physicalDevice, |
| const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, |
| VkDisplayPlaneCapabilities2KHR* pCapabilities) override; |
| |
| void PostCallRecordGetDisplayPlaneCapabilities2KHR( |
| VkPhysicalDevice physicalDevice, |
| const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, |
| VkDisplayPlaneCapabilities2KHR* pCapabilities, |
| VkResult result) override; |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| void PostCallRecordGetRandROutputDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| RROutput rrOutput, |
| VkDisplayKHR* pDisplay, |
| VkResult result) override; |
| |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| void PreCallRecordCreateInstance( |
| const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance) override; |
| |
| void PostCallRecordCreateInstance( |
| const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordEnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices) override; |
| |
| void PostCallRecordEnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices, |
| VkResult result) override; |
| |
| void PreCallRecordGetInstanceProcAddr( |
| VkInstance instance, |
| const char* pName) override; |
| |
| void PostCallRecordGetInstanceProcAddr( |
| VkInstance instance, |
| const char* pName) override; |
| |
| void PreCallRecordGetDeviceProcAddr( |
| VkDevice device, |
| const char* pName) override; |
| |
| void PostCallRecordGetDeviceProcAddr( |
| VkDevice device, |
| const char* pName) override; |
| |
| void PreCallRecordCreateDevice( |
| VkPhysicalDevice physicalDevice, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDevice* pDevice) override; |
| |
| void PostCallRecordCreateDevice( |
| VkPhysicalDevice physicalDevice, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDevice* pDevice, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDevice( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDevice( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetDeviceQueue( |
| VkDevice device, |
| uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VkQueue* pQueue) override; |
| |
| void PostCallRecordGetDeviceQueue( |
| VkDevice device, |
| uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VkQueue* pQueue) override; |
| |
| void PreCallRecordQueueSubmit( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence) override; |
| |
| void PostCallRecordQueueSubmit( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence, |
| VkResult result) override; |
| |
| void PreCallRecordQueueWaitIdle( |
| VkQueue queue) override; |
| |
| void PostCallRecordQueueWaitIdle( |
| VkQueue queue, |
| VkResult result) override; |
| |
| void PreCallRecordDeviceWaitIdle( |
| VkDevice device) override; |
| |
| void PostCallRecordDeviceWaitIdle( |
| VkDevice device, |
| VkResult result) override; |
| |
| void PreCallRecordAllocateMemory( |
| VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory) override; |
| |
| void PostCallRecordAllocateMemory( |
| VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory, |
| VkResult result) override; |
| |
| void PreCallRecordFreeMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordFreeMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordMapMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize offset, |
| VkDeviceSize size, |
| VkMemoryMapFlags flags, |
| void** ppData) override; |
| |
| void PostCallRecordMapMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize offset, |
| VkDeviceSize size, |
| VkMemoryMapFlags flags, |
| void** ppData, |
| VkResult result) override; |
| |
| void PreCallRecordUnmapMemory( |
| VkDevice device, |
| VkDeviceMemory memory) override; |
| |
| void PostCallRecordUnmapMemory( |
| VkDevice device, |
| VkDeviceMemory memory) override; |
| |
| void PreCallRecordFlushMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) override; |
| |
| void PostCallRecordFlushMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges, |
| VkResult result) override; |
| |
| void PreCallRecordInvalidateMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) override; |
| |
| void PostCallRecordInvalidateMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges, |
| VkResult result) override; |
| |
| void PreCallRecordGetDeviceMemoryCommitment( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes) override; |
| |
| void PostCallRecordGetDeviceMemoryCommitment( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes) override; |
| |
| void PreCallRecordBindBufferMemory( |
| VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset) override; |
| |
| void PostCallRecordBindBufferMemory( |
| VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset, |
| VkResult result) override; |
| |
| void PreCallRecordBindImageMemory( |
| VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset) override; |
| |
| void PostCallRecordBindImageMemory( |
| VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset, |
| VkResult result) override; |
| |
| void PreCallRecordGetBufferMemoryRequirements( |
| VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements) override; |
| |
| void PostCallRecordGetBufferMemoryRequirements( |
| VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements) override; |
| |
| void PreCallRecordGetImageMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements) override; |
| |
| void PostCallRecordGetImageMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements) override; |
| |
| void PreCallRecordGetImageSparseMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements) override; |
| |
| void PostCallRecordGetImageSparseMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements) override; |
| |
| void PreCallRecordQueueBindSparse( |
| VkQueue queue, |
| uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, |
| VkFence fence) override; |
| |
| void PostCallRecordQueueBindSparse( |
| VkQueue queue, |
| uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, |
| VkFence fence, |
| VkResult result) override; |
| |
| void PreCallRecordCreateFence( |
| VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) override; |
| |
| void PostCallRecordCreateFence( |
| VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyFence( |
| VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyFence( |
| VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordResetFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences) override; |
| |
| void PostCallRecordResetFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkResult result) override; |
| |
| void PreCallRecordGetFenceStatus( |
| VkDevice device, |
| VkFence fence) override; |
| |
| void PostCallRecordGetFenceStatus( |
| VkDevice device, |
| VkFence fence, |
| VkResult result) override; |
| |
| void PreCallRecordWaitForFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkBool32 waitAll, |
| uint64_t timeout) override; |
| |
| void PostCallRecordWaitForFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkBool32 waitAll, |
| uint64_t timeout, |
| VkResult result) override; |
| |
| void PreCallRecordCreateSemaphore( |
| VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore) override; |
| |
| void PostCallRecordCreateSemaphore( |
| VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore, |
| VkResult result) override; |
| |
| void PreCallRecordDestroySemaphore( |
| VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroySemaphore( |
| VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateEvent( |
| VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkEvent* pEvent) override; |
| |
| void PostCallRecordCreateEvent( |
| VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkEvent* pEvent, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyEvent( |
| VkDevice device, |
| VkEvent event, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyEvent( |
| VkDevice device, |
| VkEvent event, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetEventStatus( |
| VkDevice device, |
| VkEvent event) override; |
| |
| void PostCallRecordGetEventStatus( |
| VkDevice device, |
| VkEvent event, |
| VkResult result) override; |
| |
| void PreCallRecordSetEvent( |
| VkDevice device, |
| VkEvent event) override; |
| |
| void PostCallRecordSetEvent( |
| VkDevice device, |
| VkEvent event, |
| VkResult result) override; |
| |
| void PreCallRecordResetEvent( |
| VkDevice device, |
| VkEvent event) override; |
| |
| void PostCallRecordResetEvent( |
| VkDevice device, |
| VkEvent event, |
| VkResult result) override; |
| |
| void PreCallRecordCreateQueryPool( |
| VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool) override; |
| |
| void PostCallRecordCreateQueryPool( |
| VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetQueryPoolResults( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags) override; |
| |
| void PostCallRecordGetQueryPoolResults( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags, |
| VkResult result) override; |
| |
| void PreCallRecordCreateBuffer( |
| VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer) override; |
| |
| void PostCallRecordCreateBuffer( |
| VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyBuffer( |
| VkDevice device, |
| VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyBuffer( |
| VkDevice device, |
| VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateBufferView( |
| VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView) override; |
| |
| void PostCallRecordCreateBufferView( |
| VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyBufferView( |
| VkDevice device, |
| VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyBufferView( |
| VkDevice device, |
| VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateImage( |
| VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage) override; |
| |
| void PostCallRecordCreateImage( |
| VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyImage( |
| VkDevice device, |
| VkImage image, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyImage( |
| VkDevice device, |
| VkImage image, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetImageSubresourceLayout( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout) override; |
| |
| void PostCallRecordGetImageSubresourceLayout( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout) override; |
| |
| void PreCallRecordCreateImageView( |
| VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView) override; |
| |
| void PostCallRecordCreateImageView( |
| VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyImageView( |
| VkDevice device, |
| VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyImageView( |
| VkDevice device, |
| VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateShaderModule( |
| VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule) override; |
| |
| void PostCallRecordCreateShaderModule( |
| VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyShaderModule( |
| VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyShaderModule( |
| VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreatePipelineCache( |
| VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache) override; |
| |
| void PostCallRecordCreatePipelineCache( |
| VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyPipelineCache( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyPipelineCache( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetPipelineCacheData( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| size_t* pDataSize, |
| void* pData) override; |
| |
| void PostCallRecordGetPipelineCacheData( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| size_t* pDataSize, |
| void* pData, |
| VkResult result) override; |
| |
| void PreCallRecordMergePipelineCaches( |
| VkDevice device, |
| VkPipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches) override; |
| |
| void PostCallRecordMergePipelineCaches( |
| VkDevice device, |
| VkPipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches, |
| VkResult result) override; |
| |
| void PreCallRecordCreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) override; |
| |
| void PostCallRecordCreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result) override; |
| |
| void PreCallRecordCreateComputePipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) override; |
| |
| void PostCallRecordCreateComputePipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyPipeline( |
| VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyPipeline( |
| VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreatePipelineLayout( |
| VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout) override; |
| |
| void PostCallRecordCreatePipelineLayout( |
| VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyPipelineLayout( |
| VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyPipelineLayout( |
| VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateSampler( |
| VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler) override; |
| |
| void PostCallRecordCreateSampler( |
| VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler, |
| VkResult result) override; |
| |
| void PreCallRecordDestroySampler( |
| VkDevice device, |
| VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroySampler( |
| VkDevice device, |
| VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout) override; |
| |
| void PostCallRecordCreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDescriptorSetLayout( |
| VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDescriptorSetLayout( |
| VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateDescriptorPool( |
| VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool) override; |
| |
| void PostCallRecordCreateDescriptorPool( |
| VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordResetDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags) override; |
| |
| void PostCallRecordResetDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags, |
| VkResult result) override; |
| |
| void PreCallRecordAllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets) override; |
| |
| void PostCallRecordAllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets, |
| VkResult result) override; |
| |
| void PreCallRecordFreeDescriptorSets( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets) override; |
| |
| void PostCallRecordFreeDescriptorSets( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| VkResult result) override; |
| |
| void PreCallRecordUpdateDescriptorSets( |
| VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies) override; |
| |
| void PostCallRecordUpdateDescriptorSets( |
| VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies) override; |
| |
| void PreCallRecordCreateFramebuffer( |
| VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer) override; |
| |
| void PostCallRecordCreateFramebuffer( |
| VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyFramebuffer( |
| VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyFramebuffer( |
| VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateRenderPass( |
| VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) override; |
| |
| void PostCallRecordCreateRenderPass( |
| VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyRenderPass( |
| VkDevice device, |
| VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyRenderPass( |
| VkDevice device, |
| VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetRenderAreaGranularity( |
| VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity) override; |
| |
| void PostCallRecordGetRenderAreaGranularity( |
| VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity) override; |
| |
| void PreCallRecordCreateCommandPool( |
| VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool) override; |
| |
| void PostCallRecordCreateCommandPool( |
| VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordResetCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags) override; |
| |
| void PostCallRecordResetCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags, |
| VkResult result) override; |
| |
| void PreCallRecordAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers) override; |
| |
| void PostCallRecordAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers, |
| VkResult result) override; |
| |
| void PreCallRecordFreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) override; |
| |
| void PostCallRecordFreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) override; |
| |
| void PreCallRecordBeginCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo) override; |
| |
| void PostCallRecordBeginCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo, |
| VkResult result) override; |
| |
| void PreCallRecordEndCommandBuffer( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordEndCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkResult result) override; |
| |
| void PreCallRecordResetCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags) override; |
| |
| void PostCallRecordResetCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags, |
| VkResult result) override; |
| |
| void PreCallRecordCmdBindPipeline( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline) override; |
| |
| void PostCallRecordCmdBindPipeline( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline) override; |
| |
| void PreCallRecordCmdSetViewport( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) override; |
| |
| void PostCallRecordCmdSetViewport( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) override; |
| |
| void PreCallRecordCmdSetScissor( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) override; |
| |
| void PostCallRecordCmdSetScissor( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) override; |
| |
| void PreCallRecordCmdSetLineWidth( |
| VkCommandBuffer commandBuffer, |
| float lineWidth) override; |
| |
| void PostCallRecordCmdSetLineWidth( |
| VkCommandBuffer commandBuffer, |
| float lineWidth) override; |
| |
| void PreCallRecordCmdSetDepthBias( |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, |
| float depthBiasClamp, |
| float depthBiasSlopeFactor) override; |
| |
| void PostCallRecordCmdSetDepthBias( |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, |
| float depthBiasClamp, |
| float depthBiasSlopeFactor) override; |
| |
| void PreCallRecordCmdSetBlendConstants( |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]) override; |
| |
| void PostCallRecordCmdSetBlendConstants( |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]) override; |
| |
| void PreCallRecordCmdSetDepthBounds( |
| VkCommandBuffer commandBuffer, |
| float minDepthBounds, |
| float maxDepthBounds) override; |
| |
| void PostCallRecordCmdSetDepthBounds( |
| VkCommandBuffer commandBuffer, |
| float minDepthBounds, |
| float maxDepthBounds) override; |
| |
| void PreCallRecordCmdSetStencilCompareMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t compareMask) override; |
| |
| void PostCallRecordCmdSetStencilCompareMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t compareMask) override; |
| |
| void PreCallRecordCmdSetStencilWriteMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t writeMask) override; |
| |
| void PostCallRecordCmdSetStencilWriteMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t writeMask) override; |
| |
| void PreCallRecordCmdSetStencilReference( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t reference) override; |
| |
| void PostCallRecordCmdSetStencilReference( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t reference) override; |
| |
| void PreCallRecordCmdBindDescriptorSets( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t* pDynamicOffsets) override; |
| |
| void PostCallRecordCmdBindDescriptorSets( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t* pDynamicOffsets) override; |
| |
| void PreCallRecordCmdBindIndexBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkIndexType indexType) override; |
| |
| void PostCallRecordCmdBindIndexBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkIndexType indexType) override; |
| |
| void PreCallRecordCmdBindVertexBuffers( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets) override; |
| |
| void PostCallRecordCmdBindVertexBuffers( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets) override; |
| |
| void PreCallRecordCmdDraw( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexCount, |
| uint32_t instanceCount, |
| uint32_t firstVertex, |
| uint32_t firstInstance) override; |
| |
| void PostCallRecordCmdDraw( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexCount, |
| uint32_t instanceCount, |
| uint32_t firstVertex, |
| uint32_t firstInstance) override; |
| |
| void PreCallRecordCmdDrawIndexed( |
| VkCommandBuffer commandBuffer, |
| uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance) override; |
| |
| void PostCallRecordCmdDrawIndexed( |
| VkCommandBuffer commandBuffer, |
| uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance) override; |
| |
| void PreCallRecordCmdDrawIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDrawIndexedIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndexedIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDispatch( |
| VkCommandBuffer commandBuffer, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) override; |
| |
| void PostCallRecordCmdDispatch( |
| VkCommandBuffer commandBuffer, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) override; |
| |
| void PreCallRecordCmdDispatchIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset) override; |
| |
| void PostCallRecordCmdDispatchIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset) override; |
| |
| void PreCallRecordCmdCopyBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferCopy* pRegions) override; |
| |
| void PostCallRecordCmdCopyBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferCopy* pRegions) override; |
| |
| void PreCallRecordCmdCopyImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageCopy* pRegions) override; |
| |
| void PostCallRecordCmdCopyImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageCopy* pRegions) override; |
| |
| void PreCallRecordCmdBlitImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageBlit* pRegions, |
| VkFilter filter) override; |
| |
| void PostCallRecordCmdBlitImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageBlit* pRegions, |
| VkFilter filter) override; |
| |
| void PreCallRecordCmdCopyBufferToImage( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) override; |
| |
| void PostCallRecordCmdCopyBufferToImage( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) override; |
| |
| void PreCallRecordCmdCopyImageToBuffer( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) override; |
| |
| void PostCallRecordCmdCopyImageToBuffer( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) override; |
| |
| void PreCallRecordCmdUpdateBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize dataSize, |
| const void* pData) override; |
| |
| void PostCallRecordCmdUpdateBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize dataSize, |
| const void* pData) override; |
| |
| void PreCallRecordCmdFillBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize size, |
| uint32_t data) override; |
| |
| void PostCallRecordCmdFillBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize size, |
| uint32_t data) override; |
| |
| void PreCallRecordCmdClearColorImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) override; |
| |
| void PostCallRecordCmdClearColorImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) override; |
| |
| void PreCallRecordCmdClearDepthStencilImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) override; |
| |
| void PostCallRecordCmdClearDepthStencilImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) override; |
| |
| void PreCallRecordCmdClearAttachments( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkClearAttachment* pAttachments, |
| uint32_t rectCount, |
| const VkClearRect* pRects) override; |
| |
| void PostCallRecordCmdClearAttachments( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkClearAttachment* pAttachments, |
| uint32_t rectCount, |
| const VkClearRect* pRects) override; |
| |
| void PreCallRecordCmdResolveImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageResolve* pRegions) override; |
| |
| void PostCallRecordCmdResolveImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageResolve* pRegions) override; |
| |
| void PreCallRecordCmdSetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask) override; |
| |
| void PostCallRecordCmdSetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask) override; |
| |
| void PreCallRecordCmdResetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask) override; |
| |
| void PostCallRecordCmdResetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask) override; |
| |
| 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) override; |
| |
| 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) override; |
| |
| 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) override; |
| |
| 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) override; |
| |
| void PreCallRecordCmdBeginQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags) override; |
| |
| void PostCallRecordCmdBeginQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags) override; |
| |
| void PreCallRecordCmdEndQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PostCallRecordCmdEndQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PreCallRecordCmdResetQueryPool( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) override; |
| |
| void PostCallRecordCmdResetQueryPool( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) override; |
| |
| void PreCallRecordCmdWriteTimestamp( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PostCallRecordCmdWriteTimestamp( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PreCallRecordCmdCopyQueryPoolResults( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags) override; |
| |
| void PostCallRecordCmdCopyQueryPoolResults( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags) override; |
| |
| void PreCallRecordCmdPushConstants( |
| VkCommandBuffer commandBuffer, |
| VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void* pValues) override; |
| |
| void PostCallRecordCmdPushConstants( |
| VkCommandBuffer commandBuffer, |
| VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void* pValues) override; |
| |
| void PreCallRecordCmdBeginRenderPass( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents) override; |
| |
| void PostCallRecordCmdBeginRenderPass( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents) override; |
| |
| void PreCallRecordCmdNextSubpass( |
| VkCommandBuffer commandBuffer, |
| VkSubpassContents contents) override; |
| |
| void PostCallRecordCmdNextSubpass( |
| VkCommandBuffer commandBuffer, |
| VkSubpassContents contents) override; |
| |
| void PreCallRecordCmdEndRenderPass( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordCmdEndRenderPass( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PreCallRecordCmdExecuteCommands( |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) override; |
| |
| void PostCallRecordCmdExecuteCommands( |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) override; |
| |
| void PreCallRecordBindBufferMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) override; |
| |
| void PostCallRecordBindBufferMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos, |
| VkResult result) override; |
| |
| void PreCallRecordBindImageMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) override; |
| |
| void PostCallRecordBindImageMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos, |
| VkResult result) override; |
| |
| void PreCallRecordGetDeviceGroupPeerMemoryFeatures( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) override; |
| |
| void PostCallRecordGetDeviceGroupPeerMemoryFeatures( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) override; |
| |
| void PreCallRecordCmdSetDeviceMask( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask) override; |
| |
| void PostCallRecordCmdSetDeviceMask( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask) override; |
| |
| void PreCallRecordCmdDispatchBase( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) override; |
| |
| void PostCallRecordCmdDispatchBase( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) override; |
| |
| void PreCallRecordEnumeratePhysicalDeviceGroups( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) override; |
| |
| void PostCallRecordEnumeratePhysicalDeviceGroups( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, |
| VkResult result) override; |
| |
| void PreCallRecordGetImageMemoryRequirements2( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetImageMemoryRequirements2( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetBufferMemoryRequirements2( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetBufferMemoryRequirements2( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetImageSparseMemoryRequirements2( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PostCallRecordGetImageSparseMemoryRequirements2( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PreCallRecordTrimCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) override; |
| |
| void PostCallRecordTrimCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) override; |
| |
| void PreCallRecordGetDeviceQueue2( |
| VkDevice device, |
| const VkDeviceQueueInfo2* pQueueInfo, |
| VkQueue* pQueue) override; |
| |
| void PostCallRecordGetDeviceQueue2( |
| VkDevice device, |
| const VkDeviceQueueInfo2* pQueueInfo, |
| VkQueue* pQueue) override; |
| |
| void PreCallRecordCreateSamplerYcbcrConversion( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) override; |
| |
| void PostCallRecordCreateSamplerYcbcrConversion( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion, |
| VkResult result) override; |
| |
| void PreCallRecordDestroySamplerYcbcrConversion( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroySamplerYcbcrConversion( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCreateDescriptorUpdateTemplate( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) override; |
| |
| void PostCallRecordCreateDescriptorUpdateTemplate( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDescriptorUpdateTemplate( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDescriptorUpdateTemplate( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordUpdateDescriptorSetWithTemplate( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) override; |
| |
| void PostCallRecordUpdateDescriptorSetWithTemplate( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) override; |
| |
| void PreCallRecordGetDescriptorSetLayoutSupport( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) override; |
| |
| void PostCallRecordGetDescriptorSetLayoutSupport( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) override; |
| |
| void PreCallRecordCmdDrawIndirectCount( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndirectCount( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDrawIndexedIndirectCount( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndexedIndirectCount( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCreateRenderPass2( |
| VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) override; |
| |
| void PostCallRecordCreateRenderPass2( |
| VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass, |
| VkResult result) override; |
| |
| void PreCallRecordCmdBeginRenderPass2( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfo* pSubpassBeginInfo) override; |
| |
| void PostCallRecordCmdBeginRenderPass2( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfo* pSubpassBeginInfo) override; |
| |
| void PreCallRecordCmdNextSubpass2( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PostCallRecordCmdNextSubpass2( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PreCallRecordCmdEndRenderPass2( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PostCallRecordCmdEndRenderPass2( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PreCallRecordResetQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) override; |
| |
| void PostCallRecordResetQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) override; |
| |
| void PreCallRecordGetSemaphoreCounterValue( |
| VkDevice device, |
| VkSemaphore semaphore, |
| uint64_t* pValue) override; |
| |
| void PostCallRecordGetSemaphoreCounterValue( |
| VkDevice device, |
| VkSemaphore semaphore, |
| uint64_t* pValue, |
| VkResult result) override; |
| |
| void PreCallRecordWaitSemaphores( |
| VkDevice device, |
| const VkSemaphoreWaitInfo* pWaitInfo, |
| uint64_t timeout) override; |
| |
| void PostCallRecordWaitSemaphores( |
| VkDevice device, |
| const VkSemaphoreWaitInfo* pWaitInfo, |
| uint64_t timeout, |
| VkResult result) override; |
| |
| void PreCallRecordSignalSemaphore( |
| VkDevice device, |
| const VkSemaphoreSignalInfo* pSignalInfo) override; |
| |
| void PostCallRecordSignalSemaphore( |
| VkDevice device, |
| const VkSemaphoreSignalInfo* pSignalInfo, |
| VkResult result) override; |
| |
| void PreCallRecordGetBufferDeviceAddress( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetBufferDeviceAddress( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo, |
| VkDeviceAddress result) override; |
| |
| void PreCallRecordGetBufferOpaqueCaptureAddress( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetBufferOpaqueCaptureAddress( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PreCallRecordGetDeviceMemoryOpaqueCaptureAddress( |
| VkDevice device, |
| const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetDeviceMemoryOpaqueCaptureAddress( |
| VkDevice device, |
| const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) override; |
| |
| void PreCallRecordCreatePrivateDataSlot( |
| VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot) override; |
| |
| void PostCallRecordCreatePrivateDataSlot( |
| VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyPrivateDataSlot( |
| VkDevice device, |
| VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyPrivateDataSlot( |
| VkDevice device, |
| VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordSetPrivateData( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t data) override; |
| |
| void PostCallRecordSetPrivateData( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t data, |
| VkResult result) override; |
| |
| void PreCallRecordGetPrivateData( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t* pData) override; |
| |
| void PostCallRecordGetPrivateData( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t* pData) override; |
| |
| void PreCallRecordCmdSetEvent2( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PostCallRecordCmdSetEvent2( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PreCallRecordCmdResetEvent2( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags2 stageMask) override; |
| |
| void PostCallRecordCmdResetEvent2( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags2 stageMask) override; |
| |
| void PreCallRecordCmdWaitEvents2( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| const VkDependencyInfo* pDependencyInfos) override; |
| |
| void PostCallRecordCmdWaitEvents2( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| const VkDependencyInfo* pDependencyInfos) override; |
| |
| void PreCallRecordCmdPipelineBarrier2( |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PostCallRecordCmdPipelineBarrier2( |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PreCallRecordCmdWriteTimestamp2( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PostCallRecordCmdWriteTimestamp2( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PreCallRecordQueueSubmit2( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, |
| VkFence fence) override; |
| |
| void PostCallRecordQueueSubmit2( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, |
| VkFence fence, |
| VkResult result) override; |
| |
| void PreCallRecordCmdCopyBuffer2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) override; |
| |
| void PostCallRecordCmdCopyBuffer2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) override; |
| |
| void PreCallRecordCmdCopyImage2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageInfo2* pCopyImageInfo) override; |
| |
| void PostCallRecordCmdCopyImage2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageInfo2* pCopyImageInfo) override; |
| |
| void PreCallRecordCmdCopyBufferToImage2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) override; |
| |
| void PostCallRecordCmdCopyBufferToImage2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) override; |
| |
| void PreCallRecordCmdCopyImageToBuffer2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) override; |
| |
| void PostCallRecordCmdCopyImageToBuffer2( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) override; |
| |
| void PreCallRecordCmdBlitImage2( |
| VkCommandBuffer commandBuffer, |
| const VkBlitImageInfo2* pBlitImageInfo) override; |
| |
| void PostCallRecordCmdBlitImage2( |
| VkCommandBuffer commandBuffer, |
| const VkBlitImageInfo2* pBlitImageInfo) override; |
| |
| void PreCallRecordCmdResolveImage2( |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) override; |
| |
| void PostCallRecordCmdResolveImage2( |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) override; |
| |
| void PreCallRecordCmdBeginRendering( |
| VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) override; |
| |
| void PostCallRecordCmdBeginRendering( |
| VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) override; |
| |
| void PreCallRecordCmdEndRendering( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordCmdEndRendering( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PreCallRecordCmdSetCullMode( |
| VkCommandBuffer commandBuffer, |
| VkCullModeFlags cullMode) override; |
| |
| void PostCallRecordCmdSetCullMode( |
| VkCommandBuffer commandBuffer, |
| VkCullModeFlags cullMode) override; |
| |
| void PreCallRecordCmdSetFrontFace( |
| VkCommandBuffer commandBuffer, |
| VkFrontFace frontFace) override; |
| |
| void PostCallRecordCmdSetFrontFace( |
| VkCommandBuffer commandBuffer, |
| VkFrontFace frontFace) override; |
| |
| void PreCallRecordCmdSetPrimitiveTopology( |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) override; |
| |
| void PostCallRecordCmdSetPrimitiveTopology( |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) override; |
| |
| void PreCallRecordCmdSetViewportWithCount( |
| VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) override; |
| |
| void PostCallRecordCmdSetViewportWithCount( |
| VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) override; |
| |
| void PreCallRecordCmdSetScissorWithCount( |
| VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) override; |
| |
| void PostCallRecordCmdSetScissorWithCount( |
| VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) override; |
| |
| void PreCallRecordCmdBindVertexBuffers2( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes, |
| const VkDeviceSize* pStrides) override; |
| |
| void PostCallRecordCmdBindVertexBuffers2( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes, |
| const VkDeviceSize* pStrides) override; |
| |
| void PreCallRecordCmdSetDepthTestEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthTestEnable) override; |
| |
| void PostCallRecordCmdSetDepthTestEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthTestEnable) override; |
| |
| void PreCallRecordCmdSetDepthWriteEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthWriteEnable) override; |
| |
| void PostCallRecordCmdSetDepthWriteEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthWriteEnable) override; |
| |
| void PreCallRecordCmdSetDepthCompareOp( |
| VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) override; |
| |
| void PostCallRecordCmdSetDepthCompareOp( |
| VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) override; |
| |
| void PreCallRecordCmdSetDepthBoundsTestEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) override; |
| |
| void PostCallRecordCmdSetDepthBoundsTestEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) override; |
| |
| void PreCallRecordCmdSetStencilTestEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 stencilTestEnable) override; |
| |
| void PostCallRecordCmdSetStencilTestEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 stencilTestEnable) override; |
| |
| void PreCallRecordCmdSetStencilOp( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| VkStencilOp failOp, |
| VkStencilOp passOp, |
| VkStencilOp depthFailOp, |
| VkCompareOp compareOp) override; |
| |
| void PostCallRecordCmdSetStencilOp( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| VkStencilOp failOp, |
| VkStencilOp passOp, |
| VkStencilOp depthFailOp, |
| VkCompareOp compareOp) override; |
| |
| void PreCallRecordCmdSetRasterizerDiscardEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) override; |
| |
| void PostCallRecordCmdSetRasterizerDiscardEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) override; |
| |
| void PreCallRecordCmdSetDepthBiasEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBiasEnable) override; |
| |
| void PostCallRecordCmdSetDepthBiasEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBiasEnable) override; |
| |
| void PreCallRecordCmdSetPrimitiveRestartEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) override; |
| |
| void PostCallRecordCmdSetPrimitiveRestartEnable( |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) override; |
| |
| void PreCallRecordGetDeviceBufferMemoryRequirements( |
| VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetDeviceBufferMemoryRequirements( |
| VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetDeviceImageMemoryRequirements( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetDeviceImageMemoryRequirements( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetDeviceImageSparseMemoryRequirements( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PostCallRecordGetDeviceImageSparseMemoryRequirements( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PreCallRecordDestroySurfaceKHR( |
| VkInstance instance, |
| VkSurfaceKHR surface, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroySurfaceKHR( |
| VkInstance instance, |
| VkSurfaceKHR surface, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| VkSurfaceKHR surface, |
| VkBool32* pSupported) override; |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| VkSurfaceKHR surface, |
| VkBool32* pSupported, |
| VkResult result) override; |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) override; |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, |
| VkResult result) override; |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pSurfaceFormatCount, |
| VkSurfaceFormatKHR* pSurfaceFormats) override; |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pSurfaceFormatCount, |
| VkSurfaceFormatKHR* pSurfaceFormats, |
| VkResult result) override; |
| |
| void PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pPresentModeCount, |
| VkPresentModeKHR* pPresentModes) override; |
| |
| void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pPresentModeCount, |
| VkPresentModeKHR* pPresentModes, |
| VkResult result) override; |
| |
| void PreCallRecordCreateSwapchainKHR( |
| VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain) override; |
| |
| void PostCallRecordCreateSwapchainKHR( |
| VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain, |
| VkResult result) override; |
| |
| void PreCallRecordDestroySwapchainKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroySwapchainKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetSwapchainImagesKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, |
| VkImage* pSwapchainImages) override; |
| |
| void PostCallRecordGetSwapchainImagesKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, |
| VkImage* pSwapchainImages, |
| VkResult result) override; |
| |
| void PreCallRecordAcquireNextImageKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t timeout, |
| VkSemaphore semaphore, |
| VkFence fence, |
| uint32_t* pImageIndex) override; |
| |
| void PostCallRecordAcquireNextImageKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t timeout, |
| VkSemaphore semaphore, |
| VkFence fence, |
| uint32_t* pImageIndex, |
| VkResult result) override; |
| |
| void PreCallRecordGetDeviceGroupPresentCapabilitiesKHR( |
| VkDevice device, |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) override; |
| |
| void PostCallRecordGetDeviceGroupPresentCapabilitiesKHR( |
| VkDevice device, |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, |
| VkResult result) override; |
| |
| void PreCallRecordGetDeviceGroupSurfacePresentModesKHR( |
| VkDevice device, |
| VkSurfaceKHR surface, |
| VkDeviceGroupPresentModeFlagsKHR* pModes) override; |
| |
| void PostCallRecordGetDeviceGroupSurfacePresentModesKHR( |
| VkDevice device, |
| VkSurfaceKHR surface, |
| VkDeviceGroupPresentModeFlagsKHR* pModes, |
| VkResult result) override; |
| |
| void PreCallRecordGetPhysicalDevicePresentRectanglesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pRectCount, |
| VkRect2D* pRects) override; |
| |
| void PostCallRecordGetPhysicalDevicePresentRectanglesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pRectCount, |
| VkRect2D* pRects, |
| VkResult result) override; |
| |
| void PreCallRecordAcquireNextImage2KHR( |
| VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, |
| uint32_t* pImageIndex) override; |
| |
| void PostCallRecordAcquireNextImage2KHR( |
| VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, |
| uint32_t* pImageIndex, |
| VkResult result) override; |
| |
| void PreCallRecordGetDisplayPlaneSupportedDisplaysKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t planeIndex, |
| uint32_t* pDisplayCount, |
| VkDisplayKHR* pDisplays) override; |
| |
| void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t planeIndex, |
| uint32_t* pDisplayCount, |
| VkDisplayKHR* pDisplays, |
| VkResult result) override; |
| |
| void PreCallRecordGetDisplayModePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModePropertiesKHR* pProperties) override; |
| |
| void PostCallRecordGetDisplayModePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModePropertiesKHR* pProperties, |
| VkResult result) override; |
| |
| void PreCallRecordCreateDisplayModeKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDisplayModeKHR* pMode) override; |
| |
| void PostCallRecordCreateDisplayModeKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDisplayModeKHR* pMode, |
| VkResult result) override; |
| |
| void PreCallRecordGetDisplayPlaneCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayModeKHR mode, |
| uint32_t planeIndex, |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities) override; |
| |
| void PostCallRecordGetDisplayPlaneCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayModeKHR mode, |
| uint32_t planeIndex, |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities, |
| VkResult result) override; |
| |
| void PreCallRecordCreateDisplayPlaneSurfaceKHR( |
| VkInstance instance, |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateDisplayPlaneSurfaceKHR( |
| VkInstance instance, |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| |
| void PreCallRecordCreateSharedSwapchainsKHR( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchains) override; |
| |
| void PostCallRecordCreateSharedSwapchainsKHR( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchains, |
| VkResult result) override; |
| |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| |
| void PreCallRecordCreateXlibSurfaceKHR( |
| VkInstance instance, |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateXlibSurfaceKHR( |
| VkInstance instance, |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_XLIB_KHR |
| |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| |
| void PreCallRecordCreateXcbSurfaceKHR( |
| VkInstance instance, |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateXcbSurfaceKHR( |
| VkInstance instance, |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_XCB_KHR |
| |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| |
| void PreCallRecordCreateWaylandSurfaceKHR( |
| VkInstance instance, |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateWaylandSurfaceKHR( |
| VkInstance instance, |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| void PreCallRecordCreateAndroidSurfaceKHR( |
| VkInstance instance, |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateAndroidSurfaceKHR( |
| VkInstance instance, |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordCreateWin32SurfaceKHR( |
| VkInstance instance, |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateWin32SurfaceKHR( |
| VkInstance instance, |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordCreateVideoSessionKHR( |
| VkDevice device, |
| const VkVideoSessionCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkVideoSessionKHR* pVideoSession) override; |
| |
| void PostCallRecordCreateVideoSessionKHR( |
| VkDevice device, |
| const VkVideoSessionCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkVideoSessionKHR* pVideoSession, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyVideoSessionKHR( |
| VkDevice device, |
| VkVideoSessionKHR videoSession, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyVideoSessionKHR( |
| VkDevice device, |
| VkVideoSessionKHR videoSession, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetVideoSessionMemoryRequirementsKHR( |
| VkDevice device, |
| VkVideoSessionKHR videoSession, |
| uint32_t* pVideoSessionMemoryRequirementsCount, |
| VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) override; |
| |
| void PostCallRecordGetVideoSessionMemoryRequirementsKHR( |
| VkDevice device, |
| VkVideoSessionKHR videoSession, |
| uint32_t* pVideoSessionMemoryRequirementsCount, |
| VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements, |
| VkResult result) override; |
| |
| void PreCallRecordBindVideoSessionMemoryKHR( |
| VkDevice device, |
| VkVideoSessionKHR videoSession, |
| uint32_t videoSessionBindMemoryCount, |
| const VkVideoBindMemoryKHR* pVideoSessionBindMemories) override; |
| |
| void PostCallRecordBindVideoSessionMemoryKHR( |
| VkDevice device, |
| VkVideoSessionKHR videoSession, |
| uint32_t videoSessionBindMemoryCount, |
| const VkVideoBindMemoryKHR* pVideoSessionBindMemories, |
| VkResult result) override; |
| |
| void PreCallRecordCreateVideoSessionParametersKHR( |
| VkDevice device, |
| const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkVideoSessionParametersKHR* pVideoSessionParameters) override; |
| |
| void PostCallRecordCreateVideoSessionParametersKHR( |
| VkDevice device, |
| const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkVideoSessionParametersKHR* pVideoSessionParameters, |
| VkResult result) override; |
| |
| void PreCallRecordUpdateVideoSessionParametersKHR( |
| VkDevice device, |
| VkVideoSessionParametersKHR videoSessionParameters, |
| const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) override; |
| |
| void PostCallRecordUpdateVideoSessionParametersKHR( |
| VkDevice device, |
| VkVideoSessionParametersKHR videoSessionParameters, |
| const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyVideoSessionParametersKHR( |
| VkDevice device, |
| VkVideoSessionParametersKHR videoSessionParameters, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyVideoSessionParametersKHR( |
| VkDevice device, |
| VkVideoSessionParametersKHR videoSessionParameters, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCmdBeginVideoCodingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoBeginCodingInfoKHR* pBeginInfo) override; |
| |
| void PostCallRecordCmdBeginVideoCodingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoBeginCodingInfoKHR* pBeginInfo) override; |
| |
| void PreCallRecordCmdEndVideoCodingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoEndCodingInfoKHR* pEndCodingInfo) override; |
| |
| void PostCallRecordCmdEndVideoCodingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoEndCodingInfoKHR* pEndCodingInfo) override; |
| |
| void PreCallRecordCmdControlVideoCodingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoCodingControlInfoKHR* pCodingControlInfo) override; |
| |
| void PostCallRecordCmdControlVideoCodingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoCodingControlInfoKHR* pCodingControlInfo) override; |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordCmdDecodeVideoKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoDecodeInfoKHR* pFrameInfo) override; |
| |
| void PostCallRecordCmdDecodeVideoKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoDecodeInfoKHR* pFrameInfo) override; |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordCmdBeginRenderingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) override; |
| |
| void PostCallRecordCmdBeginRenderingKHR( |
| VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) override; |
| |
| void PreCallRecordCmdEndRenderingKHR( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordCmdEndRenderingKHR( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) override; |
| |
| void PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) override; |
| |
| void PreCallRecordCmdSetDeviceMaskKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask) override; |
| |
| void PostCallRecordCmdSetDeviceMaskKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask) override; |
| |
| void PreCallRecordCmdDispatchBaseKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) override; |
| |
| void PostCallRecordCmdDispatchBaseKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) override; |
| |
| void PreCallRecordTrimCommandPoolKHR( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) override; |
| |
| void PostCallRecordTrimCommandPoolKHR( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) override; |
| |
| void PreCallRecordEnumeratePhysicalDeviceGroupsKHR( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) override; |
| |
| void PostCallRecordEnumeratePhysicalDeviceGroupsKHR( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, |
| VkResult result) override; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetMemoryWin32HandleKHR( |
| VkDevice device, |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle) override; |
| |
| void PostCallRecordGetMemoryWin32HandleKHR( |
| VkDevice device, |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle, |
| VkResult result) override; |
| |
| void PreCallRecordGetMemoryWin32HandlePropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| HANDLE handle, |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) override; |
| |
| void PostCallRecordGetMemoryWin32HandlePropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| HANDLE handle, |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetMemoryFdKHR( |
| VkDevice device, |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, |
| int* pFd) override; |
| |
| void PostCallRecordGetMemoryFdKHR( |
| VkDevice device, |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, |
| int* pFd, |
| VkResult result) override; |
| |
| void PreCallRecordGetMemoryFdPropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| int fd, |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties) override; |
| |
| void PostCallRecordGetMemoryFdPropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| int fd, |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties, |
| VkResult result) override; |
| |
| #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) override; |
| |
| void PostCallRecordImportSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, |
| VkResult result) override; |
| |
| void PreCallRecordGetSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle) override; |
| |
| void PostCallRecordGetSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportSemaphoreFdKHR( |
| VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) override; |
| |
| void PostCallRecordImportSemaphoreFdKHR( |
| VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, |
| VkResult result) override; |
| |
| void PreCallRecordGetSemaphoreFdKHR( |
| VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, |
| int* pFd) override; |
| |
| void PostCallRecordGetSemaphoreFdKHR( |
| VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, |
| int* pFd, |
| VkResult result) override; |
| |
| void PreCallRecordCmdPushDescriptorSetKHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t set, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites) override; |
| |
| void PostCallRecordCmdPushDescriptorSetKHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t set, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites) override; |
| |
| void PreCallRecordCmdPushDescriptorSetWithTemplateKHR( |
| VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VkPipelineLayout layout, |
| uint32_t set, |
| const void* pData) override; |
| |
| void PostCallRecordCmdPushDescriptorSetWithTemplateKHR( |
| VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VkPipelineLayout layout, |
| uint32_t set, |
| const void* pData) override; |
| |
| void PreCallRecordCreateDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) override; |
| |
| void PostCallRecordCreateDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordUpdateDescriptorSetWithTemplateKHR( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) override; |
| |
| void PostCallRecordUpdateDescriptorSetWithTemplateKHR( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) override; |
| |
| void PreCallRecordCreateRenderPass2KHR( |
| VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) override; |
| |
| void PostCallRecordCreateRenderPass2KHR( |
| VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass, |
| VkResult result) override; |
| |
| void PreCallRecordCmdBeginRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfo* pSubpassBeginInfo) override; |
| |
| void PostCallRecordCmdBeginRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfo* pSubpassBeginInfo) override; |
| |
| void PreCallRecordCmdNextSubpass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PostCallRecordCmdNextSubpass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PreCallRecordCmdEndRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PostCallRecordCmdEndRenderPass2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) override; |
| |
| void PreCallRecordGetSwapchainStatusKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain) override; |
| |
| void PostCallRecordGetSwapchainStatusKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkResult result) override; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportFenceWin32HandleKHR( |
| VkDevice device, |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) override; |
| |
| void PostCallRecordImportFenceWin32HandleKHR( |
| VkDevice device, |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, |
| VkResult result) override; |
| |
| void PreCallRecordGetFenceWin32HandleKHR( |
| VkDevice device, |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle) override; |
| |
| void PostCallRecordGetFenceWin32HandleKHR( |
| VkDevice device, |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordImportFenceFdKHR( |
| VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo) override; |
| |
| void PostCallRecordImportFenceFdKHR( |
| VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo, |
| VkResult result) override; |
| |
| void PreCallRecordGetFenceFdKHR( |
| VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, |
| int* pFd) override; |
| |
| void PostCallRecordGetFenceFdKHR( |
| VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, |
| int* pFd, |
| VkResult result) override; |
| |
| void PreCallRecordAcquireProfilingLockKHR( |
| VkDevice device, |
| const VkAcquireProfilingLockInfoKHR* pInfo) override; |
| |
| void PostCallRecordAcquireProfilingLockKHR( |
| VkDevice device, |
| const VkAcquireProfilingLockInfoKHR* pInfo, |
| VkResult result) override; |
| |
| void PreCallRecordReleaseProfilingLockKHR( |
| VkDevice device) override; |
| |
| void PostCallRecordReleaseProfilingLockKHR( |
| VkDevice device) override; |
| |
| void PreCallRecordGetDisplayModeProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModeProperties2KHR* pProperties) override; |
| |
| void PostCallRecordGetDisplayModeProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModeProperties2KHR* pProperties, |
| VkResult result) override; |
| |
| void PreCallRecordGetImageMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetImageMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetBufferMemoryRequirements2KHR( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetBufferMemoryRequirements2KHR( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetImageSparseMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PostCallRecordGetImageSparseMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PreCallRecordCreateSamplerYcbcrConversionKHR( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) override; |
| |
| void PostCallRecordCreateSamplerYcbcrConversionKHR( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion, |
| VkResult result) override; |
| |
| void PreCallRecordDestroySamplerYcbcrConversionKHR( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroySamplerYcbcrConversionKHR( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordBindBufferMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) override; |
| |
| void PostCallRecordBindBufferMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos, |
| VkResult result) override; |
| |
| void PreCallRecordBindImageMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) override; |
| |
| void PostCallRecordBindImageMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos, |
| VkResult result) override; |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordGetDescriptorSetLayoutSupportKHR( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) override; |
| |
| void PostCallRecordGetDescriptorSetLayoutSupportKHR( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) override; |
| |
| void PreCallRecordCmdDrawIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDrawIndexedIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndexedIndirectCountKHR( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordGetSemaphoreCounterValueKHR( |
| VkDevice device, |
| VkSemaphore semaphore, |
| uint64_t* pValue) override; |
| |
| void PostCallRecordGetSemaphoreCounterValueKHR( |
| VkDevice device, |
| VkSemaphore semaphore, |
| uint64_t* pValue, |
| VkResult result) override; |
| |
| void PreCallRecordWaitSemaphoresKHR( |
| VkDevice device, |
| const VkSemaphoreWaitInfo* pWaitInfo, |
| uint64_t timeout) override; |
| |
| void PostCallRecordWaitSemaphoresKHR( |
| VkDevice device, |
| const VkSemaphoreWaitInfo* pWaitInfo, |
| uint64_t timeout, |
| VkResult result) override; |
| |
| void PreCallRecordSignalSemaphoreKHR( |
| VkDevice device, |
| const VkSemaphoreSignalInfo* pSignalInfo) override; |
| |
| void PostCallRecordSignalSemaphoreKHR( |
| VkDevice device, |
| const VkSemaphoreSignalInfo* pSignalInfo, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSetFragmentShadingRateKHR( |
| VkCommandBuffer commandBuffer, |
| const VkExtent2D* pFragmentSize, |
| const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) override; |
| |
| void PostCallRecordCmdSetFragmentShadingRateKHR( |
| VkCommandBuffer commandBuffer, |
| const VkExtent2D* pFragmentSize, |
| const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) override; |
| |
| void PreCallRecordWaitForPresentKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t presentId, |
| uint64_t timeout) override; |
| |
| void PostCallRecordWaitForPresentKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t presentId, |
| uint64_t timeout, |
| VkResult result) override; |
| |
| void PreCallRecordGetBufferDeviceAddressKHR( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetBufferDeviceAddressKHR( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo, |
| VkDeviceAddress result) override; |
| |
| void PreCallRecordGetBufferOpaqueCaptureAddressKHR( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetBufferOpaqueCaptureAddressKHR( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PreCallRecordGetDeviceMemoryOpaqueCaptureAddressKHR( |
| VkDevice device, |
| const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetDeviceMemoryOpaqueCaptureAddressKHR( |
| VkDevice device, |
| const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) override; |
| |
| void PreCallRecordCreateDeferredOperationKHR( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeferredOperationKHR* pDeferredOperation) override; |
| |
| void PostCallRecordCreateDeferredOperationKHR( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeferredOperationKHR* pDeferredOperation, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDeferredOperationKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDeferredOperationKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetDeferredOperationMaxConcurrencyKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation) override; |
| |
| void PostCallRecordGetDeferredOperationMaxConcurrencyKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation) override; |
| |
| void PreCallRecordGetDeferredOperationResultKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation) override; |
| |
| void PostCallRecordGetDeferredOperationResultKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation, |
| VkResult result) override; |
| |
| void PreCallRecordDeferredOperationJoinKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation) override; |
| |
| void PostCallRecordDeferredOperationJoinKHR( |
| VkDevice device, |
| VkDeferredOperationKHR operation, |
| VkResult result) override; |
| |
| void PreCallRecordGetPipelineExecutablePropertiesKHR( |
| VkDevice device, |
| const VkPipelineInfoKHR* pPipelineInfo, |
| uint32_t* pExecutableCount, |
| VkPipelineExecutablePropertiesKHR* pProperties) override; |
| |
| void PostCallRecordGetPipelineExecutablePropertiesKHR( |
| VkDevice device, |
| const VkPipelineInfoKHR* pPipelineInfo, |
| uint32_t* pExecutableCount, |
| VkPipelineExecutablePropertiesKHR* pProperties, |
| VkResult result) override; |
| |
| void PreCallRecordGetPipelineExecutableStatisticsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pStatisticCount, |
| VkPipelineExecutableStatisticKHR* pStatistics) override; |
| |
| void PostCallRecordGetPipelineExecutableStatisticsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pStatisticCount, |
| VkPipelineExecutableStatisticKHR* pStatistics, |
| VkResult result) override; |
| |
| void PreCallRecordGetPipelineExecutableInternalRepresentationsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pInternalRepresentationCount, |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) override; |
| |
| void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR( |
| VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pInternalRepresentationCount, |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, |
| VkResult result) override; |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordCmdEncodeVideoKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoEncodeInfoKHR* pEncodeInfo) override; |
| |
| void PostCallRecordCmdEncodeVideoKHR( |
| VkCommandBuffer commandBuffer, |
| const VkVideoEncodeInfoKHR* pEncodeInfo) override; |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordCmdSetEvent2KHR( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PostCallRecordCmdSetEvent2KHR( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PreCallRecordCmdResetEvent2KHR( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags2 stageMask) override; |
| |
| void PostCallRecordCmdResetEvent2KHR( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags2 stageMask) override; |
| |
| void PreCallRecordCmdWaitEvents2KHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| const VkDependencyInfo* pDependencyInfos) override; |
| |
| void PostCallRecordCmdWaitEvents2KHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| const VkDependencyInfo* pDependencyInfos) override; |
| |
| void PreCallRecordCmdPipelineBarrier2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PostCallRecordCmdPipelineBarrier2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) override; |
| |
| void PreCallRecordCmdWriteTimestamp2KHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PostCallRecordCmdWriteTimestamp2KHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, |
| VkQueryPool queryPool, |
| uint32_t query) override; |
| |
| void PreCallRecordQueueSubmit2KHR( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, |
| VkFence fence) override; |
| |
| void PostCallRecordQueueSubmit2KHR( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, |
| VkFence fence, |
| VkResult result) override; |
| |
| void PreCallRecordCmdWriteBufferMarker2AMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker) override; |
| |
| void PostCallRecordCmdWriteBufferMarker2AMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker) override; |
| |
| void PreCallRecordGetQueueCheckpointData2NV( |
| VkQueue queue, |
| uint32_t* pCheckpointDataCount, |
| VkCheckpointData2NV* pCheckpointData) override; |
| |
| void PostCallRecordGetQueueCheckpointData2NV( |
| VkQueue queue, |
| uint32_t* pCheckpointDataCount, |
| VkCheckpointData2NV* pCheckpointData) override; |
| |
| void PreCallRecordCmdCopyBuffer2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) override; |
| |
| void PostCallRecordCmdCopyBuffer2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) override; |
| |
| void PreCallRecordCmdCopyImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageInfo2* pCopyImageInfo) override; |
| |
| void PostCallRecordCmdCopyImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageInfo2* pCopyImageInfo) override; |
| |
| void PreCallRecordCmdCopyBufferToImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) override; |
| |
| void PostCallRecordCmdCopyBufferToImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) override; |
| |
| void PreCallRecordCmdCopyImageToBuffer2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) override; |
| |
| void PostCallRecordCmdCopyImageToBuffer2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) override; |
| |
| void PreCallRecordCmdBlitImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkBlitImageInfo2* pBlitImageInfo) override; |
| |
| void PostCallRecordCmdBlitImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkBlitImageInfo2* pBlitImageInfo) override; |
| |
| void PreCallRecordCmdResolveImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) override; |
| |
| void PostCallRecordCmdResolveImage2KHR( |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) override; |
| |
| void PreCallRecordCmdTraceRaysIndirect2KHR( |
| VkCommandBuffer commandBuffer, |
| VkDeviceAddress indirectDeviceAddress) override; |
| |
| void PostCallRecordCmdTraceRaysIndirect2KHR( |
| VkCommandBuffer commandBuffer, |
| VkDeviceAddress indirectDeviceAddress) override; |
| |
| void PreCallRecordGetDeviceBufferMemoryRequirementsKHR( |
| VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetDeviceBufferMemoryRequirementsKHR( |
| VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetDeviceImageMemoryRequirementsKHR( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetDeviceImageMemoryRequirementsKHR( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordGetDeviceImageSparseMemoryRequirementsKHR( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PostCallRecordGetDeviceImageSparseMemoryRequirementsKHR( |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) override; |
| |
| void PreCallRecordCreateDebugReportCallbackEXT( |
| VkInstance instance, |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugReportCallbackEXT* pCallback) override; |
| |
| void PostCallRecordCreateDebugReportCallbackEXT( |
| VkInstance instance, |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugReportCallbackEXT* pCallback, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDebugReportCallbackEXT( |
| VkInstance instance, |
| VkDebugReportCallbackEXT callback, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDebugReportCallbackEXT( |
| VkInstance instance, |
| VkDebugReportCallbackEXT callback, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordDebugReportMessageEXT( |
| VkInstance instance, |
| VkDebugReportFlagsEXT flags, |
| VkDebugReportObjectTypeEXT objectType, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const char* pLayerPrefix, |
| const char* pMessage) override; |
| |
| void PostCallRecordDebugReportMessageEXT( |
| VkInstance instance, |
| VkDebugReportFlagsEXT flags, |
| VkDebugReportObjectTypeEXT objectType, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const char* pLayerPrefix, |
| const char* pMessage) override; |
| // 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) override; |
| |
| void PostCallRecordCmdBindTransformFeedbackBuffersEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes) override; |
| |
| void PreCallRecordCmdBeginTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) override; |
| |
| void PostCallRecordCmdBeginTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) override; |
| |
| void PreCallRecordCmdEndTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) override; |
| |
| void PostCallRecordCmdEndTransformFeedbackEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) override; |
| |
| void PreCallRecordCmdBeginQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags, |
| uint32_t index) override; |
| |
| void PostCallRecordCmdBeginQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags, |
| uint32_t index) override; |
| |
| void PreCallRecordCmdEndQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| uint32_t index) override; |
| |
| void PostCallRecordCmdEndQueryIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| uint32_t index) override; |
| |
| void PreCallRecordCmdDrawIndirectByteCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| VkBuffer counterBuffer, |
| VkDeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride) override; |
| |
| void PostCallRecordCmdDrawIndirectByteCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| VkBuffer counterBuffer, |
| VkDeviceSize counterBufferOffset, |
| uint32_t counterOffset, |
| uint32_t vertexStride) override; |
| |
| void PreCallRecordCreateCuModuleNVX( |
| VkDevice device, |
| const VkCuModuleCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCuModuleNVX* pModule) override; |
| |
| void PostCallRecordCreateCuModuleNVX( |
| VkDevice device, |
| const VkCuModuleCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCuModuleNVX* pModule, |
| VkResult result) override; |
| |
| void PreCallRecordCreateCuFunctionNVX( |
| VkDevice device, |
| const VkCuFunctionCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCuFunctionNVX* pFunction) override; |
| |
| void PostCallRecordCreateCuFunctionNVX( |
| VkDevice device, |
| const VkCuFunctionCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCuFunctionNVX* pFunction, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyCuModuleNVX( |
| VkDevice device, |
| VkCuModuleNVX module, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyCuModuleNVX( |
| VkDevice device, |
| VkCuModuleNVX module, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordDestroyCuFunctionNVX( |
| VkDevice device, |
| VkCuFunctionNVX function, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyCuFunctionNVX( |
| VkDevice device, |
| VkCuFunctionNVX function, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCmdCuLaunchKernelNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCuLaunchInfoNVX* pLaunchInfo) override; |
| |
| void PostCallRecordCmdCuLaunchKernelNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCuLaunchInfoNVX* pLaunchInfo) override; |
| |
| void PreCallRecordGetImageViewHandleNVX( |
| VkDevice device, |
| const VkImageViewHandleInfoNVX* pInfo) override; |
| |
| void PostCallRecordGetImageViewHandleNVX( |
| VkDevice device, |
| const VkImageViewHandleInfoNVX* pInfo) override; |
| |
| void PreCallRecordGetImageViewAddressNVX( |
| VkDevice device, |
| VkImageView imageView, |
| VkImageViewAddressPropertiesNVX* pProperties) override; |
| |
| void PostCallRecordGetImageViewAddressNVX( |
| VkDevice device, |
| VkImageView imageView, |
| VkImageViewAddressPropertiesNVX* pProperties, |
| VkResult result) override; |
| |
| void PreCallRecordCmdDrawIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDrawIndexedIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawIndexedIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| void PreCallRecordGetShaderInfoAMD( |
| VkDevice device, |
| VkPipeline pipeline, |
| VkShaderStageFlagBits shaderStage, |
| VkShaderInfoTypeAMD infoType, |
| size_t* pInfoSize, |
| void* pInfo) override; |
| |
| void PostCallRecordGetShaderInfoAMD( |
| VkDevice device, |
| VkPipeline pipeline, |
| VkShaderStageFlagBits shaderStage, |
| VkShaderInfoTypeAMD infoType, |
| size_t* pInfoSize, |
| void* pInfo, |
| VkResult result) override; |
| |
| #ifdef VK_USE_PLATFORM_GGP |
| |
| void PreCallRecordCreateStreamDescriptorSurfaceGGP( |
| VkInstance instance, |
| const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateStreamDescriptorSurfaceGGP( |
| VkInstance instance, |
| const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_GGP |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordGetMemoryWin32HandleNV( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, |
| HANDLE* pHandle) override; |
| |
| void PostCallRecordGetMemoryWin32HandleNV( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, |
| HANDLE* pHandle, |
| VkResult result) override; |
| #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) override; |
| |
| void PostCallRecordCreateViSurfaceNN( |
| VkInstance instance, |
| const VkViSurfaceCreateInfoNN* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_VI_NN |
| |
| void PreCallRecordCmdBeginConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer, |
| const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) override; |
| |
| void PostCallRecordCmdBeginConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer, |
| const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) override; |
| |
| void PreCallRecordCmdEndConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordCmdEndConditionalRenderingEXT( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PreCallRecordCmdSetViewportWScalingNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewportWScalingNV* pViewportWScalings) override; |
| |
| void PostCallRecordCmdSetViewportWScalingNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewportWScalingNV* pViewportWScalings) override; |
| |
| void PreCallRecordReleaseDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display) override; |
| |
| void PostCallRecordReleaseDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| VkResult result) override; |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| void PreCallRecordAcquireXlibDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| VkDisplayKHR display) override; |
| |
| void PostCallRecordAcquireXlibDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| VkDisplayKHR display, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| void PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities) override; |
| |
| void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities, |
| VkResult result) override; |
| |
| void PreCallRecordDisplayPowerControlEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo) override; |
| |
| void PostCallRecordDisplayPowerControlEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo, |
| VkResult result) override; |
| |
| void PreCallRecordRegisterDeviceEventEXT( |
| VkDevice device, |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) override; |
| |
| void PostCallRecordRegisterDeviceEventEXT( |
| VkDevice device, |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence, |
| VkResult result) override; |
| |
| void PreCallRecordRegisterDisplayEventEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) override; |
| |
| void PostCallRecordRegisterDisplayEventEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence, |
| VkResult result) override; |
| |
| void PreCallRecordGetSwapchainCounterEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkSurfaceCounterFlagBitsEXT counter, |
| uint64_t* pCounterValue) override; |
| |
| void PostCallRecordGetSwapchainCounterEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkSurfaceCounterFlagBitsEXT counter, |
| uint64_t* pCounterValue, |
| VkResult result) override; |
| |
| void PreCallRecordGetRefreshCycleDurationGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) override; |
| |
| void PostCallRecordGetRefreshCycleDurationGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, |
| VkResult result) override; |
| |
| void PreCallRecordGetPastPresentationTimingGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pPresentationTimingCount, |
| VkPastPresentationTimingGOOGLE* pPresentationTimings) override; |
| |
| void PostCallRecordGetPastPresentationTimingGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pPresentationTimingCount, |
| VkPastPresentationTimingGOOGLE* pPresentationTimings, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSetDiscardRectangleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstDiscardRectangle, |
| uint32_t discardRectangleCount, |
| const VkRect2D* pDiscardRectangles) override; |
| |
| void PostCallRecordCmdSetDiscardRectangleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstDiscardRectangle, |
| uint32_t discardRectangleCount, |
| const VkRect2D* pDiscardRectangles) override; |
| |
| void PreCallRecordSetHdrMetadataEXT( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainKHR* pSwapchains, |
| const VkHdrMetadataEXT* pMetadata) override; |
| |
| void PostCallRecordSetHdrMetadataEXT( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainKHR* pSwapchains, |
| const VkHdrMetadataEXT* pMetadata) override; |
| |
| #ifdef VK_USE_PLATFORM_IOS_MVK |
| |
| void PreCallRecordCreateIOSSurfaceMVK( |
| VkInstance instance, |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateIOSSurfaceMVK( |
| VkInstance instance, |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_IOS_MVK |
| |
| #ifdef VK_USE_PLATFORM_MACOS_MVK |
| |
| void PreCallRecordCreateMacOSSurfaceMVK( |
| VkInstance instance, |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateMacOSSurfaceMVK( |
| VkInstance instance, |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #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) override; |
| |
| void PostCallRecordQueueBeginDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PreCallRecordQueueEndDebugUtilsLabelEXT( |
| VkQueue queue) override; |
| |
| void PostCallRecordQueueEndDebugUtilsLabelEXT( |
| VkQueue queue) override; |
| |
| void PreCallRecordQueueInsertDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PostCallRecordQueueInsertDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PreCallRecordCmdBeginDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PostCallRecordCmdBeginDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PreCallRecordCmdEndDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordCmdEndDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PreCallRecordCmdInsertDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PostCallRecordCmdInsertDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) override; |
| |
| void PreCallRecordCreateDebugUtilsMessengerEXT( |
| VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger) override; |
| |
| void PostCallRecordCreateDebugUtilsMessengerEXT( |
| VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyDebugUtilsMessengerEXT( |
| VkInstance instance, |
| VkDebugUtilsMessengerEXT messenger, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyDebugUtilsMessengerEXT( |
| VkInstance instance, |
| VkDebugUtilsMessengerEXT messenger, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordSubmitDebugUtilsMessageEXT( |
| VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) override; |
| |
| void PostCallRecordSubmitDebugUtilsMessageEXT( |
| VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) override; |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| void PreCallRecordGetAndroidHardwareBufferPropertiesANDROID( |
| VkDevice device, |
| const struct AHardwareBuffer* buffer, |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties) override; |
| |
| void PostCallRecordGetAndroidHardwareBufferPropertiesANDROID( |
| VkDevice device, |
| const struct AHardwareBuffer* buffer, |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties, |
| VkResult result) override; |
| |
| void PreCallRecordGetMemoryAndroidHardwareBufferANDROID( |
| VkDevice device, |
| const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, |
| struct AHardwareBuffer** pBuffer) override; |
| |
| void PostCallRecordGetMemoryAndroidHardwareBufferANDROID( |
| VkDevice device, |
| const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, |
| struct AHardwareBuffer** pBuffer, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| void PreCallRecordCmdSetSampleLocationsEXT( |
| VkCommandBuffer commandBuffer, |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo) override; |
| |
| void PostCallRecordCmdSetSampleLocationsEXT( |
| VkCommandBuffer commandBuffer, |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo) override; |
| |
| void PreCallRecordGetImageDrmFormatModifierPropertiesEXT( |
| VkDevice device, |
| VkImage image, |
| VkImageDrmFormatModifierPropertiesEXT* pProperties) override; |
| |
| void PostCallRecordGetImageDrmFormatModifierPropertiesEXT( |
| VkDevice device, |
| VkImage image, |
| VkImageDrmFormatModifierPropertiesEXT* pProperties, |
| VkResult result) override; |
| |
| 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) override; |
| |
| void PostCallRecordCmdBindShadingRateImageNV( |
| VkCommandBuffer commandBuffer, |
| VkImageView imageView, |
| VkImageLayout imageLayout) override; |
| |
| void PreCallRecordCmdSetViewportShadingRatePaletteNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkShadingRatePaletteNV* pShadingRatePalettes) override; |
| |
| void PostCallRecordCmdSetViewportShadingRatePaletteNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkShadingRatePaletteNV* pShadingRatePalettes) override; |
| |
| void PreCallRecordCmdSetCoarseSampleOrderNV( |
| VkCommandBuffer commandBuffer, |
| VkCoarseSampleOrderTypeNV sampleOrderType, |
| uint32_t customSampleOrderCount, |
| const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) override; |
| |
| void PostCallRecordCmdSetCoarseSampleOrderNV( |
| VkCommandBuffer commandBuffer, |
| VkCoarseSampleOrderTypeNV sampleOrderType, |
| uint32_t customSampleOrderCount, |
| const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) override; |
| |
| void PreCallRecordCreateAccelerationStructureNV( |
| VkDevice device, |
| const VkAccelerationStructureCreateInfoNV* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkAccelerationStructureNV* pAccelerationStructure) override; |
| |
| void PostCallRecordCreateAccelerationStructureNV( |
| VkDevice device, |
| const VkAccelerationStructureCreateInfoNV* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkAccelerationStructureNV* pAccelerationStructure, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyAccelerationStructureNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyAccelerationStructureNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetAccelerationStructureMemoryRequirementsNV( |
| VkDevice device, |
| const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, |
| VkMemoryRequirements2KHR* pMemoryRequirements) override; |
| |
| void PostCallRecordGetAccelerationStructureMemoryRequirementsNV( |
| VkDevice device, |
| const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, |
| VkMemoryRequirements2KHR* pMemoryRequirements) override; |
| |
| void PreCallRecordBindAccelerationStructureMemoryNV( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) override; |
| |
| void PostCallRecordBindAccelerationStructureMemoryNV( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, |
| VkResult result) override; |
| |
| void PreCallRecordCmdBuildAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| const VkAccelerationStructureInfoNV* pInfo, |
| VkBuffer instanceData, |
| VkDeviceSize instanceOffset, |
| VkBool32 update, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkBuffer scratch, |
| VkDeviceSize scratchOffset) override; |
| |
| void PostCallRecordCmdBuildAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| const VkAccelerationStructureInfoNV* pInfo, |
| VkBuffer instanceData, |
| VkDeviceSize instanceOffset, |
| VkBool32 update, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkBuffer scratch, |
| VkDeviceSize scratchOffset) override; |
| |
| void PreCallRecordCmdCopyAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkCopyAccelerationStructureModeKHR mode) override; |
| |
| void PostCallRecordCmdCopyAccelerationStructureNV( |
| VkCommandBuffer commandBuffer, |
| VkAccelerationStructureNV dst, |
| VkAccelerationStructureNV src, |
| VkCopyAccelerationStructureModeKHR mode) override; |
| |
| 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) override; |
| |
| 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) override; |
| |
| void PreCallRecordCreateRayTracingPipelinesNV( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkRayTracingPipelineCreateInfoNV* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) override; |
| |
| void PostCallRecordCreateRayTracingPipelinesNV( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkRayTracingPipelineCreateInfoNV* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result) override; |
| |
| void PreCallRecordGetRayTracingShaderGroupHandlesKHR( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData) override; |
| |
| void PostCallRecordGetRayTracingShaderGroupHandlesKHR( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData, |
| VkResult result) override; |
| |
| void PreCallRecordGetRayTracingShaderGroupHandlesNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData) override; |
| |
| void PostCallRecordGetRayTracingShaderGroupHandlesNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData, |
| VkResult result) override; |
| |
| void PreCallRecordGetAccelerationStructureHandleNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| size_t dataSize, |
| void* pData) override; |
| |
| void PostCallRecordGetAccelerationStructureHandleNV( |
| VkDevice device, |
| VkAccelerationStructureNV accelerationStructure, |
| size_t dataSize, |
| void* pData, |
| VkResult result) override; |
| |
| void PreCallRecordCmdWriteAccelerationStructuresPropertiesNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureNV* pAccelerationStructures, |
| VkQueryType queryType, |
| VkQueryPool queryPool, |
| uint32_t firstQuery) override; |
| |
| void PostCallRecordCmdWriteAccelerationStructuresPropertiesNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureNV* pAccelerationStructures, |
| VkQueryType queryType, |
| VkQueryPool queryPool, |
| uint32_t firstQuery) override; |
| |
| void PreCallRecordCompileDeferredNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t shader) override; |
| |
| void PostCallRecordCompileDeferredNV( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t shader, |
| VkResult result) override; |
| |
| void PreCallRecordGetMemoryHostPointerPropertiesEXT( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) override; |
| |
| void PostCallRecordGetMemoryHostPointerPropertiesEXT( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, |
| VkResult result) override; |
| |
| void PreCallRecordCmdWriteBufferMarkerAMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker) override; |
| |
| void PostCallRecordCmdWriteBufferMarkerAMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker) override; |
| |
| void PreCallRecordGetCalibratedTimestampsEXT( |
| VkDevice device, |
| uint32_t timestampCount, |
| const VkCalibratedTimestampInfoEXT* pTimestampInfos, |
| uint64_t* pTimestamps, |
| uint64_t* pMaxDeviation) override; |
| |
| void PostCallRecordGetCalibratedTimestampsEXT( |
| VkDevice device, |
| uint32_t timestampCount, |
| const VkCalibratedTimestampInfoEXT* pTimestampInfos, |
| uint64_t* pTimestamps, |
| uint64_t* pMaxDeviation, |
| VkResult result) override; |
| |
| #ifdef VK_ENABLE_BETA_EXTENSIONS |
| #endif // VK_ENABLE_BETA_EXTENSIONS |
| |
| #ifdef VK_USE_PLATFORM_GGP |
| #endif // VK_USE_PLATFORM_GGP |
| |
| void PreCallRecordCmdDrawMeshTasksNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t taskCount, |
| uint32_t firstTask) override; |
| |
| void PostCallRecordCmdDrawMeshTasksNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t taskCount, |
| uint32_t firstTask) override; |
| |
| void PreCallRecordCmdDrawMeshTasksIndirectNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawMeshTasksIndirectNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDrawMeshTasksIndirectCountNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawMeshTasksIndirectCountNV( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdSetExclusiveScissorNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstExclusiveScissor, |
| uint32_t exclusiveScissorCount, |
| const VkRect2D* pExclusiveScissors) override; |
| |
| void PostCallRecordCmdSetExclusiveScissorNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstExclusiveScissor, |
| uint32_t exclusiveScissorCount, |
| const VkRect2D* pExclusiveScissors) override; |
| |
| void PreCallRecordCmdSetCheckpointNV( |
| VkCommandBuffer commandBuffer, |
| const void* pCheckpointMarker) override; |
| |
| void PostCallRecordCmdSetCheckpointNV( |
| VkCommandBuffer commandBuffer, |
| const void* pCheckpointMarker) override; |
| |
| void PreCallRecordGetQueueCheckpointDataNV( |
| VkQueue queue, |
| uint32_t* pCheckpointDataCount, |
| VkCheckpointDataNV* pCheckpointData) override; |
| |
| void PostCallRecordGetQueueCheckpointDataNV( |
| VkQueue queue, |
| uint32_t* pCheckpointDataCount, |
| VkCheckpointDataNV* pCheckpointData) override; |
| |
| void PreCallRecordInitializePerformanceApiINTEL( |
| VkDevice device, |
| const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) override; |
| |
| void PostCallRecordInitializePerformanceApiINTEL( |
| VkDevice device, |
| const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, |
| VkResult result) override; |
| |
| void PreCallRecordUninitializePerformanceApiINTEL( |
| VkDevice device) override; |
| |
| void PostCallRecordUninitializePerformanceApiINTEL( |
| VkDevice device) override; |
| |
| void PreCallRecordCmdSetPerformanceMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceMarkerInfoINTEL* pMarkerInfo) override; |
| |
| void PostCallRecordCmdSetPerformanceMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceMarkerInfoINTEL* pMarkerInfo, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSetPerformanceStreamMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) override; |
| |
| void PostCallRecordCmdSetPerformanceStreamMarkerINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSetPerformanceOverrideINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceOverrideInfoINTEL* pOverrideInfo) override; |
| |
| void PostCallRecordCmdSetPerformanceOverrideINTEL( |
| VkCommandBuffer commandBuffer, |
| const VkPerformanceOverrideInfoINTEL* pOverrideInfo, |
| VkResult result) override; |
| |
| void PreCallRecordAcquirePerformanceConfigurationINTEL( |
| VkDevice device, |
| const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, |
| VkPerformanceConfigurationINTEL* pConfiguration) override; |
| |
| void PostCallRecordAcquirePerformanceConfigurationINTEL( |
| VkDevice device, |
| const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, |
| VkPerformanceConfigurationINTEL* pConfiguration, |
| VkResult result) override; |
| |
| void PreCallRecordReleasePerformanceConfigurationINTEL( |
| VkDevice device, |
| VkPerformanceConfigurationINTEL configuration) override; |
| |
| void PostCallRecordReleasePerformanceConfigurationINTEL( |
| VkDevice device, |
| VkPerformanceConfigurationINTEL configuration, |
| VkResult result) override; |
| |
| void PreCallRecordQueueSetPerformanceConfigurationINTEL( |
| VkQueue queue, |
| VkPerformanceConfigurationINTEL configuration) override; |
| |
| void PostCallRecordQueueSetPerformanceConfigurationINTEL( |
| VkQueue queue, |
| VkPerformanceConfigurationINTEL configuration, |
| VkResult result) override; |
| |
| void PreCallRecordGetPerformanceParameterINTEL( |
| VkDevice device, |
| VkPerformanceParameterTypeINTEL parameter, |
| VkPerformanceValueINTEL* pValue) override; |
| |
| void PostCallRecordGetPerformanceParameterINTEL( |
| VkDevice device, |
| VkPerformanceParameterTypeINTEL parameter, |
| VkPerformanceValueINTEL* pValue, |
| VkResult result) override; |
| |
| void PreCallRecordSetLocalDimmingAMD( |
| VkDevice device, |
| VkSwapchainKHR swapChain, |
| VkBool32 localDimmingEnable) override; |
| |
| void PostCallRecordSetLocalDimmingAMD( |
| VkDevice device, |
| VkSwapchainKHR swapChain, |
| VkBool32 localDimmingEnable) override; |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| void PreCallRecordCreateImagePipeSurfaceFUCHSIA( |
| VkInstance instance, |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateImagePipeSurfaceFUCHSIA( |
| VkInstance instance, |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_METAL_EXT |
| |
| void PreCallRecordCreateMetalSurfaceEXT( |
| VkInstance instance, |
| const VkMetalSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateMetalSurfaceEXT( |
| VkInstance instance, |
| const VkMetalSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_METAL_EXT |
| |
| void PreCallRecordGetBufferDeviceAddressEXT( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) override; |
| |
| void PostCallRecordGetBufferDeviceAddressEXT( |
| VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo, |
| VkDeviceAddress result) override; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordAcquireFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain) override; |
| |
| void PostCallRecordAcquireFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkResult result) override; |
| |
| void PreCallRecordReleaseFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain) override; |
| |
| void PostCallRecordReleaseFullScreenExclusiveModeEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkResult result) override; |
| |
| void PreCallRecordGetDeviceGroupSurfacePresentModes2EXT( |
| VkDevice device, |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, |
| VkDeviceGroupPresentModeFlagsKHR* pModes) override; |
| |
| void PostCallRecordGetDeviceGroupSurfacePresentModes2EXT( |
| VkDevice device, |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, |
| VkDeviceGroupPresentModeFlagsKHR* pModes, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordCreateHeadlessSurfaceEXT( |
| VkInstance instance, |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateHeadlessSurfaceEXT( |
| VkInstance instance, |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSetLineStippleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, |
| uint16_t lineStipplePattern) override; |
| |
| void PostCallRecordCmdSetLineStippleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, |
| uint16_t lineStipplePattern) override; |
| |
| void PreCallRecordResetQueryPoolEXT( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) override; |
| |
| void PostCallRecordResetQueryPoolEXT( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) override; |
| |
| void PreCallRecordCmdSetCullModeEXT( |
| VkCommandBuffer commandBuffer, |
| VkCullModeFlags cullMode) override; |
| |
| void PostCallRecordCmdSetCullModeEXT( |
| VkCommandBuffer commandBuffer, |
| VkCullModeFlags cullMode) override; |
| |
| void PreCallRecordCmdSetFrontFaceEXT( |
| VkCommandBuffer commandBuffer, |
| VkFrontFace frontFace) override; |
| |
| void PostCallRecordCmdSetFrontFaceEXT( |
| VkCommandBuffer commandBuffer, |
| VkFrontFace frontFace) override; |
| |
| void PreCallRecordCmdSetPrimitiveTopologyEXT( |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) override; |
| |
| void PostCallRecordCmdSetPrimitiveTopologyEXT( |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) override; |
| |
| void PreCallRecordCmdSetViewportWithCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) override; |
| |
| void PostCallRecordCmdSetViewportWithCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) override; |
| |
| void PreCallRecordCmdSetScissorWithCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) override; |
| |
| void PostCallRecordCmdSetScissorWithCountEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) override; |
| |
| void PreCallRecordCmdBindVertexBuffers2EXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes, |
| const VkDeviceSize* pStrides) override; |
| |
| void PostCallRecordCmdBindVertexBuffers2EXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, |
| const VkDeviceSize* pSizes, |
| const VkDeviceSize* pStrides) override; |
| |
| void PreCallRecordCmdSetDepthTestEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthTestEnable) override; |
| |
| void PostCallRecordCmdSetDepthTestEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthTestEnable) override; |
| |
| void PreCallRecordCmdSetDepthWriteEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthWriteEnable) override; |
| |
| void PostCallRecordCmdSetDepthWriteEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthWriteEnable) override; |
| |
| void PreCallRecordCmdSetDepthCompareOpEXT( |
| VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) override; |
| |
| void PostCallRecordCmdSetDepthCompareOpEXT( |
| VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) override; |
| |
| void PreCallRecordCmdSetDepthBoundsTestEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) override; |
| |
| void PostCallRecordCmdSetDepthBoundsTestEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) override; |
| |
| void PreCallRecordCmdSetStencilTestEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 stencilTestEnable) override; |
| |
| void PostCallRecordCmdSetStencilTestEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 stencilTestEnable) override; |
| |
| void PreCallRecordCmdSetStencilOpEXT( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| VkStencilOp failOp, |
| VkStencilOp passOp, |
| VkStencilOp depthFailOp, |
| VkCompareOp compareOp) override; |
| |
| void PostCallRecordCmdSetStencilOpEXT( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| VkStencilOp failOp, |
| VkStencilOp passOp, |
| VkStencilOp depthFailOp, |
| VkCompareOp compareOp) override; |
| |
| void PreCallRecordGetGeneratedCommandsMemoryRequirementsNV( |
| VkDevice device, |
| const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PostCallRecordGetGeneratedCommandsMemoryRequirementsNV( |
| VkDevice device, |
| const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) override; |
| |
| void PreCallRecordCmdPreprocessGeneratedCommandsNV( |
| VkCommandBuffer commandBuffer, |
| const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) override; |
| |
| void PostCallRecordCmdPreprocessGeneratedCommandsNV( |
| VkCommandBuffer commandBuffer, |
| const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) override; |
| |
| void PreCallRecordCmdExecuteGeneratedCommandsNV( |
| VkCommandBuffer commandBuffer, |
| VkBool32 isPreprocessed, |
| const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) override; |
| |
| void PostCallRecordCmdExecuteGeneratedCommandsNV( |
| VkCommandBuffer commandBuffer, |
| VkBool32 isPreprocessed, |
| const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) override; |
| |
| void PreCallRecordCmdBindPipelineShaderGroupNV( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline, |
| uint32_t groupIndex) override; |
| |
| void PostCallRecordCmdBindPipelineShaderGroupNV( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline, |
| uint32_t groupIndex) override; |
| |
| void PreCallRecordCreateIndirectCommandsLayoutNV( |
| VkDevice device, |
| const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) override; |
| |
| void PostCallRecordCreateIndirectCommandsLayoutNV( |
| VkDevice device, |
| const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkIndirectCommandsLayoutNV* pIndirectCommandsLayout, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyIndirectCommandsLayoutNV( |
| VkDevice device, |
| VkIndirectCommandsLayoutNV indirectCommandsLayout, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyIndirectCommandsLayoutNV( |
| VkDevice device, |
| VkIndirectCommandsLayoutNV indirectCommandsLayout, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordAcquireDrmDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| int32_t drmFd, |
| VkDisplayKHR display) override; |
| |
| void PostCallRecordAcquireDrmDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| int32_t drmFd, |
| VkDisplayKHR display, |
| VkResult result) override; |
| |
| void PreCallRecordCreatePrivateDataSlotEXT( |
| VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot) override; |
| |
| void PostCallRecordCreatePrivateDataSlotEXT( |
| VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyPrivateDataSlotEXT( |
| VkDevice device, |
| VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyPrivateDataSlotEXT( |
| VkDevice device, |
| VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordSetPrivateDataEXT( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t data) override; |
| |
| void PostCallRecordSetPrivateDataEXT( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t data, |
| VkResult result) override; |
| |
| void PreCallRecordGetPrivateDataEXT( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t* pData) override; |
| |
| void PostCallRecordGetPrivateDataEXT( |
| VkDevice device, |
| VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, |
| uint64_t* pData) override; |
| |
| void PreCallRecordCmdSetFragmentShadingRateEnumNV( |
| VkCommandBuffer commandBuffer, |
| VkFragmentShadingRateNV shadingRate, |
| const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) override; |
| |
| void PostCallRecordCmdSetFragmentShadingRateEnumNV( |
| VkCommandBuffer commandBuffer, |
| VkFragmentShadingRateNV shadingRate, |
| const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) override; |
| |
| void PreCallRecordGetImageSubresourceLayout2EXT( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource2EXT* pSubresource, |
| VkSubresourceLayout2EXT* pLayout) override; |
| |
| void PostCallRecordGetImageSubresourceLayout2EXT( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource2EXT* pSubresource, |
| VkSubresourceLayout2EXT* pLayout) override; |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| void PreCallRecordAcquireWinrtDisplayNV( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display) override; |
| |
| void PostCallRecordAcquireWinrtDisplayNV( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_DIRECTFB_EXT |
| |
| void PreCallRecordCreateDirectFBSurfaceEXT( |
| VkInstance instance, |
| const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateDirectFBSurfaceEXT( |
| VkInstance instance, |
| const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_DIRECTFB_EXT |
| |
| void PreCallRecordCmdSetVertexInputEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexBindingDescriptionCount, |
| const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, |
| uint32_t vertexAttributeDescriptionCount, |
| const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) override; |
| |
| void PostCallRecordCmdSetVertexInputEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexBindingDescriptionCount, |
| const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, |
| uint32_t vertexAttributeDescriptionCount, |
| const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) override; |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| void PreCallRecordGetMemoryZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, |
| zx_handle_t* pZirconHandle) override; |
| |
| void PostCallRecordGetMemoryZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, |
| zx_handle_t* pZirconHandle, |
| VkResult result) override; |
| |
| void PreCallRecordGetMemoryZirconHandlePropertiesFUCHSIA( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| zx_handle_t zirconHandle, |
| VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) override; |
| |
| void PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| zx_handle_t zirconHandle, |
| VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| void PreCallRecordImportSemaphoreZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) override; |
| |
| void PostCallRecordImportSemaphoreZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo, |
| VkResult result) override; |
| |
| void PreCallRecordGetSemaphoreZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, |
| zx_handle_t* pZirconHandle) override; |
| |
| void PostCallRecordGetSemaphoreZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, |
| zx_handle_t* pZirconHandle, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| void PreCallRecordCreateBufferCollectionFUCHSIA( |
| VkDevice device, |
| const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferCollectionFUCHSIA* pCollection) override; |
| |
| void PostCallRecordCreateBufferCollectionFUCHSIA( |
| VkDevice device, |
| const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferCollectionFUCHSIA* pCollection, |
| VkResult result) override; |
| |
| void PreCallRecordSetBufferCollectionImageConstraintsFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) override; |
| |
| void PostCallRecordSetBufferCollectionImageConstraintsFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo, |
| VkResult result) override; |
| |
| void PreCallRecordSetBufferCollectionBufferConstraintsFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) override; |
| |
| void PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyBufferCollectionFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyBufferCollectionFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordGetBufferCollectionPropertiesFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| VkBufferCollectionPropertiesFUCHSIA* pProperties) override; |
| |
| void PostCallRecordGetBufferCollectionPropertiesFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| VkBufferCollectionPropertiesFUCHSIA* pProperties, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| void PreCallRecordGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( |
| VkDevice device, |
| VkRenderPass renderpass, |
| VkExtent2D* pMaxWorkgroupSize) override; |
| |
| void PostCallRecordGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( |
| VkDevice device, |
| VkRenderPass renderpass, |
| VkExtent2D* pMaxWorkgroupSize, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSubpassShadingHUAWEI( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PostCallRecordCmdSubpassShadingHUAWEI( |
| VkCommandBuffer commandBuffer) override; |
| |
| void PreCallRecordCmdBindInvocationMaskHUAWEI( |
| VkCommandBuffer commandBuffer, |
| VkImageView imageView, |
| VkImageLayout imageLayout) override; |
| |
| void PostCallRecordCmdBindInvocationMaskHUAWEI( |
| VkCommandBuffer commandBuffer, |
| VkImageView imageView, |
| VkImageLayout imageLayout) override; |
| |
| void PreCallRecordGetMemoryRemoteAddressNV( |
| VkDevice device, |
| const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, |
| VkRemoteAddressNV* pAddress) override; |
| |
| void PostCallRecordGetMemoryRemoteAddressNV( |
| VkDevice device, |
| const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, |
| VkRemoteAddressNV* pAddress, |
| VkResult result) override; |
| |
| void PreCallRecordGetPipelinePropertiesEXT( |
| VkDevice device, |
| const VkPipelineInfoEXT* pPipelineInfo, |
| VkBaseOutStructure* pPipelineProperties) override; |
| |
| void PostCallRecordGetPipelinePropertiesEXT( |
| VkDevice device, |
| const VkPipelineInfoEXT* pPipelineInfo, |
| VkBaseOutStructure* pPipelineProperties, |
| VkResult result) override; |
| |
| void PreCallRecordCmdSetPatchControlPointsEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t patchControlPoints) override; |
| |
| void PostCallRecordCmdSetPatchControlPointsEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t patchControlPoints) override; |
| |
| void PreCallRecordCmdSetRasterizerDiscardEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) override; |
| |
| void PostCallRecordCmdSetRasterizerDiscardEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) override; |
| |
| void PreCallRecordCmdSetDepthBiasEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBiasEnable) override; |
| |
| void PostCallRecordCmdSetDepthBiasEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBiasEnable) override; |
| |
| void PreCallRecordCmdSetLogicOpEXT( |
| VkCommandBuffer commandBuffer, |
| VkLogicOp logicOp) override; |
| |
| void PostCallRecordCmdSetLogicOpEXT( |
| VkCommandBuffer commandBuffer, |
| VkLogicOp logicOp) override; |
| |
| void PreCallRecordCmdSetPrimitiveRestartEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) override; |
| |
| void PostCallRecordCmdSetPrimitiveRestartEnableEXT( |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) override; |
| |
| #ifdef VK_USE_PLATFORM_SCREEN_QNX |
| |
| void PreCallRecordCreateScreenSurfaceQNX( |
| VkInstance instance, |
| const VkScreenSurfaceCreateInfoQNX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) override; |
| |
| void PostCallRecordCreateScreenSurfaceQNX( |
| VkInstance instance, |
| const VkScreenSurfaceCreateInfoQNX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface, |
| VkResult result) override; |
| #endif // VK_USE_PLATFORM_SCREEN_QNX |
| |
| void PreCallRecordCmdSetColorWriteEnableEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkBool32* pColorWriteEnables) override; |
| |
| void PostCallRecordCmdSetColorWriteEnableEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkBool32* pColorWriteEnables) override; |
| |
| void PreCallRecordCmdDrawMultiEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t drawCount, |
| const VkMultiDrawInfoEXT* pVertexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride) override; |
| |
| void PostCallRecordCmdDrawMultiEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t drawCount, |
| const VkMultiDrawInfoEXT* pVertexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride) override; |
| |
| void PreCallRecordCmdDrawMultiIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t drawCount, |
| const VkMultiDrawIndexedInfoEXT* pIndexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride, |
| const int32_t* pVertexOffset) override; |
| |
| void PostCallRecordCmdDrawMultiIndexedEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t drawCount, |
| const VkMultiDrawIndexedInfoEXT* pIndexInfo, |
| uint32_t instanceCount, |
| uint32_t firstInstance, |
| uint32_t stride, |
| const int32_t* pVertexOffset) override; |
| |
| void PreCallRecordSetDeviceMemoryPriorityEXT( |
| VkDevice device, |
| VkDeviceMemory memory, |
| float priority) override; |
| |
| void PostCallRecordSetDeviceMemoryPriorityEXT( |
| VkDevice device, |
| VkDeviceMemory memory, |
| float priority) override; |
| |
| void PreCallRecordGetDescriptorSetLayoutHostMappingInfoVALVE( |
| VkDevice device, |
| const VkDescriptorSetBindingReferenceVALVE* pBindingReference, |
| VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) override; |
| |
| void PostCallRecordGetDescriptorSetLayoutHostMappingInfoVALVE( |
| VkDevice device, |
| const VkDescriptorSetBindingReferenceVALVE* pBindingReference, |
| VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) override; |
| |
| void PreCallRecordGetDescriptorSetHostMappingVALVE( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| void** ppData) override; |
| |
| void PostCallRecordGetDescriptorSetHostMappingVALVE( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| void** ppData) override; |
| |
| void PreCallRecordCreateAccelerationStructureKHR( |
| VkDevice device, |
| const VkAccelerationStructureCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkAccelerationStructureKHR* pAccelerationStructure) override; |
| |
| void PostCallRecordCreateAccelerationStructureKHR( |
| VkDevice device, |
| const VkAccelerationStructureCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkAccelerationStructureKHR* pAccelerationStructure, |
| VkResult result) override; |
| |
| void PreCallRecordDestroyAccelerationStructureKHR( |
| VkDevice device, |
| VkAccelerationStructureKHR accelerationStructure, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PostCallRecordDestroyAccelerationStructureKHR( |
| VkDevice device, |
| VkAccelerationStructureKHR accelerationStructure, |
| const VkAllocationCallbacks* pAllocator) override; |
| |
| void PreCallRecordCmdBuildAccelerationStructuresKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t infoCount, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, |
| const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) override; |
| |
| void PostCallRecordCmdBuildAccelerationStructuresKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t infoCount, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, |
| const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) override; |
| |
| void PreCallRecordCmdBuildAccelerationStructuresIndirectKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t infoCount, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, |
| const VkDeviceAddress* pIndirectDeviceAddresses, |
| const uint32_t* pIndirectStrides, |
| const uint32_t* const* ppMaxPrimitiveCounts) override; |
| |
| void PostCallRecordCmdBuildAccelerationStructuresIndirectKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t infoCount, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, |
| const VkDeviceAddress* pIndirectDeviceAddresses, |
| const uint32_t* pIndirectStrides, |
| const uint32_t* const* ppMaxPrimitiveCounts) override; |
| |
| void PreCallRecordBuildAccelerationStructuresKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| uint32_t infoCount, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, |
| const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) override; |
| |
| void PostCallRecordBuildAccelerationStructuresKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| uint32_t infoCount, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, |
| const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, |
| VkResult result) override; |
| |
| void PreCallRecordCopyAccelerationStructureKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| const VkCopyAccelerationStructureInfoKHR* pInfo) override; |
| |
| void PostCallRecordCopyAccelerationStructureKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| const VkCopyAccelerationStructureInfoKHR* pInfo, |
| VkResult result) override; |
| |
| void PreCallRecordCopyAccelerationStructureToMemoryKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) override; |
| |
| void PostCallRecordCopyAccelerationStructureToMemoryKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, |
| VkResult result) override; |
| |
| void PreCallRecordCopyMemoryToAccelerationStructureKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) override; |
| |
| void PostCallRecordCopyMemoryToAccelerationStructureKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, |
| VkResult result) override; |
| |
| void PreCallRecordWriteAccelerationStructuresPropertiesKHR( |
| VkDevice device, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureKHR* pAccelerationStructures, |
| VkQueryType queryType, |
| size_t dataSize, |
| void* pData, |
| size_t stride) override; |
| |
| void PostCallRecordWriteAccelerationStructuresPropertiesKHR( |
| VkDevice device, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureKHR* pAccelerationStructures, |
| VkQueryType queryType, |
| size_t dataSize, |
| void* pData, |
| size_t stride, |
| VkResult result) override; |
| |
| void PreCallRecordCmdCopyAccelerationStructureKHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyAccelerationStructureInfoKHR* pInfo) override; |
| |
| void PostCallRecordCmdCopyAccelerationStructureKHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyAccelerationStructureInfoKHR* pInfo) override; |
| |
| void PreCallRecordCmdCopyAccelerationStructureToMemoryKHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) override; |
| |
| void PostCallRecordCmdCopyAccelerationStructureToMemoryKHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) override; |
| |
| void PreCallRecordCmdCopyMemoryToAccelerationStructureKHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) override; |
| |
| void PostCallRecordCmdCopyMemoryToAccelerationStructureKHR( |
| VkCommandBuffer commandBuffer, |
| const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) override; |
| |
| void PreCallRecordGetAccelerationStructureDeviceAddressKHR( |
| VkDevice device, |
| const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) override; |
| |
| void PostCallRecordGetAccelerationStructureDeviceAddressKHR( |
| VkDevice device, |
| const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, |
| VkDeviceAddress result) override; |
| |
| void PreCallRecordCmdWriteAccelerationStructuresPropertiesKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureKHR* pAccelerationStructures, |
| VkQueryType queryType, |
| VkQueryPool queryPool, |
| uint32_t firstQuery) override; |
| |
| void PostCallRecordCmdWriteAccelerationStructuresPropertiesKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t accelerationStructureCount, |
| const VkAccelerationStructureKHR* pAccelerationStructures, |
| VkQueryType queryType, |
| VkQueryPool queryPool, |
| uint32_t firstQuery) override; |
| |
| void PreCallRecordGetDeviceAccelerationStructureCompatibilityKHR( |
| VkDevice device, |
| const VkAccelerationStructureVersionInfoKHR* pVersionInfo, |
| VkAccelerationStructureCompatibilityKHR* pCompatibility) override; |
| |
| void PostCallRecordGetDeviceAccelerationStructureCompatibilityKHR( |
| VkDevice device, |
| const VkAccelerationStructureVersionInfoKHR* pVersionInfo, |
| VkAccelerationStructureCompatibilityKHR* pCompatibility) override; |
| |
| void PreCallRecordGetAccelerationStructureBuildSizesKHR( |
| VkDevice device, |
| VkAccelerationStructureBuildTypeKHR buildType, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, |
| const uint32_t* pMaxPrimitiveCounts, |
| VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) override; |
| |
| void PostCallRecordGetAccelerationStructureBuildSizesKHR( |
| VkDevice device, |
| VkAccelerationStructureBuildTypeKHR buildType, |
| const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, |
| const uint32_t* pMaxPrimitiveCounts, |
| VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) override; |
| |
| void PreCallRecordCmdTraceRaysKHR( |
| VkCommandBuffer commandBuffer, |
| const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth) override; |
| |
| void PostCallRecordCmdTraceRaysKHR( |
| VkCommandBuffer commandBuffer, |
| const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, |
| uint32_t width, |
| uint32_t height, |
| uint32_t depth) override; |
| |
| void PreCallRecordCreateRayTracingPipelinesKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) override; |
| |
| void PostCallRecordCreateRayTracingPipelinesKHR( |
| VkDevice device, |
| VkDeferredOperationKHR deferredOperation, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines, |
| VkResult result) override; |
| |
| void PreCallRecordGetRayTracingCaptureReplayShaderGroupHandlesKHR( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData) override; |
| |
| void PostCallRecordGetRayTracingCaptureReplayShaderGroupHandlesKHR( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t firstGroup, |
| uint32_t groupCount, |
| size_t dataSize, |
| void* pData, |
| VkResult result) override; |
| |
| void PreCallRecordCmdTraceRaysIndirectKHR( |
| VkCommandBuffer commandBuffer, |
| const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, |
| VkDeviceAddress indirectDeviceAddress) override; |
| |
| void PostCallRecordCmdTraceRaysIndirectKHR( |
| VkCommandBuffer commandBuffer, |
| const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, |
| const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, |
| VkDeviceAddress indirectDeviceAddress) override; |
| |
| void PreCallRecordGetRayTracingShaderGroupStackSizeKHR( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t group, |
| VkShaderGroupShaderKHR groupShader) override; |
| |
| void PostCallRecordGetRayTracingShaderGroupStackSizeKHR( |
| VkDevice device, |
| VkPipeline pipeline, |
| uint32_t group, |
| VkShaderGroupShaderKHR groupShader) override; |
| |
| void PreCallRecordCmdSetRayTracingPipelineStackSizeKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t pipelineStackSize) override; |
| |
| void PostCallRecordCmdSetRayTracingPipelineStackSizeKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t pipelineStackSize) override; |
| }; |
