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