[vulkan] Take generated code for VkEventHandler
bug: 111137294
Taking the generated code. Also, moving VkEncoder to the
goldfish_vk namespace.
Change-Id: I62355feb73bf1880f0ba7bf9e4afd1031c01e376
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index b2a3fb9..c14e12d 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -21,12 +21,16 @@
#ifdef GOLDFISH_VULKAN
#include "VkEncoder.h"
#else
+namespace goldfish_vk {
struct VkEncoder {
VkEncoder(IOStream*) { }
int placeholder;
};
+} // namespace goldfish_vk
#endif
+using goldfish_vk::VkEncoder;
+
#include "ProcessPipe.h"
#include "QemuPipeStream.h"
#include "TcpStream.h"
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index fb15463..ac2f330 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -28,7 +28,10 @@
struct gl_client_context_t;
class GL2Encoder;
struct gl2_client_context_t;
+
+namespace goldfish_vk {
class VkEncoder;
+}
// SyncImpl determines the presence of host/guest OpenGL fence sync
// capabilities. It corresponds exactly to EGL_ANDROID_native_fence_sync
@@ -150,7 +153,7 @@
GLEncoder *glEncoder();
GL2Encoder *gl2Encoder();
- VkEncoder *vkEncoder();
+ goldfish_vk::VkEncoder *vkEncoder();
ExtendedRCEncoderContext *rcEncoder();
ChecksumCalculator *checksumHelper() { return &m_checksumHelper; }
Gralloc *grallocHelper() { return m_grallocHelper; }
@@ -186,7 +189,7 @@
IOStream *m_stream;
GLEncoder *m_glEnc;
GL2Encoder *m_gl2Enc;
- VkEncoder *m_vkEnc;
+ goldfish_vk::VkEncoder *m_vkEnc;
ExtendedRCEncoderContext *m_rcEnc;
ChecksumCalculator m_checksumHelper;
Gralloc *m_grallocHelper;
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index ced5f90..537c966 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -60,7 +60,7 @@
ALOGE("vulkan: Failed to get renderControl encoder context\n"); \
return VK_ERROR_DEVICE_LOST; \
} \
- VkEncoder *vkEnc = hostCon->vkEncoder(); \
+ goldfish_vk::VkEncoder *vkEnc = hostCon->vkEncoder(); \
if (!vkEnc) { \
ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
return VK_ERROR_DEVICE_LOST; \
diff --git a/system/vulkan_enc/Android.mk b/system/vulkan_enc/Android.mk
index bd9a6a4..7a146dc 100644
--- a/system/vulkan_enc/Android.mk
+++ b/system/vulkan_enc/Android.mk
@@ -47,6 +47,7 @@
VulkanHandleMapping.cpp \
ResourceTracker.cpp \
VkEncoder.cpp \
+VkEventHandler.cpp \
goldfish_vk_extension_structs_guest.cpp \
goldfish_vk_marshaling_guest.cpp \
goldfish_vk_deepcopy_guest.cpp \
diff --git a/system/vulkan_enc/CMakeLists.txt b/system/vulkan_enc/CMakeLists.txt
index d7af1d9..0f43f29 100644
--- a/system/vulkan_enc/CMakeLists.txt
+++ b/system/vulkan_enc/CMakeLists.txt
@@ -1,8 +1,8 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "26aaae731e38a2129c6f431fd7c7574a6786e2448306468edbc7bfd749a4ef77")
-set(vulkan_enc_src Resources.cpp Validation.cpp VulkanStream.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_handlemap_guest.cpp)
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "aad370b1675d05b89d55d471376175c21c2d4567f65a593dabe3038f8806219c")
+set(vulkan_enc_src Resources.cpp Validation.cpp VulkanStream.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp VkEventHandler.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_handlemap_guest.cpp)
android_add_shared_library(vulkan_enc)
target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include/vulkan)
target_compile_definitions(vulkan_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_ANDROID_native_buffer" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
index 13bea5f..e40e413 100644
--- a/system/vulkan_enc/ResourceTracker.h
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -18,14 +18,15 @@
#include "VulkanHandleMapping.h"
#include "VulkanHandles.h"
+#include "VkEventHandler.h"
#include <memory>
namespace goldfish_vk {
-class ResourceTracker {
+class ResourceTracker : public VkEventHandler {
public:
ResourceTracker();
- ~ResourceTracker();
+ virtual ~ResourceTracker();
static ResourceTracker* get();
VulkanHandleMapping* createMapping();
VulkanHandleMapping* unwrapMapping();
@@ -44,7 +45,6 @@
bool isValidMemoryRange(
VkDevice device,
const VkMappedMemoryRange& range) const;
-
private:
class Impl;
std::unique_ptr<Impl> mImpl;
diff --git a/system/vulkan_enc/Resources.cpp b/system/vulkan_enc/Resources.cpp
index 70778fa..c2b972e 100644
--- a/system/vulkan_enc/Resources.cpp
+++ b/system/vulkan_enc/Resources.cpp
@@ -38,6 +38,7 @@
#endif
using goldfish_vk::ResourceTracker;
+using goldfish_vk::VkEncoder;
extern "C" {
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index fd6ae57..51976f9 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -40,7 +40,7 @@
#include "goldfish_vk_private_defs.h"
-
+namespace goldfish_vk {
@@ -18954,4 +18954,4 @@
#endif
-
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index 0163b6b..2eacb67 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -32,7 +32,7 @@
class IOStream;
-
+namespace goldfish_vk {
class VkEncoder {
@@ -1747,4 +1747,4 @@
std::unique_ptr<Impl> mImpl;
};
-
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEventHandler.cpp b/system/vulkan_enc/VkEventHandler.cpp
new file mode 100644
index 0000000..0e166f3
--- /dev/null
+++ b/system/vulkan_enc/VkEventHandler.cpp
@@ -0,0 +1,3155 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 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.
+
+// Autogenerated module VkEventHandler
+// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "VkEventHandler.h"
+
+
+#include "VkEncoder.h"
+
+
+namespace goldfish_vk {
+
+
+VkEventHandler::VkEventHandler() { }
+VkEventHandler::~VkEventHandler() { }
+#ifdef VK_VERSION_1_0
+VkResult VkEventHandler::on_vkCreateInstance(
+ void*,
+ VkResult,
+ const VkInstanceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkInstance*)
+{
+ VkResult on_vkCreateInstance_VkResult_return = (VkResult)0;
+ return on_vkCreateInstance_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyInstance(
+ void*,
+ VkInstance,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkEnumeratePhysicalDevices(
+ void*,
+ VkResult,
+ VkInstance,
+ uint32_t*,
+ VkPhysicalDevice*)
+{
+ VkResult on_vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+ return on_vkEnumeratePhysicalDevices_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceFeatures*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkFormatProperties*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkFormat,
+ VkImageType,
+ VkImageTiling,
+ VkImageUsageFlags,
+ VkImageCreateFlags,
+ VkImageFormatProperties*)
+{
+ VkResult on_vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties(
+ void*,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkQueueFamilyProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties*)
+{
+}
+PFN_vkVoidFunction VkEventHandler::on_vkGetInstanceProcAddr(
+ void*,
+ PFN_vkVoidFunction,
+ VkInstance,
+ const char*)
+{
+ PFN_vkVoidFunction on_vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ return on_vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+PFN_vkVoidFunction VkEventHandler::on_vkGetDeviceProcAddr(
+ void*,
+ PFN_vkVoidFunction,
+ VkDevice,
+ const char*)
+{
+ PFN_vkVoidFunction on_vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ return on_vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+VkResult VkEventHandler::on_vkCreateDevice(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkDeviceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDevice*)
+{
+ VkResult on_vkCreateDevice_VkResult_return = (VkResult)0;
+ return on_vkCreateDevice_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDevice(
+ void*,
+ VkDevice,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkEnumerateInstanceExtensionProperties(
+ void*,
+ VkResult,
+ const char*,
+ uint32_t*,
+ VkExtensionProperties*)
+{
+ VkResult on_vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateDeviceExtensionProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const char*,
+ uint32_t*,
+ VkExtensionProperties*)
+{
+ VkResult on_vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateInstanceLayerProperties(
+ void*,
+ VkResult,
+ uint32_t*,
+ VkLayerProperties*)
+{
+ VkResult on_vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEnumerateDeviceLayerProperties(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkLayerProperties*)
+{
+ VkResult on_vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+ return on_vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceQueue(
+ void*,
+ VkDevice,
+ uint32_t,
+ uint32_t,
+ VkQueue*)
+{
+}
+VkResult VkEventHandler::on_vkQueueSubmit(
+ void*,
+ VkResult,
+ VkQueue,
+ uint32_t,
+ const VkSubmitInfo*,
+ VkFence)
+{
+ VkResult on_vkQueueSubmit_VkResult_return = (VkResult)0;
+ return on_vkQueueSubmit_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueueWaitIdle(
+ void*,
+ VkResult,
+ VkQueue)
+{
+ VkResult on_vkQueueWaitIdle_VkResult_return = (VkResult)0;
+ return on_vkQueueWaitIdle_VkResult_return;
+}
+VkResult VkEventHandler::on_vkDeviceWaitIdle(
+ void*,
+ VkResult,
+ VkDevice)
+{
+ VkResult on_vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+ return on_vkDeviceWaitIdle_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryAllocateInfo*,
+ const VkAllocationCallbacks*,
+ VkDeviceMemory*)
+{
+ VkResult on_vkAllocateMemory_VkResult_return = (VkResult)0;
+ return on_vkAllocateMemory_VkResult_return;
+}
+void VkEventHandler::on_vkFreeMemory(
+ void*,
+ VkDevice,
+ VkDeviceMemory,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkMapMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDeviceMemory,
+ VkDeviceSize,
+ VkDeviceSize,
+ VkMemoryMapFlags,
+ void**)
+{
+ VkResult on_vkMapMemory_VkResult_return = (VkResult)0;
+ return on_vkMapMemory_VkResult_return;
+}
+void VkEventHandler::on_vkUnmapMemory(
+ void*,
+ VkDevice,
+ VkDeviceMemory)
+{
+}
+VkResult VkEventHandler::on_vkFlushMappedMemoryRanges(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkMappedMemoryRange*)
+{
+ VkResult on_vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+ return on_vkFlushMappedMemoryRanges_VkResult_return;
+}
+VkResult VkEventHandler::on_vkInvalidateMappedMemoryRanges(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkMappedMemoryRange*)
+{
+ VkResult on_vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+ return on_vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceMemoryCommitment(
+ void*,
+ VkDevice,
+ VkDeviceMemory,
+ VkDeviceSize*)
+{
+}
+VkResult VkEventHandler::on_vkBindBufferMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ VkBuffer,
+ VkDeviceMemory,
+ VkDeviceSize)
+{
+ VkResult on_vkBindBufferMemory_VkResult_return = (VkResult)0;
+ return on_vkBindBufferMemory_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory(
+ void*,
+ VkResult,
+ VkDevice,
+ VkImage,
+ VkDeviceMemory,
+ VkDeviceSize)
+{
+ VkResult on_vkBindImageMemory_VkResult_return = (VkResult)0;
+ return on_vkBindImageMemory_VkResult_return;
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements(
+ void*,
+ VkDevice,
+ VkBuffer,
+ VkMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetImageMemoryRequirements(
+ void*,
+ VkDevice,
+ VkImage,
+ VkMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements(
+ void*,
+ VkDevice,
+ VkImage,
+ uint32_t*,
+ VkSparseImageMemoryRequirements*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkImageType,
+ VkSampleCountFlagBits,
+ VkImageUsageFlags,
+ VkImageTiling,
+ uint32_t*,
+ VkSparseImageFormatProperties*)
+{
+}
+VkResult VkEventHandler::on_vkQueueBindSparse(
+ void*,
+ VkResult,
+ VkQueue,
+ uint32_t,
+ const VkBindSparseInfo*,
+ VkFence)
+{
+ VkResult on_vkQueueBindSparse_VkResult_return = (VkResult)0;
+ return on_vkQueueBindSparse_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateFence(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFenceCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkFence*)
+{
+ VkResult on_vkCreateFence_VkResult_return = (VkResult)0;
+ return on_vkCreateFence_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyFence(
+ void*,
+ VkDevice,
+ VkFence,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetFences(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkFence*)
+{
+ VkResult on_vkResetFences_VkResult_return = (VkResult)0;
+ return on_vkResetFences_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceStatus(
+ void*,
+ VkResult,
+ VkDevice,
+ VkFence)
+{
+ VkResult on_vkGetFenceStatus_VkResult_return = (VkResult)0;
+ return on_vkGetFenceStatus_VkResult_return;
+}
+VkResult VkEventHandler::on_vkWaitForFences(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkFence*,
+ VkBool32,
+ uint64_t)
+{
+ VkResult on_vkWaitForFences_VkResult_return = (VkResult)0;
+ return on_vkWaitForFences_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateSemaphore(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSemaphoreCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSemaphore*)
+{
+ VkResult on_vkCreateSemaphore_VkResult_return = (VkResult)0;
+ return on_vkCreateSemaphore_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySemaphore(
+ void*,
+ VkDevice,
+ VkSemaphore,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateEvent(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkEventCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkEvent*)
+{
+ VkResult on_vkCreateEvent_VkResult_return = (VkResult)0;
+ return on_vkCreateEvent_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyEvent(
+ void*,
+ VkDevice,
+ VkEvent,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetEventStatus(
+ void*,
+ VkResult,
+ VkDevice,
+ VkEvent)
+{
+ VkResult on_vkGetEventStatus_VkResult_return = (VkResult)0;
+ return on_vkGetEventStatus_VkResult_return;
+}
+VkResult VkEventHandler::on_vkSetEvent(
+ void*,
+ VkResult,
+ VkDevice,
+ VkEvent)
+{
+ VkResult on_vkSetEvent_VkResult_return = (VkResult)0;
+ return on_vkSetEvent_VkResult_return;
+}
+VkResult VkEventHandler::on_vkResetEvent(
+ void*,
+ VkResult,
+ VkDevice,
+ VkEvent)
+{
+ VkResult on_vkResetEvent_VkResult_return = (VkResult)0;
+ return on_vkResetEvent_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateQueryPool(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkQueryPoolCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkQueryPool*)
+{
+ VkResult on_vkCreateQueryPool_VkResult_return = (VkResult)0;
+ return on_vkCreateQueryPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyQueryPool(
+ void*,
+ VkDevice,
+ VkQueryPool,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetQueryPoolResults(
+ void*,
+ VkResult,
+ VkDevice,
+ VkQueryPool,
+ uint32_t,
+ uint32_t,
+ size_t,
+ void*,
+ VkDeviceSize,
+ VkQueryResultFlags)
+{
+ VkResult on_vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+ return on_vkGetQueryPoolResults_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateBuffer(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkBufferCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkBuffer*)
+{
+ VkResult on_vkCreateBuffer_VkResult_return = (VkResult)0;
+ return on_vkCreateBuffer_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyBuffer(
+ void*,
+ VkDevice,
+ VkBuffer,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateBufferView(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkBufferViewCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkBufferView*)
+{
+ VkResult on_vkCreateBufferView_VkResult_return = (VkResult)0;
+ return on_vkCreateBufferView_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyBufferView(
+ void*,
+ VkDevice,
+ VkBufferView,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateImage(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImageCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkImage*)
+{
+ VkResult on_vkCreateImage_VkResult_return = (VkResult)0;
+ return on_vkCreateImage_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyImage(
+ void*,
+ VkDevice,
+ VkImage,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkGetImageSubresourceLayout(
+ void*,
+ VkDevice,
+ VkImage,
+ const VkImageSubresource*,
+ VkSubresourceLayout*)
+{
+}
+VkResult VkEventHandler::on_vkCreateImageView(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImageViewCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkImageView*)
+{
+ VkResult on_vkCreateImageView_VkResult_return = (VkResult)0;
+ return on_vkCreateImageView_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyImageView(
+ void*,
+ VkDevice,
+ VkImageView,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateShaderModule(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkShaderModuleCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkShaderModule*)
+{
+ VkResult on_vkCreateShaderModule_VkResult_return = (VkResult)0;
+ return on_vkCreateShaderModule_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyShaderModule(
+ void*,
+ VkDevice,
+ VkShaderModule,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreatePipelineCache(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkPipelineCacheCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipelineCache*)
+{
+ VkResult on_vkCreatePipelineCache_VkResult_return = (VkResult)0;
+ return on_vkCreatePipelineCache_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipelineCache(
+ void*,
+ VkDevice,
+ VkPipelineCache,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetPipelineCacheData(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ size_t*,
+ void*)
+{
+ VkResult on_vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+ return on_vkGetPipelineCacheData_VkResult_return;
+}
+VkResult VkEventHandler::on_vkMergePipelineCaches(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ uint32_t,
+ const VkPipelineCache*)
+{
+ VkResult on_vkMergePipelineCaches_VkResult_return = (VkResult)0;
+ return on_vkMergePipelineCaches_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateGraphicsPipelines(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ uint32_t,
+ const VkGraphicsPipelineCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipeline*)
+{
+ VkResult on_vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+ return on_vkCreateGraphicsPipelines_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateComputePipelines(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipelineCache,
+ uint32_t,
+ const VkComputePipelineCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipeline*)
+{
+ VkResult on_vkCreateComputePipelines_VkResult_return = (VkResult)0;
+ return on_vkCreateComputePipelines_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipeline(
+ void*,
+ VkDevice,
+ VkPipeline,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreatePipelineLayout(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkPipelineLayoutCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkPipelineLayout*)
+{
+ VkResult on_vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+ return on_vkCreatePipelineLayout_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyPipelineLayout(
+ void*,
+ VkDevice,
+ VkPipelineLayout,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateSampler(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSamplerCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSampler*)
+{
+ VkResult on_vkCreateSampler_VkResult_return = (VkResult)0;
+ return on_vkCreateSampler_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySampler(
+ void*,
+ VkDevice,
+ VkSampler,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorSetLayout(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorSetLayoutCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorSetLayout*)
+{
+ VkResult on_vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorSetLayout_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorSetLayout(
+ void*,
+ VkDevice,
+ VkDescriptorSetLayout,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorPool(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorPoolCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorPool*)
+{
+ VkResult on_vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorPool(
+ void*,
+ VkDevice,
+ VkDescriptorPool,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetDescriptorPool(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDescriptorPool,
+ VkDescriptorPoolResetFlags)
+{
+ VkResult on_vkResetDescriptorPool_VkResult_return = (VkResult)0;
+ return on_vkResetDescriptorPool_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateDescriptorSets(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorSetAllocateInfo*,
+ VkDescriptorSet*)
+{
+ VkResult on_vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+ return on_vkAllocateDescriptorSets_VkResult_return;
+}
+VkResult VkEventHandler::on_vkFreeDescriptorSets(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDescriptorPool,
+ uint32_t,
+ const VkDescriptorSet*)
+{
+ VkResult on_vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+ return on_vkFreeDescriptorSets_VkResult_return;
+}
+void VkEventHandler::on_vkUpdateDescriptorSets(
+ void*,
+ VkDevice,
+ uint32_t,
+ const VkWriteDescriptorSet*,
+ uint32_t,
+ const VkCopyDescriptorSet*)
+{
+}
+VkResult VkEventHandler::on_vkCreateFramebuffer(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFramebufferCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkFramebuffer*)
+{
+ VkResult on_vkCreateFramebuffer_VkResult_return = (VkResult)0;
+ return on_vkCreateFramebuffer_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyFramebuffer(
+ void*,
+ VkDevice,
+ VkFramebuffer,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateRenderPass(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkRenderPassCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkRenderPass*)
+{
+ VkResult on_vkCreateRenderPass_VkResult_return = (VkResult)0;
+ return on_vkCreateRenderPass_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyRenderPass(
+ void*,
+ VkDevice,
+ VkRenderPass,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkGetRenderAreaGranularity(
+ void*,
+ VkDevice,
+ VkRenderPass,
+ VkExtent2D*)
+{
+}
+VkResult VkEventHandler::on_vkCreateCommandPool(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkCommandPoolCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkCommandPool*)
+{
+ VkResult on_vkCreateCommandPool_VkResult_return = (VkResult)0;
+ return on_vkCreateCommandPool_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyCommandPool(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkResetCommandPool(
+ void*,
+ VkResult,
+ VkDevice,
+ VkCommandPool,
+ VkCommandPoolResetFlags)
+{
+ VkResult on_vkResetCommandPool_VkResult_return = (VkResult)0;
+ return on_vkResetCommandPool_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAllocateCommandBuffers(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkCommandBufferAllocateInfo*,
+ VkCommandBuffer*)
+{
+ VkResult on_vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+ return on_vkAllocateCommandBuffers_VkResult_return;
+}
+void VkEventHandler::on_vkFreeCommandBuffers(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ uint32_t,
+ const VkCommandBuffer*)
+{
+}
+VkResult VkEventHandler::on_vkBeginCommandBuffer(
+ void*,
+ VkResult,
+ VkCommandBuffer,
+ const VkCommandBufferBeginInfo*)
+{
+ VkResult on_vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+ return on_vkBeginCommandBuffer_VkResult_return;
+}
+VkResult VkEventHandler::on_vkEndCommandBuffer(
+ void*,
+ VkResult,
+ VkCommandBuffer)
+{
+ VkResult on_vkEndCommandBuffer_VkResult_return = (VkResult)0;
+ return on_vkEndCommandBuffer_VkResult_return;
+}
+VkResult VkEventHandler::on_vkResetCommandBuffer(
+ void*,
+ VkResult,
+ VkCommandBuffer,
+ VkCommandBufferResetFlags)
+{
+ VkResult on_vkResetCommandBuffer_VkResult_return = (VkResult)0;
+ return on_vkResetCommandBuffer_VkResult_return;
+}
+void VkEventHandler::on_vkCmdBindPipeline(
+ void*,
+ VkCommandBuffer,
+ VkPipelineBindPoint,
+ VkPipeline)
+{
+}
+void VkEventHandler::on_vkCmdSetViewport(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkViewport*)
+{
+}
+void VkEventHandler::on_vkCmdSetScissor(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkRect2D*)
+{
+}
+void VkEventHandler::on_vkCmdSetLineWidth(
+ void*,
+ VkCommandBuffer,
+ float)
+{
+}
+void VkEventHandler::on_vkCmdSetDepthBias(
+ void*,
+ VkCommandBuffer,
+ float,
+ float,
+ float)
+{
+}
+void VkEventHandler::on_vkCmdSetBlendConstants(
+ void*,
+ VkCommandBuffer,
+ const float)
+{
+}
+void VkEventHandler::on_vkCmdSetDepthBounds(
+ void*,
+ VkCommandBuffer,
+ float,
+ float)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilCompareMask(
+ void*,
+ VkCommandBuffer,
+ VkStencilFaceFlags,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilWriteMask(
+ void*,
+ VkCommandBuffer,
+ VkStencilFaceFlags,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdSetStencilReference(
+ void*,
+ VkCommandBuffer,
+ VkStencilFaceFlags,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdBindDescriptorSets(
+ void*,
+ VkCommandBuffer,
+ VkPipelineBindPoint,
+ VkPipelineLayout,
+ uint32_t,
+ uint32_t,
+ const VkDescriptorSet*,
+ uint32_t,
+ const uint32_t*)
+{
+}
+void VkEventHandler::on_vkCmdBindIndexBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkIndexType)
+{
+}
+void VkEventHandler::on_vkCmdBindVertexBuffers(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkBuffer*,
+ const VkDeviceSize*)
+{
+}
+void VkEventHandler::on_vkCmdDraw(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexed(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ int32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndirect(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirect(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatch(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchIndirect(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize)
+{
+}
+void VkEventHandler::on_vkCmdCopyBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkBuffer,
+ uint32_t,
+ const VkBufferCopy*)
+{
+}
+void VkEventHandler::on_vkCmdCopyImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdBlitImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkImageBlit*,
+ VkFilter)
+{
+}
+void VkEventHandler::on_vkCmdCopyBufferToImage(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkBufferImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdCopyImageToBuffer(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkBuffer,
+ uint32_t,
+ const VkBufferImageCopy*)
+{
+}
+void VkEventHandler::on_vkCmdUpdateBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkDeviceSize,
+ const void*)
+{
+}
+void VkEventHandler::on_vkCmdFillBuffer(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkDeviceSize,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdClearColorImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ const VkClearColorValue*,
+ uint32_t,
+ const VkImageSubresourceRange*)
+{
+}
+void VkEventHandler::on_vkCmdClearDepthStencilImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ const VkClearDepthStencilValue*,
+ uint32_t,
+ const VkImageSubresourceRange*)
+{
+}
+void VkEventHandler::on_vkCmdClearAttachments(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ const VkClearAttachment*,
+ uint32_t,
+ const VkClearRect*)
+{
+}
+void VkEventHandler::on_vkCmdResolveImage(
+ void*,
+ VkCommandBuffer,
+ VkImage,
+ VkImageLayout,
+ VkImage,
+ VkImageLayout,
+ uint32_t,
+ const VkImageResolve*)
+{
+}
+void VkEventHandler::on_vkCmdSetEvent(
+ void*,
+ VkCommandBuffer,
+ VkEvent,
+ VkPipelineStageFlags)
+{
+}
+void VkEventHandler::on_vkCmdResetEvent(
+ void*,
+ VkCommandBuffer,
+ VkEvent,
+ VkPipelineStageFlags)
+{
+}
+void VkEventHandler::on_vkCmdWaitEvents(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ const VkEvent*,
+ VkPipelineStageFlags,
+ VkPipelineStageFlags,
+ uint32_t,
+ const VkMemoryBarrier*,
+ uint32_t,
+ const VkBufferMemoryBarrier*,
+ uint32_t,
+ const VkImageMemoryBarrier*)
+{
+}
+void VkEventHandler::on_vkCmdPipelineBarrier(
+ void*,
+ VkCommandBuffer,
+ VkPipelineStageFlags,
+ VkPipelineStageFlags,
+ VkDependencyFlags,
+ uint32_t,
+ const VkMemoryBarrier*,
+ uint32_t,
+ const VkBufferMemoryBarrier*,
+ uint32_t,
+ const VkImageMemoryBarrier*)
+{
+}
+void VkEventHandler::on_vkCmdBeginQuery(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t,
+ VkQueryControlFlags)
+{
+}
+void VkEventHandler::on_vkCmdEndQuery(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdResetQueryPool(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdWriteTimestamp(
+ void*,
+ VkCommandBuffer,
+ VkPipelineStageFlagBits,
+ VkQueryPool,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdCopyQueryPoolResults(
+ void*,
+ VkCommandBuffer,
+ VkQueryPool,
+ uint32_t,
+ uint32_t,
+ VkBuffer,
+ VkDeviceSize,
+ VkDeviceSize,
+ VkQueryResultFlags)
+{
+}
+void VkEventHandler::on_vkCmdPushConstants(
+ void*,
+ VkCommandBuffer,
+ VkPipelineLayout,
+ VkShaderStageFlags,
+ uint32_t,
+ uint32_t,
+ const void*)
+{
+}
+void VkEventHandler::on_vkCmdBeginRenderPass(
+ void*,
+ VkCommandBuffer,
+ const VkRenderPassBeginInfo*,
+ VkSubpassContents)
+{
+}
+void VkEventHandler::on_vkCmdNextSubpass(
+ void*,
+ VkCommandBuffer,
+ VkSubpassContents)
+{
+}
+void VkEventHandler::on_vkCmdEndRenderPass(
+ void*,
+ VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdExecuteCommands(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ const VkCommandBuffer*)
+{
+}
+#endif
+#ifdef VK_VERSION_1_1
+VkResult VkEventHandler::on_vkEnumerateInstanceVersion(
+ void*,
+ VkResult,
+ uint32_t*)
+{
+ VkResult on_vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+ return on_vkEnumerateInstanceVersion_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindBufferMemory2(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindBufferMemoryInfo*)
+{
+ VkResult on_vkBindBufferMemory2_VkResult_return = (VkResult)0;
+ return on_vkBindBufferMemory2_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory2(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindImageMemoryInfo*)
+{
+ VkResult on_vkBindImageMemory2_VkResult_return = (VkResult)0;
+ return on_vkBindImageMemory2_VkResult_return;
+}
+void VkEventHandler::on_vkGetDeviceGroupPeerMemoryFeatures(
+ void*,
+ VkDevice,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ VkPeerMemoryFeatureFlags*)
+{
+}
+void VkEventHandler::on_vkCmdSetDeviceMask(
+ void*,
+ VkCommandBuffer,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchBase(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+VkResult VkEventHandler::on_vkEnumeratePhysicalDeviceGroups(
+ void*,
+ VkResult,
+ VkInstance,
+ uint32_t*,
+ VkPhysicalDeviceGroupProperties*)
+{
+ VkResult on_vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+ return on_vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+void VkEventHandler::on_vkGetImageMemoryRequirements2(
+ void*,
+ VkDevice,
+ const VkImageMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements2(
+ void*,
+ VkDevice,
+ const VkBufferMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements2(
+ void*,
+ VkDevice,
+ const VkImageSparseMemoryRequirementsInfo2*,
+ uint32_t*,
+ VkSparseImageMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceFeatures2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkFormatProperties2*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties2(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2*,
+ VkImageFormatProperties2*)
+{
+ VkResult on_vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties2(
+ void*,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkQueueFamilyProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties2(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties2(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2*,
+ uint32_t*,
+ VkSparseImageFormatProperties2*)
+{
+}
+void VkEventHandler::on_vkTrimCommandPool(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ VkCommandPoolTrimFlags)
+{
+}
+void VkEventHandler::on_vkGetDeviceQueue2(
+ void*,
+ VkDevice,
+ const VkDeviceQueueInfo2*,
+ VkQueue*)
+{
+}
+VkResult VkEventHandler::on_vkCreateSamplerYcbcrConversion(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSamplerYcbcrConversionCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSamplerYcbcrConversion*)
+{
+ VkResult on_vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+ return on_vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySamplerYcbcrConversion(
+ void*,
+ VkDevice,
+ VkSamplerYcbcrConversion,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDescriptorUpdateTemplate(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorUpdateTemplateCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorUpdateTemplate*)
+{
+ VkResult on_vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorUpdateTemplate(
+ void*,
+ VkDevice,
+ VkDescriptorUpdateTemplate,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkUpdateDescriptorSetWithTemplate(
+ void*,
+ VkDevice,
+ VkDescriptorSet,
+ VkDescriptorUpdateTemplate,
+ const void*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalBufferProperties(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo*,
+ VkExternalBufferProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalFenceProperties(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo*,
+ VkExternalFenceProperties*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo*,
+ VkExternalSemaphoreProperties*)
+{
+}
+void VkEventHandler::on_vkGetDescriptorSetLayoutSupport(
+ void*,
+ VkDevice,
+ const VkDescriptorSetLayoutCreateInfo*,
+ VkDescriptorSetLayoutSupport*)
+{
+}
+#endif
+#ifdef VK_KHR_surface
+void VkEventHandler::on_vkDestroySurfaceKHR(
+ void*,
+ VkInstance,
+ VkSurfaceKHR,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceSupportKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t,
+ VkSurfaceKHR,
+ VkBool32*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ VkSurfaceCapabilitiesKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ uint32_t*,
+ VkSurfaceFormatKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ uint32_t*,
+ VkPresentModeKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_swapchain
+VkResult VkEventHandler::on_vkCreateSwapchainKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSwapchainCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSwapchainKHR*)
+{
+ VkResult on_vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateSwapchainKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySwapchainKHR(
+ void*,
+ VkDevice,
+ VkSwapchainKHR,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkGetSwapchainImagesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ uint32_t*,
+ VkImage*)
+{
+ VkResult on_vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainImagesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireNextImageKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ uint64_t,
+ VkSemaphore,
+ VkFence,
+ uint32_t*)
+{
+ VkResult on_vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+ return on_vkAcquireNextImageKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueuePresentKHR(
+ void*,
+ VkResult,
+ VkQueue,
+ const VkPresentInfoKHR*)
+{
+ VkResult on_vkQueuePresentKHR_VkResult_return = (VkResult)0;
+ return on_vkQueuePresentKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDeviceGroupPresentCapabilitiesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDeviceGroupPresentCapabilitiesKHR*)
+{
+ VkResult on_vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDeviceGroupSurfacePresentModesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSurfaceKHR,
+ VkDeviceGroupPresentModeFlagsKHR*)
+{
+ VkResult on_vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDevicePresentRectanglesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ uint32_t*,
+ VkRect2D*)
+{
+ VkResult on_vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireNextImage2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkAcquireNextImageInfoKHR*,
+ uint32_t*)
+{
+ VkResult on_vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+ return on_vkAcquireNextImage2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayPropertiesKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayPlanePropertiesKHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneSupportedDisplaysKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t,
+ uint32_t*,
+ VkDisplayKHR*)
+{
+ VkResult on_vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayModePropertiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR,
+ uint32_t*,
+ VkDisplayModePropertiesKHR*)
+{
+ VkResult on_vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateDisplayModeKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR,
+ const VkDisplayModeCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkDisplayModeKHR*)
+{
+ VkResult on_vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateDisplayModeKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneCapabilitiesKHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayModeKHR,
+ uint32_t,
+ VkDisplayPlaneCapabilitiesKHR*)
+{
+ VkResult on_vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkCreateDisplayPlaneSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkDisplaySurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display_swapchain
+VkResult VkEventHandler::on_vkCreateSharedSwapchainsKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkSwapchainCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSwapchainKHR*)
+{
+ VkResult on_vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_xlib_surface
+VkResult VkEventHandler::on_vkCreateXlibSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkXlibSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateXlibSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ Display*,
+ VisualID)
+{
+ VkBool32 on_vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_xcb_surface
+VkResult VkEventHandler::on_vkCreateXcbSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkXcbSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateXcbSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ xcb_connection_t*,
+ xcb_visualid_t)
+{
+ VkBool32 on_vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_wayland_surface
+VkResult VkEventHandler::on_vkCreateWaylandSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkWaylandSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ wl_display*)
+{
+ VkBool32 on_vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_mir_surface
+VkResult VkEventHandler::on_vkCreateMirSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkMirSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateMirSurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t,
+ MirConnection*)
+{
+ VkBool32 on_vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_android_surface
+VkResult VkEventHandler::on_vkCreateAndroidSurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkAndroidSurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_surface
+VkResult VkEventHandler::on_vkCreateWin32SurfaceKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkWin32SurfaceCreateInfoKHR*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateWin32SurfaceKHR_VkResult_return;
+}
+VkBool32 VkEventHandler::on_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ void*,
+ VkBool32,
+ VkPhysicalDevice,
+ uint32_t)
+{
+ VkBool32 on_vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ return on_vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+void VkEventHandler::on_vkGetPhysicalDeviceFeatures2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceFeatures2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceFormatProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkFormat,
+ VkFormatProperties2*)
+{
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2*,
+ VkImageFormatProperties2*)
+{
+ VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkQueueFamilyProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMemoryProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties2*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2*,
+ uint32_t*,
+ VkSparseImageFormatProperties2*)
+{
+}
+#endif
+#ifdef VK_KHR_device_group
+void VkEventHandler::on_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ void*,
+ VkDevice,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ VkPeerMemoryFeatureFlags*)
+{
+}
+void VkEventHandler::on_vkCmdSetDeviceMaskKHR(
+ void*,
+ VkCommandBuffer,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDispatchBaseKHR(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+void VkEventHandler::on_vkTrimCommandPoolKHR(
+ void*,
+ VkDevice,
+ VkCommandPool,
+ VkCommandPoolTrimFlags)
+{
+}
+#endif
+#ifdef VK_KHR_device_group_creation
+VkResult VkEventHandler::on_vkEnumeratePhysicalDeviceGroupsKHR(
+ void*,
+ VkResult,
+ VkInstance,
+ uint32_t*,
+ VkPhysicalDeviceGroupProperties*)
+{
+ VkResult on_vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+ return on_vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo*,
+ VkExternalBufferProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+VkResult VkEventHandler::on_vkGetMemoryWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryGetWin32HandleInfoKHR*,
+ HANDLE*)
+{
+ VkResult on_vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryWin32HandlePropertiesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkExternalMemoryHandleTypeFlagBits,
+ HANDLE,
+ VkMemoryWin32HandlePropertiesKHR*)
+{
+ VkResult on_vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_fd
+VkResult VkEventHandler::on_vkGetMemoryFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryGetFdInfoKHR*,
+ int*)
+{
+ VkResult on_vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryFdPropertiesKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkExternalMemoryHandleTypeFlagBits,
+ int,
+ VkMemoryFdPropertiesKHR*)
+{
+ VkResult on_vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo*,
+ VkExternalSemaphoreProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+VkResult VkEventHandler::on_vkImportSemaphoreWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportSemaphoreWin32HandleInfoKHR*)
+{
+ VkResult on_vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSemaphoreWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSemaphoreGetWin32HandleInfoKHR*,
+ HANDLE*)
+{
+ VkResult on_vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+VkResult VkEventHandler::on_vkImportSemaphoreFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportSemaphoreFdInfoKHR*)
+{
+ VkResult on_vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ return on_vkImportSemaphoreFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSemaphoreFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSemaphoreGetFdInfoKHR*,
+ int*)
+{
+ VkResult on_vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSemaphoreFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_push_descriptor
+void VkEventHandler::on_vkCmdPushDescriptorSetKHR(
+ void*,
+ VkCommandBuffer,
+ VkPipelineBindPoint,
+ VkPipelineLayout,
+ uint32_t,
+ uint32_t,
+ const VkWriteDescriptorSet*)
+{
+}
+void VkEventHandler::on_vkCmdPushDescriptorSetWithTemplateKHR(
+ void*,
+ VkCommandBuffer,
+ VkDescriptorUpdateTemplate,
+ VkPipelineLayout,
+ uint32_t,
+ const void*)
+{
+}
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+VkResult VkEventHandler::on_vkCreateDescriptorUpdateTemplateKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDescriptorUpdateTemplateCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkDescriptorUpdateTemplate*)
+{
+ VkResult on_vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDescriptorUpdateTemplateKHR(
+ void*,
+ VkDevice,
+ VkDescriptorUpdateTemplate,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkUpdateDescriptorSetWithTemplateKHR(
+ void*,
+ VkDevice,
+ VkDescriptorSet,
+ VkDescriptorUpdateTemplate,
+ const void*)
+{
+}
+#endif
+#ifdef VK_KHR_create_renderpass2
+VkResult VkEventHandler::on_vkCreateRenderPass2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkRenderPassCreateInfo2KHR*,
+ const VkAllocationCallbacks*,
+ VkRenderPass*)
+{
+ VkResult on_vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+ return on_vkCreateRenderPass2KHR_VkResult_return;
+}
+void VkEventHandler::on_vkCmdBeginRenderPass2KHR(
+ void*,
+ VkCommandBuffer,
+ const VkRenderPassBeginInfo*,
+ const VkSubpassBeginInfoKHR*)
+{
+}
+void VkEventHandler::on_vkCmdNextSubpass2KHR(
+ void*,
+ VkCommandBuffer,
+ const VkSubpassBeginInfoKHR*,
+ const VkSubpassEndInfoKHR*)
+{
+}
+void VkEventHandler::on_vkCmdEndRenderPass2KHR(
+ void*,
+ VkCommandBuffer,
+ const VkSubpassEndInfoKHR*)
+{
+}
+#endif
+#ifdef VK_KHR_shared_presentable_image
+VkResult VkEventHandler::on_vkGetSwapchainStatusKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR)
+{
+ VkResult on_vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainStatusKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+void VkEventHandler::on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ void*,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo*,
+ VkExternalFenceProperties*)
+{
+}
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+VkResult VkEventHandler::on_vkImportFenceWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportFenceWin32HandleInfoKHR*)
+{
+ VkResult on_vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkImportFenceWin32HandleKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceWin32HandleKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFenceGetWin32HandleInfoKHR*,
+ HANDLE*)
+{
+ VkResult on_vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ return on_vkGetFenceWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_fd
+VkResult VkEventHandler::on_vkImportFenceFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkImportFenceFdInfoKHR*)
+{
+ VkResult on_vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+ return on_vkImportFenceFdKHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetFenceFdKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkFenceGetFdInfoKHR*,
+ int*)
+{
+ VkResult on_vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+ return on_vkGetFenceFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR*,
+ VkSurfaceCapabilities2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR*,
+ uint32_t*,
+ VkSurfaceFormat2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayProperties2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ uint32_t*,
+ VkDisplayPlaneProperties2KHR*)
+{
+ VkResult on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayModeProperties2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR,
+ uint32_t*,
+ VkDisplayModeProperties2KHR*)
+{
+ VkResult on_vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetDisplayPlaneCapabilities2KHR(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ const VkDisplayPlaneInfo2KHR*,
+ VkDisplayPlaneCapabilities2KHR*)
+{
+ VkResult on_vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+ return on_vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+void VkEventHandler::on_vkGetImageMemoryRequirements2KHR(
+ void*,
+ VkDevice,
+ const VkImageMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetBufferMemoryRequirements2KHR(
+ void*,
+ VkDevice,
+ const VkBufferMemoryRequirementsInfo2*,
+ VkMemoryRequirements2*)
+{
+}
+void VkEventHandler::on_vkGetImageSparseMemoryRequirements2KHR(
+ void*,
+ VkDevice,
+ const VkImageSparseMemoryRequirementsInfo2*,
+ uint32_t*,
+ VkSparseImageMemoryRequirements2*)
+{
+}
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+VkResult VkEventHandler::on_vkCreateSamplerYcbcrConversionKHR(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkSamplerYcbcrConversionCreateInfo*,
+ const VkAllocationCallbacks*,
+ VkSamplerYcbcrConversion*)
+{
+ VkResult on_vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+ return on_vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+void VkEventHandler::on_vkDestroySamplerYcbcrConversionKHR(
+ void*,
+ VkDevice,
+ VkSamplerYcbcrConversion,
+ const VkAllocationCallbacks*)
+{
+}
+#endif
+#ifdef VK_KHR_bind_memory2
+VkResult VkEventHandler::on_vkBindBufferMemory2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindBufferMemoryInfo*)
+{
+ VkResult on_vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+ return on_vkBindBufferMemory2KHR_VkResult_return;
+}
+VkResult VkEventHandler::on_vkBindImageMemory2KHR(
+ void*,
+ VkResult,
+ VkDevice,
+ uint32_t,
+ const VkBindImageMemoryInfo*)
+{
+ VkResult on_vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+ return on_vkBindImageMemory2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance3
+void VkEventHandler::on_vkGetDescriptorSetLayoutSupportKHR(
+ void*,
+ VkDevice,
+ const VkDescriptorSetLayoutCreateInfo*,
+ VkDescriptorSetLayoutSupport*)
+{
+}
+#endif
+#ifdef VK_KHR_draw_indirect_count
+void VkEventHandler::on_vkCmdDrawIndirectCountKHR(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirectCountKHR(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+VkResult VkEventHandler::on_vkGetSwapchainGrallocUsageANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ VkFormat,
+ VkImageUsageFlags,
+ int*)
+{
+ VkResult on_vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkAcquireImageANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ VkImage,
+ int,
+ VkSemaphore,
+ VkFence)
+{
+ VkResult on_vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+ return on_vkAcquireImageANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkQueueSignalReleaseImageANDROID(
+ void*,
+ VkResult,
+ VkQueue,
+ uint32_t,
+ const VkSemaphore*,
+ VkImage,
+ int*)
+{
+ VkResult on_vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
+ return on_vkQueueSignalReleaseImageANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_debug_report
+VkResult VkEventHandler::on_vkCreateDebugReportCallbackEXT(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkDebugReportCallbackCreateInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkDebugReportCallbackEXT*)
+{
+ VkResult on_vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+ return on_vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDebugReportCallbackEXT(
+ void*,
+ VkInstance,
+ VkDebugReportCallbackEXT,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkDebugReportMessageEXT(
+ void*,
+ VkInstance,
+ VkDebugReportFlagsEXT,
+ VkDebugReportObjectTypeEXT,
+ uint64_t,
+ size_t,
+ int32_t,
+ const char*,
+ const char*)
+{
+}
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+VkResult VkEventHandler::on_vkDebugMarkerSetObjectTagEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugMarkerObjectTagInfoEXT*)
+{
+ VkResult on_vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+ return on_vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkDebugMarkerSetObjectNameEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugMarkerObjectNameInfoEXT*)
+{
+ VkResult on_vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+ return on_vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+void VkEventHandler::on_vkCmdDebugMarkerBeginEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugMarkerMarkerInfoEXT*)
+{
+}
+void VkEventHandler::on_vkCmdDebugMarkerEndEXT(
+ void*,
+ VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdDebugMarkerInsertEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugMarkerMarkerInfoEXT*)
+{
+}
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+void VkEventHandler::on_vkCmdDrawIndirectCountAMD(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+void VkEventHandler::on_vkCmdDrawIndexedIndirectCountAMD(
+ void*,
+ VkCommandBuffer,
+ VkBuffer,
+ VkDeviceSize,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+VkResult VkEventHandler::on_vkGetShaderInfoAMD(
+ void*,
+ VkResult,
+ VkDevice,
+ VkPipeline,
+ VkShaderStageFlagBits,
+ VkShaderInfoTypeAMD,
+ size_t*,
+ void*)
+{
+ VkResult on_vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+ return on_vkGetShaderInfoAMD_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+VkResult VkEventHandler::on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkFormat,
+ VkImageType,
+ VkImageTiling,
+ VkImageUsageFlags,
+ VkImageCreateFlags,
+ VkExternalMemoryHandleTypeFlagsNV,
+ VkExternalImageFormatPropertiesNV*)
+{
+ VkResult on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+VkResult VkEventHandler::on_vkGetMemoryWin32HandleNV(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDeviceMemory,
+ VkExternalMemoryHandleTypeFlagsNV,
+ HANDLE*)
+{
+ VkResult on_vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryWin32HandleNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+VkResult VkEventHandler::on_vkCreateViSurfaceNN(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkViSurfaceCreateInfoNN*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+ return on_vkCreateViSurfaceNN_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+void VkEventHandler::on_vkCmdBeginConditionalRenderingEXT(
+ void*,
+ VkCommandBuffer,
+ const VkConditionalRenderingBeginInfoEXT*)
+{
+}
+void VkEventHandler::on_vkCmdEndConditionalRenderingEXT(
+ void*,
+ VkCommandBuffer)
+{
+}
+#endif
+#ifdef VK_NVX_device_generated_commands
+void VkEventHandler::on_vkCmdProcessCommandsNVX(
+ void*,
+ VkCommandBuffer,
+ const VkCmdProcessCommandsInfoNVX*)
+{
+}
+void VkEventHandler::on_vkCmdReserveSpaceForCommandsNVX(
+ void*,
+ VkCommandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX*)
+{
+}
+VkResult VkEventHandler::on_vkCreateIndirectCommandsLayoutNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkIndirectCommandsLayoutCreateInfoNVX*,
+ const VkAllocationCallbacks*,
+ VkIndirectCommandsLayoutNVX*)
+{
+ VkResult on_vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+ return on_vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyIndirectCommandsLayoutNVX(
+ void*,
+ VkDevice,
+ VkIndirectCommandsLayoutNVX,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkCreateObjectTableNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkObjectTableCreateInfoNVX*,
+ const VkAllocationCallbacks*,
+ VkObjectTableNVX*)
+{
+ VkResult on_vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+ return on_vkCreateObjectTableNVX_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyObjectTableNVX(
+ void*,
+ VkDevice,
+ VkObjectTableNVX,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkRegisterObjectsNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ VkObjectTableNVX,
+ uint32_t,
+ const VkObjectTableEntryNVX* const*,
+ const uint32_t*)
+{
+ VkResult on_vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+ return on_vkRegisterObjectsNVX_VkResult_return;
+}
+VkResult VkEventHandler::on_vkUnregisterObjectsNVX(
+ void*,
+ VkResult,
+ VkDevice,
+ VkObjectTableNVX,
+ uint32_t,
+ const VkObjectEntryTypeNVX*,
+ const uint32_t*)
+{
+ VkResult on_vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+ return on_vkUnregisterObjectsNVX_VkResult_return;
+}
+void VkEventHandler::on_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ void*,
+ VkPhysicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX*,
+ VkDeviceGeneratedCommandsLimitsNVX*)
+{
+}
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+void VkEventHandler::on_vkCmdSetViewportWScalingNV(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkViewportWScalingNV*)
+{
+}
+#endif
+#ifdef VK_EXT_direct_mode_display
+VkResult VkEventHandler::on_vkReleaseDisplayEXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkDisplayKHR)
+{
+ VkResult on_vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+ return on_vkReleaseDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+VkResult VkEventHandler::on_vkAcquireXlibDisplayEXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ Display*,
+ VkDisplayKHR)
+{
+ VkResult on_vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+ return on_vkAcquireXlibDisplayEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetRandROutputDisplayEXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ Display*,
+ RROutput,
+ VkDisplayKHR*)
+{
+ VkResult on_vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+ return on_vkGetRandROutputDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_surface_counter
+VkResult VkEventHandler::on_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ void*,
+ VkResult,
+ VkPhysicalDevice,
+ VkSurfaceKHR,
+ VkSurfaceCapabilities2EXT*)
+{
+ VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+ return on_vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_control
+VkResult VkEventHandler::on_vkDisplayPowerControlEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDisplayKHR,
+ const VkDisplayPowerInfoEXT*)
+{
+ VkResult on_vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+ return on_vkDisplayPowerControlEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkRegisterDeviceEventEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDeviceEventInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkFence*)
+{
+ VkResult on_vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+ return on_vkRegisterDeviceEventEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkRegisterDisplayEventEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkDisplayKHR,
+ const VkDisplayEventInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkFence*)
+{
+ VkResult on_vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+ return on_vkRegisterDisplayEventEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetSwapchainCounterEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ VkSurfaceCounterFlagBitsEXT,
+ uint64_t*)
+{
+ VkResult on_vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+ return on_vkGetSwapchainCounterEXT_VkResult_return;
+}
+#endif
+#ifdef VK_GOOGLE_display_timing
+VkResult VkEventHandler::on_vkGetRefreshCycleDurationGOOGLE(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ VkRefreshCycleDurationGOOGLE*)
+{
+ VkResult on_vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+ return on_vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetPastPresentationTimingGOOGLE(
+ void*,
+ VkResult,
+ VkDevice,
+ VkSwapchainKHR,
+ uint32_t*,
+ VkPastPresentationTimingGOOGLE*)
+{
+ VkResult on_vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+ return on_vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+void VkEventHandler::on_vkCmdSetDiscardRectangleEXT(
+ void*,
+ VkCommandBuffer,
+ uint32_t,
+ uint32_t,
+ const VkRect2D*)
+{
+}
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+void VkEventHandler::on_vkSetHdrMetadataEXT(
+ void*,
+ VkDevice,
+ uint32_t,
+ const VkSwapchainKHR*,
+ const VkHdrMetadataEXT*)
+{
+}
+#endif
+#ifdef VK_MVK_ios_surface
+VkResult VkEventHandler::on_vkCreateIOSSurfaceMVK(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkIOSSurfaceCreateInfoMVK*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+ return on_vkCreateIOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_MVK_macos_surface
+VkResult VkEventHandler::on_vkCreateMacOSSurfaceMVK(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkMacOSSurfaceCreateInfoMVK*,
+ const VkAllocationCallbacks*,
+ VkSurfaceKHR*)
+{
+ VkResult on_vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+ return on_vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+VkResult VkEventHandler::on_vkSetDebugUtilsObjectNameEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugUtilsObjectNameInfoEXT*)
+{
+ VkResult on_vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+ return on_vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkSetDebugUtilsObjectTagEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkDebugUtilsObjectTagInfoEXT*)
+{
+ VkResult on_vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+ return on_vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+void VkEventHandler::on_vkQueueBeginDebugUtilsLabelEXT(
+ void*,
+ VkQueue,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkQueueEndDebugUtilsLabelEXT(
+ void*,
+ VkQueue)
+{
+}
+void VkEventHandler::on_vkQueueInsertDebugUtilsLabelEXT(
+ void*,
+ VkQueue,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkCmdBeginDebugUtilsLabelEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+void VkEventHandler::on_vkCmdEndDebugUtilsLabelEXT(
+ void*,
+ VkCommandBuffer)
+{
+}
+void VkEventHandler::on_vkCmdInsertDebugUtilsLabelEXT(
+ void*,
+ VkCommandBuffer,
+ const VkDebugUtilsLabelEXT*)
+{
+}
+VkResult VkEventHandler::on_vkCreateDebugUtilsMessengerEXT(
+ void*,
+ VkResult,
+ VkInstance,
+ const VkDebugUtilsMessengerCreateInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkDebugUtilsMessengerEXT*)
+{
+ VkResult on_vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+ return on_vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyDebugUtilsMessengerEXT(
+ void*,
+ VkInstance,
+ VkDebugUtilsMessengerEXT,
+ const VkAllocationCallbacks*)
+{
+}
+void VkEventHandler::on_vkSubmitDebugUtilsMessageEXT(
+ void*,
+ VkInstance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT,
+ VkDebugUtilsMessageTypeFlagsEXT,
+ const VkDebugUtilsMessengerCallbackDataEXT*)
+{
+}
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+VkResult VkEventHandler::on_vkGetAndroidHardwareBufferPropertiesANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ const AHardwareBuffer*,
+ VkAndroidHardwareBufferPropertiesANDROID*)
+{
+ VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+ return on_vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetMemoryAndroidHardwareBufferANDROID(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID*,
+ AHardwareBuffer**)
+{
+ VkResult on_vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+void VkEventHandler::on_vkCmdSetSampleLocationsEXT(
+ void*,
+ VkCommandBuffer,
+ const VkSampleLocationsInfoEXT*)
+{
+}
+void VkEventHandler::on_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ void*,
+ VkPhysicalDevice,
+ VkSampleCountFlagBits,
+ VkMultisamplePropertiesEXT*)
+{
+}
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+VkResult VkEventHandler::on_vkCreateValidationCacheEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ const VkValidationCacheCreateInfoEXT*,
+ const VkAllocationCallbacks*,
+ VkValidationCacheEXT*)
+{
+ VkResult on_vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+ return on_vkCreateValidationCacheEXT_VkResult_return;
+}
+void VkEventHandler::on_vkDestroyValidationCacheEXT(
+ void*,
+ VkDevice,
+ VkValidationCacheEXT,
+ const VkAllocationCallbacks*)
+{
+}
+VkResult VkEventHandler::on_vkMergeValidationCachesEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkValidationCacheEXT,
+ uint32_t,
+ const VkValidationCacheEXT*)
+{
+ VkResult on_vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+ return on_vkMergeValidationCachesEXT_VkResult_return;
+}
+VkResult VkEventHandler::on_vkGetValidationCacheDataEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkValidationCacheEXT,
+ size_t*,
+ void*)
+{
+ VkResult on_vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+ return on_vkGetValidationCacheDataEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+VkResult VkEventHandler::on_vkGetMemoryHostPointerPropertiesEXT(
+ void*,
+ VkResult,
+ VkDevice,
+ VkExternalMemoryHandleTypeFlagBits,
+ const void*,
+ VkMemoryHostPointerPropertiesEXT*)
+{
+ VkResult on_vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+ return on_vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_buffer_marker
+void VkEventHandler::on_vkCmdWriteBufferMarkerAMD(
+ void*,
+ VkCommandBuffer,
+ VkPipelineStageFlagBits,
+ VkBuffer,
+ VkDeviceSize,
+ uint32_t)
+{
+}
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+void VkEventHandler::on_vkCmdSetCheckpointNV(
+ void*,
+ VkCommandBuffer,
+ const void*)
+{
+}
+void VkEventHandler::on_vkGetQueueCheckpointDataNV(
+ void*,
+ VkQueue,
+ uint32_t*,
+ VkCheckpointDataNV*)
+{
+}
+#endif
+
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEventHandler.h b/system/vulkan_enc/VkEventHandler.h
new file mode 100644
index 0000000..fcc4192
--- /dev/null
+++ b/system/vulkan_enc/VkEventHandler.h
@@ -0,0 +1,2218 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 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.
+
+// Autogenerated module VkEventHandler
+// (header) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+#include "goldfish_vk_private_defs.h"
+
+
+namespace goldfish_vk {
+
+
+class VkEncoder;
+class VkEventHandler {
+public:
+ VkEventHandler();
+ virtual ~VkEventHandler();
+#ifdef VK_VERSION_1_0
+ virtual VkResult on_vkCreateInstance(
+ void* context,
+ VkResult input_result,
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+ virtual void on_vkDestroyInstance(
+ void* context,
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkEnumeratePhysicalDevices(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+ virtual void on_vkGetPhysicalDeviceFeatures(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+ virtual void on_vkGetPhysicalDeviceFormatProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+ virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+ virtual void on_vkGetPhysicalDeviceProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+ virtual void on_vkGetPhysicalDeviceQueueFamilyProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+ virtual void on_vkGetPhysicalDeviceMemoryProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ virtual PFN_vkVoidFunction on_vkGetInstanceProcAddr(
+ void* context,
+ PFN_vkVoidFunction input_result,
+ VkInstance instance,
+ const char* pName);
+ virtual PFN_vkVoidFunction on_vkGetDeviceProcAddr(
+ void* context,
+ PFN_vkVoidFunction input_result,
+ VkDevice device,
+ const char* pName);
+ virtual VkResult on_vkCreateDevice(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+ virtual void on_vkDestroyDevice(
+ void* context,
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkEnumerateInstanceExtensionProperties(
+ void* context,
+ VkResult input_result,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+ virtual VkResult on_vkEnumerateDeviceExtensionProperties(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+ virtual VkResult on_vkEnumerateInstanceLayerProperties(
+ void* context,
+ VkResult input_result,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+ virtual VkResult on_vkEnumerateDeviceLayerProperties(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+ virtual void on_vkGetDeviceQueue(
+ void* context,
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue);
+ virtual VkResult on_vkQueueSubmit(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence);
+ virtual VkResult on_vkQueueWaitIdle(
+ void* context,
+ VkResult input_result,
+ VkQueue queue);
+ virtual VkResult on_vkDeviceWaitIdle(
+ void* context,
+ VkResult input_result,
+ VkDevice device);
+ virtual VkResult on_vkAllocateMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+ virtual void on_vkFreeMemory(
+ void* context,
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkMapMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData);
+ virtual void on_vkUnmapMemory(
+ void* context,
+ VkDevice device,
+ VkDeviceMemory memory);
+ virtual VkResult on_vkFlushMappedMemoryRanges(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ virtual VkResult on_vkInvalidateMappedMemoryRanges(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+ virtual void on_vkGetDeviceMemoryCommitment(
+ void* context,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes);
+ virtual VkResult on_vkBindBufferMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+ virtual VkResult on_vkBindImageMemory(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+ virtual void on_vkGetBufferMemoryRequirements(
+ void* context,
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+ virtual void on_vkGetImageMemoryRequirements(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements);
+ virtual void on_vkGetImageSparseMemoryRequirements(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+ virtual VkResult on_vkQueueBindSparse(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+ virtual VkResult on_vkCreateFence(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ virtual void on_vkDestroyFence(
+ void* context,
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkResetFences(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences);
+ virtual VkResult on_vkGetFenceStatus(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkFence fence);
+ virtual VkResult on_vkWaitForFences(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout);
+ virtual VkResult on_vkCreateSemaphore(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+ virtual void on_vkDestroySemaphore(
+ void* context,
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateEvent(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent);
+ virtual void on_vkDestroyEvent(
+ void* context,
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetEventStatus(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkEvent event);
+ virtual VkResult on_vkSetEvent(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkEvent event);
+ virtual VkResult on_vkResetEvent(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkEvent event);
+ virtual VkResult on_vkCreateQueryPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+ virtual void on_vkDestroyQueryPool(
+ void* context,
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetQueryPoolResults(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+ virtual VkResult on_vkCreateBuffer(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+ virtual void on_vkDestroyBuffer(
+ void* context,
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateBufferView(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView);
+ virtual void on_vkDestroyBufferView(
+ void* context,
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateImage(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage);
+ virtual void on_vkDestroyImage(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkGetImageSubresourceLayout(
+ void* context,
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout);
+ virtual VkResult on_vkCreateImageView(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView);
+ virtual void on_vkDestroyImageView(
+ void* context,
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateShaderModule(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+ virtual void on_vkDestroyShaderModule(
+ void* context,
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreatePipelineCache(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+ virtual void on_vkDestroyPipelineCache(
+ void* context,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetPipelineCacheData(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData);
+ virtual VkResult on_vkMergePipelineCaches(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
+ virtual VkResult on_vkCreateGraphicsPipelines(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ virtual VkResult on_vkCreateComputePipelines(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ virtual void on_vkDestroyPipeline(
+ void* context,
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreatePipelineLayout(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+ virtual void on_vkDestroyPipelineLayout(
+ void* context,
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateSampler(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
+ virtual void on_vkDestroySampler(
+ void* context,
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateDescriptorSetLayout(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+ virtual void on_vkDestroyDescriptorSetLayout(
+ void* context,
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateDescriptorPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+ virtual void on_vkDestroyDescriptorPool(
+ void* context,
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkResetDescriptorPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags);
+ virtual VkResult on_vkAllocateDescriptorSets(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+ virtual VkResult on_vkFreeDescriptorSets(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets);
+ virtual void on_vkUpdateDescriptorSets(
+ void* context,
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
+ virtual VkResult on_vkCreateFramebuffer(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+ virtual void on_vkDestroyFramebuffer(
+ void* context,
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateRenderPass(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+ virtual void on_vkDestroyRenderPass(
+ void* context,
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkGetRenderAreaGranularity(
+ void* context,
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity);
+ virtual VkResult on_vkCreateCommandPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool);
+ virtual void on_vkDestroyCommandPool(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkResetCommandPool(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags);
+ virtual VkResult on_vkAllocateCommandBuffers(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+ virtual void on_vkFreeCommandBuffers(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+ virtual VkResult on_vkBeginCommandBuffer(
+ void* context,
+ VkResult input_result,
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo);
+ virtual VkResult on_vkEndCommandBuffer(
+ void* context,
+ VkResult input_result,
+ VkCommandBuffer commandBuffer);
+ virtual VkResult on_vkResetCommandBuffer(
+ void* context,
+ VkResult input_result,
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+ virtual void on_vkCmdBindPipeline(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline);
+ virtual void on_vkCmdSetViewport(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports);
+ virtual void on_vkCmdSetScissor(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors);
+ virtual void on_vkCmdSetLineWidth(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ float lineWidth);
+ virtual void on_vkCmdSetDepthBias(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor);
+ virtual void on_vkCmdSetBlendConstants(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const float blendConstants);
+ virtual void on_vkCmdSetDepthBounds(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds);
+ virtual void on_vkCmdSetStencilCompareMask(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask);
+ virtual void on_vkCmdSetStencilWriteMask(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask);
+ virtual void on_vkCmdSetStencilReference(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference);
+ virtual void on_vkCmdBindDescriptorSets(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets);
+ virtual void on_vkCmdBindIndexBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType);
+ virtual void on_vkCmdBindVertexBuffers(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets);
+ virtual void on_vkCmdDraw(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance);
+ virtual void on_vkCmdDrawIndexed(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance);
+ virtual void on_vkCmdDrawIndirect(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDrawIndexedIndirect(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDispatch(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+ virtual void on_vkCmdDispatchIndirect(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset);
+ virtual void on_vkCmdCopyBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions);
+ virtual void on_vkCmdCopyImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions);
+ virtual void on_vkCmdBlitImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter);
+ virtual void on_vkCmdCopyBufferToImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+ virtual void on_vkCmdCopyImageToBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+ virtual void on_vkCmdUpdateBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData);
+ virtual void on_vkCmdFillBuffer(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data);
+ virtual void on_vkCmdClearColorImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+ virtual void on_vkCmdClearDepthStencilImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+ virtual void on_vkCmdClearAttachments(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects);
+ virtual void on_vkCmdResolveImage(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions);
+ virtual void on_vkCmdSetEvent(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+ virtual void on_vkCmdResetEvent(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+ virtual void on_vkCmdWaitEvents(
+ void* context,
+ 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);
+ virtual void on_vkCmdPipelineBarrier(
+ void* context,
+ 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);
+ virtual void on_vkCmdBeginQuery(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags);
+ virtual void on_vkCmdEndQuery(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query);
+ virtual void on_vkCmdResetQueryPool(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount);
+ virtual void on_vkCmdWriteTimestamp(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query);
+ virtual void on_vkCmdCopyQueryPoolResults(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+ virtual void on_vkCmdPushConstants(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues);
+ virtual void on_vkCmdBeginRenderPass(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents);
+ virtual void on_vkCmdNextSubpass(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents);
+ virtual void on_vkCmdEndRenderPass(
+ void* context,
+ VkCommandBuffer commandBuffer);
+ virtual void on_vkCmdExecuteCommands(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+#endif
+#ifdef VK_VERSION_1_1
+ virtual VkResult on_vkEnumerateInstanceVersion(
+ void* context,
+ VkResult input_result,
+ uint32_t* pApiVersion);
+ virtual VkResult on_vkBindBufferMemory2(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos);
+ virtual VkResult on_vkBindImageMemory2(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos);
+ virtual void on_vkGetDeviceGroupPeerMemoryFeatures(
+ void* context,
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+ virtual void on_vkCmdSetDeviceMask(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+ virtual void on_vkCmdDispatchBase(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+ virtual VkResult on_vkEnumeratePhysicalDeviceGroups(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+ virtual void on_vkGetImageMemoryRequirements2(
+ void* context,
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetBufferMemoryRequirements2(
+ void* context,
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetImageSparseMemoryRequirements2(
+ void* context,
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+ virtual void on_vkGetPhysicalDeviceFeatures2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures);
+ virtual void on_vkGetPhysicalDeviceProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+ virtual void on_vkGetPhysicalDeviceFormatProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties);
+ virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties2(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties);
+ virtual void on_vkGetPhysicalDeviceQueueFamilyProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties);
+ virtual void on_vkGetPhysicalDeviceMemoryProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties2(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties);
+ virtual void on_vkTrimCommandPool(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags);
+ virtual void on_vkGetDeviceQueue2(
+ void* context,
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue);
+ virtual VkResult on_vkCreateSamplerYcbcrConversion(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion);
+ virtual void on_vkDestroySamplerYcbcrConversion(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateDescriptorUpdateTemplate(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+ virtual void on_vkDestroyDescriptorUpdateTemplate(
+ void* context,
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkUpdateDescriptorSetWithTemplate(
+ void* context,
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData);
+ virtual void on_vkGetPhysicalDeviceExternalBufferProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties);
+ virtual void on_vkGetPhysicalDeviceExternalFenceProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties);
+ virtual void on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+ virtual void on_vkGetDescriptorSetLayoutSupport(
+ void* context,
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_surface
+ virtual void on_vkDestroySurfaceKHR(
+ void* context,
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceSupportKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+ virtual VkResult on_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes);
+#endif
+#ifdef VK_KHR_swapchain
+ virtual VkResult on_vkCreateSwapchainKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain);
+ virtual void on_vkDestroySwapchainKHR(
+ void* context,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkGetSwapchainImagesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+ virtual VkResult on_vkAcquireNextImageKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex);
+ virtual VkResult on_vkQueuePresentKHR(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo);
+ virtual VkResult on_vkGetDeviceGroupPresentCapabilitiesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+ virtual VkResult on_vkGetDeviceGroupSurfacePresentModesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes);
+ virtual VkResult on_vkGetPhysicalDevicePresentRectanglesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects);
+ virtual VkResult on_vkAcquireNextImage2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex);
+#endif
+#ifdef VK_KHR_display
+ virtual VkResult on_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+ virtual VkResult on_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties);
+ virtual VkResult on_vkGetDisplayPlaneSupportedDisplaysKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays);
+ virtual VkResult on_vkGetDisplayModePropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties);
+ virtual VkResult on_vkCreateDisplayModeKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode);
+ virtual VkResult on_vkGetDisplayPlaneCapabilitiesKHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+ virtual VkResult on_vkCreateDisplayPlaneSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_display_swapchain
+ virtual VkResult on_vkCreateSharedSwapchainsKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains);
+#endif
+#ifdef VK_KHR_xlib_surface
+ virtual VkResult on_vkCreateXlibSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID);
+#endif
+#ifdef VK_KHR_xcb_surface
+ virtual VkResult on_vkCreateXcbSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id);
+#endif
+#ifdef VK_KHR_wayland_surface
+ virtual VkResult on_vkCreateWaylandSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display);
+#endif
+#ifdef VK_KHR_mir_surface
+ virtual VkResult on_vkCreateMirSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection);
+#endif
+#ifdef VK_KHR_android_surface
+ virtual VkResult on_vkCreateAndroidSurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_KHR_win32_surface
+ virtual VkResult on_vkCreateWin32SurfaceKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ virtual VkBool32 on_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ void* context,
+ VkBool32 input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex);
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+ virtual void on_vkGetPhysicalDeviceFeatures2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures);
+ virtual void on_vkGetPhysicalDeviceProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties);
+ virtual void on_vkGetPhysicalDeviceFormatProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties);
+ virtual VkResult on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties);
+ virtual void on_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties);
+ virtual void on_vkGetPhysicalDeviceMemoryProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+ virtual void on_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties);
+#endif
+#ifdef VK_KHR_device_group
+ virtual void on_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ void* context,
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+ virtual void on_vkCmdSetDeviceMaskKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask);
+ virtual void on_vkCmdDispatchBaseKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ);
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+ virtual void on_vkTrimCommandPoolKHR(
+ void* context,
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags);
+#endif
+#ifdef VK_KHR_device_group_creation
+ virtual VkResult on_vkEnumeratePhysicalDeviceGroupsKHR(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+ virtual void on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties);
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+ virtual VkResult on_vkGetMemoryWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+ virtual VkResult on_vkGetMemoryWin32HandlePropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif
+#ifdef VK_KHR_external_memory_fd
+ virtual VkResult on_vkGetMemoryFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+ virtual VkResult on_vkGetMemoryFdPropertiesKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+ virtual void on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ virtual VkResult on_vkImportSemaphoreWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+ virtual VkResult on_vkGetSemaphoreWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+ virtual VkResult on_vkImportSemaphoreFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+ virtual VkResult on_vkGetSemaphoreFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+#endif
+#ifdef VK_KHR_push_descriptor
+ virtual void on_vkCmdPushDescriptorSetKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites);
+ virtual void on_vkCmdPushDescriptorSetWithTemplateKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData);
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+ virtual VkResult on_vkCreateDescriptorUpdateTemplateKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+ virtual void on_vkDestroyDescriptorUpdateTemplateKHR(
+ void* context,
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkUpdateDescriptorSetWithTemplateKHR(
+ void* context,
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData);
+#endif
+#ifdef VK_KHR_create_renderpass2
+ virtual VkResult on_vkCreateRenderPass2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+ virtual void on_vkCmdBeginRenderPass2KHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+ virtual void on_vkCmdNextSubpass2KHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+ virtual void on_vkCmdEndRenderPass2KHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ virtual VkResult on_vkGetSwapchainStatusKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain);
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+ virtual void on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties);
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+ virtual VkResult on_vkImportFenceWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+ virtual VkResult on_vkGetFenceWin32HandleKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_KHR_external_fence_fd
+ virtual VkResult on_vkImportFenceFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+ virtual VkResult on_vkGetFenceFdKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd);
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats);
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+ virtual VkResult on_vkGetPhysicalDeviceDisplayProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties);
+ virtual VkResult on_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties);
+ virtual VkResult on_vkGetDisplayModeProperties2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties);
+ virtual VkResult on_vkGetDisplayPlaneCapabilities2KHR(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities);
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+ virtual void on_vkGetImageMemoryRequirements2KHR(
+ void* context,
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetBufferMemoryRequirements2KHR(
+ void* context,
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements);
+ virtual void on_vkGetImageSparseMemoryRequirements2KHR(
+ void* context,
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+ virtual VkResult on_vkCreateSamplerYcbcrConversionKHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion);
+ virtual void on_vkDestroySamplerYcbcrConversionKHR(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+#endif
+#ifdef VK_KHR_bind_memory2
+ virtual VkResult on_vkBindBufferMemory2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos);
+ virtual VkResult on_vkBindImageMemory2KHR(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos);
+#endif
+#ifdef VK_KHR_maintenance3
+ virtual void on_vkGetDescriptorSetLayoutSupportKHR(
+ void* context,
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport);
+#endif
+#ifdef VK_KHR_draw_indirect_count
+ virtual void on_vkCmdDrawIndirectCountKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDrawIndexedIndirectCountKHR(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_ANDROID_native_buffer
+ virtual VkResult on_vkGetSwapchainGrallocUsageANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage);
+ virtual VkResult on_vkAcquireImageANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkImage image,
+ int nativeFenceFd,
+ VkSemaphore semaphore,
+ VkFence fence);
+ virtual VkResult on_vkQueueSignalReleaseImageANDROID(
+ void* context,
+ VkResult input_result,
+ VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image,
+ int* pNativeFenceFd);
+#endif
+#ifdef VK_EXT_debug_report
+ virtual VkResult on_vkCreateDebugReportCallbackEXT(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback);
+ virtual void on_vkDestroyDebugReportCallbackEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkDebugReportMessageEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage);
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+ virtual VkResult on_vkDebugMarkerSetObjectTagEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+ virtual VkResult on_vkDebugMarkerSetObjectNameEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+ virtual void on_vkCmdDebugMarkerBeginEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+ virtual void on_vkCmdDebugMarkerEndEXT(
+ void* context,
+ VkCommandBuffer commandBuffer);
+ virtual void on_vkCmdDebugMarkerInsertEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+ virtual void on_vkCmdDrawIndirectCountAMD(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+ virtual void on_vkCmdDrawIndexedIndirectCountAMD(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride);
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+ virtual VkResult on_vkGetShaderInfoAMD(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize,
+ void* pInfo);
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+ virtual VkResult on_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+ virtual VkResult on_vkGetMemoryWin32HandleNV(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle);
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+ virtual VkResult on_vkCreateViSurfaceNN(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+ virtual void on_vkCmdBeginConditionalRenderingEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+ virtual void on_vkCmdEndConditionalRenderingEXT(
+ void* context,
+ VkCommandBuffer commandBuffer);
+#endif
+#ifdef VK_NVX_device_generated_commands
+ virtual void on_vkCmdProcessCommandsNVX(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+ virtual void on_vkCmdReserveSpaceForCommandsNVX(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+ virtual VkResult on_vkCreateIndirectCommandsLayoutNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+ virtual void on_vkDestroyIndirectCommandsLayoutNVX(
+ void* context,
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkCreateObjectTableNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable);
+ virtual void on_vkDestroyObjectTableNVX(
+ void* context,
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkRegisterObjectsNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices);
+ virtual VkResult on_vkUnregisterObjectsNVX(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices);
+ virtual void on_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ virtual void on_vkCmdSetViewportWScalingNV(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings);
+#endif
+#ifdef VK_EXT_direct_mode_display
+ virtual VkResult on_vkReleaseDisplayEXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display);
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+ virtual VkResult on_vkAcquireXlibDisplayEXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display);
+ virtual VkResult on_vkGetRandROutputDisplayEXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay);
+#endif
+#ifdef VK_EXT_display_surface_counter
+ virtual VkResult on_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ void* context,
+ VkResult input_result,
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+#endif
+#ifdef VK_EXT_display_control
+ virtual VkResult on_vkDisplayPowerControlEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+ virtual VkResult on_vkRegisterDeviceEventEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ virtual VkResult on_vkRegisterDisplayEventEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+ virtual VkResult on_vkGetSwapchainCounterEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue);
+#endif
+#ifdef VK_GOOGLE_display_timing
+ virtual VkResult on_vkGetRefreshCycleDurationGOOGLE(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+ virtual VkResult on_vkGetPastPresentationTimingGOOGLE(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings);
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+ virtual void on_vkCmdSetDiscardRectangleEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles);
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+ virtual void on_vkSetHdrMetadataEXT(
+ void* context,
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata);
+#endif
+#ifdef VK_MVK_ios_surface
+ virtual VkResult on_vkCreateIOSSurfaceMVK(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_MVK_macos_surface
+ virtual VkResult on_vkCreateMacOSSurfaceMVK(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+ virtual VkResult on_vkSetDebugUtilsObjectNameEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+ virtual VkResult on_vkSetDebugUtilsObjectTagEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+ virtual void on_vkQueueBeginDebugUtilsLabelEXT(
+ void* context,
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual void on_vkQueueEndDebugUtilsLabelEXT(
+ void* context,
+ VkQueue queue);
+ virtual void on_vkQueueInsertDebugUtilsLabelEXT(
+ void* context,
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual void on_vkCmdBeginDebugUtilsLabelEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual void on_vkCmdEndDebugUtilsLabelEXT(
+ void* context,
+ VkCommandBuffer commandBuffer);
+ virtual void on_vkCmdInsertDebugUtilsLabelEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ virtual VkResult on_vkCreateDebugUtilsMessengerEXT(
+ void* context,
+ VkResult input_result,
+ VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger);
+ virtual void on_vkDestroyDebugUtilsMessengerEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator);
+ virtual void on_vkSubmitDebugUtilsMessageEXT(
+ void* context,
+ VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ virtual VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+ virtual VkResult on_vkGetMemoryAndroidHardwareBufferANDROID(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer);
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+ virtual void on_vkCmdSetSampleLocationsEXT(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+ virtual void on_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ void* context,
+ VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties);
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+ virtual VkResult on_vkCreateValidationCacheEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache);
+ virtual void on_vkDestroyValidationCacheEXT(
+ void* context,
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator);
+ virtual VkResult on_vkMergeValidationCachesEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches);
+ virtual VkResult on_vkGetValidationCacheDataEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize,
+ void* pData);
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+ virtual VkResult on_vkGetMemoryHostPointerPropertiesEXT(
+ void* context,
+ VkResult input_result,
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+#endif
+#ifdef VK_AMD_buffer_marker
+ virtual void on_vkCmdWriteBufferMarkerAMD(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker);
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ virtual void on_vkCmdSetCheckpointNV(
+ void* context,
+ VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker);
+ virtual void on_vkGetQueueCheckpointDataNV(
+ void* context,
+ VkQueue queue,
+ uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData);
+#endif
+
+};
+
+} // namespace goldfish_vk
