diff --git a/3rdparty/include/vulkan/vk_platform.h b/3rdparty/include/vulkan/vk_platform.h new file mode 100644 index 0000000000..7289299240 --- /dev/null +++ b/3rdparty/include/vulkan/vk_platform.h @@ -0,0 +1,92 @@ +// +// File: vk_platform.h +// +/* +** Copyright (c) 2014-2017 The Khronos Group 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. +*/ + + +#ifndef VK_PLATFORM_H_ +#define VK_PLATFORM_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* Platform-specific directives and type declarations +*************************************************************************************************** +*/ + +/* Platform-specific calling convention macros. + * + * Platforms should define these so that Vulkan clients call Vulkan commands + * with the same calling conventions that the Vulkan implementation expects. + * + * VKAPI_ATTR - Placed before the return type in function declarations. + * Useful for C++11 and GCC/Clang-style function attribute syntax. + * VKAPI_CALL - Placed after the return type in function declarations. + * Useful for MSVC-style calling convention syntax. + * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. + * + * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); + * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); + */ +#if defined(_WIN32) + // On Windows, Vulkan commands use the stdcall convention + #define VKAPI_ATTR + #define VKAPI_CALL __stdcall + #define VKAPI_PTR VKAPI_CALL +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 + #error "Vulkan isn't supported for the 'armeabi' NDK ABI" +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) + // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" + // calling convention, i.e. float parameters are passed in registers. This + // is true even if the rest of the application passes floats on the stack, + // as it does by default when compiling for the armeabi-v7a NDK ABI. + #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) + #define VKAPI_CALL + #define VKAPI_PTR VKAPI_ATTR +#else + // On other platforms, use the default calling convention + #define VKAPI_ATTR + #define VKAPI_CALL + #define VKAPI_PTR +#endif + +#include + +#if !defined(VK_NO_STDINT_H) + #if defined(_MSC_VER) && (_MSC_VER < 1600) + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + #include + #endif +#endif // !defined(VK_NO_STDINT_H) + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif diff --git a/3rdparty/include/vulkan/vulkan.h b/3rdparty/include/vulkan/vulkan.h new file mode 100644 index 0000000000..cf9d85ae59 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan.h @@ -0,0 +1,83 @@ +#ifndef VULKAN_H_ +#define VULKAN_H_ 1 + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +#include "vk_platform.h" +#include "vulkan_core.h" + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#include "vulkan_android.h" +#endif + +#ifdef VK_USE_PLATFORM_FUCHSIA +#include +#include "vulkan_fuchsia.h" +#endif + +#ifdef VK_USE_PLATFORM_IOS_MVK +#include "vulkan_ios.h" +#endif + + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#include "vulkan_macos.h" +#endif + + +#ifdef VK_USE_PLATFORM_MIR_KHR +#include +#include "vulkan_mir.h" +#endif + + +#ifdef VK_USE_PLATFORM_VI_NN +#include "vulkan_vi.h" +#endif + + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#include +#include "vulkan_wayland.h" +#endif + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#include +#include "vulkan_win32.h" +#endif + + +#ifdef VK_USE_PLATFORM_XCB_KHR +#include +#include "vulkan_xcb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#include +#include "vulkan_xlib.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +#include +#include +#include "vulkan_xlib_xrandr.h" +#endif + +#endif // VULKAN_H_ diff --git a/3rdparty/include/vulkan/vulkan_android.h b/3rdparty/include/vulkan/vulkan_android.h new file mode 100644 index 0000000000..07aaeda28e --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_android.h @@ -0,0 +1,126 @@ +#ifndef VULKAN_ANDROID_H_ +#define VULKAN_ANDROID_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_android_surface 1 +struct ANativeWindow; + +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" + +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + +typedef struct VkAndroidSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; +} VkAndroidSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#define VK_ANDROID_external_memory_android_hardware_buffer 1 +struct AHardwareBuffer; + +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" + +typedef struct VkAndroidHardwareBufferUsageANDROID { + VkStructureType sType; + void* pNext; + uint64_t androidHardwareBufferUsage; +} VkAndroidHardwareBufferUsageANDROID; + +typedef struct VkAndroidHardwareBufferPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkAndroidHardwareBufferPropertiesANDROID; + +typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkAndroidHardwareBufferFormatPropertiesANDROID; + +typedef struct VkImportAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + struct AHardwareBuffer* buffer; +} VkImportAndroidHardwareBufferInfoANDROID; + +typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkMemoryGetAndroidHardwareBufferInfoANDROID; + +typedef struct VkExternalFormatANDROID { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatANDROID; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_core.h b/3rdparty/include/vulkan/vulkan_core.h new file mode 100644 index 0000000000..163fb1765c --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_core.h @@ -0,0 +1,8524 @@ +#ifndef VULKAN_CORE_H_ +#define VULKAN_CORE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + +// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 + +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 + +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) +// Version of this file +#define VK_HEADER_VERSION 87 + + +#define VK_NULL_HANDLE 0 + + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif +#endif + + + +typedef uint32_t VkFlags; +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkSampleMask; + +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + +#define VK_LOD_CLAMP_NONE 1000.0f +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_WHOLE_SIZE (~0ULL) +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 +#define VK_UUID_SIZE 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME_SIZE 256 +#define VK_MAX_DESCRIPTION_SIZE 256 + + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_FRAGMENTATION_EXT = -1000161000, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, + VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, + VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX = 1000165002, + VK_STRUCTURE_TYPE_GEOMETRY_NVX = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX = 1000165006, + VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX = 1000165009, + VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX = 1000165010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000, + VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, + VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, + VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, + VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, + VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, + VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_COMPACTED_SIZE_NVX = 1000165000, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, + VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, + VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, + VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, + VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, + VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, + VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, + VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, + VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, + VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, + VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, + VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, + VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, + VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, + VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, + VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, + VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, + VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, + VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, + VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_IMG = 1000015000, + VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, + VK_FILTER_END_RANGE = VK_FILTER_LINEAR, + VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, + VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, + VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, + VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, + VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, + VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX = 1000165000, + VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_RAYTRACING_NVX = 1000165000, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, + VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, + VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, + VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, + VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, + VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX = 1000165000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, + VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, + VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkVendorId { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV, + VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN, + VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1), + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum VkSampleCountFlagBits { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_PROTECTED_BIT = 0x00000010, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; +typedef VkFlags VkDeviceCreateFlags; + +typedef enum VkDeviceQueueCreateFlagBits { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDeviceQueueCreateFlagBits; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000, + VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX = 0x00200000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, + VK_BUFFER_USAGE_RAYTRACING_BIT_NVX = 0x00000400, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, + VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX = 0x00000020, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + VK_SHADER_STAGE_RAYGEN_BIT_NVX = 0x00000100, + VK_SHADER_STAGE_ANY_HIT_BIT_NVX = 0x00000200, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX = 0x00000400, + VK_SHADER_STAGE_MISS_BIT_NVX = 0x00000800, + VK_SHADER_STAGE_INTERSECTION_BIT_NVX = 0x00001000, + VK_SHADER_STAGE_CALLABLE_BIT_NVX = 0x00002000, + VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkShaderStageFlagBits; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; +typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; +typedef VkFlags VkFramebufferCreateFlags; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, + VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX = 0x00200000, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX = 0x00400000, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBaseInStructure { + VkStructureType sType; + const struct VkBaseInStructure* pNext; +} VkBaseInStructure; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(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); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(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); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR void VKAPI_CALL vkFreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + 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); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + 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); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); +#endif + +#define VK_VERSION_1_1 1 +// Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 + + +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) + +#define VK_MAX_DEVICE_GROUP_SIZE 32 +#define VK_LUID_SIZE 8 +#define VK_QUEUE_FAMILY_EXTERNAL (~0U-1) + + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1), + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1), + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1), + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1), + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1), + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +typedef enum VkDescriptorUpdateTemplateType { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1), + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorUpdateTemplateType; + + +typedef enum VkSubgroupFeatureFlagBits { + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubgroupFeatureFlagBits; +typedef VkFlags VkSubgroupFeatureFlags; + +typedef enum VkPeerMemoryFeatureFlagBits { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBits; +typedef VkFlags VkPeerMemoryFeatureFlags; + +typedef enum VkMemoryAllocateFlagBits { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryAllocateFlagBits; +typedef VkFlags VkMemoryAllocateFlags; +typedef VkFlags VkCommandPoolTrimFlags; +typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + +typedef enum VkExternalMemoryHandleTypeFlagBits { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBits; +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +typedef enum VkExternalMemoryFeatureFlagBits { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBits; +typedef VkFlags VkExternalMemoryFeatureFlags; + +typedef enum VkExternalFenceHandleTypeFlagBits { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBits; +typedef VkFlags VkExternalFenceHandleTypeFlags; + +typedef enum VkExternalFenceFeatureFlagBits { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBits; +typedef VkFlags VkExternalFenceFeatureFlags; + +typedef enum VkFenceImportFlagBits { + VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceImportFlagBits; +typedef VkFlags VkFenceImportFlags; + +typedef enum VkSemaphoreImportFlagBits { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreImportFlagBits; +typedef VkFlags VkSemaphoreImportFlags; + +typedef enum VkExternalSemaphoreHandleTypeFlagBits { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBits; +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +typedef enum VkExternalSemaphoreFeatureFlagBits { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBits; +typedef VkFlags VkExternalSemaphoreFeatureFlags; + +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkDeviceGroupBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkImageSparseMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; + +typedef struct VkSparseImageMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkSparseImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2; + +typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo2; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceVariablePointerFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkDescriptorUpdateTemplateEntry { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntry; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + void* pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkPhysicalDeviceShaderDrawParameterFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParameterFeatures; + + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( + uint32_t* pApiVersion); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" + + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, + VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSurfaceTransformFlagBitsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; + +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHR { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHR; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; + +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + const void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); +#endif + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + +#define VK_KHR_DISPLAY_SPEC_VERSION 21 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" + + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplayModeCreateFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" + +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + +#define VK_KHR_sampler_mirror_clamp_to_edge 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" + + +#define VK_KHR_multiview 1 +#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" + +typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; + +typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; + +typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; + + + +#define VK_KHR_get_physical_device_properties2 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" + +typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; + +typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; + +typedef VkFormatProperties2 VkFormatProperties2KHR; + +typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; + +typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; + +typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; + +typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; + +typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; + +typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); +#endif + +#define VK_KHR_device_group 1 +#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3 +#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" + +typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; + +typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; + +typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; + +typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; + + +typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; + +typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; + +typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; + +typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; + +typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; + +typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; + +typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); +#endif + +#define VK_KHR_shader_draw_parameters 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" + + +#define VK_KHR_maintenance1 1 +#define VK_KHR_MAINTENANCE1_SPEC_VERSION 2 +#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" + +typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; + + +typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); +#endif + +#define VK_KHR_device_group_creation 1 +#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" +#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE + +typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; + +typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +#endif + +#define VK_KHR_external_memory_capabilities 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" +#define VK_LUID_SIZE_KHR VK_LUID_SIZE + +typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; + +typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; + +typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; + + +typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; + +typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; + +typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; + +typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; + +typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); +#endif + +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL + +typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; + +typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; + +typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; + + + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" + +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" + +typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; + +typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; + + +typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +#endif + +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" + +typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; + +typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; + + +typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; + + + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" + +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_push_descriptor 1 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" + +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); +#endif + +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" + +typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; + + + +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" + +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + +#define VK_KHR_descriptor_update_template 1 +typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; + + +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" + +typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; + + +typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + + +typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; + +typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); +#endif + +#define VK_KHR_create_renderpass2 1 +#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 +#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" + +typedef struct VkAttachmentDescription2KHR { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2KHR; + +typedef struct VkAttachmentReference2KHR { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2KHR; + +typedef struct VkSubpassDescription2KHR { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2KHR* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2KHR* pColorAttachments; + const VkAttachmentReference2KHR* pResolveAttachments; + const VkAttachmentReference2KHR* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2KHR; + +typedef struct VkSubpassDependency2KHR { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2KHR; + +typedef struct VkRenderPassCreateInfo2KHR { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2KHR* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2KHR* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2KHR* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2KHR; + +typedef struct VkSubpassBeginInfoKHR { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfoKHR; + +typedef struct VkSubpassEndInfoKHR { + VkStructureType sType; + const void* pNext; +} VkSubpassEndInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo, + const VkSubpassEndInfoKHR* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfoKHR* pSubpassEndInfo); +#endif + +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" + +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" + +typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; + +typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; + +typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; + + +typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; + +typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); +#endif + +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" + +typedef VkFenceImportFlags VkFenceImportFlagsKHR; + +typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; + + +typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; + + + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" + +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_maintenance2 1 +#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" + +typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; + +typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; + + +typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; + +typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; + +typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; + +typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; + +typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; + + + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" + +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" + +typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; + + + +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" + +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif + +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" + +typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; + +typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; + + + +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +#define VK_KHR_relaxed_block_layout 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" + + +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" + +typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; + +typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; + +typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; + +typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif + +#define VK_KHR_image_format_list 1 +#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 +#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" + +typedef struct VkImageFormatListCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfoKHR; + + + +#define VK_KHR_sampler_ycbcr_conversion 1 +typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; + + +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" + +typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; + +typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; + +typedef VkChromaLocation VkChromaLocationKHR; + + +typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; + +typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; + +typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; + +typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; + +typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + +typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +#endif + +#define VK_KHR_bind_memory2 1 +#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" + +typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; + +typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); +#endif + +#define VK_KHR_maintenance3 1 +#define VK_KHR_MAINTENANCE3_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3" + +typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; + +typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + +#define VK_KHR_draw_indirect_count 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_KHR_8bit_storage 1 +#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" + +typedef struct VkPhysicalDevice8BitStorageFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeaturesKHR; + + + +#define VK_KHR_shader_atomic_int64 1 +#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" + +typedef struct VkPhysicalDeviceShaderAtomicInt64FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; + + + +#define VK_KHR_driver_properties 1 +#define VK_MAX_DRIVER_NAME_SIZE_KHR 256 +#define VK_MAX_DRIVER_INFO_SIZE_KHR 256 +#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" + + +typedef enum VkDriverIdKHR { + VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2, + VK_DRIVER_ID_MESA_RADV_KHR = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8, + VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9, + VK_DRIVER_ID_BEGIN_RANGE_KHR = VK_DRIVER_ID_AMD_PROPRIETARY_KHR, + VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_ARM_PROPRIETARY_KHR, + VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_ARM_PROPRIETARY_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1), + VK_DRIVER_ID_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDriverIdKHR; + +typedef struct VkConformanceVersionKHR { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersionKHR; + +typedef struct VkPhysicalDeviceDriverPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; + VkConformanceVersionKHR conformanceVersion; +} VkPhysicalDeviceDriverPropertiesKHR; + + + +#define VK_KHR_vulkan_memory_model 1 +#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 2 +#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; +} VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; + + + +#define VK_EXT_debug_report 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" + + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, + VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportObjectTypeEXT; + + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); +#endif + +#define VK_NV_glsl_shader 1 +#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 +#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" + + +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +#define VK_IMG_filter_cubic 1 +#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 +#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" + + +#define VK_AMD_rasterization_order 1 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" + + +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, + VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, + VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; + +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + + + +#define VK_AMD_shader_trinary_minmax 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" + + +#define VK_AMD_shader_explicit_vertex_parameter 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" + + +#define VK_EXT_debug_marker 1 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" + +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif + +#define VK_AMD_gcn_shader 1 +#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 +#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" + + +#define VK_NV_dedicated_allocation 1 +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" + +typedef struct VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + + + +#define VK_AMD_draw_indirect_count 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_AMD_negative_viewport_height 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" + + +#define VK_AMD_gpu_shader_half_float 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" + + +#define VK_AMD_shader_ballot 1 +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" + + +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" + +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + +#define VK_AMD_shader_info 1 +#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 +#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" + + +typedef enum VkShaderInfoTypeAMD { + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, + VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1), + VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderInfoTypeAMD; + +typedef struct VkShaderResourceUsageAMD { + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; + +typedef struct VkShaderStatisticsInfoAMD { + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); +#endif + +#define VK_AMD_shader_image_load_store_lod 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" + + +#define VK_NV_corner_sampled_image 1 +#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 +#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" + +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV; + + + +#define VK_IMG_format_pvrtc 1 +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" + + +#define VK_NV_external_memory_capabilities 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsNV; +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + +typedef enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsNV; +typedef VkFlags VkExternalMemoryFeatureFlagsNV; + +typedef struct VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties; + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +} VkExternalImageFormatPropertiesNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +#endif + +#define VK_NV_external_memory 1 +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" + +typedef struct VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + +typedef struct VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + + + +#define VK_EXT_validation_flags 1 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" + + +typedef enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, + VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, + VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCheckEXT; + +typedef struct VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext; + uint32_t disabledValidationCheckCount; + const VkValidationCheckEXT* pDisabledValidationChecks; +} VkValidationFlagsEXT; + + + +#define VK_EXT_shader_subgroup_ballot 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" + + +#define VK_EXT_shader_subgroup_vote 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" + + +#define VK_EXT_astc_decode_mode 1 +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" + +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + + + +#define VK_EXT_conditional_rendering 1 +#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1 +#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" + + +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; + +typedef struct VkConditionalRenderingBeginInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT; + +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT; + +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer); +#endif + +#define VK_NVX_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) + +#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 +#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" + + +typedef enum VkIndirectCommandsTokenTypeNVX { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeNVX; + +typedef enum VkObjectEntryTypeNVX { + VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, + VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), + VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkObjectEntryTypeNVX; + + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsNVX; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; + +typedef enum VkObjectEntryUsageFlagBitsNVX { + VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, + VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, + VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkObjectEntryUsageFlagBitsNVX; +typedef VkFlags VkObjectEntryUsageFlagsNVX; + +typedef struct VkDeviceGeneratedCommandsFeaturesNVX { + VkStructureType sType; + const void* pNext; + VkBool32 computeBindingPointSupport; +} VkDeviceGeneratedCommandsFeaturesNVX; + +typedef struct VkDeviceGeneratedCommandsLimitsNVX { + VkStructureType sType; + const void* pNext; + uint32_t maxIndirectCommandsLayoutTokenCount; + uint32_t maxObjectEntryCounts; + uint32_t minSequenceCountBufferOffsetAlignment; + uint32_t minSequenceIndexBufferOffsetAlignment; + uint32_t minCommandsTokenBufferOffsetAlignment; +} VkDeviceGeneratedCommandsLimitsNVX; + +typedef struct VkIndirectCommandsTokenNVX { + VkIndirectCommandsTokenTypeNVX tokenType; + VkBuffer buffer; + VkDeviceSize offset; +} VkIndirectCommandsTokenNVX; + +typedef struct VkIndirectCommandsLayoutTokenNVX { + VkIndirectCommandsTokenTypeNVX tokenType; + uint32_t bindingUnit; + uint32_t dynamicCount; + uint32_t divisor; +} VkIndirectCommandsLayoutTokenNVX; + +typedef struct VkIndirectCommandsLayoutCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkIndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenNVX* pTokens; +} VkIndirectCommandsLayoutCreateInfoNVX; + +typedef struct VkCmdProcessCommandsInfoNVX { + VkStructureType sType; + const void* pNext; + VkObjectTableNVX objectTable; + VkIndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t indirectCommandsTokenCount; + const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; + uint32_t maxSequencesCount; + VkCommandBuffer targetCommandBuffer; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; +} VkCmdProcessCommandsInfoNVX; + +typedef struct VkCmdReserveSpaceForCommandsInfoNVX { + VkStructureType sType; + const void* pNext; + VkObjectTableNVX objectTable; + VkIndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkCmdReserveSpaceForCommandsInfoNVX; + +typedef struct VkObjectTableCreateInfoNVX { + VkStructureType sType; + const void* pNext; + uint32_t objectCount; + const VkObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; +} VkObjectTableCreateInfoNVX; + +typedef struct VkObjectTableEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; +} VkObjectTableEntryNVX; + +typedef struct VkObjectTablePipelineEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipeline pipeline; +} VkObjectTablePipelineEntryNVX; + +typedef struct VkObjectTableDescriptorSetEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipelineLayout pipelineLayout; + VkDescriptorSet descriptorSet; +} VkObjectTableDescriptorSetEntryNVX; + +typedef struct VkObjectTableVertexBufferEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkBuffer buffer; +} VkObjectTableVertexBufferEntryNVX; + +typedef struct VkObjectTableIndexBufferEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkBuffer buffer; + VkIndexType indexType; +} VkObjectTableIndexBufferEntryNVX; + +typedef struct VkObjectTablePushConstantEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipelineLayout pipelineLayout; + VkShaderStageFlags stageFlags; +} VkObjectTablePushConstantEntryNVX; + + +typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable); +typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices); +typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( + VkDevice device, + VkIndirectCommandsLayoutNVX indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( + VkDevice device, + const VkObjectTableCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkObjectTableNVX* pObjectTable); + +VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX( + VkDevice device, + VkObjectTableNVX objectTable, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( + VkDevice device, + VkObjectTableNVX objectTable, + uint32_t objectCount, + const VkObjectTableEntryNVX* const* ppObjectTableEntries, + const uint32_t* pObjectIndices); + +VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( + VkDevice device, + VkObjectTableNVX objectTable, + uint32_t objectCount, + const VkObjectEntryTypeNVX* pObjectEntryTypes, + const uint32_t* pObjectIndices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( + VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, + VkDeviceGeneratedCommandsLimitsNVX* pLimits); +#endif + +#define VK_NV_clip_space_w_scaling 1 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" + +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); +#endif + +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" + + +typedef enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSurfaceCounterFlagBitsEXT; +typedef VkFlags VkSurfaceCounterFlagsEXT; + +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif + +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, + VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, + VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1), + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, + VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, + VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1), + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, + VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, + VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1), + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; + +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif + +#define VK_GOOGLE_display_timing 1 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" + +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); +#endif + +#define VK_NV_sample_mask_override_coverage 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" + + +#define VK_NV_geometry_shader_passthrough 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" + + +#define VK_NV_viewport_array2 1 +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" + + +#define VK_NVX_multiview_per_view_attributes 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" + +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + + +#define VK_NV_viewport_swizzle 1 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" + + +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; + +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; + + + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; + +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); +#endif + +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1), + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; + +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 1 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" + +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); +#endif + +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +#define VK_QUEUE_FAMILY_FOREIGN_EXT (~0U-2) + + +#define VK_EXT_debug_utils 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) + +#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1 +#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" + +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; + +typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageSeverityFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; + +typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageTypeFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext; + const char* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( + VkQueue queue); + +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +#endif + +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" + + +typedef enum VkSamplerReductionModeEXT { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, + VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, + VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSamplerReductionModeEXT; + +typedef struct VkSamplerReductionModeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +#define VK_AMD_mixed_attachment_samples 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" + + +#define VK_AMD_shader_fragment_mask 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" + + +#define VK_EXT_inline_uniform_block 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" + +typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeaturesEXT; + +typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockPropertiesEXT; + +typedef struct VkWriteDescriptorSetInlineUniformBlockEXT { + VkStructureType sType; + const void* pNext; + uint32_t dataSize; + const void* pData; +} VkWriteDescriptorSetInlineUniformBlockEXT; + +typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxInlineUniformBlockBindings; +} VkDescriptorPoolInlineUniformBlockCreateInfoEXT; + + + +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" + +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, + VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" + +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, + VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, + VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; + +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + + + +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +#define VK_EXT_validation_cache 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + +#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" + + +typedef enum VkValidationCacheHeaderVersionEXT { + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, + VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, + VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1), + VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCacheHeaderVersionEXT; + +typedef VkFlags VkValidationCacheCreateFlagsEXT; + +typedef struct VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; +} VkValidationCacheCreateInfoEXT; + +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheEXT validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); +#endif + +#define VK_EXT_descriptor_indexing 1 +#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 +#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" + + +typedef enum VkDescriptorBindingFlagBitsEXT { + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDescriptorBindingFlagBitsEXT; +typedef VkFlags VkDescriptorBindingFlagsEXT; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlagsEXT* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + +typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingPropertiesEXT; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; + + + +#define VK_EXT_shader_viewport_index_layer 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" + + +#define VK_NV_shading_rate_image 1 +#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 +#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" + + +typedef enum VkShadingRatePaletteEntryNV { + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + VK_SHADING_RATE_PALETTE_ENTRY_BEGIN_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, + VK_SHADING_RATE_PALETTE_ENTRY_END_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV, + VK_SHADING_RATE_PALETTE_ENTRY_RANGE_SIZE_NV = (VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV + 1), + VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF +} VkShadingRatePaletteEntryNV; + +typedef enum VkCoarseSampleOrderTypeNV { + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + VK_COARSE_SAMPLE_ORDER_TYPE_BEGIN_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, + VK_COARSE_SAMPLE_ORDER_TYPE_END_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV, + VK_COARSE_SAMPLE_ORDER_TYPE_RANGE_SIZE_NV = (VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV + 1), + VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoarseSampleOrderTypeNV; + +typedef struct VkShadingRatePaletteNV { + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; +} VkShadingRatePaletteNV; + +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + const VkShadingRatePaletteNV* pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV; + +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV; + +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { + VkStructureType sType; + void* pNext; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV; + +typedef struct VkCoarseSampleLocationNV { + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; +} VkCoarseSampleLocationNV; + +typedef struct VkCoarseSampleOrderCustomNV { + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV* pSampleLocations; +} VkCoarseSampleOrderCustomNV; + +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +#endif + +#define VK_NVX_raytracing 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNVX) + +#define VK_NVX_RAYTRACING_SPEC_VERSION 1 +#define VK_NVX_RAYTRACING_EXTENSION_NAME "VK_NVX_raytracing" + + +typedef enum VkGeometryTypeNVX { + VK_GEOMETRY_TYPE_TRIANGLES_NVX = 0, + VK_GEOMETRY_TYPE_AABBS_NVX = 1, + VK_GEOMETRY_TYPE_BEGIN_RANGE_NVX = VK_GEOMETRY_TYPE_TRIANGLES_NVX, + VK_GEOMETRY_TYPE_END_RANGE_NVX = VK_GEOMETRY_TYPE_AABBS_NVX, + VK_GEOMETRY_TYPE_RANGE_SIZE_NVX = (VK_GEOMETRY_TYPE_AABBS_NVX - VK_GEOMETRY_TYPE_TRIANGLES_NVX + 1), + VK_GEOMETRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkGeometryTypeNVX; + +typedef enum VkAccelerationStructureTypeNVX { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX = 1, + VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NVX = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX, + VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NVX = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX, + VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NVX = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX + 1), + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkAccelerationStructureTypeNVX; + +typedef enum VkCopyAccelerationStructureModeNVX { + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX = 0, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX = 1, + VK_COPY_ACCELERATION_STRUCTURE_MODE_BEGIN_RANGE_NVX = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX, + VK_COPY_ACCELERATION_STRUCTURE_MODE_END_RANGE_NVX = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX, + VK_COPY_ACCELERATION_STRUCTURE_MODE_RANGE_SIZE_NVX = (VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX + 1), + VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkCopyAccelerationStructureModeNVX; + + +typedef enum VkGeometryFlagBitsNVX { + VK_GEOMETRY_OPAQUE_BIT_NVX = 0x00000001, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX = 0x00000002, + VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkGeometryFlagBitsNVX; +typedef VkFlags VkGeometryFlagsNVX; + +typedef enum VkGeometryInstanceFlagBitsNVX { + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX = 0x00000001, + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX = 0x00000002, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX = 0x00000004, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX = 0x00000008, + VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkGeometryInstanceFlagBitsNVX; +typedef VkFlags VkGeometryInstanceFlagsNVX; + +typedef enum VkBuildAccelerationStructureFlagBitsNVX { + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX = 0x00000001, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX = 0x00000002, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX = 0x00000004, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX = 0x00000008, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX = 0x00000010, + VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkBuildAccelerationStructureFlagBitsNVX; +typedef VkFlags VkBuildAccelerationStructureFlagsNVX; + +typedef struct VkRaytracingPipelineCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const uint32_t* pGroupNumbers; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRaytracingPipelineCreateInfoNVX; + +typedef struct VkGeometryTrianglesNVX { + VkStructureType sType; + const void* pNext; + VkBuffer vertexData; + VkDeviceSize vertexOffset; + uint32_t vertexCount; + VkDeviceSize vertexStride; + VkFormat vertexFormat; + VkBuffer indexData; + VkDeviceSize indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer transformData; + VkDeviceSize transformOffset; +} VkGeometryTrianglesNVX; + +typedef struct VkGeometryAABBNVX { + VkStructureType sType; + const void* pNext; + VkBuffer aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize offset; +} VkGeometryAABBNVX; + +typedef struct VkGeometryDataNVX { + VkGeometryTrianglesNVX triangles; + VkGeometryAABBNVX aabbs; +} VkGeometryDataNVX; + +typedef struct VkGeometryNVX { + VkStructureType sType; + const void* pNext; + VkGeometryTypeNVX geometryType; + VkGeometryDataNVX geometry; + VkGeometryFlagsNVX flags; +} VkGeometryNVX; + +typedef struct VkAccelerationStructureCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNVX type; + VkBuildAccelerationStructureFlagsNVX flags; + VkDeviceSize compactedSize; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNVX* pGeometries; +} VkAccelerationStructureCreateInfoNVX; + +typedef struct VkBindAccelerationStructureMemoryInfoNVX { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNVX accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNVX; + +typedef struct VkDescriptorAccelerationStructureInfoNVX { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureNVX* pAccelerationStructures; +} VkDescriptorAccelerationStructureInfoNVX; + +typedef struct VkAccelerationStructureMemoryRequirementsInfoNVX { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNVX accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNVX; + +typedef struct VkPhysicalDeviceRaytracingPropertiesNVX { + VkStructureType sType; + void* pNext; + uint32_t shaderHeaderSize; + uint32_t maxRecursionDepth; + uint32_t maxGeometryCount; +} VkPhysicalDeviceRaytracingPropertiesNVX; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNVX)(VkDevice device, const VkAccelerationStructureCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNVX* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNVX)(VkDevice device, VkAccelerationStructureNVX accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNVX)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureScratchMemoryRequirementsNVX)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNVX)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNVX)(VkCommandBuffer commandBuffer, VkAccelerationStructureTypeNVX type, uint32_t instanceCount, VkBuffer instanceData, VkDeviceSize instanceOffset, uint32_t geometryCount, const VkGeometryNVX* pGeometries, VkBuildAccelerationStructureFlagsNVX flags, VkBool32 update, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNVX)(VkCommandBuffer commandBuffer, VkAccelerationStructureNVX dst, VkAccelerationStructureNVX src, VkCopyAccelerationStructureModeNVX mode); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNVX)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, uint32_t width, uint32_t height); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRaytracingPipelinesNVX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRaytracingPipelineCreateInfoNVX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRaytracingShaderHandlesNVX)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNVX)(VkDevice device, VkAccelerationStructureNVX accelerationStructure, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructurePropertiesNVX)(VkCommandBuffer commandBuffer, VkAccelerationStructureNVX accelerationStructure, VkQueryType queryType, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNVX)(VkDevice device, VkPipeline pipeline, uint32_t shader); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNVX( + VkDevice device, + const VkAccelerationStructureCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNVX* pAccelerationStructure); + +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNVX( + VkDevice device, + VkAccelerationStructureNVX accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNVX( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureScratchMemoryRequirementsNVX( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNVX( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNVX( + VkCommandBuffer commandBuffer, + VkAccelerationStructureTypeNVX type, + uint32_t instanceCount, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + uint32_t geometryCount, + const VkGeometryNVX* pGeometries, + VkBuildAccelerationStructureFlagsNVX flags, + VkBool32 update, + VkAccelerationStructureNVX dst, + VkAccelerationStructureNVX src, + VkBuffer scratch, + VkDeviceSize scratchOffset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNVX( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNVX dst, + VkAccelerationStructureNVX src, + VkCopyAccelerationStructureModeNVX mode); + +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNVX( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + uint32_t width, + uint32_t height); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRaytracingPipelinesNVX( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRaytracingPipelineCreateInfoNVX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRaytracingShaderHandlesNVX( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNVX( + VkDevice device, + VkAccelerationStructureNVX accelerationStructure, + size_t dataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructurePropertiesNVX( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNVX accelerationStructure, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNVX( + VkDevice device, + VkPipeline pipeline, + uint32_t shader); +#endif + +#define VK_NV_representative_fragment_test 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" + +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + + + +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" + + +typedef enum VkQueueGlobalPriorityEXT { + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, + VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, + VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, + VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1), + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF +} VkQueueGlobalPriorityEXT; + +typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriorityEXT globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" + +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif + +#define VK_AMD_buffer_marker 1 +#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 +#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" + +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); +#endif + +#define VK_AMD_shader_core_properties 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" + +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { + VkStructureType sType; + void* pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD; + + + +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" + +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + +#define VK_NV_shader_subgroup_partitioned 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" + + +#define VK_NV_compute_shader_derivatives 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" + +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; + + + +#define VK_NV_mesh_shader 1 +#define VK_NV_MESH_SHADER_SPEC_VERSION 1 +#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" + +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV; + +typedef struct VkDrawMeshTasksIndirectCommandNV { + uint32_t taskCount; + uint32_t firstTask; +} VkDrawMeshTasksIndirectCommandNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_NV_fragment_shader_barycentric 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; + + + +#define VK_NV_shader_image_footprint 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" + +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV; + + + +#define VK_NV_scissor_exclusive 1 +#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1 +#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" + +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t exclusiveScissorCount; + const VkRect2D* pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV; + +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors); +#endif + +#define VK_NV_device_diagnostic_checkpoints 1 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" + +typedef struct VkQueueFamilyCheckpointPropertiesNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV; + +typedef struct VkCheckpointDataNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlagBits stage; + void* pCheckpointMarker; +} VkCheckpointDataNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker); + +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_fuchsia.h b/3rdparty/include/vulkan/vulkan_fuchsia.h new file mode 100644 index 0000000000..e0ed5455ad --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_fuchsia.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_FUCHSIA_H_ +#define VULKAN_FUCHSIA_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_FUCHSIA_imagepipe_surface 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" + +typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; + +typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; +} VkImagePipeSurfaceCreateInfoFUCHSIA; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_ios.h b/3rdparty/include/vulkan/vulkan_ios.h new file mode 100644 index 0000000000..a0924816d5 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_ios.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_IOS_H_ +#define VULKAN_IOS_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_MVK_ios_surface 1 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" + +typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + +typedef struct VkIOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkIOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkIOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_macos.h b/3rdparty/include/vulkan/vulkan_macos.h new file mode 100644 index 0000000000..ff0b701801 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_macos.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_MACOS_H_ +#define VULKAN_MACOS_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_MVK_macos_surface 1 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" + +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + +typedef struct VkMacOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkMacOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkMacOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_mir.h b/3rdparty/include/vulkan/vulkan_mir.h new file mode 100644 index 0000000000..7d24ed27a3 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_mir.h @@ -0,0 +1,65 @@ +#ifndef VULKAN_MIR_H_ +#define VULKAN_MIR_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_mir_surface 1 +#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 +#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" + +typedef VkFlags VkMirSurfaceCreateFlagsKHR; + +typedef struct VkMirSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkMirSurfaceCreateFlagsKHR flags; + MirConnection* connection; + MirSurface* mirSurface; +} VkMirSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( + VkInstance instance, + const VkMirSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + MirConnection* connection); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_vi.h b/3rdparty/include/vulkan/vulkan_vi.h new file mode 100644 index 0000000000..015166bfc6 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_vi.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_VI_H_ +#define VULKAN_VI_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_NN_vi_surface 1 +#define VK_NN_VI_SURFACE_SPEC_VERSION 1 +#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" + +typedef VkFlags VkViSurfaceCreateFlagsNN; + +typedef struct VkViSurfaceCreateInfoNN { + VkStructureType sType; + const void* pNext; + VkViSurfaceCreateFlagsNN flags; + void* window; +} VkViSurfaceCreateInfoNN; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_wayland.h b/3rdparty/include/vulkan/vulkan_wayland.h new file mode 100644 index 0000000000..5ba0827aa3 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_wayland.h @@ -0,0 +1,65 @@ +#ifndef VULKAN_WAYLAND_H_ +#define VULKAN_WAYLAND_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_wayland_surface 1 +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" + +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + +typedef struct VkWaylandSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; +} VkWaylandSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_win32.h b/3rdparty/include/vulkan/vulkan_win32.h new file mode 100644 index 0000000000..6a85409ebe --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_win32.h @@ -0,0 +1,276 @@ +#ifndef VULKAN_WIN32_H_ +#define VULKAN_WIN32_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_win32_surface 1 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" + +typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + +typedef struct VkWin32SurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif + +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif + +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + + +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" + +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" + +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + +#define VK_NV_external_memory_win32 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; +} VkImportMemoryWin32HandleInfoNV; + +typedef struct VkExportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; +} VkExportMemoryWin32HandleInfoNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif + +#define VK_NV_win32_keyed_mutex 1 +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoNV; + + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_xcb.h b/3rdparty/include/vulkan/vulkan_xcb.h new file mode 100644 index 0000000000..ba03600602 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_xcb.h @@ -0,0 +1,66 @@ +#ifndef VULKAN_XCB_H_ +#define VULKAN_XCB_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_xcb_surface 1 +#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" + +typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + +typedef struct VkXcbSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; +} VkXcbSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_xlib.h b/3rdparty/include/vulkan/vulkan_xlib.h new file mode 100644 index 0000000000..e1d967e018 --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_xlib.h @@ -0,0 +1,66 @@ +#ifndef VULKAN_XLIB_H_ +#define VULKAN_XLIB_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_KHR_xlib_surface 1 +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" + +typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + +typedef struct VkXlibSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; +} VkXlibSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/include/vulkan/vulkan_xlib_xrandr.h b/3rdparty/include/vulkan/vulkan_xlib_xrandr.h new file mode 100644 index 0000000000..117d01799e --- /dev/null +++ b/3rdparty/include/vulkan/vulkan_xlib_xrandr.h @@ -0,0 +1,54 @@ +#ifndef VULKAN_XLIB_XRANDR_H_ +#define VULKAN_XLIB_XRANDR_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_EXT_acquire_xlib_display 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" + +typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/CMakeLists.txt b/CMakeLists.txt index e51945503a..237d283949 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -237,6 +237,7 @@ OCV_OPTION(WITH_GTK "Include GTK support" ON OCV_OPTION(WITH_GTK_2_X "Use GTK version 2" OFF IF (UNIX AND NOT APPLE AND NOT ANDROID) ) OCV_OPTION(WITH_IPP "Include Intel IPP support" (NOT MINGW AND NOT CV_DISABLE_OPTIMIZATION) IF (X86_64 OR X86) AND NOT WINRT AND NOT IOS ) OCV_OPTION(WITH_HALIDE "Include Halide support" OFF) +OCV_OPTION(WITH_VULKAN "Include Vulkan support" OFF) OCV_OPTION(WITH_INF_ENGINE "Include Intel Inference Engine support" OFF) OCV_OPTION(WITH_JASPER "Include JPEG2K support" ON IF (NOT IOS) ) OCV_OPTION(WITH_JPEG "Include JPEG support" ON) @@ -685,6 +686,11 @@ if(WITH_HALIDE) include(cmake/OpenCVDetectHalide.cmake) endif() +# --- VkCom --- +if(WITH_VULKAN) + include(cmake/OpenCVDetectVulkan.cmake) +endif() + # --- Inference Engine --- if(WITH_INF_ENGINE) include(cmake/OpenCVDetectInferenceEngine.cmake) @@ -1456,6 +1462,15 @@ if(WITH_CUDA OR HAVE_CUDA) endif() endif() +if(WITH_VULKAN OR HAVE_VULKAN) + status("") + status(" Vulkan:" HAVE_VULKAN THEN "YES" ELSE "NO") + if(HAVE_VULKAN) + status(" Include path:" VULKAN_INCLUDE_DIRS THEN "${VULKAN_INCLUDE_DIRS}" ELSE "NO") + status(" Link libraries:" VULKAN_LIBRARIES THEN "${VULKAN_LIBRARIES}" ELSE "Dynamic load") + endif() +endif() + if(WITH_OPENCL OR HAVE_OPENCL) ocv_build_features_string(opencl_features IF HAVE_OPENCL_SVM THEN "SVM" diff --git a/cmake/FindVulkan.cmake b/cmake/FindVulkan.cmake new file mode 100644 index 0000000000..bf7a56418f --- /dev/null +++ b/cmake/FindVulkan.cmake @@ -0,0 +1,27 @@ +# Find Vulkan +# +# Vulkan_INCLUDE_DIRS +# Vulkan_LIBRARIES +# Vulkan_FOUND +if (WIN32) + find_path(Vulkan_INCLUDE_DIRS NAMES vulkan/vulkan.h HINTS + "$ENV{VULKAN_SDK}/Include" + "$ENV{VK_SDK_PATH}/Include") + if (CMAKE_CL_64) + find_library(Vulkan_LIBRARIES NAMES vulkan-1 HINTS + "$ENV{VULKAN_SDK}/Bin" + "$ENV{VK_SDK_PATH}/Bin") + else() + find_library(Vulkan_LIBRARIES NAMES vulkan-1 HINTS + "$ENV{VULKAN_SDK}/Bin32" + "$ENV{VK_SDK_PATH}/Bin32") + endif() +else() + find_path(Vulkan_INCLUDE_DIRS NAMES vulkan/vulkan.h HINTS + "$ENV{VULKAN_SDK}/include") + find_library(Vulkan_LIBRARIES NAMES vulkan HINTS + "$ENV{VULKAN_SDK}/lib") +endif() +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Vulkan DEFAULT_MSG Vulkan_LIBRARIES Vulkan_INCLUDE_DIRS) +mark_as_advanced(Vulkan_INCLUDE_DIRS Vulkan_LIBRARIES) diff --git a/cmake/OpenCVDetectVulkan.cmake b/cmake/OpenCVDetectVulkan.cmake new file mode 100644 index 0000000000..2bb7cc1b56 --- /dev/null +++ b/cmake/OpenCVDetectVulkan.cmake @@ -0,0 +1,20 @@ +set(VULKAN_INCLUDE_DIRS "${OpenCV_SOURCE_DIR}/3rdparty/include" CACHE PATH "Vulkan include directory") +set(VULKAN_LIBRARIES "") + +try_compile(VALID_VULKAN + "${OpenCV_BINARY_DIR}" + "${OpenCV_SOURCE_DIR}/cmake/checks/vulkan.cpp" + CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${VULKAN_INCLUDE_DIRS}" + OUTPUT_VARIABLE TRY_OUT + ) +if(NOT ${VALID_VULKAN}) + message(WARNING "Can't use Vulkan") + return() +endif() + +set(HAVE_VULKAN 1) + +if(HAVE_VULKAN) + add_definitions(-DVK_NO_PROTOTYPES) + include_directories(${VULKAN_INCLUDE_DIRS}) +endif() diff --git a/cmake/checks/vulkan.cpp b/cmake/checks/vulkan.cpp new file mode 100644 index 0000000000..ba7138516a --- /dev/null +++ b/cmake/checks/vulkan.cpp @@ -0,0 +1,6 @@ +#include + +int main(int /*argc*/, char** /*argv*/) +{ + return 0; +} diff --git a/cmake/templates/cvconfig.h.in b/cmake/templates/cvconfig.h.in index d9fe043b8d..c3a9d5dbb6 100644 --- a/cmake/templates/cvconfig.h.in +++ b/cmake/templates/cvconfig.h.in @@ -92,6 +92,9 @@ /* Halide support */ #cmakedefine HAVE_HALIDE +/* Vulkan support */ +#cmakedefine HAVE_VULKAN + /* Define to 1 if you have the header file. */ #cmakedefine HAVE_INTTYPES_H 1 diff --git a/modules/dnn/include/opencv2/dnn/dnn.hpp b/modules/dnn/include/opencv2/dnn/dnn.hpp index d9851f84b5..1a214f384a 100644 --- a/modules/dnn/include/opencv2/dnn/dnn.hpp +++ b/modules/dnn/include/opencv2/dnn/dnn.hpp @@ -69,7 +69,8 @@ CV__DNN_INLINE_NS_BEGIN DNN_BACKEND_DEFAULT, DNN_BACKEND_HALIDE, DNN_BACKEND_INFERENCE_ENGINE, - DNN_BACKEND_OPENCV + DNN_BACKEND_OPENCV, + DNN_BACKEND_VKCOM }; /** @@ -81,7 +82,8 @@ CV__DNN_INLINE_NS_BEGIN DNN_TARGET_CPU, DNN_TARGET_OPENCL, DNN_TARGET_OPENCL_FP16, - DNN_TARGET_MYRIAD + DNN_TARGET_MYRIAD, + DNN_TARGET_VULKAN }; /** @brief This class provides all data needed to initialize layer. @@ -263,6 +265,7 @@ CV__DNN_INLINE_NS_BEGIN virtual Ptr initInfEngine(const std::vector > &inputs); + virtual Ptr initVkCom(const std::vector > &inputs); /** * @brief Automatic Halide scheduling based on layer hyper-parameters. * @param[in] node Backend node with Halide functions. diff --git a/modules/dnn/src/dnn.cpp b/modules/dnn/src/dnn.cpp index 5578e64e9a..bec49f4e70 100644 --- a/modules/dnn/src/dnn.cpp +++ b/modules/dnn/src/dnn.cpp @@ -42,6 +42,7 @@ #include "precomp.hpp" #include "op_halide.hpp" #include "op_inf_engine.hpp" +#include "op_vkcom.hpp" #include "halide_scheduler.hpp" #include #include @@ -892,6 +893,13 @@ static Ptr wrapMat(int backendId, int targetId, cv::Mat& m) #ifdef HAVE_INF_ENGINE return Ptr(new InfEngineBackendWrapper(targetId, m)); #endif // HAVE_INF_ENGINE + } + else if (backendId == DNN_BACKEND_VKCOM) + { + CV_Assert(haveVulkan()); +#ifdef HAVE_VULKAN + return Ptr(new VkComBackendWrapper(m)); +#endif // HAVE_VULKAN } else CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); @@ -903,8 +911,21 @@ struct Net::Impl typedef std::map LayersShapesMap; typedef std::map MapIdToLayerData; + ~Impl() + { +#ifdef HAVE_VULKAN + // Vulkan requires explicit releasing the child objects of + // VkDevice object prior to releasing VkDevice object itself. + layers.clear(); + backendWrappers.clear(); + vkcom::deinitPerThread(); +#endif + } Impl() { +#ifdef HAVE_VULKAN + vkcom::initPerThread(); +#endif //allocate fake net input layer netInputLayer = Ptr(new DataLayer()); LayerData &inpl = layers.insert( make_pair(0, LayerData()) ).first->second; @@ -970,6 +991,12 @@ struct Net::Impl { return wrapMat(preferableBackend, preferableTarget, host); } + else if (preferableBackend == DNN_BACKEND_VKCOM) + { + #ifdef HAVE_VULKAN + return Ptr(new VkComBackendWrapper(baseBuffer, host)); + #endif + } else CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); } @@ -1078,6 +1105,8 @@ struct Net::Impl preferableTarget == DNN_TARGET_OPENCL || preferableTarget == DNN_TARGET_OPENCL_FP16 || preferableTarget == DNN_TARGET_MYRIAD); + CV_Assert(preferableBackend != DNN_BACKEND_VKCOM || + preferableTarget == DNN_TARGET_VULKAN); if (!netWasAllocated || this->blobsToKeep != blobsToKeep_) { if (preferableBackend == DNN_BACKEND_OPENCV && IS_DNN_OPENCL_TARGET(preferableTarget)) @@ -1107,6 +1136,12 @@ struct Net::Impl } } #endif + if (preferableBackend == DNN_BACKEND_VKCOM && !haveVulkan()) + { + preferableBackend = DNN_BACKEND_OPENCV; + preferableTarget = DNN_TARGET_CPU; + } + clear(); allocateLayers(blobsToKeep_); @@ -1259,6 +1294,8 @@ struct Net::Impl initHalideBackend(); else if (preferableBackend == DNN_BACKEND_INFERENCE_ENGINE) initInfEngineBackend(); + else if (preferableBackend == DNN_BACKEND_VKCOM) + initVkComBackend(); else CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); } @@ -1356,6 +1393,31 @@ struct Net::Impl } #endif // HAVE_INF_ENGINE + void initVkComBackend() + { + CV_TRACE_FUNCTION(); + CV_Assert(preferableBackend == DNN_BACKEND_VKCOM); +#ifdef HAVE_VULKAN + if (!haveVulkan()) + return; + + MapIdToLayerData::iterator it = layers.begin(); + for (; it != layers.end(); it++) + { + LayerData &ld = it->second; + Ptr layer = ld.layerInstance; + if (!layer->supportBackend(preferableBackend)) + { + continue; + } + + ld.skip = false; + ld.backendNodes[DNN_BACKEND_VKCOM] = + layer->initVkCom(ld.inputBlobsWrappers); + } +#endif + } + void initInfEngineBackend() { CV_TRACE_FUNCTION(); @@ -2254,6 +2316,10 @@ struct Net::Impl { forwardInfEngine(node); } + else if (preferableBackend == DNN_BACKEND_VKCOM) + { + forwardVkCom(ld.outputBlobsWrappers, node); + } else { CV_Error(Error::StsNotImplemented, "Unknown backend identifier"); @@ -3110,6 +3176,13 @@ bool Layer::supportBackend(int backendId) return backendId == DNN_BACKEND_OPENCV; } +Ptr Layer::initVkCom(const std::vector > &) +{ + CV_Error(Error::StsNotImplemented, "VkCom pipeline of " + type + + " layers is not defined."); + return Ptr(); +} + Ptr Layer::initHalide(const std::vector > &) { CV_Error(Error::StsNotImplemented, "Halide pipeline of " + type + diff --git a/modules/dnn/src/layers/concat_layer.cpp b/modules/dnn/src/layers/concat_layer.cpp index 76468b12f6..7389684d53 100644 --- a/modules/dnn/src/layers/concat_layer.cpp +++ b/modules/dnn/src/layers/concat_layer.cpp @@ -44,6 +44,7 @@ #include "layers_common.hpp" #include "../op_halide.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #ifdef HAVE_OPENCL #include "opencl_kernels_dnn.hpp" @@ -105,7 +106,8 @@ public: { return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE && haveHalide() && axis == 1 && !padding || // By channels - backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine() && !padding; + backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine() && !padding || + backendId == DNN_BACKEND_VKCOM && haveVulkan() && !padding; } class ChannelConcatInvoker : public ParallelLoopBody @@ -274,6 +276,16 @@ public: } } } + virtual Ptr initVkCom(const std::vector > &input) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + vkcom::Tensor in = VkComTensor(input[0]); + int cAxis = clamp(axis, in.dimNum()); + std::shared_ptr op(new vkcom::OpConcat(cAxis)); + return Ptr(new VkComBackendNode(input, op)); +#endif // HAVE_VULKAN + return Ptr(); + } virtual Ptr initHalide(const std::vector > &input) CV_OVERRIDE { diff --git a/modules/dnn/src/layers/convolution_layer.cpp b/modules/dnn/src/layers/convolution_layer.cpp index cfd0ee00c4..cffb5d3637 100644 --- a/modules/dnn/src/layers/convolution_layer.cpp +++ b/modules/dnn/src/layers/convolution_layer.cpp @@ -44,6 +44,7 @@ #include "layers_common.hpp" #include "../op_halide.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include "opencv2/core/hal/hal.hpp" #include "opencv2/core/hal/intrin.hpp" #include @@ -222,7 +223,9 @@ public: if (backendId == DNN_BACKEND_INFERENCE_ENGINE) return preferableTarget != DNN_TARGET_MYRIAD || dilation.width == dilation.height; else - return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE; + return backendId == DNN_BACKEND_OPENCV || + backendId == DNN_BACKEND_HALIDE || + backendId == DNN_BACKEND_VKCOM && haveVulkan(); } bool getMemoryShapes(const std::vector &inputs, @@ -384,6 +387,73 @@ public: biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1]; } + virtual Ptr initVkCom(const std::vector > &inputs) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + int out_channel = blobs[0].size[0]; + bool has_bias = hasBias() || fusedBias; + int filter_size[2] = {kernel.height, kernel.width}; + int pad_size[2] = {pad.height, pad.width}; + int stride_size[2] = {stride.height, stride.width}; + int dilation_size[2] = {dilation.height, dilation.width}; + int activation = 0; + vkcom::Tensor input_tensor = VkComTensor(inputs[0]); + int in_channel = input_tensor.dimSize(1); + int group = in_channel / blobs[0].size[1]; + + // TODO: support group > 1 + if (group != 1) + return Ptr(); + + int padding_mode; + if (padMode.empty()) + { + padding_mode = vkcom::kPaddingModeCaffe; + } + else if (padMode == "VALID") + { + padding_mode = vkcom::kPaddingModeValid; + } + else if (padMode == "SAME") + { + padding_mode = vkcom::kPaddingModeSame; + } + else + CV_Error(Error::StsError, "Unsupported padding mode " + padMode); + + std::shared_ptr op(new vkcom::OpConv(out_channel, has_bias, + filter_size, pad_size, + stride_size, dilation_size, + activation, group, + padding_mode)); + + std::vector > blobsWrapper; + + if (newWeightAndBias) + { + Mat wm; + weightsMat.copyTo(wm); // to handle the case of isContinuous() == false + wm.reshape(1, blobs[0].dims, blobs[0].size); + blobsWrapper.push_back(Ptr(new VkComBackendWrapper(wm))); + } + else + { + blobsWrapper.push_back(Ptr(new VkComBackendWrapper(blobs[0]))); + } + + if (has_bias) + { + Mat biasesMat({out_channel}, CV_32F, &biasvec[0]); + blobsWrapper.push_back(Ptr(new VkComBackendWrapper(biasesMat))); + } + + return Ptr(new VkComBackendNode(inputs, op, blobsWrapper)); +#endif // HAVE_VULKAN + return Ptr(); + } + + + virtual Ptr initHalide(const std::vector > &inputs) CV_OVERRIDE { #ifdef HAVE_HALIDE diff --git a/modules/dnn/src/layers/elementwise_layers.cpp b/modules/dnn/src/layers/elementwise_layers.cpp index 536c0ff50d..00aa4efc21 100644 --- a/modules/dnn/src/layers/elementwise_layers.cpp +++ b/modules/dnn/src/layers/elementwise_layers.cpp @@ -44,6 +44,7 @@ #include "layers_common.hpp" #include "../op_halide.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include "opencv2/imgproc.hpp" #include #include @@ -161,6 +162,14 @@ public: return Ptr(); } + virtual Ptr initVkCom(const std::vector >& inputs) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + return Ptr(new VkComBackendNode(inputs, func.initVkCom())); +#endif // HAVE_VULKAN + return Ptr(); + } + virtual bool tryFuse(Ptr& top) CV_OVERRIDE { return func.tryFuse(top); @@ -252,7 +261,8 @@ struct ReLUFunctor bool supportBackend(int backendId, int) { return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE || - backendId == DNN_BACKEND_INFERENCE_ENGINE; + backendId == DNN_BACKEND_INFERENCE_ENGINE || + backendId == DNN_BACKEND_VKCOM; } void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const @@ -356,6 +366,16 @@ struct ReLUFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + std::shared_ptr op(new vkcom::OpReLU(slope)); + return op; + } +#endif // HAVE_VULKAN + + + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -465,6 +485,14 @@ struct ReLU6Functor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -539,6 +567,14 @@ struct TanHFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -613,6 +649,14 @@ struct SigmoidFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -688,6 +732,14 @@ struct ELUFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -760,6 +812,14 @@ struct AbsValFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -812,6 +872,14 @@ struct BNLLFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} @@ -935,6 +1003,14 @@ struct PowerFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr& top) { if (power != 1.0f && shift != 0.0f) @@ -1070,6 +1146,14 @@ struct ChannelsPReLUFunctor } #endif // HAVE_INF_ENGINE +#ifdef HAVE_VULKAN + std::shared_ptr initVkCom() + { + // TODO: add vkcom implementation + return std::shared_ptr(); + } +#endif // HAVE_VULKAN + bool tryFuse(Ptr&) { return false; } void getScaleShift(Mat&, Mat&) const {} diff --git a/modules/dnn/src/layers/lrn_layer.cpp b/modules/dnn/src/layers/lrn_layer.cpp index cc2955bbc0..d3a4c26547 100644 --- a/modules/dnn/src/layers/lrn_layer.cpp +++ b/modules/dnn/src/layers/lrn_layer.cpp @@ -44,6 +44,7 @@ #include "layers_common.hpp" #include "../op_halide.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include "opencv2/imgproc.hpp" #include "opencv2/dnn/shape_utils.hpp" #include "opencv2/core/hal/hal.hpp" @@ -92,7 +93,8 @@ public: { return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE || - backendId == DNN_BACKEND_INFERENCE_ENGINE && (preferableTarget != DNN_TARGET_MYRIAD || type == CHANNEL_NRM); + backendId == DNN_BACKEND_INFERENCE_ENGINE && (preferableTarget != DNN_TARGET_MYRIAD || type == CHANNEL_NRM) || + backendId == DNN_BACKEND_VKCOM && haveVulkan() && (size % 2 == 1) && (type == CHANNEL_NRM); } #ifdef HAVE_OPENCL @@ -306,6 +308,15 @@ public: } } + virtual Ptr initVkCom(const std::vector > &inputs) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + std::shared_ptr op(new vkcom::OpLRN(size / 2, bias, alpha, beta, normBySize)); + return Ptr(new VkComBackendNode(inputs, op)); +#endif + return Ptr(); + } + virtual Ptr initHalide(const std::vector > &inputs) CV_OVERRIDE { #ifdef HAVE_HALIDE diff --git a/modules/dnn/src/layers/permute_layer.cpp b/modules/dnn/src/layers/permute_layer.cpp index 36f18de561..bdf27b5f96 100644 --- a/modules/dnn/src/layers/permute_layer.cpp +++ b/modules/dnn/src/layers/permute_layer.cpp @@ -43,6 +43,7 @@ #include "../precomp.hpp" #include "layers_common.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include #include @@ -105,7 +106,8 @@ public: virtual bool supportBackend(int backendId) CV_OVERRIDE { return backendId == DNN_BACKEND_OPENCV || - backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine(); + backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine() || + backendId == DNN_BACKEND_VKCOM && haveVulkan(); } bool getMemoryShapes(const std::vector &inputs, @@ -370,6 +372,16 @@ public: } } + virtual Ptr initVkCom(const std::vector > &input) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + CV_Assert(!_order.empty()); + std::shared_ptr op(new vkcom::OpPermute(_order)); + return Ptr(new VkComBackendNode(input, op)); +#endif // HAVE_VULKAN + return Ptr(); + } + virtual Ptr initInfEngine(const std::vector >&) CV_OVERRIDE { #ifdef HAVE_INF_ENGINE diff --git a/modules/dnn/src/layers/pooling_layer.cpp b/modules/dnn/src/layers/pooling_layer.cpp index a0d22d073d..3ec5c662e0 100644 --- a/modules/dnn/src/layers/pooling_layer.cpp +++ b/modules/dnn/src/layers/pooling_layer.cpp @@ -45,6 +45,7 @@ #include "opencv2/core/hal/intrin.hpp" #include "../op_halide.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include #include using std::max; @@ -155,7 +156,9 @@ public: else return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE && haveHalide() && - (type == MAX || type == AVE && !pad_t && !pad_l && !pad_b && !pad_r); + (type == MAX || type == AVE && !pad_t && !pad_l && !pad_b && !pad_r) || + backendId == DNN_BACKEND_VKCOM && haveVulkan() && + (type == MAX || type == AVE); } #ifdef HAVE_OPENCL @@ -246,6 +249,41 @@ public: } } + virtual Ptr initVkCom(const std::vector > &inputs) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + int padding_mode; + vkcom::PoolType pool_type; + int filter_size[2] = {kernel.height, kernel.width}; + int pad_size[2] = {pad.height, pad.width}; + int stride_size[2] = {stride.height, stride.width}; + pool_type = type == MAX ? vkcom::kPoolTypeMax: + (type == AVE ? vkcom::kPoolTypeAvg: + vkcom::kPoolTypeNum); + + if (padMode.empty()) + { + padding_mode = vkcom::kPaddingModeCaffe; + } + else if (padMode == "VALID") + { + padding_mode = vkcom::kPaddingModeValid; + } + else if (padMode == "SAME") + { + padding_mode = vkcom::kPaddingModeSame; + } + else + CV_Error(Error::StsError, "Unsupported padding mode " + padMode); + + std::shared_ptr op(new vkcom::OpPool(filter_size, pad_size, + stride_size, padding_mode, + pool_type, avePoolPaddedArea)); + return Ptr(new VkComBackendNode(inputs, op)); +#endif + return Ptr(); + } + virtual Ptr initHalide(const std::vector > &inputs) CV_OVERRIDE { if (type == MAX) diff --git a/modules/dnn/src/layers/prior_box_layer.cpp b/modules/dnn/src/layers/prior_box_layer.cpp index fbe631fff4..3b7faa7320 100644 --- a/modules/dnn/src/layers/prior_box_layer.cpp +++ b/modules/dnn/src/layers/prior_box_layer.cpp @@ -43,6 +43,7 @@ #include "../precomp.hpp" #include "layers_common.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include #include #include @@ -271,7 +272,8 @@ public: virtual bool supportBackend(int backendId) CV_OVERRIDE { return backendId == DNN_BACKEND_OPENCV || - backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine(); + backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine() || + backendId == DNN_BACKEND_VKCOM && haveVulkan(); } bool getMemoryShapes(const std::vector &inputs, @@ -480,6 +482,19 @@ public: } } + virtual Ptr initVkCom(const std::vector > &input) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + std::shared_ptr op(new vkcom::OpPriorBox(_stepX, _stepY, + _clip, _numPriors, + _variance, _offsetsX, + _offsetsY, _boxWidths, + _boxHeights)); + return Ptr(new VkComBackendNode(input, op)); +#endif // HAVE_VULKAN + return Ptr(); + } + virtual Ptr initInfEngine(const std::vector >&) CV_OVERRIDE { #ifdef HAVE_INF_ENGINE diff --git a/modules/dnn/src/layers/softmax_layer.cpp b/modules/dnn/src/layers/softmax_layer.cpp index f1872a0026..7e2026531b 100644 --- a/modules/dnn/src/layers/softmax_layer.cpp +++ b/modules/dnn/src/layers/softmax_layer.cpp @@ -44,6 +44,7 @@ #include "layers_common.hpp" #include "../op_halide.hpp" #include "../op_inf_engine.hpp" +#include "../op_vkcom.hpp" #include #include using std::max; @@ -90,7 +91,8 @@ public: { return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE && haveHalide() && axisRaw == 1 || - backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine() && !logSoftMax; + backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine() && !logSoftMax || + backendId == DNN_BACKEND_VKCOM && haveVulkan(); } #ifdef HAVE_OPENCL @@ -284,6 +286,18 @@ public: } } + virtual Ptr initVkCom(const std::vector > &inputs) CV_OVERRIDE + { +#ifdef HAVE_VULKAN + vkcom::Tensor in = VkComTensor(inputs[0]); + int cAxis = clamp(axisRaw, in.dimNum()); + std::shared_ptr op(new vkcom::OpSoftmax(cAxis, logSoftMax)); + return Ptr(new VkComBackendNode(inputs, op)); +#endif // HAVE_VULKAN + return Ptr(); + } + + virtual Ptr initHalide(const std::vector > &inputs) CV_OVERRIDE { #ifdef HAVE_HALIDE diff --git a/modules/dnn/src/op_vkcom.cpp b/modules/dnn/src/op_vkcom.cpp new file mode 100644 index 0000000000..a252104240 --- /dev/null +++ b/modules/dnn/src/op_vkcom.cpp @@ -0,0 +1,162 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "precomp.hpp" +#include +#include "op_vkcom.hpp" + +namespace cv +{ +namespace dnn +{ +#ifdef HAVE_VULKAN + void copyToTensor(vkcom::Tensor &dst, const Mat &src) + { + CV_Assert(src.isContinuous() && src.type() == CV_32F); + + std::vector mat_shape = shape(src); + dst.reshape((const char*)src.data, mat_shape); + } + + void copyToMat(Mat &dst, vkcom::Tensor &src) + { + CV_Assert(dst.type() == CV_32F); + + std::vector shape = src.getShape(); + void *data = src.map(); + Mat tmp(shape, CV_32F, data); + tmp.copyTo(dst); + src.unMap(); + } + + vkcom::Tensor VkComTensor(const Ptr& ptr) + { + CV_Assert(!ptr.empty()); + return ptr.dynamicCast()->getTensor(); + } + + void setDirty(std::vector >& ptrs) + { + for (const Ptr& ptr : ptrs) + { + ptr.dynamicCast()->setDeviceDirty(); + } + } + + std::vector VkComTensors(const std::vector >& ptrs) + { + std::vector vec; + vec.reserve(ptrs.size()); + for (const Ptr& ptr : ptrs) + { + vec.push_back(VkComTensor(ptr)); + } + return vec; + } + + VkComBackendNode::VkComBackendNode(const std::vector >& inputsWrapper, + const std::shared_ptr& op, + const std::vector >& blobsWrapper) + : BackendNode(DNN_BACKEND_VKCOM) + { + operation = op; + + inputsWrapper_ = inputsWrapper; + ins = VkComTensors(inputsWrapper_); + + if (!blobsWrapper.empty()) + { + blobs = VkComTensors(blobsWrapper); + } + } + + bool VkComBackendNode::forward(std::vector& outs) + { + for (int i = 0, n = inputsWrapper_.size(); i < n; ++i) + { + inputsWrapper_[i].dynamicCast()->copyToDevice(); + } + + return operation->forward(ins, blobs, outs); + } + + VkComBackendWrapper::VkComBackendWrapper(Mat& m) : BackendWrapper(DNN_BACKEND_VKCOM, DNN_TARGET_VULKAN) + { + copyToTensor(tensor, m); + host = &m; + hostDirty = false; + deviceDirty = false; + } + + VkComBackendWrapper::VkComBackendWrapper(const Ptr& baseBuffer, Mat& m) + : BackendWrapper(DNN_BACKEND_VKCOM, DNN_TARGET_VULKAN) + { + Ptr base = baseBuffer.dynamicCast(); + CV_Assert(!base.empty()); + + host = &m; + tensor = base->tensor; + CV_Assert(tensor.count() >= m.total()); + tensor.reshape(0, shape(m)); + hostDirty = false; + deviceDirty = false; + } + + void VkComBackendWrapper::copyToHost() + { + if (deviceDirty) + copyToMat(*host, tensor); + } + + void VkComBackendWrapper::setHostDirty() + { + hostDirty = true; + }; + + void VkComBackendWrapper::setDeviceDirty() + { + deviceDirty = true; + }; + + void VkComBackendWrapper::copyToDevice() + { + if (hostDirty) + { + copyToTensor(tensor, *host); + hostDirty = false; + } + } + + vkcom::Tensor VkComBackendWrapper::getTensor() + { + return tensor; + } +#endif + void forwardVkCom(std::vector > &outputs, + const Ptr& node) + { +#ifdef HAVE_VULKAN + CV_Assert(!node.empty()); + + Ptr node_ = node.dynamicCast(); + std::vector outs = VkComTensors(outputs); + node_->forward(outs); + setDirty(outputs); +#endif + } + + bool haveVulkan() + { +#ifdef HAVE_VULKAN + return vkcom::isAvailable(); +#else + return false; +#endif // HAVE_VULKAN + } + +} // namespace dnn +} // namespace cv diff --git a/modules/dnn/src/op_vkcom.hpp b/modules/dnn/src/op_vkcom.hpp new file mode 100644 index 0000000000..4f979629e0 --- /dev/null +++ b/modules/dnn/src/op_vkcom.hpp @@ -0,0 +1,74 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_OP_VKCOM_HPP +#define OPENCV_DNN_OP_VKCOM_HPP + +#include +#ifdef HAVE_VULKAN +#include "vkcom/include/vkcom.hpp" +#endif // HAVE_VULKAN + +namespace cv +{ +namespace dnn +{ +#ifdef HAVE_VULKAN + std::vector VkComTensors(const std::vector >& ptrs); + + vkcom::Tensor VkComTensor(const Ptr& ptr); + + // Data copied from/to Mat to/from Tensor. Change the shape of dst if + // needed to make it the same shape as src + void copyToTensor(vkcom::Tensor &dst, const Mat &src); + + void copyToMat(Mat &dst, const vkcom::Tensor &src); + + class VkComBackendNode : public BackendNode + { + public: + VkComBackendNode(const std::vector >& inputsWrapper, + const std::shared_ptr &op, + const std::vector >& blobsWrapper = + std::vector >()); + + bool forward(std::vector& outs); + + private: + std::vector ins; + std::vector blobs; + std::vector > inputsWrapper_; + std::shared_ptr operation; + }; + + class VkComBackendWrapper : public BackendWrapper + { + public: + VkComBackendWrapper(Mat& m); + VkComBackendWrapper(const Ptr& baseBuffer, Mat& m); + + virtual void copyToHost() CV_OVERRIDE; + virtual void setHostDirty() CV_OVERRIDE; + void setDeviceDirty(); + void copyToDevice(); + vkcom::Tensor getTensor(); + + private: + vkcom::Tensor tensor; + Mat* host; + bool hostDirty; + bool deviceDirty; + }; +#endif // HAVE_VULKAN + + void forwardVkCom(std::vector > &outputs, const Ptr& node); + + bool haveVulkan(); +} // namespace dnn +} // namespace cv + +#endif // OPENCV_DNN_OP_VKCOM_HPP diff --git a/modules/dnn/src/vkcom/include/buffer.hpp b/modules/dnn/src/vkcom/include/buffer.hpp new file mode 100644 index 0000000000..dfb705c42a --- /dev/null +++ b/modules/dnn/src/vkcom/include/buffer.hpp @@ -0,0 +1,41 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_BUFFER_HPP +#define OPENCV_DNN_VKCOM_BUFFER_HPP + +#ifdef HAVE_VULKAN +#include +#endif // HAVE_VULKAN + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +class Buffer +{ +public: + Buffer(VkDevice& device) + : device_(device), buffer_(VK_NULL_HANDLE), memory_(VK_NULL_HANDLE){}; + Buffer(VkDevice& device, size_t size_in_bytes, const char* data); + ~Buffer(); + VkDeviceMemory getVkMemory() { return memory_; } + VkBuffer getVkBuffer() { return buffer_; } + +private: + Buffer(); + bool init(size_t size_in_bytes, const char* data); + VkDevice device_; + VkBuffer buffer_; + VkDeviceMemory memory_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_BUFFER_HPP diff --git a/modules/dnn/src/vkcom/include/op_base.hpp b/modules/dnn/src/vkcom/include/op_base.hpp new file mode 100644 index 0000000000..a44467062b --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_base.hpp @@ -0,0 +1,58 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_BASE_HPP +#define OPENCV_DNN_VKCOM_OP_BASE_HPP + +#include "../../precomp.hpp" +#include "vkcom.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +// Forward declare +class Context; + +class OpBase +{ +public: + OpBase(); + virtual ~OpBase(); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) = 0; +protected: + void initVulkanThing(int buffer_num); + void createDescriptorSetLayout(int buffer_num); + void createDescriptorSet(int buffer_num); + void createShaderModule(const uint32_t* spv, size_t sz, const std::string& source = std::string()); + void createPipeline(size_t push_constants_size = 0); + void createCommandBuffer(); + void recordCommandBuffer(void* push_constants = NULL, size_t push_constants_size = 0); + void runCommandBuffer(); + + const Context* ctx_; + VkPipeline pipeline_; + VkCommandBuffer cmd_buffer_; + VkDescriptorPool descriptor_pool_; + VkDescriptorSet descriptor_set_; + VkDevice device_; + VkDescriptorSetLayout descriptor_set_layout_; + VkPipelineLayout pipeline_layout_; + VkShaderModule module_; + int group_x_; + int group_y_; + int group_z_; + std::string type_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_BASE_HPP diff --git a/modules/dnn/src/vkcom/include/op_concat.hpp b/modules/dnn/src/vkcom/include/op_concat.hpp new file mode 100644 index 0000000000..c754a61233 --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_concat.hpp @@ -0,0 +1,55 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_CONCAT_HPP +#define OPENCV_DNN_VKCOM_OP_CONCAT_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +struct ConcatShaderConfig +{ + int local_size_x; + int local_size_y; + int local_size_z; + int block_height; + int block_width; + int block_depth; +}; + +class OpConcat: public OpBase +{ +public: + OpConcat(const int axis); + bool forward(std::vector& ins, Tensor& out); + void reshapeOutTensor(std::vector& in, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; + +private: + bool init(const int axis); + bool computeGroupCount(); + + ConcatShaderConfig config_; + int axis_; + int out_concat_axis_; + int accumulated_concat_axis_; + int concat_size_; + int total_concat_size_; + int thread_num_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_CONCAT_HPP diff --git a/modules/dnn/src/vkcom/include/op_conv.hpp b/modules/dnn/src/vkcom/include/op_conv.hpp new file mode 100644 index 0000000000..b3f883f518 --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_conv.hpp @@ -0,0 +1,85 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_CONV_HPP +#define OPENCV_DNN_VKCOM_OP_CONV_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +enum ConvShaderType +{ + kConvShaderTypeBasic = 0, + kConvShaderTypeIDLF = 1, + kConvShaderTypeNum +}; + +struct ConvShaderConfig +{ + int local_size_x; + int local_size_y; + int local_size_z; + int block_height; + int block_width; + int block_depth; + ConvShaderType shader_type; +}; + +class OpConv : public OpBase +{ +public: + OpConv(const int out_channel, const bool has_bias, + const int* filter_size, const int* pad, + const int* stride, const int* dilation, + const int activation, const int group, + const int padding_mode); + void reshapeOutTensor(Tensor& in, Tensor& out); + bool forward(Tensor& in, Tensor& filter_weights, Tensor& bias, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; +private: + bool init(const int out_channel, const bool has_bias, + const int* filter_size, const int* pad, + const int* stride, const int* dilation, + const int activation, const int group, + const int padding_mode); + bool computeGroupCount(); + + int batch_; + int in_height_; + int in_width_; + int in_channel_; + int out_height_; + int out_width_; + int out_channel_; + int filter_height_; + int filter_width_; + int stride_height_; + int stride_width_; + int padding_top_; + int padding_left_; + int dilation_height_; + int dilation_width_; + int activation_; + PaddingMode padding_mode_; + int group_; + int has_bias_; + Tensor swizzled_weights; + ConvShaderConfig config_; + bool dwconv_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_CONV_HPP diff --git a/modules/dnn/src/vkcom/include/op_lrn.hpp b/modules/dnn/src/vkcom/include/op_lrn.hpp new file mode 100644 index 0000000000..caafb9d09a --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_lrn.hpp @@ -0,0 +1,70 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_LRN_HPP +#define OPENCV_DNN_VKCOM_OP_LRN_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +enum LRNShaderType +{ + kLRNShaderTypeBasic = 0, + kLRNShaderTypeNum +}; + +struct LRNShaderConfig +{ + int local_size_x; + int local_size_y; + int local_size_z; + int block_height; + int block_width; + int block_depth; + LRNShaderType shader_type; +}; + +class OpLRN : public OpBase +{ +public: + OpLRN(const int radius, const float bias, + const float alpha, const float beta, + const bool norm_by_size); + void reshapeOutTensor(Tensor& in, Tensor& out); + bool forward(Tensor& in, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; + +private: + bool init(const int radius, const float bias, + const float alpha, const float beta, + const bool norm_by_size); + bool computeGroupCount(); + int batch_; + int height_; + int width_; + int channels_; + int radius_; + float bias_; + float alpha_; + float beta_; + int filter_len_; + int thread_num_; + bool norm_by_size_; + LRNShaderConfig config_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_LRN_HPP diff --git a/modules/dnn/src/vkcom/include/op_permute.hpp b/modules/dnn/src/vkcom/include/op_permute.hpp new file mode 100644 index 0000000000..b594d30cbe --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_permute.hpp @@ -0,0 +1,50 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_PERMUTE_HPP +#define OPENCV_DNN_VKCOM_OP_PERMUTE_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +class OpPermute: public OpBase +{ +public: + OpPermute(std::vector& order); + bool forward(std::vector& ins, std::vector& outs); + void reshapeOutTensor(std::vector& in, std::vector& outs); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; + +private: + void prepareStrides(const Shape &shape_before, const Shape &shape_after); + bool computeGroupCount(); + + std::vector order_; + bool need_permute_; + int global_size_; + int nthreads_; + int dims_; + Tensor tensor_order_; + Tensor tensor_old_stride_; + Tensor tensor_new_stride_; + std::vector old_stride_; + std::vector new_stride_; + Shape in_shape_; + Shape out_shape_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_PERMUTE_HPP diff --git a/modules/dnn/src/vkcom/include/op_pool.hpp b/modules/dnn/src/vkcom/include/op_pool.hpp new file mode 100644 index 0000000000..fa4acc1a76 --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_pool.hpp @@ -0,0 +1,70 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_POOL_HPP +#define OPENCV_DNN_VKCOM_OP_POOL_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +enum PoolType { kPoolTypeAvg, kPoolTypeMax, kPoolTypeNum }; + +struct PoolShaderConfig +{ + int local_size_x; + int local_size_y; + int local_size_z; + int block_height; + int block_width; + int block_depth; +}; + +class OpPool: public OpBase +{ +public: + OpPool(const int* filter_size, const int* pad, const int* stride, + const int padding_mode, const PoolType pool_type, + const bool avg_pool_padded_area); + bool forward(Tensor& in, Tensor& out, Tensor& mask); + void reshapeOutTensor(Tensor& in, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; +private: + bool init(const int* filter_size, const int* pad, const int* stride, + const int padding_mode, const PoolType type, const bool avg_pool_padded_area); + bool computeGroupCount(); + + int batch_; + int channels_; + int in_height_; + int in_width_; + int out_height_; + int out_width_; + int filter_height_; + int filter_width_; + int stride_height_; + int stride_width_; + int padding_left_; + int padding_top_; + PoolType pool_type_; + int avg_pool_padded_area_; + int need_mask_; + PaddingMode padding_mode_; + int activation_; + PoolShaderConfig config_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_POOL_HPP diff --git a/modules/dnn/src/vkcom/include/op_prior_box.hpp b/modules/dnn/src/vkcom/include/op_prior_box.hpp new file mode 100644 index 0000000000..7068d66cfb --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_prior_box.hpp @@ -0,0 +1,66 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_PRIOR_BOX_HPP +#define OPENCV_DNN_VKCOM_OP_PRIOR_BOX_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +class OpPriorBox: public OpBase +{ +public: + OpPriorBox(float step_x, + float step_y, + bool clip, + int num_priors, + std::vector& variance, + std::vector& offsets_x, + std::vector& offsets_y, + std::vector& box_widths, + std::vector& box_heights); + bool forward(std::vector& in, Tensor& out); + void reshapeOutTensor(std::vector& in, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; +private: + bool computeGroupCount(); + + int global_size_; + int nthreads_; + float step_x_; + float step_y_; + bool clip_; + int num_priors_; + std::vector variance_; + std::vector offsets_x_; + std::vector offsets_y_; + std::vector box_widths_; + std::vector box_heights_; + int img_h_; + int img_w_; + int in_h_; + int in_w_; + int out_channel_; + int out_channel_size_; + Tensor tensor_offsets_x_; + Tensor tensor_offsets_y_; + Tensor tensor_widths_; + Tensor tensor_heights_; + Tensor tensor_variance_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_PRIOR_BOX_HPP diff --git a/modules/dnn/src/vkcom/include/op_relu.hpp b/modules/dnn/src/vkcom/include/op_relu.hpp new file mode 100644 index 0000000000..82846c7495 --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_relu.hpp @@ -0,0 +1,37 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_RELU_HPP +#define OPENCV_DNN_VKCOM_OP_RELU_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +class OpReLU: public OpBase +{ +public: + OpReLU(const float slope = 1.f); + bool forward(Tensor& in, Tensor& out); + void reshapeOutTensor(Tensor& in, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; +private: + bool computeGroupCount(); + int total_; + float slope_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_RELU_HPP diff --git a/modules/dnn/src/vkcom/include/op_softmax.hpp b/modules/dnn/src/vkcom/include/op_softmax.hpp new file mode 100644 index 0000000000..12127a8bb7 --- /dev/null +++ b/modules/dnn/src/vkcom/include/op_softmax.hpp @@ -0,0 +1,56 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_OP_SOFTMAX_HPP +#define OPENCV_DNN_VKCOM_OP_SOFTMAX_HPP + +#include "vkcom.hpp" +#include "op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +struct SoftmaxShaderConfig +{ + int local_size_x; + int local_size_y; + int local_size_z; + int block_height; + int block_width; + int block_depth; +}; + +class OpSoftmax: public OpBase +{ +public: + OpSoftmax(const int axis, const bool log_softmax = false); + ~OpSoftmax(); + void reshapeOutTensor(Tensor& in, Tensor& out); + bool forward(Tensor& in, Tensor& out); + virtual bool forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) CV_OVERRIDE; +private: + bool init(const int axis, const bool log_softmax); + bool computeGroupCount(); + + int axis_; + int channels_; + int channel_size_; + int outer_size_; + bool log_softmax_; + SoftmaxShaderConfig config_; + Tensor* max_tensor_; + Tensor* sum_tensor_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_OP_SOFTMAX_HPP diff --git a/modules/dnn/src/vkcom/include/tensor.hpp b/modules/dnn/src/vkcom/include/tensor.hpp new file mode 100644 index 0000000000..d8ed9a20a0 --- /dev/null +++ b/modules/dnn/src/vkcom/include/tensor.hpp @@ -0,0 +1,59 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_TENSOR_HPP +#define OPENCV_DNN_VKCOM_TENSOR_HPP + +#ifdef HAVE_VULKAN +#include +#endif +#include +#include "vkcom.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +class Buffer; + +class Tensor +{ +public: + Tensor(Format fmt = kFormatFp32); + Tensor(const char* data, std::vector& shape, Format fmt = kFormatFp32); + void* map(); + void unMap(); + Shape getShape() const; + int dimSize(const int dim) const; + int dimNum() const; + int count(const int start_axis = 0, const int end_axis = -1) const; + + // Change shape and format to as passed in. + // Copy data if data != NULL + // Allocate new internal buffer if new size > old size or alloc flag is true + Tensor reshape(const char* data, const std::vector& shape, bool alloc = false, Format fmt = kFormatInvalid); + + void setTo(float val); + int getFormat() const; + size_t size() const { return size_in_byte_; } + bool isEmpty() { return size_in_byte_ == 0 ? true : false; } + void copyTo(Tensor& dst); + std::shared_ptr getBuffer() { return buffer_; } + +private: + VkDevice device_; + std::vector shape_; + size_t size_in_byte_; + std::shared_ptr buffer_; + Format format_; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_TENSOR_HPP diff --git a/modules/dnn/src/vkcom/include/vkcom.hpp b/modules/dnn/src/vkcom/include/vkcom.hpp new file mode 100644 index 0000000000..252b00b153 --- /dev/null +++ b/modules/dnn/src/vkcom/include/vkcom.hpp @@ -0,0 +1,63 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_HPP +#define OPENCV_DNN_VKCOM_HPP + +#include + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +enum Format{ + kFormatInvalid = -1, + kFormatFp16, + kFormatFp32, + kFormatFp64, + kFormatInt32, + kFormatNum +}; + +enum OpType { + kOpTypeConv, + kOpTypePool, + kOpTypeDWConv, + kOpTypeLRN, + kOpTypeConcat, + kOpTypeSoftmax, + kOpTypeReLU, + kOpTypePriorBox, + kOpTypePermute, + kOpTypeNum +}; +enum PaddingMode { kPaddingModeSame, kPaddingModeValid, kPaddingModeCaffe, kPaddingModeNum }; +enum FusedActivationType { kNone, kRelu, kRelu1, kRelu6, kActivationNum }; +typedef std::vector Shape; + +/* context APIs */ +bool initPerThread(); +void deinitPerThread(); +bool isAvailable(); + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#include "tensor.hpp" +#include "buffer.hpp" +#include "op_base.hpp" +#include "op_concat.hpp" +#include "op_conv.hpp" +#include "op_lrn.hpp" +#include "op_softmax.hpp" +#include "op_relu.hpp" +#include "op_pool.hpp" +#include "op_prior_box.hpp" +#include "op_permute.hpp" + +#endif // OPENCV_DNN_VKCOM_HPP diff --git a/modules/dnn/src/vkcom/shader/avg_pool.comp b/modules/dnn/src/vkcom/shader/avg_pool.comp new file mode 100644 index 0000000000..06ef06aaae --- /dev/null +++ b/modules/dnn/src/vkcom/shader/avg_pool.comp @@ -0,0 +1,69 @@ +#version 450 +#define LOCAL_SZ_X 256 +layout(push_constant) uniform pushBlock { + int channels; + int in_h; + int in_w; + int out_h; + int out_w; + int padding_h; + int padding_w; + int filter_h; + int filter_w; + int stride_h; + int stride_w; + int total; + int padded_area; +} p; + +layout(binding = 0) readonly buffer Input0{ + float in_buffer[]; +}; + +layout(binding = 1) writeonly buffer Output{ + float out_buffer[]; +}; + +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; + +void main() +{ + int global_size = int(gl_WorkGroupSize.x * gl_NumWorkGroups.x); + int gid = int(gl_GlobalInvocationID.x); + for (int index = gid; index < p.total; index += global_size) + { + const int pw = index % p.out_w; + const int ph = (index / p.out_w) % p.out_h; + const int c = (index / p.out_w / p.out_h) % p.channels; + const int n = index / p.out_w / p.out_h / p.channels; + int hstart = ph * p.stride_h - p.padding_h; + int wstart = pw * p.stride_w - p.padding_w; + int hend = min(hstart + p.filter_h, p.in_h + p.padding_h); + int wend = min(wstart + p.filter_w, p.in_w + p.padding_w); + int pool_size; + if (p.padded_area == 1) + { + pool_size = (hend - hstart) * (wend - wstart); + hstart = max(hstart, 0); + wstart = max(wstart, 0); + hend = min(hend, p.in_h); + wend = min(wend, p.in_w); + } + else + { + hstart = max(hstart, 0); + wstart = max(wstart, 0); + hend = min(hend, p.in_h); + wend = min(wend, p.in_w); + pool_size = (hend - hstart) * (wend - wstart); + } + float aveval = 0; + int off = (n * p.channels + c) * p.in_h * p.in_w; + for (int h = hstart; h < hend; ++h) { + for (int w = wstart; w < wend; ++w) { + aveval += in_buffer[off + h * p.in_w + w]; + } + } + out_buffer[index] = aveval / pool_size; + } +} diff --git a/modules/dnn/src/vkcom/shader/avg_pool_spv.cpp b/modules/dnn/src/vkcom/shader/avg_pool_spv.cpp new file mode 100644 index 0000000000..f2a0a02ebe --- /dev/null +++ b/modules/dnn/src/vkcom/shader/avg_pool_spv.cpp @@ -0,0 +1,208 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int avg_pool_spv[1538] = { + 0x07230203,0x00010000,0x00080001,0x000000f5,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0007000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x00000015,0x00060010, + 0x00000004,0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2, + 0x00040005,0x00000004,0x6e69616d,0x00000000,0x00050005,0x00000008,0x626f6c67,0x735f6c61, + 0x00657a69,0x00070005,0x0000000d,0x4e5f6c67,0x6f576d75,0x72476b72,0x7370756f,0x00000000, + 0x00030005,0x00000014,0x00646967,0x00080005,0x00000015,0x475f6c67,0x61626f6c,0x766e496c, + 0x7461636f,0x496e6f69,0x00000044,0x00040005,0x00000019,0x65646e69,0x00000078,0x00050005, + 0x00000021,0x68737570,0x636f6c42,0x0000006b,0x00060006,0x00000021,0x00000000,0x6e616863, + 0x736c656e,0x00000000,0x00050006,0x00000021,0x00000001,0x685f6e69,0x00000000,0x00050006, + 0x00000021,0x00000002,0x775f6e69,0x00000000,0x00050006,0x00000021,0x00000003,0x5f74756f, + 0x00000068,0x00050006,0x00000021,0x00000004,0x5f74756f,0x00000077,0x00060006,0x00000021, + 0x00000005,0x64646170,0x5f676e69,0x00000068,0x00060006,0x00000021,0x00000006,0x64646170, + 0x5f676e69,0x00000077,0x00060006,0x00000021,0x00000007,0x746c6966,0x685f7265,0x00000000, + 0x00060006,0x00000021,0x00000008,0x746c6966,0x775f7265,0x00000000,0x00060006,0x00000021, + 0x00000009,0x69727473,0x685f6564,0x00000000,0x00060006,0x00000021,0x0000000a,0x69727473, + 0x775f6564,0x00000000,0x00050006,0x00000021,0x0000000b,0x61746f74,0x0000006c,0x00060006, + 0x00000021,0x0000000c,0x64646170,0x615f6465,0x00616572,0x00030005,0x00000023,0x00000070, + 0x00030005,0x0000002a,0x00007770,0x00030005,0x00000030,0x00006870,0x00030005,0x00000039, + 0x00000063,0x00030005,0x00000045,0x0000006e,0x00040005,0x00000050,0x61747368,0x00007472, + 0x00040005,0x0000005a,0x61747377,0x00007472,0x00040005,0x00000064,0x646e6568,0x00000000, + 0x00040005,0x00000071,0x646e6577,0x00000000,0x00050005,0x00000084,0x6c6f6f70,0x7a69735f, + 0x00000065,0x00040005,0x000000ae,0x76657661,0x00006c61,0x00030005,0x000000b0,0x0066666f, + 0x00030005,0x000000bd,0x00000068,0x00030005,0x000000c7,0x00000077,0x00040005,0x000000d2, + 0x75706e49,0x00003074,0x00060006,0x000000d2,0x00000000,0x625f6e69,0x65666675,0x00000072, + 0x00030005,0x000000d4,0x00000000,0x00040005,0x000000e7,0x7074754f,0x00007475,0x00060006, + 0x000000e7,0x00000000,0x5f74756f,0x66667562,0x00007265,0x00030005,0x000000e9,0x00000000, + 0x00040047,0x0000000d,0x0000000b,0x00000018,0x00040047,0x00000015,0x0000000b,0x0000001c, + 0x00050048,0x00000021,0x00000000,0x00000023,0x00000000,0x00050048,0x00000021,0x00000001, + 0x00000023,0x00000004,0x00050048,0x00000021,0x00000002,0x00000023,0x00000008,0x00050048, + 0x00000021,0x00000003,0x00000023,0x0000000c,0x00050048,0x00000021,0x00000004,0x00000023, + 0x00000010,0x00050048,0x00000021,0x00000005,0x00000023,0x00000014,0x00050048,0x00000021, + 0x00000006,0x00000023,0x00000018,0x00050048,0x00000021,0x00000007,0x00000023,0x0000001c, + 0x00050048,0x00000021,0x00000008,0x00000023,0x00000020,0x00050048,0x00000021,0x00000009, + 0x00000023,0x00000024,0x00050048,0x00000021,0x0000000a,0x00000023,0x00000028,0x00050048, + 0x00000021,0x0000000b,0x00000023,0x0000002c,0x00050048,0x00000021,0x0000000c,0x00000023, + 0x00000030,0x00030047,0x00000021,0x00000002,0x00040047,0x000000d1,0x00000006,0x00000004, + 0x00040048,0x000000d2,0x00000000,0x00000018,0x00050048,0x000000d2,0x00000000,0x00000023, + 0x00000000,0x00030047,0x000000d2,0x00000003,0x00040047,0x000000d4,0x00000022,0x00000000, + 0x00040047,0x000000d4,0x00000021,0x00000000,0x00040047,0x000000e6,0x00000006,0x00000004, + 0x00040048,0x000000e7,0x00000000,0x00000019,0x00050048,0x000000e7,0x00000000,0x00000023, + 0x00000000,0x00030047,0x000000e7,0x00000003,0x00040047,0x000000e9,0x00000022,0x00000000, + 0x00040047,0x000000e9,0x00000021,0x00000001,0x00040047,0x000000f4,0x0000000b,0x00000019, + 0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00040015,0x00000006,0x00000020, + 0x00000001,0x00040020,0x00000007,0x00000007,0x00000006,0x00040015,0x00000009,0x00000020, + 0x00000000,0x0004002b,0x00000009,0x0000000a,0x00000100,0x00040017,0x0000000b,0x00000009, + 0x00000003,0x00040020,0x0000000c,0x00000001,0x0000000b,0x0004003b,0x0000000c,0x0000000d, + 0x00000001,0x0004002b,0x00000009,0x0000000e,0x00000000,0x00040020,0x0000000f,0x00000001, + 0x00000009,0x0004003b,0x0000000c,0x00000015,0x00000001,0x000f001e,0x00000021,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00040020,0x00000022,0x00000009,0x00000021, + 0x0004003b,0x00000022,0x00000023,0x00000009,0x0004002b,0x00000006,0x00000024,0x0000000b, + 0x00040020,0x00000025,0x00000009,0x00000006,0x00020014,0x00000028,0x0004002b,0x00000006, + 0x0000002c,0x00000004,0x0004002b,0x00000006,0x00000035,0x00000003,0x0004002b,0x00000006, + 0x00000041,0x00000000,0x0004002b,0x00000006,0x00000052,0x00000009,0x0004002b,0x00000006, + 0x00000056,0x00000005,0x0004002b,0x00000006,0x0000005c,0x0000000a,0x0004002b,0x00000006, + 0x00000060,0x00000006,0x0004002b,0x00000006,0x00000066,0x00000007,0x0004002b,0x00000006, + 0x0000006a,0x00000001,0x0004002b,0x00000006,0x00000073,0x00000008,0x0004002b,0x00000006, + 0x00000077,0x00000002,0x0004002b,0x00000006,0x0000007e,0x0000000c,0x00030016,0x000000ac, + 0x00000020,0x00040020,0x000000ad,0x00000007,0x000000ac,0x0004002b,0x000000ac,0x000000af, + 0x00000000,0x0003001d,0x000000d1,0x000000ac,0x0003001e,0x000000d2,0x000000d1,0x00040020, + 0x000000d3,0x00000002,0x000000d2,0x0004003b,0x000000d3,0x000000d4,0x00000002,0x00040020, + 0x000000dd,0x00000002,0x000000ac,0x0003001d,0x000000e6,0x000000ac,0x0003001e,0x000000e7, + 0x000000e6,0x00040020,0x000000e8,0x00000002,0x000000e7,0x0004003b,0x000000e8,0x000000e9, + 0x00000002,0x0004002b,0x00000009,0x000000f3,0x00000001,0x0006002c,0x0000000b,0x000000f4, + 0x0000000a,0x000000f3,0x000000f3,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003, + 0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008,0x00000007,0x0004003b,0x00000007, + 0x00000014,0x00000007,0x0004003b,0x00000007,0x00000019,0x00000007,0x0004003b,0x00000007, + 0x0000002a,0x00000007,0x0004003b,0x00000007,0x00000030,0x00000007,0x0004003b,0x00000007, + 0x00000039,0x00000007,0x0004003b,0x00000007,0x00000045,0x00000007,0x0004003b,0x00000007, + 0x00000050,0x00000007,0x0004003b,0x00000007,0x0000005a,0x00000007,0x0004003b,0x00000007, + 0x00000064,0x00000007,0x0004003b,0x00000007,0x00000071,0x00000007,0x0004003b,0x00000007, + 0x00000084,0x00000007,0x0004003b,0x000000ad,0x000000ae,0x00000007,0x0004003b,0x00000007, + 0x000000b0,0x00000007,0x0004003b,0x00000007,0x000000bd,0x00000007,0x0004003b,0x00000007, + 0x000000c7,0x00000007,0x00050041,0x0000000f,0x00000010,0x0000000d,0x0000000e,0x0004003d, + 0x00000009,0x00000011,0x00000010,0x00050084,0x00000009,0x00000012,0x0000000a,0x00000011, + 0x0004007c,0x00000006,0x00000013,0x00000012,0x0003003e,0x00000008,0x00000013,0x00050041, + 0x0000000f,0x00000016,0x00000015,0x0000000e,0x0004003d,0x00000009,0x00000017,0x00000016, + 0x0004007c,0x00000006,0x00000018,0x00000017,0x0003003e,0x00000014,0x00000018,0x0004003d, + 0x00000006,0x0000001a,0x00000014,0x0003003e,0x00000019,0x0000001a,0x000200f9,0x0000001b, + 0x000200f8,0x0000001b,0x000400f6,0x0000001d,0x0000001e,0x00000000,0x000200f9,0x0000001f, + 0x000200f8,0x0000001f,0x0004003d,0x00000006,0x00000020,0x00000019,0x00050041,0x00000025, + 0x00000026,0x00000023,0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026,0x000500b1, + 0x00000028,0x00000029,0x00000020,0x00000027,0x000400fa,0x00000029,0x0000001c,0x0000001d, + 0x000200f8,0x0000001c,0x0004003d,0x00000006,0x0000002b,0x00000019,0x00050041,0x00000025, + 0x0000002d,0x00000023,0x0000002c,0x0004003d,0x00000006,0x0000002e,0x0000002d,0x0005008b, + 0x00000006,0x0000002f,0x0000002b,0x0000002e,0x0003003e,0x0000002a,0x0000002f,0x0004003d, + 0x00000006,0x00000031,0x00000019,0x00050041,0x00000025,0x00000032,0x00000023,0x0000002c, + 0x0004003d,0x00000006,0x00000033,0x00000032,0x00050087,0x00000006,0x00000034,0x00000031, + 0x00000033,0x00050041,0x00000025,0x00000036,0x00000023,0x00000035,0x0004003d,0x00000006, + 0x00000037,0x00000036,0x0005008b,0x00000006,0x00000038,0x00000034,0x00000037,0x0003003e, + 0x00000030,0x00000038,0x0004003d,0x00000006,0x0000003a,0x00000019,0x00050041,0x00000025, + 0x0000003b,0x00000023,0x0000002c,0x0004003d,0x00000006,0x0000003c,0x0000003b,0x00050087, + 0x00000006,0x0000003d,0x0000003a,0x0000003c,0x00050041,0x00000025,0x0000003e,0x00000023, + 0x00000035,0x0004003d,0x00000006,0x0000003f,0x0000003e,0x00050087,0x00000006,0x00000040, + 0x0000003d,0x0000003f,0x00050041,0x00000025,0x00000042,0x00000023,0x00000041,0x0004003d, + 0x00000006,0x00000043,0x00000042,0x0005008b,0x00000006,0x00000044,0x00000040,0x00000043, + 0x0003003e,0x00000039,0x00000044,0x0004003d,0x00000006,0x00000046,0x00000019,0x00050041, + 0x00000025,0x00000047,0x00000023,0x0000002c,0x0004003d,0x00000006,0x00000048,0x00000047, + 0x00050087,0x00000006,0x00000049,0x00000046,0x00000048,0x00050041,0x00000025,0x0000004a, + 0x00000023,0x00000035,0x0004003d,0x00000006,0x0000004b,0x0000004a,0x00050087,0x00000006, + 0x0000004c,0x00000049,0x0000004b,0x00050041,0x00000025,0x0000004d,0x00000023,0x00000041, + 0x0004003d,0x00000006,0x0000004e,0x0000004d,0x00050087,0x00000006,0x0000004f,0x0000004c, + 0x0000004e,0x0003003e,0x00000045,0x0000004f,0x0004003d,0x00000006,0x00000051,0x00000030, + 0x00050041,0x00000025,0x00000053,0x00000023,0x00000052,0x0004003d,0x00000006,0x00000054, + 0x00000053,0x00050084,0x00000006,0x00000055,0x00000051,0x00000054,0x00050041,0x00000025, + 0x00000057,0x00000023,0x00000056,0x0004003d,0x00000006,0x00000058,0x00000057,0x00050082, + 0x00000006,0x00000059,0x00000055,0x00000058,0x0003003e,0x00000050,0x00000059,0x0004003d, + 0x00000006,0x0000005b,0x0000002a,0x00050041,0x00000025,0x0000005d,0x00000023,0x0000005c, + 0x0004003d,0x00000006,0x0000005e,0x0000005d,0x00050084,0x00000006,0x0000005f,0x0000005b, + 0x0000005e,0x00050041,0x00000025,0x00000061,0x00000023,0x00000060,0x0004003d,0x00000006, + 0x00000062,0x00000061,0x00050082,0x00000006,0x00000063,0x0000005f,0x00000062,0x0003003e, + 0x0000005a,0x00000063,0x0004003d,0x00000006,0x00000065,0x00000050,0x00050041,0x00000025, + 0x00000067,0x00000023,0x00000066,0x0004003d,0x00000006,0x00000068,0x00000067,0x00050080, + 0x00000006,0x00000069,0x00000065,0x00000068,0x00050041,0x00000025,0x0000006b,0x00000023, + 0x0000006a,0x0004003d,0x00000006,0x0000006c,0x0000006b,0x00050041,0x00000025,0x0000006d, + 0x00000023,0x00000056,0x0004003d,0x00000006,0x0000006e,0x0000006d,0x00050080,0x00000006, + 0x0000006f,0x0000006c,0x0000006e,0x0007000c,0x00000006,0x00000070,0x00000001,0x00000027, + 0x00000069,0x0000006f,0x0003003e,0x00000064,0x00000070,0x0004003d,0x00000006,0x00000072, + 0x0000005a,0x00050041,0x00000025,0x00000074,0x00000023,0x00000073,0x0004003d,0x00000006, + 0x00000075,0x00000074,0x00050080,0x00000006,0x00000076,0x00000072,0x00000075,0x00050041, + 0x00000025,0x00000078,0x00000023,0x00000077,0x0004003d,0x00000006,0x00000079,0x00000078, + 0x00050041,0x00000025,0x0000007a,0x00000023,0x00000060,0x0004003d,0x00000006,0x0000007b, + 0x0000007a,0x00050080,0x00000006,0x0000007c,0x00000079,0x0000007b,0x0007000c,0x00000006, + 0x0000007d,0x00000001,0x00000027,0x00000076,0x0000007c,0x0003003e,0x00000071,0x0000007d, + 0x00050041,0x00000025,0x0000007f,0x00000023,0x0000007e,0x0004003d,0x00000006,0x00000080, + 0x0000007f,0x000500aa,0x00000028,0x00000081,0x00000080,0x0000006a,0x000300f7,0x00000083, + 0x00000000,0x000400fa,0x00000081,0x00000082,0x00000098,0x000200f8,0x00000082,0x0004003d, + 0x00000006,0x00000085,0x00000064,0x0004003d,0x00000006,0x00000086,0x00000050,0x00050082, + 0x00000006,0x00000087,0x00000085,0x00000086,0x0004003d,0x00000006,0x00000088,0x00000071, + 0x0004003d,0x00000006,0x00000089,0x0000005a,0x00050082,0x00000006,0x0000008a,0x00000088, + 0x00000089,0x00050084,0x00000006,0x0000008b,0x00000087,0x0000008a,0x0003003e,0x00000084, + 0x0000008b,0x0004003d,0x00000006,0x0000008c,0x00000050,0x0007000c,0x00000006,0x0000008d, + 0x00000001,0x0000002a,0x0000008c,0x00000041,0x0003003e,0x00000050,0x0000008d,0x0004003d, + 0x00000006,0x0000008e,0x0000005a,0x0007000c,0x00000006,0x0000008f,0x00000001,0x0000002a, + 0x0000008e,0x00000041,0x0003003e,0x0000005a,0x0000008f,0x0004003d,0x00000006,0x00000090, + 0x00000064,0x00050041,0x00000025,0x00000091,0x00000023,0x0000006a,0x0004003d,0x00000006, + 0x00000092,0x00000091,0x0007000c,0x00000006,0x00000093,0x00000001,0x00000027,0x00000090, + 0x00000092,0x0003003e,0x00000064,0x00000093,0x0004003d,0x00000006,0x00000094,0x00000071, + 0x00050041,0x00000025,0x00000095,0x00000023,0x00000077,0x0004003d,0x00000006,0x00000096, + 0x00000095,0x0007000c,0x00000006,0x00000097,0x00000001,0x00000027,0x00000094,0x00000096, + 0x0003003e,0x00000071,0x00000097,0x000200f9,0x00000083,0x000200f8,0x00000098,0x0004003d, + 0x00000006,0x00000099,0x00000050,0x0007000c,0x00000006,0x0000009a,0x00000001,0x0000002a, + 0x00000099,0x00000041,0x0003003e,0x00000050,0x0000009a,0x0004003d,0x00000006,0x0000009b, + 0x0000005a,0x0007000c,0x00000006,0x0000009c,0x00000001,0x0000002a,0x0000009b,0x00000041, + 0x0003003e,0x0000005a,0x0000009c,0x0004003d,0x00000006,0x0000009d,0x00000064,0x00050041, + 0x00000025,0x0000009e,0x00000023,0x0000006a,0x0004003d,0x00000006,0x0000009f,0x0000009e, + 0x0007000c,0x00000006,0x000000a0,0x00000001,0x00000027,0x0000009d,0x0000009f,0x0003003e, + 0x00000064,0x000000a0,0x0004003d,0x00000006,0x000000a1,0x00000071,0x00050041,0x00000025, + 0x000000a2,0x00000023,0x00000077,0x0004003d,0x00000006,0x000000a3,0x000000a2,0x0007000c, + 0x00000006,0x000000a4,0x00000001,0x00000027,0x000000a1,0x000000a3,0x0003003e,0x00000071, + 0x000000a4,0x0004003d,0x00000006,0x000000a5,0x00000064,0x0004003d,0x00000006,0x000000a6, + 0x00000050,0x00050082,0x00000006,0x000000a7,0x000000a5,0x000000a6,0x0004003d,0x00000006, + 0x000000a8,0x00000071,0x0004003d,0x00000006,0x000000a9,0x0000005a,0x00050082,0x00000006, + 0x000000aa,0x000000a8,0x000000a9,0x00050084,0x00000006,0x000000ab,0x000000a7,0x000000aa, + 0x0003003e,0x00000084,0x000000ab,0x000200f9,0x00000083,0x000200f8,0x00000083,0x0003003e, + 0x000000ae,0x000000af,0x0004003d,0x00000006,0x000000b1,0x00000045,0x00050041,0x00000025, + 0x000000b2,0x00000023,0x00000041,0x0004003d,0x00000006,0x000000b3,0x000000b2,0x00050084, + 0x00000006,0x000000b4,0x000000b1,0x000000b3,0x0004003d,0x00000006,0x000000b5,0x00000039, + 0x00050080,0x00000006,0x000000b6,0x000000b4,0x000000b5,0x00050041,0x00000025,0x000000b7, + 0x00000023,0x0000006a,0x0004003d,0x00000006,0x000000b8,0x000000b7,0x00050084,0x00000006, + 0x000000b9,0x000000b6,0x000000b8,0x00050041,0x00000025,0x000000ba,0x00000023,0x00000077, + 0x0004003d,0x00000006,0x000000bb,0x000000ba,0x00050084,0x00000006,0x000000bc,0x000000b9, + 0x000000bb,0x0003003e,0x000000b0,0x000000bc,0x0004003d,0x00000006,0x000000be,0x00000050, + 0x0003003e,0x000000bd,0x000000be,0x000200f9,0x000000bf,0x000200f8,0x000000bf,0x000400f6, + 0x000000c1,0x000000c2,0x00000000,0x000200f9,0x000000c3,0x000200f8,0x000000c3,0x0004003d, + 0x00000006,0x000000c4,0x000000bd,0x0004003d,0x00000006,0x000000c5,0x00000064,0x000500b1, + 0x00000028,0x000000c6,0x000000c4,0x000000c5,0x000400fa,0x000000c6,0x000000c0,0x000000c1, + 0x000200f8,0x000000c0,0x0004003d,0x00000006,0x000000c8,0x0000005a,0x0003003e,0x000000c7, + 0x000000c8,0x000200f9,0x000000c9,0x000200f8,0x000000c9,0x000400f6,0x000000cb,0x000000cc, + 0x00000000,0x000200f9,0x000000cd,0x000200f8,0x000000cd,0x0004003d,0x00000006,0x000000ce, + 0x000000c7,0x0004003d,0x00000006,0x000000cf,0x00000071,0x000500b1,0x00000028,0x000000d0, + 0x000000ce,0x000000cf,0x000400fa,0x000000d0,0x000000ca,0x000000cb,0x000200f8,0x000000ca, + 0x0004003d,0x00000006,0x000000d5,0x000000b0,0x0004003d,0x00000006,0x000000d6,0x000000bd, + 0x00050041,0x00000025,0x000000d7,0x00000023,0x00000077,0x0004003d,0x00000006,0x000000d8, + 0x000000d7,0x00050084,0x00000006,0x000000d9,0x000000d6,0x000000d8,0x00050080,0x00000006, + 0x000000da,0x000000d5,0x000000d9,0x0004003d,0x00000006,0x000000db,0x000000c7,0x00050080, + 0x00000006,0x000000dc,0x000000da,0x000000db,0x00060041,0x000000dd,0x000000de,0x000000d4, + 0x00000041,0x000000dc,0x0004003d,0x000000ac,0x000000df,0x000000de,0x0004003d,0x000000ac, + 0x000000e0,0x000000ae,0x00050081,0x000000ac,0x000000e1,0x000000e0,0x000000df,0x0003003e, + 0x000000ae,0x000000e1,0x000200f9,0x000000cc,0x000200f8,0x000000cc,0x0004003d,0x00000006, + 0x000000e2,0x000000c7,0x00050080,0x00000006,0x000000e3,0x000000e2,0x0000006a,0x0003003e, + 0x000000c7,0x000000e3,0x000200f9,0x000000c9,0x000200f8,0x000000cb,0x000200f9,0x000000c2, + 0x000200f8,0x000000c2,0x0004003d,0x00000006,0x000000e4,0x000000bd,0x00050080,0x00000006, + 0x000000e5,0x000000e4,0x0000006a,0x0003003e,0x000000bd,0x000000e5,0x000200f9,0x000000bf, + 0x000200f8,0x000000c1,0x0004003d,0x00000006,0x000000ea,0x00000019,0x0004003d,0x000000ac, + 0x000000eb,0x000000ae,0x0004003d,0x00000006,0x000000ec,0x00000084,0x0004006f,0x000000ac, + 0x000000ed,0x000000ec,0x00050088,0x000000ac,0x000000ee,0x000000eb,0x000000ed,0x00060041, + 0x000000dd,0x000000ef,0x000000e9,0x00000041,0x000000ea,0x0003003e,0x000000ef,0x000000ee, + 0x000200f9,0x0000001e,0x000200f8,0x0000001e,0x0004003d,0x00000006,0x000000f0,0x00000008, + 0x0004003d,0x00000006,0x000000f1,0x00000019,0x00050080,0x00000006,0x000000f2,0x000000f1, + 0x000000f0,0x0003003e,0x00000019,0x000000f2,0x000200f9,0x0000001b,0x000200f8,0x0000001d, + 0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/concat.comp b/modules/dnn/src/vkcom/shader/concat.comp new file mode 100644 index 0000000000..2957a3b71d --- /dev/null +++ b/modules/dnn/src/vkcom/shader/concat.comp @@ -0,0 +1,29 @@ +#version 450 +#define LOCAL_SZ_X 256 + +layout(push_constant) uniform pushBlock { + int out_concat_axis; + int accumulated_concat_axis; + int concat_size; + int total_concat_size; + int thread_num; +} p; + +layout(binding = 0) readonly buffer Input0{ + float data[]; +} src; +layout(binding = 1) writeonly buffer Output{ + float data[]; +} dst; +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; +void main() +{ + int index = int(gl_GlobalInvocationID.x); + if (index < p.thread_num) + { + int concat_num = index / p.total_concat_size; + int concat_index = index % p.total_concat_size; + int out_index = concat_index + (concat_num * p.out_concat_axis + p.accumulated_concat_axis) * p.concat_size; + dst.data[out_index] = src.data[index]; + } +} diff --git a/modules/dnn/src/vkcom/shader/concat_spv.cpp b/modules/dnn/src/vkcom/shader/concat_spv.cpp new file mode 100644 index 0000000000..7ef7ea786b --- /dev/null +++ b/modules/dnn/src/vkcom/shader/concat_spv.cpp @@ -0,0 +1,83 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int concat_spv[541] = { + 0x07230203,0x00010000,0x00080001,0x0000004b,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00060010,0x00000004, + 0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00040005,0x00000008,0x65646e69,0x00000078,0x00080005, + 0x0000000c,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00050005, + 0x00000013,0x68737570,0x636f6c42,0x0000006b,0x00070006,0x00000013,0x00000000,0x5f74756f, + 0x636e6f63,0x615f7461,0x00736978,0x00090006,0x00000013,0x00000001,0x75636361,0x616c756d, + 0x5f646574,0x636e6f63,0x615f7461,0x00736978,0x00060006,0x00000013,0x00000002,0x636e6f63, + 0x735f7461,0x00657a69,0x00080006,0x00000013,0x00000003,0x61746f74,0x6f635f6c,0x7461636e, + 0x7a69735f,0x00000065,0x00060006,0x00000013,0x00000004,0x65726874,0x6e5f6461,0x00006d75, + 0x00030005,0x00000015,0x00000070,0x00050005,0x0000001e,0x636e6f63,0x6e5f7461,0x00006d75, + 0x00060005,0x00000024,0x636e6f63,0x695f7461,0x7865646e,0x00000000,0x00050005,0x00000029, + 0x5f74756f,0x65646e69,0x00000078,0x00040005,0x0000003b,0x7074754f,0x00007475,0x00050006, + 0x0000003b,0x00000000,0x61746164,0x00000000,0x00030005,0x0000003d,0x00747364,0x00040005, + 0x00000040,0x75706e49,0x00003074,0x00050006,0x00000040,0x00000000,0x61746164,0x00000000, + 0x00030005,0x00000042,0x00637273,0x00040047,0x0000000c,0x0000000b,0x0000001c,0x00050048, + 0x00000013,0x00000000,0x00000023,0x00000000,0x00050048,0x00000013,0x00000001,0x00000023, + 0x00000004,0x00050048,0x00000013,0x00000002,0x00000023,0x00000008,0x00050048,0x00000013, + 0x00000003,0x00000023,0x0000000c,0x00050048,0x00000013,0x00000004,0x00000023,0x00000010, + 0x00030047,0x00000013,0x00000002,0x00040047,0x0000003a,0x00000006,0x00000004,0x00040048, + 0x0000003b,0x00000000,0x00000019,0x00050048,0x0000003b,0x00000000,0x00000023,0x00000000, + 0x00030047,0x0000003b,0x00000003,0x00040047,0x0000003d,0x00000022,0x00000000,0x00040047, + 0x0000003d,0x00000021,0x00000001,0x00040047,0x0000003f,0x00000006,0x00000004,0x00040048, + 0x00000040,0x00000000,0x00000018,0x00050048,0x00000040,0x00000000,0x00000023,0x00000000, + 0x00030047,0x00000040,0x00000003,0x00040047,0x00000042,0x00000022,0x00000000,0x00040047, + 0x00000042,0x00000021,0x00000000,0x00040047,0x0000004a,0x0000000b,0x00000019,0x00020013, + 0x00000002,0x00030021,0x00000003,0x00000002,0x00040015,0x00000006,0x00000020,0x00000001, + 0x00040020,0x00000007,0x00000007,0x00000006,0x00040015,0x00000009,0x00000020,0x00000000, + 0x00040017,0x0000000a,0x00000009,0x00000003,0x00040020,0x0000000b,0x00000001,0x0000000a, + 0x0004003b,0x0000000b,0x0000000c,0x00000001,0x0004002b,0x00000009,0x0000000d,0x00000000, + 0x00040020,0x0000000e,0x00000001,0x00000009,0x0007001e,0x00000013,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00040020,0x00000014,0x00000009,0x00000013,0x0004003b, + 0x00000014,0x00000015,0x00000009,0x0004002b,0x00000006,0x00000016,0x00000004,0x00040020, + 0x00000017,0x00000009,0x00000006,0x00020014,0x0000001a,0x0004002b,0x00000006,0x00000020, + 0x00000003,0x0004002b,0x00000006,0x0000002c,0x00000000,0x0004002b,0x00000006,0x00000030, + 0x00000001,0x0004002b,0x00000006,0x00000034,0x00000002,0x00030016,0x00000039,0x00000020, + 0x0003001d,0x0000003a,0x00000039,0x0003001e,0x0000003b,0x0000003a,0x00040020,0x0000003c, + 0x00000002,0x0000003b,0x0004003b,0x0000003c,0x0000003d,0x00000002,0x0003001d,0x0000003f, + 0x00000039,0x0003001e,0x00000040,0x0000003f,0x00040020,0x00000041,0x00000002,0x00000040, + 0x0004003b,0x00000041,0x00000042,0x00000002,0x00040020,0x00000044,0x00000002,0x00000039, + 0x0004002b,0x00000009,0x00000048,0x00000100,0x0004002b,0x00000009,0x00000049,0x00000001, + 0x0006002c,0x0000000a,0x0000004a,0x00000048,0x00000049,0x00000049,0x00050036,0x00000002, + 0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008, + 0x00000007,0x0004003b,0x00000007,0x0000001e,0x00000007,0x0004003b,0x00000007,0x00000024, + 0x00000007,0x0004003b,0x00000007,0x00000029,0x00000007,0x00050041,0x0000000e,0x0000000f, + 0x0000000c,0x0000000d,0x0004003d,0x00000009,0x00000010,0x0000000f,0x0004007c,0x00000006, + 0x00000011,0x00000010,0x0003003e,0x00000008,0x00000011,0x0004003d,0x00000006,0x00000012, + 0x00000008,0x00050041,0x00000017,0x00000018,0x00000015,0x00000016,0x0004003d,0x00000006, + 0x00000019,0x00000018,0x000500b1,0x0000001a,0x0000001b,0x00000012,0x00000019,0x000300f7, + 0x0000001d,0x00000000,0x000400fa,0x0000001b,0x0000001c,0x0000001d,0x000200f8,0x0000001c, + 0x0004003d,0x00000006,0x0000001f,0x00000008,0x00050041,0x00000017,0x00000021,0x00000015, + 0x00000020,0x0004003d,0x00000006,0x00000022,0x00000021,0x00050087,0x00000006,0x00000023, + 0x0000001f,0x00000022,0x0003003e,0x0000001e,0x00000023,0x0004003d,0x00000006,0x00000025, + 0x00000008,0x00050041,0x00000017,0x00000026,0x00000015,0x00000020,0x0004003d,0x00000006, + 0x00000027,0x00000026,0x0005008b,0x00000006,0x00000028,0x00000025,0x00000027,0x0003003e, + 0x00000024,0x00000028,0x0004003d,0x00000006,0x0000002a,0x00000024,0x0004003d,0x00000006, + 0x0000002b,0x0000001e,0x00050041,0x00000017,0x0000002d,0x00000015,0x0000002c,0x0004003d, + 0x00000006,0x0000002e,0x0000002d,0x00050084,0x00000006,0x0000002f,0x0000002b,0x0000002e, + 0x00050041,0x00000017,0x00000031,0x00000015,0x00000030,0x0004003d,0x00000006,0x00000032, + 0x00000031,0x00050080,0x00000006,0x00000033,0x0000002f,0x00000032,0x00050041,0x00000017, + 0x00000035,0x00000015,0x00000034,0x0004003d,0x00000006,0x00000036,0x00000035,0x00050084, + 0x00000006,0x00000037,0x00000033,0x00000036,0x00050080,0x00000006,0x00000038,0x0000002a, + 0x00000037,0x0003003e,0x00000029,0x00000038,0x0004003d,0x00000006,0x0000003e,0x00000029, + 0x0004003d,0x00000006,0x00000043,0x00000008,0x00060041,0x00000044,0x00000045,0x00000042, + 0x0000002c,0x00000043,0x0004003d,0x00000039,0x00000046,0x00000045,0x00060041,0x00000044, + 0x00000047,0x0000003d,0x0000002c,0x0000003e,0x0003003e,0x00000047,0x00000046,0x000200f9, + 0x0000001d,0x000200f8,0x0000001d,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/conv.comp b/modules/dnn/src/vkcom/shader/conv.comp new file mode 100644 index 0000000000..50b13a198b --- /dev/null +++ b/modules/dnn/src/vkcom/shader/conv.comp @@ -0,0 +1,73 @@ +#version 450 +#define LOCAL_SZ_X 256 +layout(binding = 0) readonly buffer Input0{ + float image_data[]; +}; +layout(binding = 1) readonly buffer Input1 { + float bias_data[]; +}; +layout(binding = 2) readonly buffer Input3{ + float weight_data[]; +}; +layout(binding = 3) writeonly buffer Output{ + float convolved_image_data[]; +}; + +layout(push_constant) uniform pushBlock { + int in_h; + int in_w; + int out_h; + int out_w; + int stride_h; + int stride_w; + int pad_h; + int pad_w; + int filter_h; + int filter_w; + int dilation_h; + int dilation_w; + int channels; + int batch; + int has_bias; + int M; + int K; + int N; +} p; + +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; +void main() +{ + int gx = int(gl_GlobalInvocationID.x); + int gy = int(gl_GlobalInvocationID.y); + int gz = int(gl_GlobalInvocationID.z); + if(gx < p.M && gy < p.N && gz < p.batch) + { + float sum = 0.0f; + int output_y = gx / p.out_w; + int output_x = gx % p.out_w; + int org_y = output_y * p.stride_h - p.pad_h; + int org_x = output_x * p.stride_w - p.pad_w; + int weight_off = gy * p.K; + int input_off = gz * p.in_h * p.in_w * p.channels + (org_y * p.in_w + org_x); + for(int c = 0; c < p.channels; c++) + { + for(int y = 0; y < p.filter_h; y++) + { + for(int x = 0; x < p.filter_w; x++) + { + if((org_y + y * p.dilation_h >= 0) && (org_y + y * p.dilation_h < p.in_h) && (org_x + x * p.dilation_w >= 0) && (org_x + x * p.dilation_w < p.in_w)) + { + sum += image_data[input_off + x * p.dilation_w] * weight_data[weight_off + x]; + } + } + input_off += p.in_w * p.dilation_h; + weight_off += p.filter_w; + } + input_off += p.in_h * p.in_w - p.in_w * p.filter_h * p.dilation_h; + } + int offset = gz * p.M * p.N + gx + gy * p.M; + if (p.has_bias == 1) + sum += bias_data[gy]; + convolved_image_data[offset] = sum; + } +} diff --git a/modules/dnn/src/vkcom/shader/conv_spv.cpp b/modules/dnn/src/vkcom/shader/conv_spv.cpp new file mode 100644 index 0000000000..830a9c0a87 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/conv_spv.cpp @@ -0,0 +1,248 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int conv_spv[1859] = { + 0x07230203,0x00010000,0x00080001,0x00000124,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00060010,0x00000004, + 0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00007867,0x00080005,0x0000000c, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00030005,0x00000012, + 0x00007967,0x00030005,0x00000017,0x00007a67,0x00050005,0x0000001e,0x68737570,0x636f6c42, + 0x0000006b,0x00050006,0x0000001e,0x00000000,0x685f6e69,0x00000000,0x00050006,0x0000001e, + 0x00000001,0x775f6e69,0x00000000,0x00050006,0x0000001e,0x00000002,0x5f74756f,0x00000068, + 0x00050006,0x0000001e,0x00000003,0x5f74756f,0x00000077,0x00060006,0x0000001e,0x00000004, + 0x69727473,0x685f6564,0x00000000,0x00060006,0x0000001e,0x00000005,0x69727473,0x775f6564, + 0x00000000,0x00050006,0x0000001e,0x00000006,0x5f646170,0x00000068,0x00050006,0x0000001e, + 0x00000007,0x5f646170,0x00000077,0x00060006,0x0000001e,0x00000008,0x746c6966,0x685f7265, + 0x00000000,0x00060006,0x0000001e,0x00000009,0x746c6966,0x775f7265,0x00000000,0x00060006, + 0x0000001e,0x0000000a,0x616c6964,0x6e6f6974,0x0000685f,0x00060006,0x0000001e,0x0000000b, + 0x616c6964,0x6e6f6974,0x0000775f,0x00060006,0x0000001e,0x0000000c,0x6e616863,0x736c656e, + 0x00000000,0x00050006,0x0000001e,0x0000000d,0x63746162,0x00000068,0x00060006,0x0000001e, + 0x0000000e,0x5f736168,0x73616962,0x00000000,0x00040006,0x0000001e,0x0000000f,0x0000004d, + 0x00040006,0x0000001e,0x00000010,0x0000004b,0x00040006,0x0000001e,0x00000011,0x0000004e, + 0x00030005,0x00000020,0x00000070,0x00030005,0x0000003a,0x006d7573,0x00050005,0x0000003c, + 0x7074756f,0x795f7475,0x00000000,0x00050005,0x00000042,0x7074756f,0x785f7475,0x00000000, + 0x00040005,0x00000047,0x5f67726f,0x00000079,0x00040005,0x00000051,0x5f67726f,0x00000078, + 0x00050005,0x0000005b,0x67696577,0x6f5f7468,0x00006666,0x00050005,0x00000061,0x75706e69, + 0x666f5f74,0x00000066,0x00030005,0x00000076,0x00000063,0x00030005,0x00000080,0x00000079, + 0x00030005,0x0000008b,0x00000078,0x00040005,0x000000c4,0x75706e49,0x00003074,0x00060006, + 0x000000c4,0x00000000,0x67616d69,0x61645f65,0x00006174,0x00030005,0x000000c6,0x00000000, + 0x00040005,0x000000d1,0x75706e49,0x00003374,0x00060006,0x000000d1,0x00000000,0x67696577, + 0x645f7468,0x00617461,0x00030005,0x000000d3,0x00000000,0x00040005,0x000000fd,0x7366666f, + 0x00007465,0x00040005,0x00000113,0x75706e49,0x00003174,0x00060006,0x00000113,0x00000000, + 0x73616962,0x7461645f,0x00000061,0x00030005,0x00000115,0x00000000,0x00040005,0x0000011c, + 0x7074754f,0x00007475,0x00090006,0x0000011c,0x00000000,0x766e6f63,0x65766c6f,0x6d695f64, + 0x5f656761,0x61746164,0x00000000,0x00030005,0x0000011e,0x00000000,0x00040047,0x0000000c, + 0x0000000b,0x0000001c,0x00050048,0x0000001e,0x00000000,0x00000023,0x00000000,0x00050048, + 0x0000001e,0x00000001,0x00000023,0x00000004,0x00050048,0x0000001e,0x00000002,0x00000023, + 0x00000008,0x00050048,0x0000001e,0x00000003,0x00000023,0x0000000c,0x00050048,0x0000001e, + 0x00000004,0x00000023,0x00000010,0x00050048,0x0000001e,0x00000005,0x00000023,0x00000014, + 0x00050048,0x0000001e,0x00000006,0x00000023,0x00000018,0x00050048,0x0000001e,0x00000007, + 0x00000023,0x0000001c,0x00050048,0x0000001e,0x00000008,0x00000023,0x00000020,0x00050048, + 0x0000001e,0x00000009,0x00000023,0x00000024,0x00050048,0x0000001e,0x0000000a,0x00000023, + 0x00000028,0x00050048,0x0000001e,0x0000000b,0x00000023,0x0000002c,0x00050048,0x0000001e, + 0x0000000c,0x00000023,0x00000030,0x00050048,0x0000001e,0x0000000d,0x00000023,0x00000034, + 0x00050048,0x0000001e,0x0000000e,0x00000023,0x00000038,0x00050048,0x0000001e,0x0000000f, + 0x00000023,0x0000003c,0x00050048,0x0000001e,0x00000010,0x00000023,0x00000040,0x00050048, + 0x0000001e,0x00000011,0x00000023,0x00000044,0x00030047,0x0000001e,0x00000002,0x00040047, + 0x000000c3,0x00000006,0x00000004,0x00040048,0x000000c4,0x00000000,0x00000018,0x00050048, + 0x000000c4,0x00000000,0x00000023,0x00000000,0x00030047,0x000000c4,0x00000003,0x00040047, + 0x000000c6,0x00000022,0x00000000,0x00040047,0x000000c6,0x00000021,0x00000000,0x00040047, + 0x000000d0,0x00000006,0x00000004,0x00040048,0x000000d1,0x00000000,0x00000018,0x00050048, + 0x000000d1,0x00000000,0x00000023,0x00000000,0x00030047,0x000000d1,0x00000003,0x00040047, + 0x000000d3,0x00000022,0x00000000,0x00040047,0x000000d3,0x00000021,0x00000002,0x00040047, + 0x00000112,0x00000006,0x00000004,0x00040048,0x00000113,0x00000000,0x00000018,0x00050048, + 0x00000113,0x00000000,0x00000023,0x00000000,0x00030047,0x00000113,0x00000003,0x00040047, + 0x00000115,0x00000022,0x00000000,0x00040047,0x00000115,0x00000021,0x00000001,0x00040047, + 0x0000011b,0x00000006,0x00000004,0x00040048,0x0000011c,0x00000000,0x00000019,0x00050048, + 0x0000011c,0x00000000,0x00000023,0x00000000,0x00030047,0x0000011c,0x00000003,0x00040047, + 0x0000011e,0x00000022,0x00000000,0x00040047,0x0000011e,0x00000021,0x00000003,0x00040047, + 0x00000123,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002, + 0x00040015,0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007,0x00000006, + 0x00040015,0x00000009,0x00000020,0x00000000,0x00040017,0x0000000a,0x00000009,0x00000003, + 0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,0x0000000c,0x00000001, + 0x0004002b,0x00000009,0x0000000d,0x00000000,0x00040020,0x0000000e,0x00000001,0x00000009, + 0x0004002b,0x00000009,0x00000013,0x00000001,0x0004002b,0x00000009,0x00000018,0x00000002, + 0x00020014,0x0000001c,0x0014001e,0x0000001e,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00040020,0x0000001f, + 0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009,0x0004002b,0x00000006, + 0x00000021,0x0000000f,0x00040020,0x00000022,0x00000009,0x00000006,0x0004002b,0x00000006, + 0x00000029,0x00000011,0x0004002b,0x00000006,0x00000031,0x0000000d,0x00030016,0x00000038, + 0x00000020,0x00040020,0x00000039,0x00000007,0x00000038,0x0004002b,0x00000038,0x0000003b, + 0x00000000,0x0004002b,0x00000006,0x0000003e,0x00000003,0x0004002b,0x00000006,0x00000049, + 0x00000004,0x0004002b,0x00000006,0x0000004d,0x00000006,0x0004002b,0x00000006,0x00000053, + 0x00000005,0x0004002b,0x00000006,0x00000057,0x00000007,0x0004002b,0x00000006,0x0000005d, + 0x00000010,0x0004002b,0x00000006,0x00000063,0x00000000,0x0004002b,0x00000006,0x00000067, + 0x00000001,0x0004002b,0x00000006,0x0000006b,0x0000000c,0x0004002b,0x00000006,0x00000087, + 0x00000008,0x0004002b,0x00000006,0x00000092,0x00000009,0x0004002b,0x00000006,0x00000098, + 0x0000000a,0x0004002b,0x00000006,0x000000ae,0x0000000b,0x0003001d,0x000000c3,0x00000038, + 0x0003001e,0x000000c4,0x000000c3,0x00040020,0x000000c5,0x00000002,0x000000c4,0x0004003b, + 0x000000c5,0x000000c6,0x00000002,0x00040020,0x000000cd,0x00000002,0x00000038,0x0003001d, + 0x000000d0,0x00000038,0x0003001e,0x000000d1,0x000000d0,0x00040020,0x000000d2,0x00000002, + 0x000000d1,0x0004003b,0x000000d2,0x000000d3,0x00000002,0x0004002b,0x00000006,0x0000010c, + 0x0000000e,0x0003001d,0x00000112,0x00000038,0x0003001e,0x00000113,0x00000112,0x00040020, + 0x00000114,0x00000002,0x00000113,0x0004003b,0x00000114,0x00000115,0x00000002,0x0003001d, + 0x0000011b,0x00000038,0x0003001e,0x0000011c,0x0000011b,0x00040020,0x0000011d,0x00000002, + 0x0000011c,0x0004003b,0x0000011d,0x0000011e,0x00000002,0x0004002b,0x00000009,0x00000122, + 0x00000100,0x0006002c,0x0000000a,0x00000123,0x00000122,0x00000013,0x00000013,0x00050036, + 0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007, + 0x00000008,0x00000007,0x0004003b,0x00000007,0x00000012,0x00000007,0x0004003b,0x00000007, + 0x00000017,0x00000007,0x0004003b,0x00000039,0x0000003a,0x00000007,0x0004003b,0x00000007, + 0x0000003c,0x00000007,0x0004003b,0x00000007,0x00000042,0x00000007,0x0004003b,0x00000007, + 0x00000047,0x00000007,0x0004003b,0x00000007,0x00000051,0x00000007,0x0004003b,0x00000007, + 0x0000005b,0x00000007,0x0004003b,0x00000007,0x00000061,0x00000007,0x0004003b,0x00000007, + 0x00000076,0x00000007,0x0004003b,0x00000007,0x00000080,0x00000007,0x0004003b,0x00000007, + 0x0000008b,0x00000007,0x0004003b,0x00000007,0x000000fd,0x00000007,0x00050041,0x0000000e, + 0x0000000f,0x0000000c,0x0000000d,0x0004003d,0x00000009,0x00000010,0x0000000f,0x0004007c, + 0x00000006,0x00000011,0x00000010,0x0003003e,0x00000008,0x00000011,0x00050041,0x0000000e, + 0x00000014,0x0000000c,0x00000013,0x0004003d,0x00000009,0x00000015,0x00000014,0x0004007c, + 0x00000006,0x00000016,0x00000015,0x0003003e,0x00000012,0x00000016,0x00050041,0x0000000e, + 0x00000019,0x0000000c,0x00000018,0x0004003d,0x00000009,0x0000001a,0x00000019,0x0004007c, + 0x00000006,0x0000001b,0x0000001a,0x0003003e,0x00000017,0x0000001b,0x0004003d,0x00000006, + 0x0000001d,0x00000008,0x00050041,0x00000022,0x00000023,0x00000020,0x00000021,0x0004003d, + 0x00000006,0x00000024,0x00000023,0x000500b1,0x0000001c,0x00000025,0x0000001d,0x00000024, + 0x000300f7,0x00000027,0x00000000,0x000400fa,0x00000025,0x00000026,0x00000027,0x000200f8, + 0x00000026,0x0004003d,0x00000006,0x00000028,0x00000012,0x00050041,0x00000022,0x0000002a, + 0x00000020,0x00000029,0x0004003d,0x00000006,0x0000002b,0x0000002a,0x000500b1,0x0000001c, + 0x0000002c,0x00000028,0x0000002b,0x000200f9,0x00000027,0x000200f8,0x00000027,0x000700f5, + 0x0000001c,0x0000002d,0x00000025,0x00000005,0x0000002c,0x00000026,0x000300f7,0x0000002f, + 0x00000000,0x000400fa,0x0000002d,0x0000002e,0x0000002f,0x000200f8,0x0000002e,0x0004003d, + 0x00000006,0x00000030,0x00000017,0x00050041,0x00000022,0x00000032,0x00000020,0x00000031, + 0x0004003d,0x00000006,0x00000033,0x00000032,0x000500b1,0x0000001c,0x00000034,0x00000030, + 0x00000033,0x000200f9,0x0000002f,0x000200f8,0x0000002f,0x000700f5,0x0000001c,0x00000035, + 0x0000002d,0x00000027,0x00000034,0x0000002e,0x000300f7,0x00000037,0x00000000,0x000400fa, + 0x00000035,0x00000036,0x00000037,0x000200f8,0x00000036,0x0003003e,0x0000003a,0x0000003b, + 0x0004003d,0x00000006,0x0000003d,0x00000008,0x00050041,0x00000022,0x0000003f,0x00000020, + 0x0000003e,0x0004003d,0x00000006,0x00000040,0x0000003f,0x00050087,0x00000006,0x00000041, + 0x0000003d,0x00000040,0x0003003e,0x0000003c,0x00000041,0x0004003d,0x00000006,0x00000043, + 0x00000008,0x00050041,0x00000022,0x00000044,0x00000020,0x0000003e,0x0004003d,0x00000006, + 0x00000045,0x00000044,0x0005008b,0x00000006,0x00000046,0x00000043,0x00000045,0x0003003e, + 0x00000042,0x00000046,0x0004003d,0x00000006,0x00000048,0x0000003c,0x00050041,0x00000022, + 0x0000004a,0x00000020,0x00000049,0x0004003d,0x00000006,0x0000004b,0x0000004a,0x00050084, + 0x00000006,0x0000004c,0x00000048,0x0000004b,0x00050041,0x00000022,0x0000004e,0x00000020, + 0x0000004d,0x0004003d,0x00000006,0x0000004f,0x0000004e,0x00050082,0x00000006,0x00000050, + 0x0000004c,0x0000004f,0x0003003e,0x00000047,0x00000050,0x0004003d,0x00000006,0x00000052, + 0x00000042,0x00050041,0x00000022,0x00000054,0x00000020,0x00000053,0x0004003d,0x00000006, + 0x00000055,0x00000054,0x00050084,0x00000006,0x00000056,0x00000052,0x00000055,0x00050041, + 0x00000022,0x00000058,0x00000020,0x00000057,0x0004003d,0x00000006,0x00000059,0x00000058, + 0x00050082,0x00000006,0x0000005a,0x00000056,0x00000059,0x0003003e,0x00000051,0x0000005a, + 0x0004003d,0x00000006,0x0000005c,0x00000012,0x00050041,0x00000022,0x0000005e,0x00000020, + 0x0000005d,0x0004003d,0x00000006,0x0000005f,0x0000005e,0x00050084,0x00000006,0x00000060, + 0x0000005c,0x0000005f,0x0003003e,0x0000005b,0x00000060,0x0004003d,0x00000006,0x00000062, + 0x00000017,0x00050041,0x00000022,0x00000064,0x00000020,0x00000063,0x0004003d,0x00000006, + 0x00000065,0x00000064,0x00050084,0x00000006,0x00000066,0x00000062,0x00000065,0x00050041, + 0x00000022,0x00000068,0x00000020,0x00000067,0x0004003d,0x00000006,0x00000069,0x00000068, + 0x00050084,0x00000006,0x0000006a,0x00000066,0x00000069,0x00050041,0x00000022,0x0000006c, + 0x00000020,0x0000006b,0x0004003d,0x00000006,0x0000006d,0x0000006c,0x00050084,0x00000006, + 0x0000006e,0x0000006a,0x0000006d,0x0004003d,0x00000006,0x0000006f,0x00000047,0x00050041, + 0x00000022,0x00000070,0x00000020,0x00000067,0x0004003d,0x00000006,0x00000071,0x00000070, + 0x00050084,0x00000006,0x00000072,0x0000006f,0x00000071,0x0004003d,0x00000006,0x00000073, + 0x00000051,0x00050080,0x00000006,0x00000074,0x00000072,0x00000073,0x00050080,0x00000006, + 0x00000075,0x0000006e,0x00000074,0x0003003e,0x00000061,0x00000075,0x0003003e,0x00000076, + 0x00000063,0x000200f9,0x00000077,0x000200f8,0x00000077,0x000400f6,0x00000079,0x0000007a, + 0x00000000,0x000200f9,0x0000007b,0x000200f8,0x0000007b,0x0004003d,0x00000006,0x0000007c, + 0x00000076,0x00050041,0x00000022,0x0000007d,0x00000020,0x0000006b,0x0004003d,0x00000006, + 0x0000007e,0x0000007d,0x000500b1,0x0000001c,0x0000007f,0x0000007c,0x0000007e,0x000400fa, + 0x0000007f,0x00000078,0x00000079,0x000200f8,0x00000078,0x0003003e,0x00000080,0x00000063, + 0x000200f9,0x00000081,0x000200f8,0x00000081,0x000400f6,0x00000083,0x00000084,0x00000000, + 0x000200f9,0x00000085,0x000200f8,0x00000085,0x0004003d,0x00000006,0x00000086,0x00000080, + 0x00050041,0x00000022,0x00000088,0x00000020,0x00000087,0x0004003d,0x00000006,0x00000089, + 0x00000088,0x000500b1,0x0000001c,0x0000008a,0x00000086,0x00000089,0x000400fa,0x0000008a, + 0x00000082,0x00000083,0x000200f8,0x00000082,0x0003003e,0x0000008b,0x00000063,0x000200f9, + 0x0000008c,0x000200f8,0x0000008c,0x000400f6,0x0000008e,0x0000008f,0x00000000,0x000200f9, + 0x00000090,0x000200f8,0x00000090,0x0004003d,0x00000006,0x00000091,0x0000008b,0x00050041, + 0x00000022,0x00000093,0x00000020,0x00000092,0x0004003d,0x00000006,0x00000094,0x00000093, + 0x000500b1,0x0000001c,0x00000095,0x00000091,0x00000094,0x000400fa,0x00000095,0x0000008d, + 0x0000008e,0x000200f8,0x0000008d,0x0004003d,0x00000006,0x00000096,0x00000047,0x0004003d, + 0x00000006,0x00000097,0x00000080,0x00050041,0x00000022,0x00000099,0x00000020,0x00000098, + 0x0004003d,0x00000006,0x0000009a,0x00000099,0x00050084,0x00000006,0x0000009b,0x00000097, + 0x0000009a,0x00050080,0x00000006,0x0000009c,0x00000096,0x0000009b,0x000500af,0x0000001c, + 0x0000009d,0x0000009c,0x00000063,0x000300f7,0x0000009f,0x00000000,0x000400fa,0x0000009d, + 0x0000009e,0x0000009f,0x000200f8,0x0000009e,0x0004003d,0x00000006,0x000000a0,0x00000047, + 0x0004003d,0x00000006,0x000000a1,0x00000080,0x00050041,0x00000022,0x000000a2,0x00000020, + 0x00000098,0x0004003d,0x00000006,0x000000a3,0x000000a2,0x00050084,0x00000006,0x000000a4, + 0x000000a1,0x000000a3,0x00050080,0x00000006,0x000000a5,0x000000a0,0x000000a4,0x00050041, + 0x00000022,0x000000a6,0x00000020,0x00000063,0x0004003d,0x00000006,0x000000a7,0x000000a6, + 0x000500b1,0x0000001c,0x000000a8,0x000000a5,0x000000a7,0x000200f9,0x0000009f,0x000200f8, + 0x0000009f,0x000700f5,0x0000001c,0x000000a9,0x0000009d,0x0000008d,0x000000a8,0x0000009e, + 0x000300f7,0x000000ab,0x00000000,0x000400fa,0x000000a9,0x000000aa,0x000000ab,0x000200f8, + 0x000000aa,0x0004003d,0x00000006,0x000000ac,0x00000051,0x0004003d,0x00000006,0x000000ad, + 0x0000008b,0x00050041,0x00000022,0x000000af,0x00000020,0x000000ae,0x0004003d,0x00000006, + 0x000000b0,0x000000af,0x00050084,0x00000006,0x000000b1,0x000000ad,0x000000b0,0x00050080, + 0x00000006,0x000000b2,0x000000ac,0x000000b1,0x000500af,0x0000001c,0x000000b3,0x000000b2, + 0x00000063,0x000200f9,0x000000ab,0x000200f8,0x000000ab,0x000700f5,0x0000001c,0x000000b4, + 0x000000a9,0x0000009f,0x000000b3,0x000000aa,0x000300f7,0x000000b6,0x00000000,0x000400fa, + 0x000000b4,0x000000b5,0x000000b6,0x000200f8,0x000000b5,0x0004003d,0x00000006,0x000000b7, + 0x00000051,0x0004003d,0x00000006,0x000000b8,0x0000008b,0x00050041,0x00000022,0x000000b9, + 0x00000020,0x000000ae,0x0004003d,0x00000006,0x000000ba,0x000000b9,0x00050084,0x00000006, + 0x000000bb,0x000000b8,0x000000ba,0x00050080,0x00000006,0x000000bc,0x000000b7,0x000000bb, + 0x00050041,0x00000022,0x000000bd,0x00000020,0x00000067,0x0004003d,0x00000006,0x000000be, + 0x000000bd,0x000500b1,0x0000001c,0x000000bf,0x000000bc,0x000000be,0x000200f9,0x000000b6, + 0x000200f8,0x000000b6,0x000700f5,0x0000001c,0x000000c0,0x000000b4,0x000000ab,0x000000bf, + 0x000000b5,0x000300f7,0x000000c2,0x00000000,0x000400fa,0x000000c0,0x000000c1,0x000000c2, + 0x000200f8,0x000000c1,0x0004003d,0x00000006,0x000000c7,0x00000061,0x0004003d,0x00000006, + 0x000000c8,0x0000008b,0x00050041,0x00000022,0x000000c9,0x00000020,0x000000ae,0x0004003d, + 0x00000006,0x000000ca,0x000000c9,0x00050084,0x00000006,0x000000cb,0x000000c8,0x000000ca, + 0x00050080,0x00000006,0x000000cc,0x000000c7,0x000000cb,0x00060041,0x000000cd,0x000000ce, + 0x000000c6,0x00000063,0x000000cc,0x0004003d,0x00000038,0x000000cf,0x000000ce,0x0004003d, + 0x00000006,0x000000d4,0x0000005b,0x0004003d,0x00000006,0x000000d5,0x0000008b,0x00050080, + 0x00000006,0x000000d6,0x000000d4,0x000000d5,0x00060041,0x000000cd,0x000000d7,0x000000d3, + 0x00000063,0x000000d6,0x0004003d,0x00000038,0x000000d8,0x000000d7,0x00050085,0x00000038, + 0x000000d9,0x000000cf,0x000000d8,0x0004003d,0x00000038,0x000000da,0x0000003a,0x00050081, + 0x00000038,0x000000db,0x000000da,0x000000d9,0x0003003e,0x0000003a,0x000000db,0x000200f9, + 0x000000c2,0x000200f8,0x000000c2,0x000200f9,0x0000008f,0x000200f8,0x0000008f,0x0004003d, + 0x00000006,0x000000dc,0x0000008b,0x00050080,0x00000006,0x000000dd,0x000000dc,0x00000067, + 0x0003003e,0x0000008b,0x000000dd,0x000200f9,0x0000008c,0x000200f8,0x0000008e,0x00050041, + 0x00000022,0x000000de,0x00000020,0x00000067,0x0004003d,0x00000006,0x000000df,0x000000de, + 0x00050041,0x00000022,0x000000e0,0x00000020,0x00000098,0x0004003d,0x00000006,0x000000e1, + 0x000000e0,0x00050084,0x00000006,0x000000e2,0x000000df,0x000000e1,0x0004003d,0x00000006, + 0x000000e3,0x00000061,0x00050080,0x00000006,0x000000e4,0x000000e3,0x000000e2,0x0003003e, + 0x00000061,0x000000e4,0x00050041,0x00000022,0x000000e5,0x00000020,0x00000092,0x0004003d, + 0x00000006,0x000000e6,0x000000e5,0x0004003d,0x00000006,0x000000e7,0x0000005b,0x00050080, + 0x00000006,0x000000e8,0x000000e7,0x000000e6,0x0003003e,0x0000005b,0x000000e8,0x000200f9, + 0x00000084,0x000200f8,0x00000084,0x0004003d,0x00000006,0x000000e9,0x00000080,0x00050080, + 0x00000006,0x000000ea,0x000000e9,0x00000067,0x0003003e,0x00000080,0x000000ea,0x000200f9, + 0x00000081,0x000200f8,0x00000083,0x00050041,0x00000022,0x000000eb,0x00000020,0x00000063, + 0x0004003d,0x00000006,0x000000ec,0x000000eb,0x00050041,0x00000022,0x000000ed,0x00000020, + 0x00000067,0x0004003d,0x00000006,0x000000ee,0x000000ed,0x00050084,0x00000006,0x000000ef, + 0x000000ec,0x000000ee,0x00050041,0x00000022,0x000000f0,0x00000020,0x00000067,0x0004003d, + 0x00000006,0x000000f1,0x000000f0,0x00050041,0x00000022,0x000000f2,0x00000020,0x00000087, + 0x0004003d,0x00000006,0x000000f3,0x000000f2,0x00050084,0x00000006,0x000000f4,0x000000f1, + 0x000000f3,0x00050041,0x00000022,0x000000f5,0x00000020,0x00000098,0x0004003d,0x00000006, + 0x000000f6,0x000000f5,0x00050084,0x00000006,0x000000f7,0x000000f4,0x000000f6,0x00050082, + 0x00000006,0x000000f8,0x000000ef,0x000000f7,0x0004003d,0x00000006,0x000000f9,0x00000061, + 0x00050080,0x00000006,0x000000fa,0x000000f9,0x000000f8,0x0003003e,0x00000061,0x000000fa, + 0x000200f9,0x0000007a,0x000200f8,0x0000007a,0x0004003d,0x00000006,0x000000fb,0x00000076, + 0x00050080,0x00000006,0x000000fc,0x000000fb,0x00000067,0x0003003e,0x00000076,0x000000fc, + 0x000200f9,0x00000077,0x000200f8,0x00000079,0x0004003d,0x00000006,0x000000fe,0x00000017, + 0x00050041,0x00000022,0x000000ff,0x00000020,0x00000021,0x0004003d,0x00000006,0x00000100, + 0x000000ff,0x00050084,0x00000006,0x00000101,0x000000fe,0x00000100,0x00050041,0x00000022, + 0x00000102,0x00000020,0x00000029,0x0004003d,0x00000006,0x00000103,0x00000102,0x00050084, + 0x00000006,0x00000104,0x00000101,0x00000103,0x0004003d,0x00000006,0x00000105,0x00000008, + 0x00050080,0x00000006,0x00000106,0x00000104,0x00000105,0x0004003d,0x00000006,0x00000107, + 0x00000012,0x00050041,0x00000022,0x00000108,0x00000020,0x00000021,0x0004003d,0x00000006, + 0x00000109,0x00000108,0x00050084,0x00000006,0x0000010a,0x00000107,0x00000109,0x00050080, + 0x00000006,0x0000010b,0x00000106,0x0000010a,0x0003003e,0x000000fd,0x0000010b,0x00050041, + 0x00000022,0x0000010d,0x00000020,0x0000010c,0x0004003d,0x00000006,0x0000010e,0x0000010d, + 0x000500aa,0x0000001c,0x0000010f,0x0000010e,0x00000067,0x000300f7,0x00000111,0x00000000, + 0x000400fa,0x0000010f,0x00000110,0x00000111,0x000200f8,0x00000110,0x0004003d,0x00000006, + 0x00000116,0x00000012,0x00060041,0x000000cd,0x00000117,0x00000115,0x00000063,0x00000116, + 0x0004003d,0x00000038,0x00000118,0x00000117,0x0004003d,0x00000038,0x00000119,0x0000003a, + 0x00050081,0x00000038,0x0000011a,0x00000119,0x00000118,0x0003003e,0x0000003a,0x0000011a, + 0x000200f9,0x00000111,0x000200f8,0x00000111,0x0004003d,0x00000006,0x0000011f,0x000000fd, + 0x0004003d,0x00000038,0x00000120,0x0000003a,0x00060041,0x000000cd,0x00000121,0x0000011e, + 0x00000063,0x0000011f,0x0003003e,0x00000121,0x00000120,0x000200f9,0x00000037,0x000200f8, + 0x00000037,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/dw_conv.comp b/modules/dnn/src/vkcom/shader/dw_conv.comp new file mode 100644 index 0000000000..b76d766eb1 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/dw_conv.comp @@ -0,0 +1,74 @@ +#version 450 +#define LOCAL_SZ_X 256 +layout(push_constant) uniform pushBlock { + int in_h; + int in_w; + int out_h; + int out_w; + int stride_h; + int stride_w; + int pad_h; + int pad_w; + int filter_h; + int filter_w; + int dilation_h; + int dilation_w; + int channels; + int batch; + int has_bias; + int M; + int K; + int N; +} p; + +layout(binding = 0) readonly buffer Input0{ + float in_buffer[]; +}; +layout(binding = 1) readonly buffer Input1 { + float bias_data[]; +}; +layout(binding = 2) readonly buffer Input3{ + float weight_data[]; +}; +layout(binding = 3) writeonly buffer Output{ + float out_buffer[]; +}; +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; + +/* + Each work item compute batch * multiplier output cell along the output depth dimension and batch +*/ +void main() +{ + int gx = int(gl_GlobalInvocationID.x); + int gy = int(gl_GlobalInvocationID.y); + int gz = int(gl_GlobalInvocationID.z); + if(gx < p.out_w && gy < p.out_h && gz < p.channels) + { + float sum = 0.0f; + + int org_y = gy * p.stride_h - p.pad_h; + int org_x = gx * p.stride_w - p.pad_w; + + int weight_off = gz * p.filter_h * p.filter_w; + int input_off = gz * p.in_h * p.in_w + org_y * p.in_w + org_x; + for(int y = 0; y < p.filter_h; y++) + { + for(int x = 0; x < p.filter_w; x++) + { + if(org_y + y * p.dilation_h >= 0 && org_y + y * p.dilation_h < p.in_h && org_x + x * p.dilation_w >= 0 && org_x + x * p.dilation_w < p.in_w) + { + sum += in_buffer[input_off + x * p.dilation_w] * weight_data[weight_off + x]; + } + } + weight_off += p.filter_w; + input_off += p.in_w * p.dilation_h; + } + + int offset = gz * p.out_h * p.out_w + gy * p.out_w + gx; + if (p.has_bias == 1) + out_buffer[offset] = sum + bias_data[gz]; + else + out_buffer[offset] = sum; + } +} diff --git a/modules/dnn/src/vkcom/shader/dw_conv_spv.cpp b/modules/dnn/src/vkcom/shader/dw_conv_spv.cpp new file mode 100644 index 0000000000..43ad14c67b --- /dev/null +++ b/modules/dnn/src/vkcom/shader/dw_conv_spv.cpp @@ -0,0 +1,222 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int dw_conv_spv[1655] = { + 0x07230203,0x00010000,0x00080001,0x000000fe,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00060010,0x00000004, + 0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00007867,0x00080005,0x0000000c, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00030005,0x00000012, + 0x00007967,0x00030005,0x00000017,0x00007a67,0x00050005,0x0000001e,0x68737570,0x636f6c42, + 0x0000006b,0x00050006,0x0000001e,0x00000000,0x685f6e69,0x00000000,0x00050006,0x0000001e, + 0x00000001,0x775f6e69,0x00000000,0x00050006,0x0000001e,0x00000002,0x5f74756f,0x00000068, + 0x00050006,0x0000001e,0x00000003,0x5f74756f,0x00000077,0x00060006,0x0000001e,0x00000004, + 0x69727473,0x685f6564,0x00000000,0x00060006,0x0000001e,0x00000005,0x69727473,0x775f6564, + 0x00000000,0x00050006,0x0000001e,0x00000006,0x5f646170,0x00000068,0x00050006,0x0000001e, + 0x00000007,0x5f646170,0x00000077,0x00060006,0x0000001e,0x00000008,0x746c6966,0x685f7265, + 0x00000000,0x00060006,0x0000001e,0x00000009,0x746c6966,0x775f7265,0x00000000,0x00060006, + 0x0000001e,0x0000000a,0x616c6964,0x6e6f6974,0x0000685f,0x00060006,0x0000001e,0x0000000b, + 0x616c6964,0x6e6f6974,0x0000775f,0x00060006,0x0000001e,0x0000000c,0x6e616863,0x736c656e, + 0x00000000,0x00050006,0x0000001e,0x0000000d,0x63746162,0x00000068,0x00060006,0x0000001e, + 0x0000000e,0x5f736168,0x73616962,0x00000000,0x00040006,0x0000001e,0x0000000f,0x0000004d, + 0x00040006,0x0000001e,0x00000010,0x0000004b,0x00040006,0x0000001e,0x00000011,0x0000004e, + 0x00030005,0x00000020,0x00000070,0x00030005,0x0000003a,0x006d7573,0x00040005,0x0000003c, + 0x5f67726f,0x00000079,0x00040005,0x00000046,0x5f67726f,0x00000078,0x00050005,0x00000050, + 0x67696577,0x6f5f7468,0x00006666,0x00050005,0x0000005a,0x75706e69,0x666f5f74,0x00000066, + 0x00030005,0x0000006b,0x00000079,0x00030005,0x00000075,0x00000078,0x00040005,0x000000ad, + 0x75706e49,0x00003074,0x00060006,0x000000ad,0x00000000,0x625f6e69,0x65666675,0x00000072, + 0x00030005,0x000000af,0x00000000,0x00040005,0x000000ba,0x75706e49,0x00003374,0x00060006, + 0x000000ba,0x00000000,0x67696577,0x645f7468,0x00617461,0x00030005,0x000000bc,0x00000000, + 0x00040005,0x000000d4,0x7366666f,0x00007465,0x00040005,0x000000ea,0x7074754f,0x00007475, + 0x00060006,0x000000ea,0x00000000,0x5f74756f,0x66667562,0x00007265,0x00030005,0x000000ec, + 0x00000000,0x00040005,0x000000f0,0x75706e49,0x00003174,0x00060006,0x000000f0,0x00000000, + 0x73616962,0x7461645f,0x00000061,0x00030005,0x000000f2,0x00000000,0x00040047,0x0000000c, + 0x0000000b,0x0000001c,0x00050048,0x0000001e,0x00000000,0x00000023,0x00000000,0x00050048, + 0x0000001e,0x00000001,0x00000023,0x00000004,0x00050048,0x0000001e,0x00000002,0x00000023, + 0x00000008,0x00050048,0x0000001e,0x00000003,0x00000023,0x0000000c,0x00050048,0x0000001e, + 0x00000004,0x00000023,0x00000010,0x00050048,0x0000001e,0x00000005,0x00000023,0x00000014, + 0x00050048,0x0000001e,0x00000006,0x00000023,0x00000018,0x00050048,0x0000001e,0x00000007, + 0x00000023,0x0000001c,0x00050048,0x0000001e,0x00000008,0x00000023,0x00000020,0x00050048, + 0x0000001e,0x00000009,0x00000023,0x00000024,0x00050048,0x0000001e,0x0000000a,0x00000023, + 0x00000028,0x00050048,0x0000001e,0x0000000b,0x00000023,0x0000002c,0x00050048,0x0000001e, + 0x0000000c,0x00000023,0x00000030,0x00050048,0x0000001e,0x0000000d,0x00000023,0x00000034, + 0x00050048,0x0000001e,0x0000000e,0x00000023,0x00000038,0x00050048,0x0000001e,0x0000000f, + 0x00000023,0x0000003c,0x00050048,0x0000001e,0x00000010,0x00000023,0x00000040,0x00050048, + 0x0000001e,0x00000011,0x00000023,0x00000044,0x00030047,0x0000001e,0x00000002,0x00040047, + 0x000000ac,0x00000006,0x00000004,0x00040048,0x000000ad,0x00000000,0x00000018,0x00050048, + 0x000000ad,0x00000000,0x00000023,0x00000000,0x00030047,0x000000ad,0x00000003,0x00040047, + 0x000000af,0x00000022,0x00000000,0x00040047,0x000000af,0x00000021,0x00000000,0x00040047, + 0x000000b9,0x00000006,0x00000004,0x00040048,0x000000ba,0x00000000,0x00000018,0x00050048, + 0x000000ba,0x00000000,0x00000023,0x00000000,0x00030047,0x000000ba,0x00000003,0x00040047, + 0x000000bc,0x00000022,0x00000000,0x00040047,0x000000bc,0x00000021,0x00000002,0x00040047, + 0x000000e9,0x00000006,0x00000004,0x00040048,0x000000ea,0x00000000,0x00000019,0x00050048, + 0x000000ea,0x00000000,0x00000023,0x00000000,0x00030047,0x000000ea,0x00000003,0x00040047, + 0x000000ec,0x00000022,0x00000000,0x00040047,0x000000ec,0x00000021,0x00000003,0x00040047, + 0x000000ef,0x00000006,0x00000004,0x00040048,0x000000f0,0x00000000,0x00000018,0x00050048, + 0x000000f0,0x00000000,0x00000023,0x00000000,0x00030047,0x000000f0,0x00000003,0x00040047, + 0x000000f2,0x00000022,0x00000000,0x00040047,0x000000f2,0x00000021,0x00000001,0x00040047, + 0x000000fd,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002, + 0x00040015,0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007,0x00000006, + 0x00040015,0x00000009,0x00000020,0x00000000,0x00040017,0x0000000a,0x00000009,0x00000003, + 0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,0x0000000c,0x00000001, + 0x0004002b,0x00000009,0x0000000d,0x00000000,0x00040020,0x0000000e,0x00000001,0x00000009, + 0x0004002b,0x00000009,0x00000013,0x00000001,0x0004002b,0x00000009,0x00000018,0x00000002, + 0x00020014,0x0000001c,0x0014001e,0x0000001e,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00040020,0x0000001f, + 0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009,0x0004002b,0x00000006, + 0x00000021,0x00000003,0x00040020,0x00000022,0x00000009,0x00000006,0x0004002b,0x00000006, + 0x00000029,0x00000002,0x0004002b,0x00000006,0x00000031,0x0000000c,0x00030016,0x00000038, + 0x00000020,0x00040020,0x00000039,0x00000007,0x00000038,0x0004002b,0x00000038,0x0000003b, + 0x00000000,0x0004002b,0x00000006,0x0000003e,0x00000004,0x0004002b,0x00000006,0x00000042, + 0x00000006,0x0004002b,0x00000006,0x00000048,0x00000005,0x0004002b,0x00000006,0x0000004c, + 0x00000007,0x0004002b,0x00000006,0x00000052,0x00000008,0x0004002b,0x00000006,0x00000056, + 0x00000009,0x0004002b,0x00000006,0x0000005c,0x00000000,0x0004002b,0x00000006,0x00000060, + 0x00000001,0x0004002b,0x00000006,0x00000081,0x0000000a,0x0004002b,0x00000006,0x00000097, + 0x0000000b,0x0003001d,0x000000ac,0x00000038,0x0003001e,0x000000ad,0x000000ac,0x00040020, + 0x000000ae,0x00000002,0x000000ad,0x0004003b,0x000000ae,0x000000af,0x00000002,0x00040020, + 0x000000b6,0x00000002,0x00000038,0x0003001d,0x000000b9,0x00000038,0x0003001e,0x000000ba, + 0x000000b9,0x00040020,0x000000bb,0x00000002,0x000000ba,0x0004003b,0x000000bb,0x000000bc, + 0x00000002,0x0004002b,0x00000006,0x000000e3,0x0000000e,0x0003001d,0x000000e9,0x00000038, + 0x0003001e,0x000000ea,0x000000e9,0x00040020,0x000000eb,0x00000002,0x000000ea,0x0004003b, + 0x000000eb,0x000000ec,0x00000002,0x0003001d,0x000000ef,0x00000038,0x0003001e,0x000000f0, + 0x000000ef,0x00040020,0x000000f1,0x00000002,0x000000f0,0x0004003b,0x000000f1,0x000000f2, + 0x00000002,0x0004002b,0x00000009,0x000000fc,0x00000100,0x0006002c,0x0000000a,0x000000fd, + 0x000000fc,0x00000013,0x00000013,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003, + 0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008,0x00000007,0x0004003b,0x00000007, + 0x00000012,0x00000007,0x0004003b,0x00000007,0x00000017,0x00000007,0x0004003b,0x00000039, + 0x0000003a,0x00000007,0x0004003b,0x00000007,0x0000003c,0x00000007,0x0004003b,0x00000007, + 0x00000046,0x00000007,0x0004003b,0x00000007,0x00000050,0x00000007,0x0004003b,0x00000007, + 0x0000005a,0x00000007,0x0004003b,0x00000007,0x0000006b,0x00000007,0x0004003b,0x00000007, + 0x00000075,0x00000007,0x0004003b,0x00000007,0x000000d4,0x00000007,0x00050041,0x0000000e, + 0x0000000f,0x0000000c,0x0000000d,0x0004003d,0x00000009,0x00000010,0x0000000f,0x0004007c, + 0x00000006,0x00000011,0x00000010,0x0003003e,0x00000008,0x00000011,0x00050041,0x0000000e, + 0x00000014,0x0000000c,0x00000013,0x0004003d,0x00000009,0x00000015,0x00000014,0x0004007c, + 0x00000006,0x00000016,0x00000015,0x0003003e,0x00000012,0x00000016,0x00050041,0x0000000e, + 0x00000019,0x0000000c,0x00000018,0x0004003d,0x00000009,0x0000001a,0x00000019,0x0004007c, + 0x00000006,0x0000001b,0x0000001a,0x0003003e,0x00000017,0x0000001b,0x0004003d,0x00000006, + 0x0000001d,0x00000008,0x00050041,0x00000022,0x00000023,0x00000020,0x00000021,0x0004003d, + 0x00000006,0x00000024,0x00000023,0x000500b1,0x0000001c,0x00000025,0x0000001d,0x00000024, + 0x000300f7,0x00000027,0x00000000,0x000400fa,0x00000025,0x00000026,0x00000027,0x000200f8, + 0x00000026,0x0004003d,0x00000006,0x00000028,0x00000012,0x00050041,0x00000022,0x0000002a, + 0x00000020,0x00000029,0x0004003d,0x00000006,0x0000002b,0x0000002a,0x000500b1,0x0000001c, + 0x0000002c,0x00000028,0x0000002b,0x000200f9,0x00000027,0x000200f8,0x00000027,0x000700f5, + 0x0000001c,0x0000002d,0x00000025,0x00000005,0x0000002c,0x00000026,0x000300f7,0x0000002f, + 0x00000000,0x000400fa,0x0000002d,0x0000002e,0x0000002f,0x000200f8,0x0000002e,0x0004003d, + 0x00000006,0x00000030,0x00000017,0x00050041,0x00000022,0x00000032,0x00000020,0x00000031, + 0x0004003d,0x00000006,0x00000033,0x00000032,0x000500b1,0x0000001c,0x00000034,0x00000030, + 0x00000033,0x000200f9,0x0000002f,0x000200f8,0x0000002f,0x000700f5,0x0000001c,0x00000035, + 0x0000002d,0x00000027,0x00000034,0x0000002e,0x000300f7,0x00000037,0x00000000,0x000400fa, + 0x00000035,0x00000036,0x00000037,0x000200f8,0x00000036,0x0003003e,0x0000003a,0x0000003b, + 0x0004003d,0x00000006,0x0000003d,0x00000012,0x00050041,0x00000022,0x0000003f,0x00000020, + 0x0000003e,0x0004003d,0x00000006,0x00000040,0x0000003f,0x00050084,0x00000006,0x00000041, + 0x0000003d,0x00000040,0x00050041,0x00000022,0x00000043,0x00000020,0x00000042,0x0004003d, + 0x00000006,0x00000044,0x00000043,0x00050082,0x00000006,0x00000045,0x00000041,0x00000044, + 0x0003003e,0x0000003c,0x00000045,0x0004003d,0x00000006,0x00000047,0x00000008,0x00050041, + 0x00000022,0x00000049,0x00000020,0x00000048,0x0004003d,0x00000006,0x0000004a,0x00000049, + 0x00050084,0x00000006,0x0000004b,0x00000047,0x0000004a,0x00050041,0x00000022,0x0000004d, + 0x00000020,0x0000004c,0x0004003d,0x00000006,0x0000004e,0x0000004d,0x00050082,0x00000006, + 0x0000004f,0x0000004b,0x0000004e,0x0003003e,0x00000046,0x0000004f,0x0004003d,0x00000006, + 0x00000051,0x00000017,0x00050041,0x00000022,0x00000053,0x00000020,0x00000052,0x0004003d, + 0x00000006,0x00000054,0x00000053,0x00050084,0x00000006,0x00000055,0x00000051,0x00000054, + 0x00050041,0x00000022,0x00000057,0x00000020,0x00000056,0x0004003d,0x00000006,0x00000058, + 0x00000057,0x00050084,0x00000006,0x00000059,0x00000055,0x00000058,0x0003003e,0x00000050, + 0x00000059,0x0004003d,0x00000006,0x0000005b,0x00000017,0x00050041,0x00000022,0x0000005d, + 0x00000020,0x0000005c,0x0004003d,0x00000006,0x0000005e,0x0000005d,0x00050084,0x00000006, + 0x0000005f,0x0000005b,0x0000005e,0x00050041,0x00000022,0x00000061,0x00000020,0x00000060, + 0x0004003d,0x00000006,0x00000062,0x00000061,0x00050084,0x00000006,0x00000063,0x0000005f, + 0x00000062,0x0004003d,0x00000006,0x00000064,0x0000003c,0x00050041,0x00000022,0x00000065, + 0x00000020,0x00000060,0x0004003d,0x00000006,0x00000066,0x00000065,0x00050084,0x00000006, + 0x00000067,0x00000064,0x00000066,0x00050080,0x00000006,0x00000068,0x00000063,0x00000067, + 0x0004003d,0x00000006,0x00000069,0x00000046,0x00050080,0x00000006,0x0000006a,0x00000068, + 0x00000069,0x0003003e,0x0000005a,0x0000006a,0x0003003e,0x0000006b,0x0000005c,0x000200f9, + 0x0000006c,0x000200f8,0x0000006c,0x000400f6,0x0000006e,0x0000006f,0x00000000,0x000200f9, + 0x00000070,0x000200f8,0x00000070,0x0004003d,0x00000006,0x00000071,0x0000006b,0x00050041, + 0x00000022,0x00000072,0x00000020,0x00000052,0x0004003d,0x00000006,0x00000073,0x00000072, + 0x000500b1,0x0000001c,0x00000074,0x00000071,0x00000073,0x000400fa,0x00000074,0x0000006d, + 0x0000006e,0x000200f8,0x0000006d,0x0003003e,0x00000075,0x0000005c,0x000200f9,0x00000076, + 0x000200f8,0x00000076,0x000400f6,0x00000078,0x00000079,0x00000000,0x000200f9,0x0000007a, + 0x000200f8,0x0000007a,0x0004003d,0x00000006,0x0000007b,0x00000075,0x00050041,0x00000022, + 0x0000007c,0x00000020,0x00000056,0x0004003d,0x00000006,0x0000007d,0x0000007c,0x000500b1, + 0x0000001c,0x0000007e,0x0000007b,0x0000007d,0x000400fa,0x0000007e,0x00000077,0x00000078, + 0x000200f8,0x00000077,0x0004003d,0x00000006,0x0000007f,0x0000003c,0x0004003d,0x00000006, + 0x00000080,0x0000006b,0x00050041,0x00000022,0x00000082,0x00000020,0x00000081,0x0004003d, + 0x00000006,0x00000083,0x00000082,0x00050084,0x00000006,0x00000084,0x00000080,0x00000083, + 0x00050080,0x00000006,0x00000085,0x0000007f,0x00000084,0x000500af,0x0000001c,0x00000086, + 0x00000085,0x0000005c,0x000300f7,0x00000088,0x00000000,0x000400fa,0x00000086,0x00000087, + 0x00000088,0x000200f8,0x00000087,0x0004003d,0x00000006,0x00000089,0x0000003c,0x0004003d, + 0x00000006,0x0000008a,0x0000006b,0x00050041,0x00000022,0x0000008b,0x00000020,0x00000081, + 0x0004003d,0x00000006,0x0000008c,0x0000008b,0x00050084,0x00000006,0x0000008d,0x0000008a, + 0x0000008c,0x00050080,0x00000006,0x0000008e,0x00000089,0x0000008d,0x00050041,0x00000022, + 0x0000008f,0x00000020,0x0000005c,0x0004003d,0x00000006,0x00000090,0x0000008f,0x000500b1, + 0x0000001c,0x00000091,0x0000008e,0x00000090,0x000200f9,0x00000088,0x000200f8,0x00000088, + 0x000700f5,0x0000001c,0x00000092,0x00000086,0x00000077,0x00000091,0x00000087,0x000300f7, + 0x00000094,0x00000000,0x000400fa,0x00000092,0x00000093,0x00000094,0x000200f8,0x00000093, + 0x0004003d,0x00000006,0x00000095,0x00000046,0x0004003d,0x00000006,0x00000096,0x00000075, + 0x00050041,0x00000022,0x00000098,0x00000020,0x00000097,0x0004003d,0x00000006,0x00000099, + 0x00000098,0x00050084,0x00000006,0x0000009a,0x00000096,0x00000099,0x00050080,0x00000006, + 0x0000009b,0x00000095,0x0000009a,0x000500af,0x0000001c,0x0000009c,0x0000009b,0x0000005c, + 0x000200f9,0x00000094,0x000200f8,0x00000094,0x000700f5,0x0000001c,0x0000009d,0x00000092, + 0x00000088,0x0000009c,0x00000093,0x000300f7,0x0000009f,0x00000000,0x000400fa,0x0000009d, + 0x0000009e,0x0000009f,0x000200f8,0x0000009e,0x0004003d,0x00000006,0x000000a0,0x00000046, + 0x0004003d,0x00000006,0x000000a1,0x00000075,0x00050041,0x00000022,0x000000a2,0x00000020, + 0x00000097,0x0004003d,0x00000006,0x000000a3,0x000000a2,0x00050084,0x00000006,0x000000a4, + 0x000000a1,0x000000a3,0x00050080,0x00000006,0x000000a5,0x000000a0,0x000000a4,0x00050041, + 0x00000022,0x000000a6,0x00000020,0x00000060,0x0004003d,0x00000006,0x000000a7,0x000000a6, + 0x000500b1,0x0000001c,0x000000a8,0x000000a5,0x000000a7,0x000200f9,0x0000009f,0x000200f8, + 0x0000009f,0x000700f5,0x0000001c,0x000000a9,0x0000009d,0x00000094,0x000000a8,0x0000009e, + 0x000300f7,0x000000ab,0x00000000,0x000400fa,0x000000a9,0x000000aa,0x000000ab,0x000200f8, + 0x000000aa,0x0004003d,0x00000006,0x000000b0,0x0000005a,0x0004003d,0x00000006,0x000000b1, + 0x00000075,0x00050041,0x00000022,0x000000b2,0x00000020,0x00000097,0x0004003d,0x00000006, + 0x000000b3,0x000000b2,0x00050084,0x00000006,0x000000b4,0x000000b1,0x000000b3,0x00050080, + 0x00000006,0x000000b5,0x000000b0,0x000000b4,0x00060041,0x000000b6,0x000000b7,0x000000af, + 0x0000005c,0x000000b5,0x0004003d,0x00000038,0x000000b8,0x000000b7,0x0004003d,0x00000006, + 0x000000bd,0x00000050,0x0004003d,0x00000006,0x000000be,0x00000075,0x00050080,0x00000006, + 0x000000bf,0x000000bd,0x000000be,0x00060041,0x000000b6,0x000000c0,0x000000bc,0x0000005c, + 0x000000bf,0x0004003d,0x00000038,0x000000c1,0x000000c0,0x00050085,0x00000038,0x000000c2, + 0x000000b8,0x000000c1,0x0004003d,0x00000038,0x000000c3,0x0000003a,0x00050081,0x00000038, + 0x000000c4,0x000000c3,0x000000c2,0x0003003e,0x0000003a,0x000000c4,0x000200f9,0x000000ab, + 0x000200f8,0x000000ab,0x000200f9,0x00000079,0x000200f8,0x00000079,0x0004003d,0x00000006, + 0x000000c5,0x00000075,0x00050080,0x00000006,0x000000c6,0x000000c5,0x00000060,0x0003003e, + 0x00000075,0x000000c6,0x000200f9,0x00000076,0x000200f8,0x00000078,0x00050041,0x00000022, + 0x000000c7,0x00000020,0x00000056,0x0004003d,0x00000006,0x000000c8,0x000000c7,0x0004003d, + 0x00000006,0x000000c9,0x00000050,0x00050080,0x00000006,0x000000ca,0x000000c9,0x000000c8, + 0x0003003e,0x00000050,0x000000ca,0x00050041,0x00000022,0x000000cb,0x00000020,0x00000060, + 0x0004003d,0x00000006,0x000000cc,0x000000cb,0x00050041,0x00000022,0x000000cd,0x00000020, + 0x00000081,0x0004003d,0x00000006,0x000000ce,0x000000cd,0x00050084,0x00000006,0x000000cf, + 0x000000cc,0x000000ce,0x0004003d,0x00000006,0x000000d0,0x0000005a,0x00050080,0x00000006, + 0x000000d1,0x000000d0,0x000000cf,0x0003003e,0x0000005a,0x000000d1,0x000200f9,0x0000006f, + 0x000200f8,0x0000006f,0x0004003d,0x00000006,0x000000d2,0x0000006b,0x00050080,0x00000006, + 0x000000d3,0x000000d2,0x00000060,0x0003003e,0x0000006b,0x000000d3,0x000200f9,0x0000006c, + 0x000200f8,0x0000006e,0x0004003d,0x00000006,0x000000d5,0x00000017,0x00050041,0x00000022, + 0x000000d6,0x00000020,0x00000029,0x0004003d,0x00000006,0x000000d7,0x000000d6,0x00050084, + 0x00000006,0x000000d8,0x000000d5,0x000000d7,0x00050041,0x00000022,0x000000d9,0x00000020, + 0x00000021,0x0004003d,0x00000006,0x000000da,0x000000d9,0x00050084,0x00000006,0x000000db, + 0x000000d8,0x000000da,0x0004003d,0x00000006,0x000000dc,0x00000012,0x00050041,0x00000022, + 0x000000dd,0x00000020,0x00000021,0x0004003d,0x00000006,0x000000de,0x000000dd,0x00050084, + 0x00000006,0x000000df,0x000000dc,0x000000de,0x00050080,0x00000006,0x000000e0,0x000000db, + 0x000000df,0x0004003d,0x00000006,0x000000e1,0x00000008,0x00050080,0x00000006,0x000000e2, + 0x000000e0,0x000000e1,0x0003003e,0x000000d4,0x000000e2,0x00050041,0x00000022,0x000000e4, + 0x00000020,0x000000e3,0x0004003d,0x00000006,0x000000e5,0x000000e4,0x000500aa,0x0000001c, + 0x000000e6,0x000000e5,0x00000060,0x000300f7,0x000000e8,0x00000000,0x000400fa,0x000000e6, + 0x000000e7,0x000000f8,0x000200f8,0x000000e7,0x0004003d,0x00000006,0x000000ed,0x000000d4, + 0x0004003d,0x00000038,0x000000ee,0x0000003a,0x0004003d,0x00000006,0x000000f3,0x00000017, + 0x00060041,0x000000b6,0x000000f4,0x000000f2,0x0000005c,0x000000f3,0x0004003d,0x00000038, + 0x000000f5,0x000000f4,0x00050081,0x00000038,0x000000f6,0x000000ee,0x000000f5,0x00060041, + 0x000000b6,0x000000f7,0x000000ec,0x0000005c,0x000000ed,0x0003003e,0x000000f7,0x000000f6, + 0x000200f9,0x000000e8,0x000200f8,0x000000f8,0x0004003d,0x00000006,0x000000f9,0x000000d4, + 0x0004003d,0x00000038,0x000000fa,0x0000003a,0x00060041,0x000000b6,0x000000fb,0x000000ec, + 0x0000005c,0x000000f9,0x0003003e,0x000000fb,0x000000fa,0x000200f9,0x000000e8,0x000200f8, + 0x000000e8,0x000200f9,0x00000037,0x000200f8,0x00000037,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/lrn.comp b/modules/dnn/src/vkcom/shader/lrn.comp new file mode 100644 index 0000000000..ac8edadf1d --- /dev/null +++ b/modules/dnn/src/vkcom/shader/lrn.comp @@ -0,0 +1,63 @@ +#version 450 +#define LOCAL_SZ_X 256 +layout(push_constant) uniform pushBlock { + int thread_num; + int channels; + int height; + int width; + int filter_len; + int radius; + float alpha; + float bias; + float negative_beta; +} p; + +layout(binding = 0) readonly buffer Input0{ + float in_buffer[]; +}; +layout(binding = 1) writeonly buffer Output{ + float dst_buffer[]; +}; +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; +void main() +{ + int gid = int(gl_GlobalInvocationID.x); + int gsz = int(gl_NumWorkGroups.x * gl_WorkGroupSize.x); + for (int index = gid; index < p.thread_num; index += gsz) + { + int x = index % p.width; + int y = (index / p.width) % p.height; + int b = index / (p.width * p.height); + int offset = b * p.channels * p.height * p.width + y * p.width + x; + int channel_off = p.height * p.width; + float scale_val; + int head = 0; + float accum_scale = 0.0f; + int min_val = p.radius < p.channels ? p.radius : p.channels; + while (head < min_val) { + accum_scale += in_buffer[offset + head * channel_off] * in_buffer[offset + head * channel_off]; + ++head; + } + while (head < p.channels) { + accum_scale += in_buffer[offset + head * channel_off] * in_buffer[offset + head * channel_off]; + if (head - p.filter_len >= 0) { + accum_scale -= in_buffer[offset + (head - p.filter_len) * channel_off] + * in_buffer[offset + (head - p.filter_len) * channel_off]; + } + scale_val = p.bias + accum_scale * p.alpha; + dst_buffer[offset + (head - p.radius) * channel_off] = in_buffer[offset + (head - p.radius) * channel_off] * pow(scale_val, p.negative_beta); + ++head; + } + int pos = head - min_val; + while (pos >= 0 && pos < p.channels) { + if (head - p.filter_len >= 0) { + accum_scale -= in_buffer[offset + (head - p.filter_len) * channel_off] + * in_buffer[offset + (head - p.filter_len) * channel_off]; + } + scale_val = p.bias + accum_scale * p.alpha; + dst_buffer[offset + pos * channel_off] = in_buffer[offset + pos * channel_off] * pow(scale_val, p.negative_beta); + ++head; + ++pos; + } + } +} diff --git a/modules/dnn/src/vkcom/shader/lrn_spv.cpp b/modules/dnn/src/vkcom/shader/lrn_spv.cpp new file mode 100644 index 0000000000..06159d05bb --- /dev/null +++ b/modules/dnn/src/vkcom/shader/lrn_spv.cpp @@ -0,0 +1,246 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int lrn_spv[1845] = { + 0x07230203,0x00010000,0x00080001,0x00000144,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0007000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00000013,0x00060010, + 0x00000004,0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2, + 0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00646967,0x00080005, + 0x0000000c,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00030005, + 0x00000012,0x007a7367,0x00070005,0x00000013,0x4e5f6c67,0x6f576d75,0x72476b72,0x7370756f, + 0x00000000,0x00040005,0x00000019,0x65646e69,0x00000078,0x00050005,0x00000022,0x68737570, + 0x636f6c42,0x0000006b,0x00060006,0x00000022,0x00000000,0x65726874,0x6e5f6461,0x00006d75, + 0x00060006,0x00000022,0x00000001,0x6e616863,0x736c656e,0x00000000,0x00050006,0x00000022, + 0x00000002,0x67696568,0x00007468,0x00050006,0x00000022,0x00000003,0x74646977,0x00000068, + 0x00060006,0x00000022,0x00000004,0x746c6966,0x6c5f7265,0x00006e65,0x00050006,0x00000022, + 0x00000005,0x69646172,0x00007375,0x00050006,0x00000022,0x00000006,0x68706c61,0x00000061, + 0x00050006,0x00000022,0x00000007,0x73616962,0x00000000,0x00070006,0x00000022,0x00000008, + 0x6167656e,0x65766974,0x7465625f,0x00000061,0x00030005,0x00000024,0x00000070,0x00030005, + 0x0000002b,0x00000078,0x00030005,0x00000031,0x00000079,0x00030005,0x0000003a,0x00000062, + 0x00040005,0x00000042,0x7366666f,0x00007465,0x00050005,0x00000055,0x6e616863,0x5f6c656e, + 0x0066666f,0x00040005,0x0000005b,0x64616568,0x00000000,0x00050005,0x0000005d,0x75636361, + 0x63735f6d,0x00656c61,0x00040005,0x0000005f,0x5f6e696d,0x006c6176,0x00040005,0x00000078, + 0x75706e49,0x00003074,0x00060006,0x00000078,0x00000000,0x625f6e69,0x65666675,0x00000072, + 0x00030005,0x0000007a,0x00000000,0x00050005,0x000000c8,0x6c616373,0x61765f65,0x0000006c, + 0x00040005,0x000000d4,0x7074754f,0x00007475,0x00060006,0x000000d4,0x00000000,0x5f747364, + 0x66667562,0x00007265,0x00030005,0x000000d6,0x00000000,0x00030005,0x000000f2,0x00736f70, + 0x00040047,0x0000000c,0x0000000b,0x0000001c,0x00040047,0x00000013,0x0000000b,0x00000018, + 0x00050048,0x00000022,0x00000000,0x00000023,0x00000000,0x00050048,0x00000022,0x00000001, + 0x00000023,0x00000004,0x00050048,0x00000022,0x00000002,0x00000023,0x00000008,0x00050048, + 0x00000022,0x00000003,0x00000023,0x0000000c,0x00050048,0x00000022,0x00000004,0x00000023, + 0x00000010,0x00050048,0x00000022,0x00000005,0x00000023,0x00000014,0x00050048,0x00000022, + 0x00000006,0x00000023,0x00000018,0x00050048,0x00000022,0x00000007,0x00000023,0x0000001c, + 0x00050048,0x00000022,0x00000008,0x00000023,0x00000020,0x00030047,0x00000022,0x00000002, + 0x00040047,0x00000077,0x00000006,0x00000004,0x00040048,0x00000078,0x00000000,0x00000018, + 0x00050048,0x00000078,0x00000000,0x00000023,0x00000000,0x00030047,0x00000078,0x00000003, + 0x00040047,0x0000007a,0x00000022,0x00000000,0x00040047,0x0000007a,0x00000021,0x00000000, + 0x00040047,0x000000d3,0x00000006,0x00000004,0x00040048,0x000000d4,0x00000000,0x00000019, + 0x00050048,0x000000d4,0x00000000,0x00000023,0x00000000,0x00030047,0x000000d4,0x00000003, + 0x00040047,0x000000d6,0x00000022,0x00000000,0x00040047,0x000000d6,0x00000021,0x00000001, + 0x00040047,0x00000143,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003, + 0x00000002,0x00040015,0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007, + 0x00000006,0x00040015,0x00000009,0x00000020,0x00000000,0x00040017,0x0000000a,0x00000009, + 0x00000003,0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,0x0000000c, + 0x00000001,0x0004002b,0x00000009,0x0000000d,0x00000000,0x00040020,0x0000000e,0x00000001, + 0x00000009,0x0004003b,0x0000000b,0x00000013,0x00000001,0x0004002b,0x00000009,0x00000016, + 0x00000100,0x00030016,0x00000021,0x00000020,0x000b001e,0x00000022,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000021,0x00000021,0x00000021,0x00040020, + 0x00000023,0x00000009,0x00000022,0x0004003b,0x00000023,0x00000024,0x00000009,0x0004002b, + 0x00000006,0x00000025,0x00000000,0x00040020,0x00000026,0x00000009,0x00000006,0x00020014, + 0x00000029,0x0004002b,0x00000006,0x0000002d,0x00000003,0x0004002b,0x00000006,0x00000036, + 0x00000002,0x0004002b,0x00000006,0x00000044,0x00000001,0x00040020,0x0000005c,0x00000007, + 0x00000021,0x0004002b,0x00000021,0x0000005e,0x00000000,0x0004002b,0x00000006,0x00000061, + 0x00000005,0x0003001d,0x00000077,0x00000021,0x0003001e,0x00000078,0x00000077,0x00040020, + 0x00000079,0x00000002,0x00000078,0x0004003b,0x00000079,0x0000007a,0x00000002,0x00040020, + 0x00000080,0x00000002,0x00000021,0x0004002b,0x00000006,0x000000aa,0x00000004,0x0004002b, + 0x00000006,0x000000c9,0x00000007,0x00040020,0x000000ca,0x00000009,0x00000021,0x0004002b, + 0x00000006,0x000000ce,0x00000006,0x0003001d,0x000000d3,0x00000021,0x0003001e,0x000000d4, + 0x000000d3,0x00040020,0x000000d5,0x00000002,0x000000d4,0x0004003b,0x000000d5,0x000000d6, + 0x00000002,0x0004002b,0x00000006,0x000000ea,0x00000008,0x0004002b,0x00000009,0x00000142, + 0x00000001,0x0006002c,0x0000000a,0x00000143,0x00000016,0x00000142,0x00000142,0x00050036, + 0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007, + 0x00000008,0x00000007,0x0004003b,0x00000007,0x00000012,0x00000007,0x0004003b,0x00000007, + 0x00000019,0x00000007,0x0004003b,0x00000007,0x0000002b,0x00000007,0x0004003b,0x00000007, + 0x00000031,0x00000007,0x0004003b,0x00000007,0x0000003a,0x00000007,0x0004003b,0x00000007, + 0x00000042,0x00000007,0x0004003b,0x00000007,0x00000055,0x00000007,0x0004003b,0x00000007, + 0x0000005b,0x00000007,0x0004003b,0x0000005c,0x0000005d,0x00000007,0x0004003b,0x00000007, + 0x0000005f,0x00000007,0x0004003b,0x00000007,0x00000060,0x00000007,0x0004003b,0x0000005c, + 0x000000c8,0x00000007,0x0004003b,0x00000007,0x000000f2,0x00000007,0x00050041,0x0000000e, + 0x0000000f,0x0000000c,0x0000000d,0x0004003d,0x00000009,0x00000010,0x0000000f,0x0004007c, + 0x00000006,0x00000011,0x00000010,0x0003003e,0x00000008,0x00000011,0x00050041,0x0000000e, + 0x00000014,0x00000013,0x0000000d,0x0004003d,0x00000009,0x00000015,0x00000014,0x00050084, + 0x00000009,0x00000017,0x00000015,0x00000016,0x0004007c,0x00000006,0x00000018,0x00000017, + 0x0003003e,0x00000012,0x00000018,0x0004003d,0x00000006,0x0000001a,0x00000008,0x0003003e, + 0x00000019,0x0000001a,0x000200f9,0x0000001b,0x000200f8,0x0000001b,0x000400f6,0x0000001d, + 0x0000001e,0x00000000,0x000200f9,0x0000001f,0x000200f8,0x0000001f,0x0004003d,0x00000006, + 0x00000020,0x00000019,0x00050041,0x00000026,0x00000027,0x00000024,0x00000025,0x0004003d, + 0x00000006,0x00000028,0x00000027,0x000500b1,0x00000029,0x0000002a,0x00000020,0x00000028, + 0x000400fa,0x0000002a,0x0000001c,0x0000001d,0x000200f8,0x0000001c,0x0004003d,0x00000006, + 0x0000002c,0x00000019,0x00050041,0x00000026,0x0000002e,0x00000024,0x0000002d,0x0004003d, + 0x00000006,0x0000002f,0x0000002e,0x0005008b,0x00000006,0x00000030,0x0000002c,0x0000002f, + 0x0003003e,0x0000002b,0x00000030,0x0004003d,0x00000006,0x00000032,0x00000019,0x00050041, + 0x00000026,0x00000033,0x00000024,0x0000002d,0x0004003d,0x00000006,0x00000034,0x00000033, + 0x00050087,0x00000006,0x00000035,0x00000032,0x00000034,0x00050041,0x00000026,0x00000037, + 0x00000024,0x00000036,0x0004003d,0x00000006,0x00000038,0x00000037,0x0005008b,0x00000006, + 0x00000039,0x00000035,0x00000038,0x0003003e,0x00000031,0x00000039,0x0004003d,0x00000006, + 0x0000003b,0x00000019,0x00050041,0x00000026,0x0000003c,0x00000024,0x0000002d,0x0004003d, + 0x00000006,0x0000003d,0x0000003c,0x00050041,0x00000026,0x0000003e,0x00000024,0x00000036, + 0x0004003d,0x00000006,0x0000003f,0x0000003e,0x00050084,0x00000006,0x00000040,0x0000003d, + 0x0000003f,0x00050087,0x00000006,0x00000041,0x0000003b,0x00000040,0x0003003e,0x0000003a, + 0x00000041,0x0004003d,0x00000006,0x00000043,0x0000003a,0x00050041,0x00000026,0x00000045, + 0x00000024,0x00000044,0x0004003d,0x00000006,0x00000046,0x00000045,0x00050084,0x00000006, + 0x00000047,0x00000043,0x00000046,0x00050041,0x00000026,0x00000048,0x00000024,0x00000036, + 0x0004003d,0x00000006,0x00000049,0x00000048,0x00050084,0x00000006,0x0000004a,0x00000047, + 0x00000049,0x00050041,0x00000026,0x0000004b,0x00000024,0x0000002d,0x0004003d,0x00000006, + 0x0000004c,0x0000004b,0x00050084,0x00000006,0x0000004d,0x0000004a,0x0000004c,0x0004003d, + 0x00000006,0x0000004e,0x00000031,0x00050041,0x00000026,0x0000004f,0x00000024,0x0000002d, + 0x0004003d,0x00000006,0x00000050,0x0000004f,0x00050084,0x00000006,0x00000051,0x0000004e, + 0x00000050,0x00050080,0x00000006,0x00000052,0x0000004d,0x00000051,0x0004003d,0x00000006, + 0x00000053,0x0000002b,0x00050080,0x00000006,0x00000054,0x00000052,0x00000053,0x0003003e, + 0x00000042,0x00000054,0x00050041,0x00000026,0x00000056,0x00000024,0x00000036,0x0004003d, + 0x00000006,0x00000057,0x00000056,0x00050041,0x00000026,0x00000058,0x00000024,0x0000002d, + 0x0004003d,0x00000006,0x00000059,0x00000058,0x00050084,0x00000006,0x0000005a,0x00000057, + 0x00000059,0x0003003e,0x00000055,0x0000005a,0x0003003e,0x0000005b,0x00000025,0x0003003e, + 0x0000005d,0x0000005e,0x00050041,0x00000026,0x00000062,0x00000024,0x00000061,0x0004003d, + 0x00000006,0x00000063,0x00000062,0x00050041,0x00000026,0x00000064,0x00000024,0x00000044, + 0x0004003d,0x00000006,0x00000065,0x00000064,0x000500b1,0x00000029,0x00000066,0x00000063, + 0x00000065,0x000300f7,0x00000068,0x00000000,0x000400fa,0x00000066,0x00000067,0x0000006b, + 0x000200f8,0x00000067,0x00050041,0x00000026,0x00000069,0x00000024,0x00000061,0x0004003d, + 0x00000006,0x0000006a,0x00000069,0x0003003e,0x00000060,0x0000006a,0x000200f9,0x00000068, + 0x000200f8,0x0000006b,0x00050041,0x00000026,0x0000006c,0x00000024,0x00000044,0x0004003d, + 0x00000006,0x0000006d,0x0000006c,0x0003003e,0x00000060,0x0000006d,0x000200f9,0x00000068, + 0x000200f8,0x00000068,0x0004003d,0x00000006,0x0000006e,0x00000060,0x0003003e,0x0000005f, + 0x0000006e,0x000200f9,0x0000006f,0x000200f8,0x0000006f,0x000400f6,0x00000071,0x00000072, + 0x00000000,0x000200f9,0x00000073,0x000200f8,0x00000073,0x0004003d,0x00000006,0x00000074, + 0x0000005b,0x0004003d,0x00000006,0x00000075,0x0000005f,0x000500b1,0x00000029,0x00000076, + 0x00000074,0x00000075,0x000400fa,0x00000076,0x00000070,0x00000071,0x000200f8,0x00000070, + 0x0004003d,0x00000006,0x0000007b,0x00000042,0x0004003d,0x00000006,0x0000007c,0x0000005b, + 0x0004003d,0x00000006,0x0000007d,0x00000055,0x00050084,0x00000006,0x0000007e,0x0000007c, + 0x0000007d,0x00050080,0x00000006,0x0000007f,0x0000007b,0x0000007e,0x00060041,0x00000080, + 0x00000081,0x0000007a,0x00000025,0x0000007f,0x0004003d,0x00000021,0x00000082,0x00000081, + 0x0004003d,0x00000006,0x00000083,0x00000042,0x0004003d,0x00000006,0x00000084,0x0000005b, + 0x0004003d,0x00000006,0x00000085,0x00000055,0x00050084,0x00000006,0x00000086,0x00000084, + 0x00000085,0x00050080,0x00000006,0x00000087,0x00000083,0x00000086,0x00060041,0x00000080, + 0x00000088,0x0000007a,0x00000025,0x00000087,0x0004003d,0x00000021,0x00000089,0x00000088, + 0x00050085,0x00000021,0x0000008a,0x00000082,0x00000089,0x0004003d,0x00000021,0x0000008b, + 0x0000005d,0x00050081,0x00000021,0x0000008c,0x0000008b,0x0000008a,0x0003003e,0x0000005d, + 0x0000008c,0x0004003d,0x00000006,0x0000008d,0x0000005b,0x00050080,0x00000006,0x0000008e, + 0x0000008d,0x00000044,0x0003003e,0x0000005b,0x0000008e,0x000200f9,0x00000072,0x000200f8, + 0x00000072,0x000200f9,0x0000006f,0x000200f8,0x00000071,0x000200f9,0x0000008f,0x000200f8, + 0x0000008f,0x000400f6,0x00000091,0x00000092,0x00000000,0x000200f9,0x00000093,0x000200f8, + 0x00000093,0x0004003d,0x00000006,0x00000094,0x0000005b,0x00050041,0x00000026,0x00000095, + 0x00000024,0x00000044,0x0004003d,0x00000006,0x00000096,0x00000095,0x000500b1,0x00000029, + 0x00000097,0x00000094,0x00000096,0x000400fa,0x00000097,0x00000090,0x00000091,0x000200f8, + 0x00000090,0x0004003d,0x00000006,0x00000098,0x00000042,0x0004003d,0x00000006,0x00000099, + 0x0000005b,0x0004003d,0x00000006,0x0000009a,0x00000055,0x00050084,0x00000006,0x0000009b, + 0x00000099,0x0000009a,0x00050080,0x00000006,0x0000009c,0x00000098,0x0000009b,0x00060041, + 0x00000080,0x0000009d,0x0000007a,0x00000025,0x0000009c,0x0004003d,0x00000021,0x0000009e, + 0x0000009d,0x0004003d,0x00000006,0x0000009f,0x00000042,0x0004003d,0x00000006,0x000000a0, + 0x0000005b,0x0004003d,0x00000006,0x000000a1,0x00000055,0x00050084,0x00000006,0x000000a2, + 0x000000a0,0x000000a1,0x00050080,0x00000006,0x000000a3,0x0000009f,0x000000a2,0x00060041, + 0x00000080,0x000000a4,0x0000007a,0x00000025,0x000000a3,0x0004003d,0x00000021,0x000000a5, + 0x000000a4,0x00050085,0x00000021,0x000000a6,0x0000009e,0x000000a5,0x0004003d,0x00000021, + 0x000000a7,0x0000005d,0x00050081,0x00000021,0x000000a8,0x000000a7,0x000000a6,0x0003003e, + 0x0000005d,0x000000a8,0x0004003d,0x00000006,0x000000a9,0x0000005b,0x00050041,0x00000026, + 0x000000ab,0x00000024,0x000000aa,0x0004003d,0x00000006,0x000000ac,0x000000ab,0x00050082, + 0x00000006,0x000000ad,0x000000a9,0x000000ac,0x000500af,0x00000029,0x000000ae,0x000000ad, + 0x00000025,0x000300f7,0x000000b0,0x00000000,0x000400fa,0x000000ae,0x000000af,0x000000b0, + 0x000200f8,0x000000af,0x0004003d,0x00000006,0x000000b1,0x00000042,0x0004003d,0x00000006, + 0x000000b2,0x0000005b,0x00050041,0x00000026,0x000000b3,0x00000024,0x000000aa,0x0004003d, + 0x00000006,0x000000b4,0x000000b3,0x00050082,0x00000006,0x000000b5,0x000000b2,0x000000b4, + 0x0004003d,0x00000006,0x000000b6,0x00000055,0x00050084,0x00000006,0x000000b7,0x000000b5, + 0x000000b6,0x00050080,0x00000006,0x000000b8,0x000000b1,0x000000b7,0x00060041,0x00000080, + 0x000000b9,0x0000007a,0x00000025,0x000000b8,0x0004003d,0x00000021,0x000000ba,0x000000b9, + 0x0004003d,0x00000006,0x000000bb,0x00000042,0x0004003d,0x00000006,0x000000bc,0x0000005b, + 0x00050041,0x00000026,0x000000bd,0x00000024,0x000000aa,0x0004003d,0x00000006,0x000000be, + 0x000000bd,0x00050082,0x00000006,0x000000bf,0x000000bc,0x000000be,0x0004003d,0x00000006, + 0x000000c0,0x00000055,0x00050084,0x00000006,0x000000c1,0x000000bf,0x000000c0,0x00050080, + 0x00000006,0x000000c2,0x000000bb,0x000000c1,0x00060041,0x00000080,0x000000c3,0x0000007a, + 0x00000025,0x000000c2,0x0004003d,0x00000021,0x000000c4,0x000000c3,0x00050085,0x00000021, + 0x000000c5,0x000000ba,0x000000c4,0x0004003d,0x00000021,0x000000c6,0x0000005d,0x00050083, + 0x00000021,0x000000c7,0x000000c6,0x000000c5,0x0003003e,0x0000005d,0x000000c7,0x000200f9, + 0x000000b0,0x000200f8,0x000000b0,0x00050041,0x000000ca,0x000000cb,0x00000024,0x000000c9, + 0x0004003d,0x00000021,0x000000cc,0x000000cb,0x0004003d,0x00000021,0x000000cd,0x0000005d, + 0x00050041,0x000000ca,0x000000cf,0x00000024,0x000000ce,0x0004003d,0x00000021,0x000000d0, + 0x000000cf,0x00050085,0x00000021,0x000000d1,0x000000cd,0x000000d0,0x00050081,0x00000021, + 0x000000d2,0x000000cc,0x000000d1,0x0003003e,0x000000c8,0x000000d2,0x0004003d,0x00000006, + 0x000000d7,0x00000042,0x0004003d,0x00000006,0x000000d8,0x0000005b,0x00050041,0x00000026, + 0x000000d9,0x00000024,0x00000061,0x0004003d,0x00000006,0x000000da,0x000000d9,0x00050082, + 0x00000006,0x000000db,0x000000d8,0x000000da,0x0004003d,0x00000006,0x000000dc,0x00000055, + 0x00050084,0x00000006,0x000000dd,0x000000db,0x000000dc,0x00050080,0x00000006,0x000000de, + 0x000000d7,0x000000dd,0x0004003d,0x00000006,0x000000df,0x00000042,0x0004003d,0x00000006, + 0x000000e0,0x0000005b,0x00050041,0x00000026,0x000000e1,0x00000024,0x00000061,0x0004003d, + 0x00000006,0x000000e2,0x000000e1,0x00050082,0x00000006,0x000000e3,0x000000e0,0x000000e2, + 0x0004003d,0x00000006,0x000000e4,0x00000055,0x00050084,0x00000006,0x000000e5,0x000000e3, + 0x000000e4,0x00050080,0x00000006,0x000000e6,0x000000df,0x000000e5,0x00060041,0x00000080, + 0x000000e7,0x0000007a,0x00000025,0x000000e6,0x0004003d,0x00000021,0x000000e8,0x000000e7, + 0x0004003d,0x00000021,0x000000e9,0x000000c8,0x00050041,0x000000ca,0x000000eb,0x00000024, + 0x000000ea,0x0004003d,0x00000021,0x000000ec,0x000000eb,0x0007000c,0x00000021,0x000000ed, + 0x00000001,0x0000001a,0x000000e9,0x000000ec,0x00050085,0x00000021,0x000000ee,0x000000e8, + 0x000000ed,0x00060041,0x00000080,0x000000ef,0x000000d6,0x00000025,0x000000de,0x0003003e, + 0x000000ef,0x000000ee,0x0004003d,0x00000006,0x000000f0,0x0000005b,0x00050080,0x00000006, + 0x000000f1,0x000000f0,0x00000044,0x0003003e,0x0000005b,0x000000f1,0x000200f9,0x00000092, + 0x000200f8,0x00000092,0x000200f9,0x0000008f,0x000200f8,0x00000091,0x0004003d,0x00000006, + 0x000000f3,0x0000005b,0x0004003d,0x00000006,0x000000f4,0x0000005f,0x00050082,0x00000006, + 0x000000f5,0x000000f3,0x000000f4,0x0003003e,0x000000f2,0x000000f5,0x000200f9,0x000000f6, + 0x000200f8,0x000000f6,0x000400f6,0x000000f8,0x000000f9,0x00000000,0x000200f9,0x000000fa, + 0x000200f8,0x000000fa,0x0004003d,0x00000006,0x000000fb,0x000000f2,0x000500af,0x00000029, + 0x000000fc,0x000000fb,0x00000025,0x000300f7,0x000000fe,0x00000000,0x000400fa,0x000000fc, + 0x000000fd,0x000000fe,0x000200f8,0x000000fd,0x0004003d,0x00000006,0x000000ff,0x000000f2, + 0x00050041,0x00000026,0x00000100,0x00000024,0x00000044,0x0004003d,0x00000006,0x00000101, + 0x00000100,0x000500b1,0x00000029,0x00000102,0x000000ff,0x00000101,0x000200f9,0x000000fe, + 0x000200f8,0x000000fe,0x000700f5,0x00000029,0x00000103,0x000000fc,0x000000fa,0x00000102, + 0x000000fd,0x000400fa,0x00000103,0x000000f7,0x000000f8,0x000200f8,0x000000f7,0x0004003d, + 0x00000006,0x00000104,0x0000005b,0x00050041,0x00000026,0x00000105,0x00000024,0x000000aa, + 0x0004003d,0x00000006,0x00000106,0x00000105,0x00050082,0x00000006,0x00000107,0x00000104, + 0x00000106,0x000500af,0x00000029,0x00000108,0x00000107,0x00000025,0x000300f7,0x0000010a, + 0x00000000,0x000400fa,0x00000108,0x00000109,0x0000010a,0x000200f8,0x00000109,0x0004003d, + 0x00000006,0x0000010b,0x00000042,0x0004003d,0x00000006,0x0000010c,0x0000005b,0x00050041, + 0x00000026,0x0000010d,0x00000024,0x000000aa,0x0004003d,0x00000006,0x0000010e,0x0000010d, + 0x00050082,0x00000006,0x0000010f,0x0000010c,0x0000010e,0x0004003d,0x00000006,0x00000110, + 0x00000055,0x00050084,0x00000006,0x00000111,0x0000010f,0x00000110,0x00050080,0x00000006, + 0x00000112,0x0000010b,0x00000111,0x00060041,0x00000080,0x00000113,0x0000007a,0x00000025, + 0x00000112,0x0004003d,0x00000021,0x00000114,0x00000113,0x0004003d,0x00000006,0x00000115, + 0x00000042,0x0004003d,0x00000006,0x00000116,0x0000005b,0x00050041,0x00000026,0x00000117, + 0x00000024,0x000000aa,0x0004003d,0x00000006,0x00000118,0x00000117,0x00050082,0x00000006, + 0x00000119,0x00000116,0x00000118,0x0004003d,0x00000006,0x0000011a,0x00000055,0x00050084, + 0x00000006,0x0000011b,0x00000119,0x0000011a,0x00050080,0x00000006,0x0000011c,0x00000115, + 0x0000011b,0x00060041,0x00000080,0x0000011d,0x0000007a,0x00000025,0x0000011c,0x0004003d, + 0x00000021,0x0000011e,0x0000011d,0x00050085,0x00000021,0x0000011f,0x00000114,0x0000011e, + 0x0004003d,0x00000021,0x00000120,0x0000005d,0x00050083,0x00000021,0x00000121,0x00000120, + 0x0000011f,0x0003003e,0x0000005d,0x00000121,0x000200f9,0x0000010a,0x000200f8,0x0000010a, + 0x00050041,0x000000ca,0x00000122,0x00000024,0x000000c9,0x0004003d,0x00000021,0x00000123, + 0x00000122,0x0004003d,0x00000021,0x00000124,0x0000005d,0x00050041,0x000000ca,0x00000125, + 0x00000024,0x000000ce,0x0004003d,0x00000021,0x00000126,0x00000125,0x00050085,0x00000021, + 0x00000127,0x00000124,0x00000126,0x00050081,0x00000021,0x00000128,0x00000123,0x00000127, + 0x0003003e,0x000000c8,0x00000128,0x0004003d,0x00000006,0x00000129,0x00000042,0x0004003d, + 0x00000006,0x0000012a,0x000000f2,0x0004003d,0x00000006,0x0000012b,0x00000055,0x00050084, + 0x00000006,0x0000012c,0x0000012a,0x0000012b,0x00050080,0x00000006,0x0000012d,0x00000129, + 0x0000012c,0x0004003d,0x00000006,0x0000012e,0x00000042,0x0004003d,0x00000006,0x0000012f, + 0x000000f2,0x0004003d,0x00000006,0x00000130,0x00000055,0x00050084,0x00000006,0x00000131, + 0x0000012f,0x00000130,0x00050080,0x00000006,0x00000132,0x0000012e,0x00000131,0x00060041, + 0x00000080,0x00000133,0x0000007a,0x00000025,0x00000132,0x0004003d,0x00000021,0x00000134, + 0x00000133,0x0004003d,0x00000021,0x00000135,0x000000c8,0x00050041,0x000000ca,0x00000136, + 0x00000024,0x000000ea,0x0004003d,0x00000021,0x00000137,0x00000136,0x0007000c,0x00000021, + 0x00000138,0x00000001,0x0000001a,0x00000135,0x00000137,0x00050085,0x00000021,0x00000139, + 0x00000134,0x00000138,0x00060041,0x00000080,0x0000013a,0x000000d6,0x00000025,0x0000012d, + 0x0003003e,0x0000013a,0x00000139,0x0004003d,0x00000006,0x0000013b,0x0000005b,0x00050080, + 0x00000006,0x0000013c,0x0000013b,0x00000044,0x0003003e,0x0000005b,0x0000013c,0x0004003d, + 0x00000006,0x0000013d,0x000000f2,0x00050080,0x00000006,0x0000013e,0x0000013d,0x00000044, + 0x0003003e,0x000000f2,0x0000013e,0x000200f9,0x000000f9,0x000200f8,0x000000f9,0x000200f9, + 0x000000f6,0x000200f8,0x000000f8,0x000200f9,0x0000001e,0x000200f8,0x0000001e,0x0004003d, + 0x00000006,0x0000013f,0x00000012,0x0004003d,0x00000006,0x00000140,0x00000019,0x00050080, + 0x00000006,0x00000141,0x00000140,0x0000013f,0x0003003e,0x00000019,0x00000141,0x000200f9, + 0x0000001b,0x000200f8,0x0000001d,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/max_pool.comp b/modules/dnn/src/vkcom/shader/max_pool.comp new file mode 100644 index 0000000000..0bf2ce55af --- /dev/null +++ b/modules/dnn/src/vkcom/shader/max_pool.comp @@ -0,0 +1,64 @@ +#version 450 +#define LOCAL_SZ_X 256 +layout(push_constant) uniform pushBlock { + int channels; + int in_h; + int in_w; + int out_h; + int out_w; + int padding_h; + int padding_w; + int filter_h; + int filter_w; + int stride_h; + int stride_w; + int total; + int need_mask; +} p; + +layout(binding = 0) readonly buffer Input0{ + float in_buffer[]; +}; + +layout(binding = 1) writeonly buffer Output{ + float out_buffer[]; +}; + +layout(binding = 2) writeonly buffer Mask{ + float mask_buffer[]; +}; + +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; + +void main() +{ + int global_size = int(gl_WorkGroupSize.x * gl_NumWorkGroups.x); + int gid = int(gl_GlobalInvocationID.x); + for (int index = gid; index < p.total; index += global_size) + { + const int pw = index % p.out_w; + const int ph = (index / p.out_w) % p.out_h; + const int c = (index / p.out_w / p.out_h) % p.channels; + const int n = index / p.out_w / p.out_h / p.channels; + int hstart = ph * p.stride_h - p.padding_h; + int wstart = pw * p.stride_w - p.padding_w; + const int hend = min(hstart + p.filter_h, p.in_h); + const int wend = min(wstart + p.filter_w, p.in_w); + hstart = max(hstart, 0); + wstart = max(wstart, 0); + float maxval = -1./0.; + int maxidx = -1; + int off = (n * p.channels + c) * p.in_h * p.in_w; + for (int h = hstart; h < hend; ++h) { + for (int w = wstart; w < wend; ++w) { + if (in_buffer[off + h * p.in_w + w] > maxval) { + maxidx = h * p.in_w + w; + maxval = in_buffer[off + maxidx]; + } + } + } + out_buffer[index] = maxval; + if (p.need_mask == 1) + mask_buffer[index] = maxidx; + } +} diff --git a/modules/dnn/src/vkcom/shader/max_pool_spv.cpp b/modules/dnn/src/vkcom/shader/max_pool_spv.cpp new file mode 100644 index 0000000000..6e4809d8cf --- /dev/null +++ b/modules/dnn/src/vkcom/shader/max_pool_spv.cpp @@ -0,0 +1,197 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int max_pool_spv[1449] = { + 0x07230203,0x00010000,0x00080001,0x000000df,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0007000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x00000015,0x00060010, + 0x00000004,0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2, + 0x00040005,0x00000004,0x6e69616d,0x00000000,0x00050005,0x00000008,0x626f6c67,0x735f6c61, + 0x00657a69,0x00070005,0x0000000d,0x4e5f6c67,0x6f576d75,0x72476b72,0x7370756f,0x00000000, + 0x00030005,0x00000014,0x00646967,0x00080005,0x00000015,0x475f6c67,0x61626f6c,0x766e496c, + 0x7461636f,0x496e6f69,0x00000044,0x00040005,0x00000019,0x65646e69,0x00000078,0x00050005, + 0x00000021,0x68737570,0x636f6c42,0x0000006b,0x00060006,0x00000021,0x00000000,0x6e616863, + 0x736c656e,0x00000000,0x00050006,0x00000021,0x00000001,0x685f6e69,0x00000000,0x00050006, + 0x00000021,0x00000002,0x775f6e69,0x00000000,0x00050006,0x00000021,0x00000003,0x5f74756f, + 0x00000068,0x00050006,0x00000021,0x00000004,0x5f74756f,0x00000077,0x00060006,0x00000021, + 0x00000005,0x64646170,0x5f676e69,0x00000068,0x00060006,0x00000021,0x00000006,0x64646170, + 0x5f676e69,0x00000077,0x00060006,0x00000021,0x00000007,0x746c6966,0x685f7265,0x00000000, + 0x00060006,0x00000021,0x00000008,0x746c6966,0x775f7265,0x00000000,0x00060006,0x00000021, + 0x00000009,0x69727473,0x685f6564,0x00000000,0x00060006,0x00000021,0x0000000a,0x69727473, + 0x775f6564,0x00000000,0x00050006,0x00000021,0x0000000b,0x61746f74,0x0000006c,0x00060006, + 0x00000021,0x0000000c,0x6465656e,0x73616d5f,0x0000006b,0x00030005,0x00000023,0x00000070, + 0x00030005,0x0000002a,0x00007770,0x00030005,0x00000030,0x00006870,0x00030005,0x00000039, + 0x00000063,0x00030005,0x00000045,0x0000006e,0x00040005,0x00000050,0x61747368,0x00007472, + 0x00040005,0x0000005a,0x61747377,0x00007472,0x00040005,0x00000064,0x646e6568,0x00000000, + 0x00040005,0x0000006e,0x646e6577,0x00000000,0x00040005,0x0000007e,0x7678616d,0x00006c61, + 0x00040005,0x00000080,0x6978616d,0x00007864,0x00030005,0x00000082,0x0066666f,0x00030005, + 0x0000008f,0x00000068,0x00030005,0x00000099,0x00000077,0x00040005,0x000000a4,0x75706e49, + 0x00003074,0x00060006,0x000000a4,0x00000000,0x625f6e69,0x65666675,0x00000072,0x00030005, + 0x000000a6,0x00000000,0x00040005,0x000000c6,0x7074754f,0x00007475,0x00060006,0x000000c6, + 0x00000000,0x5f74756f,0x66667562,0x00007265,0x00030005,0x000000c8,0x00000000,0x00040005, + 0x000000d3,0x6b73614d,0x00000000,0x00060006,0x000000d3,0x00000000,0x6b73616d,0x6675625f, + 0x00726566,0x00030005,0x000000d5,0x00000000,0x00040047,0x0000000d,0x0000000b,0x00000018, + 0x00040047,0x00000015,0x0000000b,0x0000001c,0x00050048,0x00000021,0x00000000,0x00000023, + 0x00000000,0x00050048,0x00000021,0x00000001,0x00000023,0x00000004,0x00050048,0x00000021, + 0x00000002,0x00000023,0x00000008,0x00050048,0x00000021,0x00000003,0x00000023,0x0000000c, + 0x00050048,0x00000021,0x00000004,0x00000023,0x00000010,0x00050048,0x00000021,0x00000005, + 0x00000023,0x00000014,0x00050048,0x00000021,0x00000006,0x00000023,0x00000018,0x00050048, + 0x00000021,0x00000007,0x00000023,0x0000001c,0x00050048,0x00000021,0x00000008,0x00000023, + 0x00000020,0x00050048,0x00000021,0x00000009,0x00000023,0x00000024,0x00050048,0x00000021, + 0x0000000a,0x00000023,0x00000028,0x00050048,0x00000021,0x0000000b,0x00000023,0x0000002c, + 0x00050048,0x00000021,0x0000000c,0x00000023,0x00000030,0x00030047,0x00000021,0x00000002, + 0x00040047,0x000000a3,0x00000006,0x00000004,0x00040048,0x000000a4,0x00000000,0x00000018, + 0x00050048,0x000000a4,0x00000000,0x00000023,0x00000000,0x00030047,0x000000a4,0x00000003, + 0x00040047,0x000000a6,0x00000022,0x00000000,0x00040047,0x000000a6,0x00000021,0x00000000, + 0x00040047,0x000000c5,0x00000006,0x00000004,0x00040048,0x000000c6,0x00000000,0x00000019, + 0x00050048,0x000000c6,0x00000000,0x00000023,0x00000000,0x00030047,0x000000c6,0x00000003, + 0x00040047,0x000000c8,0x00000022,0x00000000,0x00040047,0x000000c8,0x00000021,0x00000001, + 0x00040047,0x000000d2,0x00000006,0x00000004,0x00040048,0x000000d3,0x00000000,0x00000019, + 0x00050048,0x000000d3,0x00000000,0x00000023,0x00000000,0x00030047,0x000000d3,0x00000003, + 0x00040047,0x000000d5,0x00000022,0x00000000,0x00040047,0x000000d5,0x00000021,0x00000002, + 0x00040047,0x000000de,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003, + 0x00000002,0x00040015,0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007, + 0x00000006,0x00040015,0x00000009,0x00000020,0x00000000,0x0004002b,0x00000009,0x0000000a, + 0x00000100,0x00040017,0x0000000b,0x00000009,0x00000003,0x00040020,0x0000000c,0x00000001, + 0x0000000b,0x0004003b,0x0000000c,0x0000000d,0x00000001,0x0004002b,0x00000009,0x0000000e, + 0x00000000,0x00040020,0x0000000f,0x00000001,0x00000009,0x0004003b,0x0000000c,0x00000015, + 0x00000001,0x000f001e,0x00000021,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006, + 0x00040020,0x00000022,0x00000009,0x00000021,0x0004003b,0x00000022,0x00000023,0x00000009, + 0x0004002b,0x00000006,0x00000024,0x0000000b,0x00040020,0x00000025,0x00000009,0x00000006, + 0x00020014,0x00000028,0x0004002b,0x00000006,0x0000002c,0x00000004,0x0004002b,0x00000006, + 0x00000035,0x00000003,0x0004002b,0x00000006,0x00000041,0x00000000,0x0004002b,0x00000006, + 0x00000052,0x00000009,0x0004002b,0x00000006,0x00000056,0x00000005,0x0004002b,0x00000006, + 0x0000005c,0x0000000a,0x0004002b,0x00000006,0x00000060,0x00000006,0x0004002b,0x00000006, + 0x00000066,0x00000007,0x0004002b,0x00000006,0x0000006a,0x00000001,0x0004002b,0x00000006, + 0x00000070,0x00000008,0x0004002b,0x00000006,0x00000074,0x00000002,0x00030016,0x0000007c, + 0x00000020,0x00040020,0x0000007d,0x00000007,0x0000007c,0x0004002b,0x0000007c,0x0000007f, + 0xff800000,0x0004002b,0x00000006,0x00000081,0xffffffff,0x0003001d,0x000000a3,0x0000007c, + 0x0003001e,0x000000a4,0x000000a3,0x00040020,0x000000a5,0x00000002,0x000000a4,0x0004003b, + 0x000000a5,0x000000a6,0x00000002,0x00040020,0x000000af,0x00000002,0x0000007c,0x0003001d, + 0x000000c5,0x0000007c,0x0003001e,0x000000c6,0x000000c5,0x00040020,0x000000c7,0x00000002, + 0x000000c6,0x0004003b,0x000000c7,0x000000c8,0x00000002,0x0004002b,0x00000006,0x000000cc, + 0x0000000c,0x0003001d,0x000000d2,0x0000007c,0x0003001e,0x000000d3,0x000000d2,0x00040020, + 0x000000d4,0x00000002,0x000000d3,0x0004003b,0x000000d4,0x000000d5,0x00000002,0x0004002b, + 0x00000009,0x000000dd,0x00000001,0x0006002c,0x0000000b,0x000000de,0x0000000a,0x000000dd, + 0x000000dd,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005, + 0x0004003b,0x00000007,0x00000008,0x00000007,0x0004003b,0x00000007,0x00000014,0x00000007, + 0x0004003b,0x00000007,0x00000019,0x00000007,0x0004003b,0x00000007,0x0000002a,0x00000007, + 0x0004003b,0x00000007,0x00000030,0x00000007,0x0004003b,0x00000007,0x00000039,0x00000007, + 0x0004003b,0x00000007,0x00000045,0x00000007,0x0004003b,0x00000007,0x00000050,0x00000007, + 0x0004003b,0x00000007,0x0000005a,0x00000007,0x0004003b,0x00000007,0x00000064,0x00000007, + 0x0004003b,0x00000007,0x0000006e,0x00000007,0x0004003b,0x0000007d,0x0000007e,0x00000007, + 0x0004003b,0x00000007,0x00000080,0x00000007,0x0004003b,0x00000007,0x00000082,0x00000007, + 0x0004003b,0x00000007,0x0000008f,0x00000007,0x0004003b,0x00000007,0x00000099,0x00000007, + 0x00050041,0x0000000f,0x00000010,0x0000000d,0x0000000e,0x0004003d,0x00000009,0x00000011, + 0x00000010,0x00050084,0x00000009,0x00000012,0x0000000a,0x00000011,0x0004007c,0x00000006, + 0x00000013,0x00000012,0x0003003e,0x00000008,0x00000013,0x00050041,0x0000000f,0x00000016, + 0x00000015,0x0000000e,0x0004003d,0x00000009,0x00000017,0x00000016,0x0004007c,0x00000006, + 0x00000018,0x00000017,0x0003003e,0x00000014,0x00000018,0x0004003d,0x00000006,0x0000001a, + 0x00000014,0x0003003e,0x00000019,0x0000001a,0x000200f9,0x0000001b,0x000200f8,0x0000001b, + 0x000400f6,0x0000001d,0x0000001e,0x00000000,0x000200f9,0x0000001f,0x000200f8,0x0000001f, + 0x0004003d,0x00000006,0x00000020,0x00000019,0x00050041,0x00000025,0x00000026,0x00000023, + 0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026,0x000500b1,0x00000028,0x00000029, + 0x00000020,0x00000027,0x000400fa,0x00000029,0x0000001c,0x0000001d,0x000200f8,0x0000001c, + 0x0004003d,0x00000006,0x0000002b,0x00000019,0x00050041,0x00000025,0x0000002d,0x00000023, + 0x0000002c,0x0004003d,0x00000006,0x0000002e,0x0000002d,0x0005008b,0x00000006,0x0000002f, + 0x0000002b,0x0000002e,0x0003003e,0x0000002a,0x0000002f,0x0004003d,0x00000006,0x00000031, + 0x00000019,0x00050041,0x00000025,0x00000032,0x00000023,0x0000002c,0x0004003d,0x00000006, + 0x00000033,0x00000032,0x00050087,0x00000006,0x00000034,0x00000031,0x00000033,0x00050041, + 0x00000025,0x00000036,0x00000023,0x00000035,0x0004003d,0x00000006,0x00000037,0x00000036, + 0x0005008b,0x00000006,0x00000038,0x00000034,0x00000037,0x0003003e,0x00000030,0x00000038, + 0x0004003d,0x00000006,0x0000003a,0x00000019,0x00050041,0x00000025,0x0000003b,0x00000023, + 0x0000002c,0x0004003d,0x00000006,0x0000003c,0x0000003b,0x00050087,0x00000006,0x0000003d, + 0x0000003a,0x0000003c,0x00050041,0x00000025,0x0000003e,0x00000023,0x00000035,0x0004003d, + 0x00000006,0x0000003f,0x0000003e,0x00050087,0x00000006,0x00000040,0x0000003d,0x0000003f, + 0x00050041,0x00000025,0x00000042,0x00000023,0x00000041,0x0004003d,0x00000006,0x00000043, + 0x00000042,0x0005008b,0x00000006,0x00000044,0x00000040,0x00000043,0x0003003e,0x00000039, + 0x00000044,0x0004003d,0x00000006,0x00000046,0x00000019,0x00050041,0x00000025,0x00000047, + 0x00000023,0x0000002c,0x0004003d,0x00000006,0x00000048,0x00000047,0x00050087,0x00000006, + 0x00000049,0x00000046,0x00000048,0x00050041,0x00000025,0x0000004a,0x00000023,0x00000035, + 0x0004003d,0x00000006,0x0000004b,0x0000004a,0x00050087,0x00000006,0x0000004c,0x00000049, + 0x0000004b,0x00050041,0x00000025,0x0000004d,0x00000023,0x00000041,0x0004003d,0x00000006, + 0x0000004e,0x0000004d,0x00050087,0x00000006,0x0000004f,0x0000004c,0x0000004e,0x0003003e, + 0x00000045,0x0000004f,0x0004003d,0x00000006,0x00000051,0x00000030,0x00050041,0x00000025, + 0x00000053,0x00000023,0x00000052,0x0004003d,0x00000006,0x00000054,0x00000053,0x00050084, + 0x00000006,0x00000055,0x00000051,0x00000054,0x00050041,0x00000025,0x00000057,0x00000023, + 0x00000056,0x0004003d,0x00000006,0x00000058,0x00000057,0x00050082,0x00000006,0x00000059, + 0x00000055,0x00000058,0x0003003e,0x00000050,0x00000059,0x0004003d,0x00000006,0x0000005b, + 0x0000002a,0x00050041,0x00000025,0x0000005d,0x00000023,0x0000005c,0x0004003d,0x00000006, + 0x0000005e,0x0000005d,0x00050084,0x00000006,0x0000005f,0x0000005b,0x0000005e,0x00050041, + 0x00000025,0x00000061,0x00000023,0x00000060,0x0004003d,0x00000006,0x00000062,0x00000061, + 0x00050082,0x00000006,0x00000063,0x0000005f,0x00000062,0x0003003e,0x0000005a,0x00000063, + 0x0004003d,0x00000006,0x00000065,0x00000050,0x00050041,0x00000025,0x00000067,0x00000023, + 0x00000066,0x0004003d,0x00000006,0x00000068,0x00000067,0x00050080,0x00000006,0x00000069, + 0x00000065,0x00000068,0x00050041,0x00000025,0x0000006b,0x00000023,0x0000006a,0x0004003d, + 0x00000006,0x0000006c,0x0000006b,0x0007000c,0x00000006,0x0000006d,0x00000001,0x00000027, + 0x00000069,0x0000006c,0x0003003e,0x00000064,0x0000006d,0x0004003d,0x00000006,0x0000006f, + 0x0000005a,0x00050041,0x00000025,0x00000071,0x00000023,0x00000070,0x0004003d,0x00000006, + 0x00000072,0x00000071,0x00050080,0x00000006,0x00000073,0x0000006f,0x00000072,0x00050041, + 0x00000025,0x00000075,0x00000023,0x00000074,0x0004003d,0x00000006,0x00000076,0x00000075, + 0x0007000c,0x00000006,0x00000077,0x00000001,0x00000027,0x00000073,0x00000076,0x0003003e, + 0x0000006e,0x00000077,0x0004003d,0x00000006,0x00000078,0x00000050,0x0007000c,0x00000006, + 0x00000079,0x00000001,0x0000002a,0x00000078,0x00000041,0x0003003e,0x00000050,0x00000079, + 0x0004003d,0x00000006,0x0000007a,0x0000005a,0x0007000c,0x00000006,0x0000007b,0x00000001, + 0x0000002a,0x0000007a,0x00000041,0x0003003e,0x0000005a,0x0000007b,0x0003003e,0x0000007e, + 0x0000007f,0x0003003e,0x00000080,0x00000081,0x0004003d,0x00000006,0x00000083,0x00000045, + 0x00050041,0x00000025,0x00000084,0x00000023,0x00000041,0x0004003d,0x00000006,0x00000085, + 0x00000084,0x00050084,0x00000006,0x00000086,0x00000083,0x00000085,0x0004003d,0x00000006, + 0x00000087,0x00000039,0x00050080,0x00000006,0x00000088,0x00000086,0x00000087,0x00050041, + 0x00000025,0x00000089,0x00000023,0x0000006a,0x0004003d,0x00000006,0x0000008a,0x00000089, + 0x00050084,0x00000006,0x0000008b,0x00000088,0x0000008a,0x00050041,0x00000025,0x0000008c, + 0x00000023,0x00000074,0x0004003d,0x00000006,0x0000008d,0x0000008c,0x00050084,0x00000006, + 0x0000008e,0x0000008b,0x0000008d,0x0003003e,0x00000082,0x0000008e,0x0004003d,0x00000006, + 0x00000090,0x00000050,0x0003003e,0x0000008f,0x00000090,0x000200f9,0x00000091,0x000200f8, + 0x00000091,0x000400f6,0x00000093,0x00000094,0x00000000,0x000200f9,0x00000095,0x000200f8, + 0x00000095,0x0004003d,0x00000006,0x00000096,0x0000008f,0x0004003d,0x00000006,0x00000097, + 0x00000064,0x000500b1,0x00000028,0x00000098,0x00000096,0x00000097,0x000400fa,0x00000098, + 0x00000092,0x00000093,0x000200f8,0x00000092,0x0004003d,0x00000006,0x0000009a,0x0000005a, + 0x0003003e,0x00000099,0x0000009a,0x000200f9,0x0000009b,0x000200f8,0x0000009b,0x000400f6, + 0x0000009d,0x0000009e,0x00000000,0x000200f9,0x0000009f,0x000200f8,0x0000009f,0x0004003d, + 0x00000006,0x000000a0,0x00000099,0x0004003d,0x00000006,0x000000a1,0x0000006e,0x000500b1, + 0x00000028,0x000000a2,0x000000a0,0x000000a1,0x000400fa,0x000000a2,0x0000009c,0x0000009d, + 0x000200f8,0x0000009c,0x0004003d,0x00000006,0x000000a7,0x00000082,0x0004003d,0x00000006, + 0x000000a8,0x0000008f,0x00050041,0x00000025,0x000000a9,0x00000023,0x00000074,0x0004003d, + 0x00000006,0x000000aa,0x000000a9,0x00050084,0x00000006,0x000000ab,0x000000a8,0x000000aa, + 0x00050080,0x00000006,0x000000ac,0x000000a7,0x000000ab,0x0004003d,0x00000006,0x000000ad, + 0x00000099,0x00050080,0x00000006,0x000000ae,0x000000ac,0x000000ad,0x00060041,0x000000af, + 0x000000b0,0x000000a6,0x00000041,0x000000ae,0x0004003d,0x0000007c,0x000000b1,0x000000b0, + 0x0004003d,0x0000007c,0x000000b2,0x0000007e,0x000500ba,0x00000028,0x000000b3,0x000000b1, + 0x000000b2,0x000300f7,0x000000b5,0x00000000,0x000400fa,0x000000b3,0x000000b4,0x000000b5, + 0x000200f8,0x000000b4,0x0004003d,0x00000006,0x000000b6,0x0000008f,0x00050041,0x00000025, + 0x000000b7,0x00000023,0x00000074,0x0004003d,0x00000006,0x000000b8,0x000000b7,0x00050084, + 0x00000006,0x000000b9,0x000000b6,0x000000b8,0x0004003d,0x00000006,0x000000ba,0x00000099, + 0x00050080,0x00000006,0x000000bb,0x000000b9,0x000000ba,0x0003003e,0x00000080,0x000000bb, + 0x0004003d,0x00000006,0x000000bc,0x00000082,0x0004003d,0x00000006,0x000000bd,0x00000080, + 0x00050080,0x00000006,0x000000be,0x000000bc,0x000000bd,0x00060041,0x000000af,0x000000bf, + 0x000000a6,0x00000041,0x000000be,0x0004003d,0x0000007c,0x000000c0,0x000000bf,0x0003003e, + 0x0000007e,0x000000c0,0x000200f9,0x000000b5,0x000200f8,0x000000b5,0x000200f9,0x0000009e, + 0x000200f8,0x0000009e,0x0004003d,0x00000006,0x000000c1,0x00000099,0x00050080,0x00000006, + 0x000000c2,0x000000c1,0x0000006a,0x0003003e,0x00000099,0x000000c2,0x000200f9,0x0000009b, + 0x000200f8,0x0000009d,0x000200f9,0x00000094,0x000200f8,0x00000094,0x0004003d,0x00000006, + 0x000000c3,0x0000008f,0x00050080,0x00000006,0x000000c4,0x000000c3,0x0000006a,0x0003003e, + 0x0000008f,0x000000c4,0x000200f9,0x00000091,0x000200f8,0x00000093,0x0004003d,0x00000006, + 0x000000c9,0x00000019,0x0004003d,0x0000007c,0x000000ca,0x0000007e,0x00060041,0x000000af, + 0x000000cb,0x000000c8,0x00000041,0x000000c9,0x0003003e,0x000000cb,0x000000ca,0x00050041, + 0x00000025,0x000000cd,0x00000023,0x000000cc,0x0004003d,0x00000006,0x000000ce,0x000000cd, + 0x000500aa,0x00000028,0x000000cf,0x000000ce,0x0000006a,0x000300f7,0x000000d1,0x00000000, + 0x000400fa,0x000000cf,0x000000d0,0x000000d1,0x000200f8,0x000000d0,0x0004003d,0x00000006, + 0x000000d6,0x00000019,0x0004003d,0x00000006,0x000000d7,0x00000080,0x0004006f,0x0000007c, + 0x000000d8,0x000000d7,0x00060041,0x000000af,0x000000d9,0x000000d5,0x00000041,0x000000d6, + 0x0003003e,0x000000d9,0x000000d8,0x000200f9,0x000000d1,0x000200f8,0x000000d1,0x000200f9, + 0x0000001e,0x000200f8,0x0000001e,0x0004003d,0x00000006,0x000000da,0x00000008,0x0004003d, + 0x00000006,0x000000db,0x00000019,0x00050080,0x00000006,0x000000dc,0x000000db,0x000000da, + 0x0003003e,0x00000019,0x000000dc,0x000200f9,0x0000001b,0x000200f8,0x0000001d,0x000100fd, + 0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/permute.comp b/modules/dnn/src/vkcom/shader/permute.comp new file mode 100644 index 0000000000..df4b997544 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/permute.comp @@ -0,0 +1,44 @@ +#version 450 +#define LOCAL_SZ_X 256 + +layout(push_constant) uniform pushBlock { + int nthreads; + int num_axes; + int global_size; +} p; + +layout(binding = 0) readonly buffer Input0{ + float in_buffer[]; +}; +layout(binding = 1) readonly buffer Input1{ + int permute_order[]; +}; +layout(binding = 2) readonly buffer Input2{ + int old_stride[]; +}; +layout(binding = 3) readonly buffer Input3{ + int new_stride[]; +}; +layout(binding = 4) writeonly buffer Output{ + float out_buffer[]; +}; + +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; + +void main() +{ + for (int i = int(gl_GlobalInvocationID.x); i < p.nthreads; i += p.global_size) + { + int old_pos = 0; + int new_pos = i; + + for (int j = 0; j < p.num_axes; ++j) + { + int order = permute_order[j]; + old_pos += (new_pos / new_stride[j]) * old_stride[order]; + new_pos %= new_stride[j]; + } + + out_buffer[i] = in_buffer[old_pos]; + } +} diff --git a/modules/dnn/src/vkcom/shader/permute_spv.cpp b/modules/dnn/src/vkcom/shader/permute_spv.cpp new file mode 100644 index 0000000000..65de196a84 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/permute_spv.cpp @@ -0,0 +1,111 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int permute_spv[765] = { + 0x07230203,0x00010000,0x00080001,0x00000069,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00060010,0x00000004, + 0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00000069,0x00080005,0x0000000c, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00050005,0x00000018, + 0x68737570,0x636f6c42,0x0000006b,0x00060006,0x00000018,0x00000000,0x7268746e,0x73646165, + 0x00000000,0x00060006,0x00000018,0x00000001,0x5f6d756e,0x73657861,0x00000000,0x00060006, + 0x00000018,0x00000002,0x626f6c67,0x735f6c61,0x00657a69,0x00030005,0x0000001a,0x00000070, + 0x00040005,0x00000021,0x5f646c6f,0x00736f70,0x00040005,0x00000022,0x5f77656e,0x00736f70, + 0x00030005,0x00000024,0x0000006a,0x00040005,0x0000002f,0x6564726f,0x00000072,0x00040005, + 0x00000031,0x75706e49,0x00003174,0x00070006,0x00000031,0x00000000,0x6d726570,0x5f657475, + 0x6564726f,0x00000072,0x00030005,0x00000033,0x00000000,0x00040005,0x0000003a,0x75706e49, + 0x00003374,0x00060006,0x0000003a,0x00000000,0x5f77656e,0x69727473,0x00006564,0x00030005, + 0x0000003c,0x00000000,0x00040005,0x00000042,0x75706e49,0x00003274,0x00060006,0x00000042, + 0x00000000,0x5f646c6f,0x69727473,0x00006564,0x00030005,0x00000044,0x00000000,0x00040005, + 0x00000054,0x7074754f,0x00007475,0x00060006,0x00000054,0x00000000,0x5f74756f,0x66667562, + 0x00007265,0x00030005,0x00000056,0x00000000,0x00040005,0x00000059,0x75706e49,0x00003074, + 0x00060006,0x00000059,0x00000000,0x625f6e69,0x65666675,0x00000072,0x00030005,0x0000005b, + 0x00000000,0x00040047,0x0000000c,0x0000000b,0x0000001c,0x00050048,0x00000018,0x00000000, + 0x00000023,0x00000000,0x00050048,0x00000018,0x00000001,0x00000023,0x00000004,0x00050048, + 0x00000018,0x00000002,0x00000023,0x00000008,0x00030047,0x00000018,0x00000002,0x00040047, + 0x00000030,0x00000006,0x00000004,0x00040048,0x00000031,0x00000000,0x00000018,0x00050048, + 0x00000031,0x00000000,0x00000023,0x00000000,0x00030047,0x00000031,0x00000003,0x00040047, + 0x00000033,0x00000022,0x00000000,0x00040047,0x00000033,0x00000021,0x00000001,0x00040047, + 0x00000039,0x00000006,0x00000004,0x00040048,0x0000003a,0x00000000,0x00000018,0x00050048, + 0x0000003a,0x00000000,0x00000023,0x00000000,0x00030047,0x0000003a,0x00000003,0x00040047, + 0x0000003c,0x00000022,0x00000000,0x00040047,0x0000003c,0x00000021,0x00000003,0x00040047, + 0x00000041,0x00000006,0x00000004,0x00040048,0x00000042,0x00000000,0x00000018,0x00050048, + 0x00000042,0x00000000,0x00000023,0x00000000,0x00030047,0x00000042,0x00000003,0x00040047, + 0x00000044,0x00000022,0x00000000,0x00040047,0x00000044,0x00000021,0x00000002,0x00040047, + 0x00000053,0x00000006,0x00000004,0x00040048,0x00000054,0x00000000,0x00000019,0x00050048, + 0x00000054,0x00000000,0x00000023,0x00000000,0x00030047,0x00000054,0x00000003,0x00040047, + 0x00000056,0x00000022,0x00000000,0x00040047,0x00000056,0x00000021,0x00000004,0x00040047, + 0x00000058,0x00000006,0x00000004,0x00040048,0x00000059,0x00000000,0x00000018,0x00050048, + 0x00000059,0x00000000,0x00000023,0x00000000,0x00030047,0x00000059,0x00000003,0x00040047, + 0x0000005b,0x00000022,0x00000000,0x00040047,0x0000005b,0x00000021,0x00000000,0x00040047, + 0x00000068,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002, + 0x00040015,0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007,0x00000006, + 0x00040015,0x00000009,0x00000020,0x00000000,0x00040017,0x0000000a,0x00000009,0x00000003, + 0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,0x0000000c,0x00000001, + 0x0004002b,0x00000009,0x0000000d,0x00000000,0x00040020,0x0000000e,0x00000001,0x00000009, + 0x0005001e,0x00000018,0x00000006,0x00000006,0x00000006,0x00040020,0x00000019,0x00000009, + 0x00000018,0x0004003b,0x00000019,0x0000001a,0x00000009,0x0004002b,0x00000006,0x0000001b, + 0x00000000,0x00040020,0x0000001c,0x00000009,0x00000006,0x00020014,0x0000001f,0x0004002b, + 0x00000006,0x0000002b,0x00000001,0x0003001d,0x00000030,0x00000006,0x0003001e,0x00000031, + 0x00000030,0x00040020,0x00000032,0x00000002,0x00000031,0x0004003b,0x00000032,0x00000033, + 0x00000002,0x00040020,0x00000035,0x00000002,0x00000006,0x0003001d,0x00000039,0x00000006, + 0x0003001e,0x0000003a,0x00000039,0x00040020,0x0000003b,0x00000002,0x0000003a,0x0004003b, + 0x0000003b,0x0000003c,0x00000002,0x0003001d,0x00000041,0x00000006,0x0003001e,0x00000042, + 0x00000041,0x00040020,0x00000043,0x00000002,0x00000042,0x0004003b,0x00000043,0x00000044, + 0x00000002,0x00030016,0x00000052,0x00000020,0x0003001d,0x00000053,0x00000052,0x0003001e, + 0x00000054,0x00000053,0x00040020,0x00000055,0x00000002,0x00000054,0x0004003b,0x00000055, + 0x00000056,0x00000002,0x0003001d,0x00000058,0x00000052,0x0003001e,0x00000059,0x00000058, + 0x00040020,0x0000005a,0x00000002,0x00000059,0x0004003b,0x0000005a,0x0000005b,0x00000002, + 0x00040020,0x0000005d,0x00000002,0x00000052,0x0004002b,0x00000006,0x00000061,0x00000002, + 0x0004002b,0x00000009,0x00000066,0x00000100,0x0004002b,0x00000009,0x00000067,0x00000001, + 0x0006002c,0x0000000a,0x00000068,0x00000066,0x00000067,0x00000067,0x00050036,0x00000002, + 0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008, + 0x00000007,0x0004003b,0x00000007,0x00000021,0x00000007,0x0004003b,0x00000007,0x00000022, + 0x00000007,0x0004003b,0x00000007,0x00000024,0x00000007,0x0004003b,0x00000007,0x0000002f, + 0x00000007,0x00050041,0x0000000e,0x0000000f,0x0000000c,0x0000000d,0x0004003d,0x00000009, + 0x00000010,0x0000000f,0x0004007c,0x00000006,0x00000011,0x00000010,0x0003003e,0x00000008, + 0x00000011,0x000200f9,0x00000012,0x000200f8,0x00000012,0x000400f6,0x00000014,0x00000015, + 0x00000000,0x000200f9,0x00000016,0x000200f8,0x00000016,0x0004003d,0x00000006,0x00000017, + 0x00000008,0x00050041,0x0000001c,0x0000001d,0x0000001a,0x0000001b,0x0004003d,0x00000006, + 0x0000001e,0x0000001d,0x000500b1,0x0000001f,0x00000020,0x00000017,0x0000001e,0x000400fa, + 0x00000020,0x00000013,0x00000014,0x000200f8,0x00000013,0x0003003e,0x00000021,0x0000001b, + 0x0004003d,0x00000006,0x00000023,0x00000008,0x0003003e,0x00000022,0x00000023,0x0003003e, + 0x00000024,0x0000001b,0x000200f9,0x00000025,0x000200f8,0x00000025,0x000400f6,0x00000027, + 0x00000028,0x00000000,0x000200f9,0x00000029,0x000200f8,0x00000029,0x0004003d,0x00000006, + 0x0000002a,0x00000024,0x00050041,0x0000001c,0x0000002c,0x0000001a,0x0000002b,0x0004003d, + 0x00000006,0x0000002d,0x0000002c,0x000500b1,0x0000001f,0x0000002e,0x0000002a,0x0000002d, + 0x000400fa,0x0000002e,0x00000026,0x00000027,0x000200f8,0x00000026,0x0004003d,0x00000006, + 0x00000034,0x00000024,0x00060041,0x00000035,0x00000036,0x00000033,0x0000001b,0x00000034, + 0x0004003d,0x00000006,0x00000037,0x00000036,0x0003003e,0x0000002f,0x00000037,0x0004003d, + 0x00000006,0x00000038,0x00000022,0x0004003d,0x00000006,0x0000003d,0x00000024,0x00060041, + 0x00000035,0x0000003e,0x0000003c,0x0000001b,0x0000003d,0x0004003d,0x00000006,0x0000003f, + 0x0000003e,0x00050087,0x00000006,0x00000040,0x00000038,0x0000003f,0x0004003d,0x00000006, + 0x00000045,0x0000002f,0x00060041,0x00000035,0x00000046,0x00000044,0x0000001b,0x00000045, + 0x0004003d,0x00000006,0x00000047,0x00000046,0x00050084,0x00000006,0x00000048,0x00000040, + 0x00000047,0x0004003d,0x00000006,0x00000049,0x00000021,0x00050080,0x00000006,0x0000004a, + 0x00000049,0x00000048,0x0003003e,0x00000021,0x0000004a,0x0004003d,0x00000006,0x0000004b, + 0x00000024,0x00060041,0x00000035,0x0000004c,0x0000003c,0x0000001b,0x0000004b,0x0004003d, + 0x00000006,0x0000004d,0x0000004c,0x0004003d,0x00000006,0x0000004e,0x00000022,0x0005008b, + 0x00000006,0x0000004f,0x0000004e,0x0000004d,0x0003003e,0x00000022,0x0000004f,0x000200f9, + 0x00000028,0x000200f8,0x00000028,0x0004003d,0x00000006,0x00000050,0x00000024,0x00050080, + 0x00000006,0x00000051,0x00000050,0x0000002b,0x0003003e,0x00000024,0x00000051,0x000200f9, + 0x00000025,0x000200f8,0x00000027,0x0004003d,0x00000006,0x00000057,0x00000008,0x0004003d, + 0x00000006,0x0000005c,0x00000021,0x00060041,0x0000005d,0x0000005e,0x0000005b,0x0000001b, + 0x0000005c,0x0004003d,0x00000052,0x0000005f,0x0000005e,0x00060041,0x0000005d,0x00000060, + 0x00000056,0x0000001b,0x00000057,0x0003003e,0x00000060,0x0000005f,0x000200f9,0x00000015, + 0x000200f8,0x00000015,0x00050041,0x0000001c,0x00000062,0x0000001a,0x00000061,0x0004003d, + 0x00000006,0x00000063,0x00000062,0x0004003d,0x00000006,0x00000064,0x00000008,0x00050080, + 0x00000006,0x00000065,0x00000064,0x00000063,0x0003003e,0x00000008,0x00000065,0x000200f9, + 0x00000012,0x000200f8,0x00000014,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/prior_box.comp b/modules/dnn/src/vkcom/shader/prior_box.comp new file mode 100644 index 0000000000..dfb378177a --- /dev/null +++ b/modules/dnn/src/vkcom/shader/prior_box.comp @@ -0,0 +1,78 @@ +#version 450 +#define LOCAL_SZ_X 256 + +layout(push_constant) uniform pushBlock { + int global_size; + int nthreads; + float step_x; + float step_y; + int offset_x_size; + int width_size; + int layer_w; + int image_h; + int image_w; + int clip; + int variance_off; +} p; + +layout(binding = 0) readonly buffer Input0{ + float offset_x[]; +}; +layout(binding = 1) readonly buffer Input1{ + float offset_y[]; +}; +layout(binding = 2) readonly buffer Input2{ + float widths[]; +}; +layout(binding = 3) readonly buffer Input3{ + float heights[]; +}; +layout(binding = 4) readonly buffer Input4{ + vec4 variance[]; +}; +layout(binding = 5) writeonly buffer Output{ + vec4 out_buffer[]; +}; + +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; + +void main() +{ + for (int index = int(gl_GlobalInvocationID.x); index < p.nthreads; index += p.global_size) + { + int w = index % p.layer_w; + int h = index / p.layer_w; + int output_offset = index * p.offset_x_size * p.width_size; + + float box_w, box_h; + vec4 outer; + for (int i = 0; i < p.width_size; ++i) + { + box_w = widths[i]; + box_h = heights[i]; + for (int j = 0; j < p.offset_x_size; ++j) + { + float center_x = (w + offset_x[j]) * p.step_x; + float center_y = (h + offset_y[j]) * p.step_y; + + outer.x = (center_x - box_w * 0.5f) / p.image_w; // xmin + outer.y = (center_y - box_h * 0.5f) / p.image_h; // ymin + outer.z = (center_x + box_w * 0.5f) / p.image_w; // xmax + outer.w = (center_y + box_h * 0.5f) / p.image_h; // ymax + + // clip + if (p.clip == 1) + { + vec4 start = vec4(0.f, 0.f, 0.f, 0.f); + vec4 end = vec4(1.f, 1.f, 1.f, 1.f); + outer = min(max(outer, start), end); + } + + //set variance + out_buffer[p.variance_off + output_offset] = variance[0]; + out_buffer[output_offset] = outer; + output_offset++; + } + } + } +} diff --git a/modules/dnn/src/vkcom/shader/prior_box_spv.cpp b/modules/dnn/src/vkcom/shader/prior_box_spv.cpp new file mode 100644 index 0000000000..9d988c67b9 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/prior_box_spv.cpp @@ -0,0 +1,200 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int prior_box_spv[1480] = { + 0x07230203,0x00010000,0x00080001,0x000000db,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00060010,0x00000004, + 0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00040005,0x00000008,0x65646e69,0x00000078,0x00080005, + 0x0000000c,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00050005, + 0x00000019,0x68737570,0x636f6c42,0x0000006b,0x00060006,0x00000019,0x00000000,0x626f6c67, + 0x735f6c61,0x00657a69,0x00060006,0x00000019,0x00000001,0x7268746e,0x73646165,0x00000000, + 0x00050006,0x00000019,0x00000002,0x70657473,0x0000785f,0x00050006,0x00000019,0x00000003, + 0x70657473,0x0000795f,0x00070006,0x00000019,0x00000004,0x7366666f,0x785f7465,0x7a69735f, + 0x00000065,0x00060006,0x00000019,0x00000005,0x74646977,0x69735f68,0x0000657a,0x00050006, + 0x00000019,0x00000006,0x6579616c,0x00775f72,0x00050006,0x00000019,0x00000007,0x67616d69, + 0x00685f65,0x00050006,0x00000019,0x00000008,0x67616d69,0x00775f65,0x00050006,0x00000019, + 0x00000009,0x70696c63,0x00000000,0x00070006,0x00000019,0x0000000a,0x69726176,0x65636e61, + 0x66666f5f,0x00000000,0x00030005,0x0000001b,0x00000070,0x00030005,0x00000022,0x00000077, + 0x00030005,0x00000028,0x00000068,0x00060005,0x0000002d,0x7074756f,0x6f5f7475,0x65736666, + 0x00000074,0x00030005,0x00000037,0x00000069,0x00040005,0x00000043,0x5f786f62,0x00000077, + 0x00040005,0x00000045,0x75706e49,0x00003274,0x00050006,0x00000045,0x00000000,0x74646977, + 0x00007368,0x00030005,0x00000047,0x00000000,0x00040005,0x0000004c,0x5f786f62,0x00000068, + 0x00040005,0x0000004e,0x75706e49,0x00003374,0x00050006,0x0000004e,0x00000000,0x67696568, + 0x00737468,0x00030005,0x00000050,0x00000000,0x00030005,0x00000054,0x0000006a,0x00050005, + 0x0000005e,0x746e6563,0x785f7265,0x00000000,0x00040005,0x00000062,0x75706e49,0x00003074, + 0x00060006,0x00000062,0x00000000,0x7366666f,0x785f7465,0x00000000,0x00030005,0x00000064, + 0x00000000,0x00050005,0x0000006e,0x746e6563,0x795f7265,0x00000000,0x00040005,0x00000072, + 0x75706e49,0x00003174,0x00060006,0x00000072,0x00000000,0x7366666f,0x795f7465,0x00000000, + 0x00030005,0x00000074,0x00000000,0x00040005,0x0000007f,0x6574756f,0x00000072,0x00040005, + 0x000000b0,0x72617473,0x00000074,0x00030005,0x000000b3,0x00646e65,0x00040005,0x000000bc, + 0x7074754f,0x00007475,0x00060006,0x000000bc,0x00000000,0x5f74756f,0x66667562,0x00007265, + 0x00030005,0x000000be,0x00000000,0x00040005,0x000000c5,0x75706e49,0x00003474,0x00060006, + 0x000000c5,0x00000000,0x69726176,0x65636e61,0x00000000,0x00030005,0x000000c7,0x00000000, + 0x00040047,0x0000000c,0x0000000b,0x0000001c,0x00050048,0x00000019,0x00000000,0x00000023, + 0x00000000,0x00050048,0x00000019,0x00000001,0x00000023,0x00000004,0x00050048,0x00000019, + 0x00000002,0x00000023,0x00000008,0x00050048,0x00000019,0x00000003,0x00000023,0x0000000c, + 0x00050048,0x00000019,0x00000004,0x00000023,0x00000010,0x00050048,0x00000019,0x00000005, + 0x00000023,0x00000014,0x00050048,0x00000019,0x00000006,0x00000023,0x00000018,0x00050048, + 0x00000019,0x00000007,0x00000023,0x0000001c,0x00050048,0x00000019,0x00000008,0x00000023, + 0x00000020,0x00050048,0x00000019,0x00000009,0x00000023,0x00000024,0x00050048,0x00000019, + 0x0000000a,0x00000023,0x00000028,0x00030047,0x00000019,0x00000002,0x00040047,0x00000044, + 0x00000006,0x00000004,0x00040048,0x00000045,0x00000000,0x00000018,0x00050048,0x00000045, + 0x00000000,0x00000023,0x00000000,0x00030047,0x00000045,0x00000003,0x00040047,0x00000047, + 0x00000022,0x00000000,0x00040047,0x00000047,0x00000021,0x00000002,0x00040047,0x0000004d, + 0x00000006,0x00000004,0x00040048,0x0000004e,0x00000000,0x00000018,0x00050048,0x0000004e, + 0x00000000,0x00000023,0x00000000,0x00030047,0x0000004e,0x00000003,0x00040047,0x00000050, + 0x00000022,0x00000000,0x00040047,0x00000050,0x00000021,0x00000003,0x00040047,0x00000061, + 0x00000006,0x00000004,0x00040048,0x00000062,0x00000000,0x00000018,0x00050048,0x00000062, + 0x00000000,0x00000023,0x00000000,0x00030047,0x00000062,0x00000003,0x00040047,0x00000064, + 0x00000022,0x00000000,0x00040047,0x00000064,0x00000021,0x00000000,0x00040047,0x00000071, + 0x00000006,0x00000004,0x00040048,0x00000072,0x00000000,0x00000018,0x00050048,0x00000072, + 0x00000000,0x00000023,0x00000000,0x00030047,0x00000072,0x00000003,0x00040047,0x00000074, + 0x00000022,0x00000000,0x00040047,0x00000074,0x00000021,0x00000001,0x00040047,0x000000bb, + 0x00000006,0x00000010,0x00040048,0x000000bc,0x00000000,0x00000019,0x00050048,0x000000bc, + 0x00000000,0x00000023,0x00000000,0x00030047,0x000000bc,0x00000003,0x00040047,0x000000be, + 0x00000022,0x00000000,0x00040047,0x000000be,0x00000021,0x00000005,0x00040047,0x000000c4, + 0x00000006,0x00000010,0x00040048,0x000000c5,0x00000000,0x00000018,0x00050048,0x000000c5, + 0x00000000,0x00000023,0x00000000,0x00030047,0x000000c5,0x00000003,0x00040047,0x000000c7, + 0x00000022,0x00000000,0x00040047,0x000000c7,0x00000021,0x00000004,0x00040047,0x000000da, + 0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00040015, + 0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007,0x00000006,0x00040015, + 0x00000009,0x00000020,0x00000000,0x00040017,0x0000000a,0x00000009,0x00000003,0x00040020, + 0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,0x0000000c,0x00000001,0x0004002b, + 0x00000009,0x0000000d,0x00000000,0x00040020,0x0000000e,0x00000001,0x00000009,0x00030016, + 0x00000018,0x00000020,0x000d001e,0x00000019,0x00000006,0x00000006,0x00000018,0x00000018, + 0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00040020, + 0x0000001a,0x00000009,0x00000019,0x0004003b,0x0000001a,0x0000001b,0x00000009,0x0004002b, + 0x00000006,0x0000001c,0x00000001,0x00040020,0x0000001d,0x00000009,0x00000006,0x00020014, + 0x00000020,0x0004002b,0x00000006,0x00000024,0x00000006,0x0004002b,0x00000006,0x0000002f, + 0x00000004,0x0004002b,0x00000006,0x00000033,0x00000005,0x0004002b,0x00000006,0x00000038, + 0x00000000,0x00040020,0x00000042,0x00000007,0x00000018,0x0003001d,0x00000044,0x00000018, + 0x0003001e,0x00000045,0x00000044,0x00040020,0x00000046,0x00000002,0x00000045,0x0004003b, + 0x00000046,0x00000047,0x00000002,0x00040020,0x00000049,0x00000002,0x00000018,0x0003001d, + 0x0000004d,0x00000018,0x0003001e,0x0000004e,0x0000004d,0x00040020,0x0000004f,0x00000002, + 0x0000004e,0x0004003b,0x0000004f,0x00000050,0x00000002,0x0003001d,0x00000061,0x00000018, + 0x0003001e,0x00000062,0x00000061,0x00040020,0x00000063,0x00000002,0x00000062,0x0004003b, + 0x00000063,0x00000064,0x00000002,0x0004002b,0x00000006,0x00000069,0x00000002,0x00040020, + 0x0000006a,0x00000009,0x00000018,0x0003001d,0x00000071,0x00000018,0x0003001e,0x00000072, + 0x00000071,0x00040020,0x00000073,0x00000002,0x00000072,0x0004003b,0x00000073,0x00000074, + 0x00000002,0x0004002b,0x00000006,0x00000079,0x00000003,0x00040017,0x0000007d,0x00000018, + 0x00000004,0x00040020,0x0000007e,0x00000007,0x0000007d,0x0004002b,0x00000018,0x00000082, + 0x3f000000,0x0004002b,0x00000006,0x00000085,0x00000008,0x0004002b,0x00000006,0x0000008f, + 0x00000007,0x0004002b,0x00000009,0x00000094,0x00000001,0x0004002b,0x00000009,0x0000009e, + 0x00000002,0x0004002b,0x00000009,0x000000a8,0x00000003,0x0004002b,0x00000006,0x000000aa, + 0x00000009,0x0004002b,0x00000018,0x000000b1,0x00000000,0x0007002c,0x0000007d,0x000000b2, + 0x000000b1,0x000000b1,0x000000b1,0x000000b1,0x0004002b,0x00000018,0x000000b4,0x3f800000, + 0x0007002c,0x0000007d,0x000000b5,0x000000b4,0x000000b4,0x000000b4,0x000000b4,0x0003001d, + 0x000000bb,0x0000007d,0x0003001e,0x000000bc,0x000000bb,0x00040020,0x000000bd,0x00000002, + 0x000000bc,0x0004003b,0x000000bd,0x000000be,0x00000002,0x0004002b,0x00000006,0x000000bf, + 0x0000000a,0x0003001d,0x000000c4,0x0000007d,0x0003001e,0x000000c5,0x000000c4,0x00040020, + 0x000000c6,0x00000002,0x000000c5,0x0004003b,0x000000c6,0x000000c7,0x00000002,0x00040020, + 0x000000c8,0x00000002,0x0000007d,0x0004002b,0x00000009,0x000000d9,0x00000100,0x0006002c, + 0x0000000a,0x000000da,0x000000d9,0x00000094,0x00000094,0x00050036,0x00000002,0x00000004, + 0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008,0x00000007, + 0x0004003b,0x00000007,0x00000022,0x00000007,0x0004003b,0x00000007,0x00000028,0x00000007, + 0x0004003b,0x00000007,0x0000002d,0x00000007,0x0004003b,0x00000007,0x00000037,0x00000007, + 0x0004003b,0x00000042,0x00000043,0x00000007,0x0004003b,0x00000042,0x0000004c,0x00000007, + 0x0004003b,0x00000007,0x00000054,0x00000007,0x0004003b,0x00000042,0x0000005e,0x00000007, + 0x0004003b,0x00000042,0x0000006e,0x00000007,0x0004003b,0x0000007e,0x0000007f,0x00000007, + 0x0004003b,0x0000007e,0x000000b0,0x00000007,0x0004003b,0x0000007e,0x000000b3,0x00000007, + 0x00050041,0x0000000e,0x0000000f,0x0000000c,0x0000000d,0x0004003d,0x00000009,0x00000010, + 0x0000000f,0x0004007c,0x00000006,0x00000011,0x00000010,0x0003003e,0x00000008,0x00000011, + 0x000200f9,0x00000012,0x000200f8,0x00000012,0x000400f6,0x00000014,0x00000015,0x00000000, + 0x000200f9,0x00000016,0x000200f8,0x00000016,0x0004003d,0x00000006,0x00000017,0x00000008, + 0x00050041,0x0000001d,0x0000001e,0x0000001b,0x0000001c,0x0004003d,0x00000006,0x0000001f, + 0x0000001e,0x000500b1,0x00000020,0x00000021,0x00000017,0x0000001f,0x000400fa,0x00000021, + 0x00000013,0x00000014,0x000200f8,0x00000013,0x0004003d,0x00000006,0x00000023,0x00000008, + 0x00050041,0x0000001d,0x00000025,0x0000001b,0x00000024,0x0004003d,0x00000006,0x00000026, + 0x00000025,0x0005008b,0x00000006,0x00000027,0x00000023,0x00000026,0x0003003e,0x00000022, + 0x00000027,0x0004003d,0x00000006,0x00000029,0x00000008,0x00050041,0x0000001d,0x0000002a, + 0x0000001b,0x00000024,0x0004003d,0x00000006,0x0000002b,0x0000002a,0x00050087,0x00000006, + 0x0000002c,0x00000029,0x0000002b,0x0003003e,0x00000028,0x0000002c,0x0004003d,0x00000006, + 0x0000002e,0x00000008,0x00050041,0x0000001d,0x00000030,0x0000001b,0x0000002f,0x0004003d, + 0x00000006,0x00000031,0x00000030,0x00050084,0x00000006,0x00000032,0x0000002e,0x00000031, + 0x00050041,0x0000001d,0x00000034,0x0000001b,0x00000033,0x0004003d,0x00000006,0x00000035, + 0x00000034,0x00050084,0x00000006,0x00000036,0x00000032,0x00000035,0x0003003e,0x0000002d, + 0x00000036,0x0003003e,0x00000037,0x00000038,0x000200f9,0x00000039,0x000200f8,0x00000039, + 0x000400f6,0x0000003b,0x0000003c,0x00000000,0x000200f9,0x0000003d,0x000200f8,0x0000003d, + 0x0004003d,0x00000006,0x0000003e,0x00000037,0x00050041,0x0000001d,0x0000003f,0x0000001b, + 0x00000033,0x0004003d,0x00000006,0x00000040,0x0000003f,0x000500b1,0x00000020,0x00000041, + 0x0000003e,0x00000040,0x000400fa,0x00000041,0x0000003a,0x0000003b,0x000200f8,0x0000003a, + 0x0004003d,0x00000006,0x00000048,0x00000037,0x00060041,0x00000049,0x0000004a,0x00000047, + 0x00000038,0x00000048,0x0004003d,0x00000018,0x0000004b,0x0000004a,0x0003003e,0x00000043, + 0x0000004b,0x0004003d,0x00000006,0x00000051,0x00000037,0x00060041,0x00000049,0x00000052, + 0x00000050,0x00000038,0x00000051,0x0004003d,0x00000018,0x00000053,0x00000052,0x0003003e, + 0x0000004c,0x00000053,0x0003003e,0x00000054,0x00000038,0x000200f9,0x00000055,0x000200f8, + 0x00000055,0x000400f6,0x00000057,0x00000058,0x00000000,0x000200f9,0x00000059,0x000200f8, + 0x00000059,0x0004003d,0x00000006,0x0000005a,0x00000054,0x00050041,0x0000001d,0x0000005b, + 0x0000001b,0x0000002f,0x0004003d,0x00000006,0x0000005c,0x0000005b,0x000500b1,0x00000020, + 0x0000005d,0x0000005a,0x0000005c,0x000400fa,0x0000005d,0x00000056,0x00000057,0x000200f8, + 0x00000056,0x0004003d,0x00000006,0x0000005f,0x00000022,0x0004006f,0x00000018,0x00000060, + 0x0000005f,0x0004003d,0x00000006,0x00000065,0x00000054,0x00060041,0x00000049,0x00000066, + 0x00000064,0x00000038,0x00000065,0x0004003d,0x00000018,0x00000067,0x00000066,0x00050081, + 0x00000018,0x00000068,0x00000060,0x00000067,0x00050041,0x0000006a,0x0000006b,0x0000001b, + 0x00000069,0x0004003d,0x00000018,0x0000006c,0x0000006b,0x00050085,0x00000018,0x0000006d, + 0x00000068,0x0000006c,0x0003003e,0x0000005e,0x0000006d,0x0004003d,0x00000006,0x0000006f, + 0x00000028,0x0004006f,0x00000018,0x00000070,0x0000006f,0x0004003d,0x00000006,0x00000075, + 0x00000054,0x00060041,0x00000049,0x00000076,0x00000074,0x00000038,0x00000075,0x0004003d, + 0x00000018,0x00000077,0x00000076,0x00050081,0x00000018,0x00000078,0x00000070,0x00000077, + 0x00050041,0x0000006a,0x0000007a,0x0000001b,0x00000079,0x0004003d,0x00000018,0x0000007b, + 0x0000007a,0x00050085,0x00000018,0x0000007c,0x00000078,0x0000007b,0x0003003e,0x0000006e, + 0x0000007c,0x0004003d,0x00000018,0x00000080,0x0000005e,0x0004003d,0x00000018,0x00000081, + 0x00000043,0x00050085,0x00000018,0x00000083,0x00000081,0x00000082,0x00050083,0x00000018, + 0x00000084,0x00000080,0x00000083,0x00050041,0x0000001d,0x00000086,0x0000001b,0x00000085, + 0x0004003d,0x00000006,0x00000087,0x00000086,0x0004006f,0x00000018,0x00000088,0x00000087, + 0x00050088,0x00000018,0x00000089,0x00000084,0x00000088,0x00050041,0x00000042,0x0000008a, + 0x0000007f,0x0000000d,0x0003003e,0x0000008a,0x00000089,0x0004003d,0x00000018,0x0000008b, + 0x0000006e,0x0004003d,0x00000018,0x0000008c,0x0000004c,0x00050085,0x00000018,0x0000008d, + 0x0000008c,0x00000082,0x00050083,0x00000018,0x0000008e,0x0000008b,0x0000008d,0x00050041, + 0x0000001d,0x00000090,0x0000001b,0x0000008f,0x0004003d,0x00000006,0x00000091,0x00000090, + 0x0004006f,0x00000018,0x00000092,0x00000091,0x00050088,0x00000018,0x00000093,0x0000008e, + 0x00000092,0x00050041,0x00000042,0x00000095,0x0000007f,0x00000094,0x0003003e,0x00000095, + 0x00000093,0x0004003d,0x00000018,0x00000096,0x0000005e,0x0004003d,0x00000018,0x00000097, + 0x00000043,0x00050085,0x00000018,0x00000098,0x00000097,0x00000082,0x00050081,0x00000018, + 0x00000099,0x00000096,0x00000098,0x00050041,0x0000001d,0x0000009a,0x0000001b,0x00000085, + 0x0004003d,0x00000006,0x0000009b,0x0000009a,0x0004006f,0x00000018,0x0000009c,0x0000009b, + 0x00050088,0x00000018,0x0000009d,0x00000099,0x0000009c,0x00050041,0x00000042,0x0000009f, + 0x0000007f,0x0000009e,0x0003003e,0x0000009f,0x0000009d,0x0004003d,0x00000018,0x000000a0, + 0x0000006e,0x0004003d,0x00000018,0x000000a1,0x0000004c,0x00050085,0x00000018,0x000000a2, + 0x000000a1,0x00000082,0x00050081,0x00000018,0x000000a3,0x000000a0,0x000000a2,0x00050041, + 0x0000001d,0x000000a4,0x0000001b,0x0000008f,0x0004003d,0x00000006,0x000000a5,0x000000a4, + 0x0004006f,0x00000018,0x000000a6,0x000000a5,0x00050088,0x00000018,0x000000a7,0x000000a3, + 0x000000a6,0x00050041,0x00000042,0x000000a9,0x0000007f,0x000000a8,0x0003003e,0x000000a9, + 0x000000a7,0x00050041,0x0000001d,0x000000ab,0x0000001b,0x000000aa,0x0004003d,0x00000006, + 0x000000ac,0x000000ab,0x000500aa,0x00000020,0x000000ad,0x000000ac,0x0000001c,0x000300f7, + 0x000000af,0x00000000,0x000400fa,0x000000ad,0x000000ae,0x000000af,0x000200f8,0x000000ae, + 0x0003003e,0x000000b0,0x000000b2,0x0003003e,0x000000b3,0x000000b5,0x0004003d,0x0000007d, + 0x000000b6,0x0000007f,0x0004003d,0x0000007d,0x000000b7,0x000000b0,0x0007000c,0x0000007d, + 0x000000b8,0x00000001,0x00000028,0x000000b6,0x000000b7,0x0004003d,0x0000007d,0x000000b9, + 0x000000b3,0x0007000c,0x0000007d,0x000000ba,0x00000001,0x00000025,0x000000b8,0x000000b9, + 0x0003003e,0x0000007f,0x000000ba,0x000200f9,0x000000af,0x000200f8,0x000000af,0x00050041, + 0x0000001d,0x000000c0,0x0000001b,0x000000bf,0x0004003d,0x00000006,0x000000c1,0x000000c0, + 0x0004003d,0x00000006,0x000000c2,0x0000002d,0x00050080,0x00000006,0x000000c3,0x000000c1, + 0x000000c2,0x00060041,0x000000c8,0x000000c9,0x000000c7,0x00000038,0x00000038,0x0004003d, + 0x0000007d,0x000000ca,0x000000c9,0x00060041,0x000000c8,0x000000cb,0x000000be,0x00000038, + 0x000000c3,0x0003003e,0x000000cb,0x000000ca,0x0004003d,0x00000006,0x000000cc,0x0000002d, + 0x0004003d,0x0000007d,0x000000cd,0x0000007f,0x00060041,0x000000c8,0x000000ce,0x000000be, + 0x00000038,0x000000cc,0x0003003e,0x000000ce,0x000000cd,0x0004003d,0x00000006,0x000000cf, + 0x0000002d,0x00050080,0x00000006,0x000000d0,0x000000cf,0x0000001c,0x0003003e,0x0000002d, + 0x000000d0,0x000200f9,0x00000058,0x000200f8,0x00000058,0x0004003d,0x00000006,0x000000d1, + 0x00000054,0x00050080,0x00000006,0x000000d2,0x000000d1,0x0000001c,0x0003003e,0x00000054, + 0x000000d2,0x000200f9,0x00000055,0x000200f8,0x00000057,0x000200f9,0x0000003c,0x000200f8, + 0x0000003c,0x0004003d,0x00000006,0x000000d3,0x00000037,0x00050080,0x00000006,0x000000d4, + 0x000000d3,0x0000001c,0x0003003e,0x00000037,0x000000d4,0x000200f9,0x00000039,0x000200f8, + 0x0000003b,0x000200f9,0x00000015,0x000200f8,0x00000015,0x00050041,0x0000001d,0x000000d5, + 0x0000001b,0x00000038,0x0004003d,0x00000006,0x000000d6,0x000000d5,0x0004003d,0x00000006, + 0x000000d7,0x00000008,0x00050080,0x00000006,0x000000d8,0x000000d7,0x000000d6,0x0003003e, + 0x00000008,0x000000d8,0x000200f9,0x00000012,0x000200f8,0x00000014,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/relu.comp b/modules/dnn/src/vkcom/shader/relu.comp new file mode 100644 index 0000000000..e93f52675d --- /dev/null +++ b/modules/dnn/src/vkcom/shader/relu.comp @@ -0,0 +1,24 @@ +#version 450 +#define LOCAL_SZ_X 32 +layout(push_constant) uniform pushBlock { + int total; + float slope; +} p; + +layout(binding = 0) readonly buffer inbuf{ + float in_buffer[]; +}; + +layout(binding = 1) writeonly buffer outbuf{ + float out_buffer[]; +}; + +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; +void main() +{ + for (int i = int(gl_GlobalInvocationID.x); i < p.total; i += int(gl_NumWorkGroups.x * gl_WorkGroupSize.x)) + { + float in_val = in_buffer[i]; + out_buffer[i] = in_val >= 0.f ? in_val : p.slope * in_val; + } +} diff --git a/modules/dnn/src/vkcom/shader/relu_spv.cpp b/modules/dnn/src/vkcom/shader/relu_spv.cpp new file mode 100644 index 0000000000..0e7884a928 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/relu_spv.cpp @@ -0,0 +1,78 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int relu_spv[502] = { + 0x07230203,0x00010000,0x00080001,0x0000004b,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0007000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00000041,0x00060010, + 0x00000004,0x00000011,0x00000020,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2, + 0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00000069,0x00080005, + 0x0000000c,0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00050005, + 0x00000019,0x68737570,0x636f6c42,0x0000006b,0x00050006,0x00000019,0x00000000,0x61746f74, + 0x0000006c,0x00050006,0x00000019,0x00000001,0x706f6c73,0x00000065,0x00030005,0x0000001b, + 0x00000070,0x00040005,0x00000023,0x765f6e69,0x00006c61,0x00040005,0x00000025,0x75626e69, + 0x00000066,0x00060006,0x00000025,0x00000000,0x625f6e69,0x65666675,0x00000072,0x00030005, + 0x00000027,0x00000000,0x00040005,0x0000002d,0x6274756f,0x00006675,0x00060006,0x0000002d, + 0x00000000,0x5f74756f,0x66667562,0x00007265,0x00030005,0x0000002f,0x00000000,0x00070005, + 0x00000041,0x4e5f6c67,0x6f576d75,0x72476b72,0x7370756f,0x00000000,0x00040047,0x0000000c, + 0x0000000b,0x0000001c,0x00050048,0x00000019,0x00000000,0x00000023,0x00000000,0x00050048, + 0x00000019,0x00000001,0x00000023,0x00000004,0x00030047,0x00000019,0x00000002,0x00040047, + 0x00000024,0x00000006,0x00000004,0x00040048,0x00000025,0x00000000,0x00000018,0x00050048, + 0x00000025,0x00000000,0x00000023,0x00000000,0x00030047,0x00000025,0x00000003,0x00040047, + 0x00000027,0x00000022,0x00000000,0x00040047,0x00000027,0x00000021,0x00000000,0x00040047, + 0x0000002c,0x00000006,0x00000004,0x00040048,0x0000002d,0x00000000,0x00000019,0x00050048, + 0x0000002d,0x00000000,0x00000023,0x00000000,0x00030047,0x0000002d,0x00000003,0x00040047, + 0x0000002f,0x00000022,0x00000000,0x00040047,0x0000002f,0x00000021,0x00000001,0x00040047, + 0x00000041,0x0000000b,0x00000018,0x00040047,0x0000004a,0x0000000b,0x00000019,0x00020013, + 0x00000002,0x00030021,0x00000003,0x00000002,0x00040015,0x00000006,0x00000020,0x00000001, + 0x00040020,0x00000007,0x00000007,0x00000006,0x00040015,0x00000009,0x00000020,0x00000000, + 0x00040017,0x0000000a,0x00000009,0x00000003,0x00040020,0x0000000b,0x00000001,0x0000000a, + 0x0004003b,0x0000000b,0x0000000c,0x00000001,0x0004002b,0x00000009,0x0000000d,0x00000000, + 0x00040020,0x0000000e,0x00000001,0x00000009,0x00030016,0x00000018,0x00000020,0x0004001e, + 0x00000019,0x00000006,0x00000018,0x00040020,0x0000001a,0x00000009,0x00000019,0x0004003b, + 0x0000001a,0x0000001b,0x00000009,0x0004002b,0x00000006,0x0000001c,0x00000000,0x00040020, + 0x0000001d,0x00000009,0x00000006,0x00020014,0x00000020,0x00040020,0x00000022,0x00000007, + 0x00000018,0x0003001d,0x00000024,0x00000018,0x0003001e,0x00000025,0x00000024,0x00040020, + 0x00000026,0x00000002,0x00000025,0x0004003b,0x00000026,0x00000027,0x00000002,0x00040020, + 0x00000029,0x00000002,0x00000018,0x0003001d,0x0000002c,0x00000018,0x0003001e,0x0000002d, + 0x0000002c,0x00040020,0x0000002e,0x00000002,0x0000002d,0x0004003b,0x0000002e,0x0000002f, + 0x00000002,0x0004002b,0x00000018,0x00000033,0x00000000,0x0004002b,0x00000006,0x00000039, + 0x00000001,0x00040020,0x0000003a,0x00000009,0x00000018,0x0004003b,0x0000000b,0x00000041, + 0x00000001,0x0004002b,0x00000009,0x00000044,0x00000020,0x0004002b,0x00000009,0x00000049, + 0x00000001,0x0006002c,0x0000000a,0x0000004a,0x00000044,0x00000049,0x00000049,0x00050036, + 0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007, + 0x00000008,0x00000007,0x0004003b,0x00000022,0x00000023,0x00000007,0x0004003b,0x00000022, + 0x00000031,0x00000007,0x00050041,0x0000000e,0x0000000f,0x0000000c,0x0000000d,0x0004003d, + 0x00000009,0x00000010,0x0000000f,0x0004007c,0x00000006,0x00000011,0x00000010,0x0003003e, + 0x00000008,0x00000011,0x000200f9,0x00000012,0x000200f8,0x00000012,0x000400f6,0x00000014, + 0x00000015,0x00000000,0x000200f9,0x00000016,0x000200f8,0x00000016,0x0004003d,0x00000006, + 0x00000017,0x00000008,0x00050041,0x0000001d,0x0000001e,0x0000001b,0x0000001c,0x0004003d, + 0x00000006,0x0000001f,0x0000001e,0x000500b1,0x00000020,0x00000021,0x00000017,0x0000001f, + 0x000400fa,0x00000021,0x00000013,0x00000014,0x000200f8,0x00000013,0x0004003d,0x00000006, + 0x00000028,0x00000008,0x00060041,0x00000029,0x0000002a,0x00000027,0x0000001c,0x00000028, + 0x0004003d,0x00000018,0x0000002b,0x0000002a,0x0003003e,0x00000023,0x0000002b,0x0004003d, + 0x00000006,0x00000030,0x00000008,0x0004003d,0x00000018,0x00000032,0x00000023,0x000500be, + 0x00000020,0x00000034,0x00000032,0x00000033,0x000300f7,0x00000036,0x00000000,0x000400fa, + 0x00000034,0x00000035,0x00000038,0x000200f8,0x00000035,0x0004003d,0x00000018,0x00000037, + 0x00000023,0x0003003e,0x00000031,0x00000037,0x000200f9,0x00000036,0x000200f8,0x00000038, + 0x00050041,0x0000003a,0x0000003b,0x0000001b,0x00000039,0x0004003d,0x00000018,0x0000003c, + 0x0000003b,0x0004003d,0x00000018,0x0000003d,0x00000023,0x00050085,0x00000018,0x0000003e, + 0x0000003c,0x0000003d,0x0003003e,0x00000031,0x0000003e,0x000200f9,0x00000036,0x000200f8, + 0x00000036,0x0004003d,0x00000018,0x0000003f,0x00000031,0x00060041,0x00000029,0x00000040, + 0x0000002f,0x0000001c,0x00000030,0x0003003e,0x00000040,0x0000003f,0x000200f9,0x00000015, + 0x000200f8,0x00000015,0x00050041,0x0000000e,0x00000042,0x00000041,0x0000000d,0x0004003d, + 0x00000009,0x00000043,0x00000042,0x00050084,0x00000009,0x00000045,0x00000043,0x00000044, + 0x0004007c,0x00000006,0x00000046,0x00000045,0x0004003d,0x00000006,0x00000047,0x00000008, + 0x00050080,0x00000006,0x00000048,0x00000047,0x00000046,0x0003003e,0x00000008,0x00000048, + 0x000200f9,0x00000012,0x000200f8,0x00000014,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/softmax.comp b/modules/dnn/src/vkcom/shader/softmax.comp new file mode 100644 index 0000000000..f1f83df087 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/softmax.comp @@ -0,0 +1,78 @@ + +#version 450 +#define LOCAL_SZ_X 256 + +layout(binding = 0) readonly buffer buf0{ + float input_buffer[]; // outer_size * channels * channel_size +}; +layout(binding = 1) buffer buf1{ + float max_buffer[]; // outer_size * channel_size +}; +layout(binding = 2) buffer buf2{ + float sum_buffer[]; // outer_size * channel_size +}; +layout(binding = 3) buffer buf3{ + float output_buffer[]; // outer_size * channels * channel_size +}; +layout(push_constant) uniform pushBlock { + int channel_size; + int outer_size; + int channels; +} p; +layout(local_size_x = LOCAL_SZ_X, local_size_y = 1, local_size_z = 1) in; + +void main() +{ + int gid = int(gl_GlobalInvocationID.x); + if (gid >= p.outer_size) return; + + int global_off = gid * p.channels * p.channel_size; + int reduced_buffer_off = gid * p.channel_size; + + // find the max along channel + int index = global_off; + for (int i = 0; i < p.channel_size; ++i) + { + max_buffer[reduced_buffer_off + i] = input_buffer[index]; + index++; + } + for (int c = 1; c < p.channels; ++c) + { + for (int i = 0; i < p.channel_size; ++i) + { + max_buffer[reduced_buffer_off + i] = max(max_buffer[reduced_buffer_off + i], input_buffer[index]); + index++; + } + } + + // substract, exp and accumulate along channel + for (int i = 0; i < p.channel_size; ++i) + sum_buffer[reduced_buffer_off + i] = 0.f; + + index = global_off; + for (int c = 0; c < p.channels; ++c) + { + for (int i = 0; i < p.channel_size; ++i) + { + float exp_val = exp(input_buffer[index] - max_buffer[reduced_buffer_off + i]); + output_buffer[index] = exp_val; + sum_buffer[reduced_buffer_off + i] += exp_val; + index++; + } + } + + // divide by computed sum + index = global_off; + for (int c = 0; c < p.channels; ++c) + { + for (int i = 0; i < p.channel_size; ++i) + { + float v = output_buffer[index] / sum_buffer[reduced_buffer_off + i]; +#ifdef LOG_SOFTMAX + v = log(v); +#endif + output_buffer[index] = v; + index++; + } + } +} diff --git a/modules/dnn/src/vkcom/shader/softmax_spv.cpp b/modules/dnn/src/vkcom/shader/softmax_spv.cpp new file mode 100644 index 0000000000..d95a451288 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/softmax_spv.cpp @@ -0,0 +1,195 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int softmax_spv[1440] = { + 0x07230203,0x00010000,0x00080001,0x000000ec,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x00060010,0x00000004, + 0x00000011,0x00000100,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00646967,0x00080005,0x0000000c, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00050005,0x00000013, + 0x68737570,0x636f6c42,0x0000006b,0x00070006,0x00000013,0x00000000,0x6e616863,0x5f6c656e, + 0x657a6973,0x00000000,0x00060006,0x00000013,0x00000001,0x6574756f,0x69735f72,0x0000657a, + 0x00060006,0x00000013,0x00000002,0x6e616863,0x736c656e,0x00000000,0x00030005,0x00000015, + 0x00000070,0x00050005,0x0000001f,0x626f6c67,0x6f5f6c61,0x00006666,0x00070005,0x00000029, + 0x75646572,0x5f646563,0x66667562,0x6f5f7265,0x00006666,0x00040005,0x0000002e,0x65646e69, + 0x00000078,0x00030005,0x00000030,0x00000069,0x00040005,0x0000003c,0x31667562,0x00000000, + 0x00060006,0x0000003c,0x00000000,0x5f78616d,0x66667562,0x00007265,0x00030005,0x0000003e, + 0x00000000,0x00040005,0x00000043,0x30667562,0x00000000,0x00070006,0x00000043,0x00000000, + 0x75706e69,0x75625f74,0x72656666,0x00000000,0x00030005,0x00000045,0x00000000,0x00030005, + 0x0000004f,0x00000063,0x00030005,0x00000059,0x00000069,0x00030005,0x00000076,0x00000069, + 0x00040005,0x00000081,0x32667562,0x00000000,0x00060006,0x00000081,0x00000000,0x5f6d7573, + 0x66667562,0x00007265,0x00030005,0x00000083,0x00000000,0x00030005,0x0000008c,0x00000063, + 0x00030005,0x00000096,0x00000069,0x00040005,0x000000a1,0x5f707865,0x006c6176,0x00040005, + 0x000000ad,0x33667562,0x00000000,0x00070006,0x000000ad,0x00000000,0x7074756f,0x625f7475, + 0x65666675,0x00000072,0x00030005,0x000000af,0x00000000,0x00030005,0x000000c2,0x00000063, + 0x00030005,0x000000cc,0x00000069,0x00030005,0x000000d6,0x00000076,0x00040047,0x0000000c, + 0x0000000b,0x0000001c,0x00050048,0x00000013,0x00000000,0x00000023,0x00000000,0x00050048, + 0x00000013,0x00000001,0x00000023,0x00000004,0x00050048,0x00000013,0x00000002,0x00000023, + 0x00000008,0x00030047,0x00000013,0x00000002,0x00040047,0x0000003b,0x00000006,0x00000004, + 0x00050048,0x0000003c,0x00000000,0x00000023,0x00000000,0x00030047,0x0000003c,0x00000003, + 0x00040047,0x0000003e,0x00000022,0x00000000,0x00040047,0x0000003e,0x00000021,0x00000001, + 0x00040047,0x00000042,0x00000006,0x00000004,0x00040048,0x00000043,0x00000000,0x00000018, + 0x00050048,0x00000043,0x00000000,0x00000023,0x00000000,0x00030047,0x00000043,0x00000003, + 0x00040047,0x00000045,0x00000022,0x00000000,0x00040047,0x00000045,0x00000021,0x00000000, + 0x00040047,0x00000080,0x00000006,0x00000004,0x00050048,0x00000081,0x00000000,0x00000023, + 0x00000000,0x00030047,0x00000081,0x00000003,0x00040047,0x00000083,0x00000022,0x00000000, + 0x00040047,0x00000083,0x00000021,0x00000002,0x00040047,0x000000ac,0x00000006,0x00000004, + 0x00050048,0x000000ad,0x00000000,0x00000023,0x00000000,0x00030047,0x000000ad,0x00000003, + 0x00040047,0x000000af,0x00000022,0x00000000,0x00040047,0x000000af,0x00000021,0x00000003, + 0x00040047,0x000000eb,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003, + 0x00000002,0x00040015,0x00000006,0x00000020,0x00000001,0x00040020,0x00000007,0x00000007, + 0x00000006,0x00040015,0x00000009,0x00000020,0x00000000,0x00040017,0x0000000a,0x00000009, + 0x00000003,0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b,0x0000000c, + 0x00000001,0x0004002b,0x00000009,0x0000000d,0x00000000,0x00040020,0x0000000e,0x00000001, + 0x00000009,0x0005001e,0x00000013,0x00000006,0x00000006,0x00000006,0x00040020,0x00000014, + 0x00000009,0x00000013,0x0004003b,0x00000014,0x00000015,0x00000009,0x0004002b,0x00000006, + 0x00000016,0x00000001,0x00040020,0x00000017,0x00000009,0x00000006,0x00020014,0x0000001a, + 0x0004002b,0x00000006,0x00000021,0x00000002,0x0004002b,0x00000006,0x00000025,0x00000000, + 0x00030016,0x0000003a,0x00000020,0x0003001d,0x0000003b,0x0000003a,0x0003001e,0x0000003c, + 0x0000003b,0x00040020,0x0000003d,0x00000002,0x0000003c,0x0004003b,0x0000003d,0x0000003e, + 0x00000002,0x0003001d,0x00000042,0x0000003a,0x0003001e,0x00000043,0x00000042,0x00040020, + 0x00000044,0x00000002,0x00000043,0x0004003b,0x00000044,0x00000045,0x00000002,0x00040020, + 0x00000047,0x00000002,0x0000003a,0x0003001d,0x00000080,0x0000003a,0x0003001e,0x00000081, + 0x00000080,0x00040020,0x00000082,0x00000002,0x00000081,0x0004003b,0x00000082,0x00000083, + 0x00000002,0x0004002b,0x0000003a,0x00000087,0x00000000,0x00040020,0x000000a0,0x00000007, + 0x0000003a,0x0003001d,0x000000ac,0x0000003a,0x0003001e,0x000000ad,0x000000ac,0x00040020, + 0x000000ae,0x00000002,0x000000ad,0x0004003b,0x000000ae,0x000000af,0x00000002,0x0004002b, + 0x00000009,0x000000e9,0x00000100,0x0004002b,0x00000009,0x000000ea,0x00000001,0x0006002c, + 0x0000000a,0x000000eb,0x000000e9,0x000000ea,0x000000ea,0x00050036,0x00000002,0x00000004, + 0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008,0x00000007, + 0x0004003b,0x00000007,0x0000001f,0x00000007,0x0004003b,0x00000007,0x00000029,0x00000007, + 0x0004003b,0x00000007,0x0000002e,0x00000007,0x0004003b,0x00000007,0x00000030,0x00000007, + 0x0004003b,0x00000007,0x0000004f,0x00000007,0x0004003b,0x00000007,0x00000059,0x00000007, + 0x0004003b,0x00000007,0x00000076,0x00000007,0x0004003b,0x00000007,0x0000008c,0x00000007, + 0x0004003b,0x00000007,0x00000096,0x00000007,0x0004003b,0x000000a0,0x000000a1,0x00000007, + 0x0004003b,0x00000007,0x000000c2,0x00000007,0x0004003b,0x00000007,0x000000cc,0x00000007, + 0x0004003b,0x000000a0,0x000000d6,0x00000007,0x00050041,0x0000000e,0x0000000f,0x0000000c, + 0x0000000d,0x0004003d,0x00000009,0x00000010,0x0000000f,0x0004007c,0x00000006,0x00000011, + 0x00000010,0x0003003e,0x00000008,0x00000011,0x0004003d,0x00000006,0x00000012,0x00000008, + 0x00050041,0x00000017,0x00000018,0x00000015,0x00000016,0x0004003d,0x00000006,0x00000019, + 0x00000018,0x000500af,0x0000001a,0x0000001b,0x00000012,0x00000019,0x000300f7,0x0000001d, + 0x00000000,0x000400fa,0x0000001b,0x0000001c,0x0000001d,0x000200f8,0x0000001c,0x000100fd, + 0x000200f8,0x0000001d,0x0004003d,0x00000006,0x00000020,0x00000008,0x00050041,0x00000017, + 0x00000022,0x00000015,0x00000021,0x0004003d,0x00000006,0x00000023,0x00000022,0x00050084, + 0x00000006,0x00000024,0x00000020,0x00000023,0x00050041,0x00000017,0x00000026,0x00000015, + 0x00000025,0x0004003d,0x00000006,0x00000027,0x00000026,0x00050084,0x00000006,0x00000028, + 0x00000024,0x00000027,0x0003003e,0x0000001f,0x00000028,0x0004003d,0x00000006,0x0000002a, + 0x00000008,0x00050041,0x00000017,0x0000002b,0x00000015,0x00000025,0x0004003d,0x00000006, + 0x0000002c,0x0000002b,0x00050084,0x00000006,0x0000002d,0x0000002a,0x0000002c,0x0003003e, + 0x00000029,0x0000002d,0x0004003d,0x00000006,0x0000002f,0x0000001f,0x0003003e,0x0000002e, + 0x0000002f,0x0003003e,0x00000030,0x00000025,0x000200f9,0x00000031,0x000200f8,0x00000031, + 0x000400f6,0x00000033,0x00000034,0x00000000,0x000200f9,0x00000035,0x000200f8,0x00000035, + 0x0004003d,0x00000006,0x00000036,0x00000030,0x00050041,0x00000017,0x00000037,0x00000015, + 0x00000025,0x0004003d,0x00000006,0x00000038,0x00000037,0x000500b1,0x0000001a,0x00000039, + 0x00000036,0x00000038,0x000400fa,0x00000039,0x00000032,0x00000033,0x000200f8,0x00000032, + 0x0004003d,0x00000006,0x0000003f,0x00000029,0x0004003d,0x00000006,0x00000040,0x00000030, + 0x00050080,0x00000006,0x00000041,0x0000003f,0x00000040,0x0004003d,0x00000006,0x00000046, + 0x0000002e,0x00060041,0x00000047,0x00000048,0x00000045,0x00000025,0x00000046,0x0004003d, + 0x0000003a,0x00000049,0x00000048,0x00060041,0x00000047,0x0000004a,0x0000003e,0x00000025, + 0x00000041,0x0003003e,0x0000004a,0x00000049,0x0004003d,0x00000006,0x0000004b,0x0000002e, + 0x00050080,0x00000006,0x0000004c,0x0000004b,0x00000016,0x0003003e,0x0000002e,0x0000004c, + 0x000200f9,0x00000034,0x000200f8,0x00000034,0x0004003d,0x00000006,0x0000004d,0x00000030, + 0x00050080,0x00000006,0x0000004e,0x0000004d,0x00000016,0x0003003e,0x00000030,0x0000004e, + 0x000200f9,0x00000031,0x000200f8,0x00000033,0x0003003e,0x0000004f,0x00000016,0x000200f9, + 0x00000050,0x000200f8,0x00000050,0x000400f6,0x00000052,0x00000053,0x00000000,0x000200f9, + 0x00000054,0x000200f8,0x00000054,0x0004003d,0x00000006,0x00000055,0x0000004f,0x00050041, + 0x00000017,0x00000056,0x00000015,0x00000021,0x0004003d,0x00000006,0x00000057,0x00000056, + 0x000500b1,0x0000001a,0x00000058,0x00000055,0x00000057,0x000400fa,0x00000058,0x00000051, + 0x00000052,0x000200f8,0x00000051,0x0003003e,0x00000059,0x00000025,0x000200f9,0x0000005a, + 0x000200f8,0x0000005a,0x000400f6,0x0000005c,0x0000005d,0x00000000,0x000200f9,0x0000005e, + 0x000200f8,0x0000005e,0x0004003d,0x00000006,0x0000005f,0x00000059,0x00050041,0x00000017, + 0x00000060,0x00000015,0x00000025,0x0004003d,0x00000006,0x00000061,0x00000060,0x000500b1, + 0x0000001a,0x00000062,0x0000005f,0x00000061,0x000400fa,0x00000062,0x0000005b,0x0000005c, + 0x000200f8,0x0000005b,0x0004003d,0x00000006,0x00000063,0x00000029,0x0004003d,0x00000006, + 0x00000064,0x00000059,0x00050080,0x00000006,0x00000065,0x00000063,0x00000064,0x0004003d, + 0x00000006,0x00000066,0x00000029,0x0004003d,0x00000006,0x00000067,0x00000059,0x00050080, + 0x00000006,0x00000068,0x00000066,0x00000067,0x00060041,0x00000047,0x00000069,0x0000003e, + 0x00000025,0x00000068,0x0004003d,0x0000003a,0x0000006a,0x00000069,0x0004003d,0x00000006, + 0x0000006b,0x0000002e,0x00060041,0x00000047,0x0000006c,0x00000045,0x00000025,0x0000006b, + 0x0004003d,0x0000003a,0x0000006d,0x0000006c,0x0007000c,0x0000003a,0x0000006e,0x00000001, + 0x00000028,0x0000006a,0x0000006d,0x00060041,0x00000047,0x0000006f,0x0000003e,0x00000025, + 0x00000065,0x0003003e,0x0000006f,0x0000006e,0x0004003d,0x00000006,0x00000070,0x0000002e, + 0x00050080,0x00000006,0x00000071,0x00000070,0x00000016,0x0003003e,0x0000002e,0x00000071, + 0x000200f9,0x0000005d,0x000200f8,0x0000005d,0x0004003d,0x00000006,0x00000072,0x00000059, + 0x00050080,0x00000006,0x00000073,0x00000072,0x00000016,0x0003003e,0x00000059,0x00000073, + 0x000200f9,0x0000005a,0x000200f8,0x0000005c,0x000200f9,0x00000053,0x000200f8,0x00000053, + 0x0004003d,0x00000006,0x00000074,0x0000004f,0x00050080,0x00000006,0x00000075,0x00000074, + 0x00000016,0x0003003e,0x0000004f,0x00000075,0x000200f9,0x00000050,0x000200f8,0x00000052, + 0x0003003e,0x00000076,0x00000025,0x000200f9,0x00000077,0x000200f8,0x00000077,0x000400f6, + 0x00000079,0x0000007a,0x00000000,0x000200f9,0x0000007b,0x000200f8,0x0000007b,0x0004003d, + 0x00000006,0x0000007c,0x00000076,0x00050041,0x00000017,0x0000007d,0x00000015,0x00000025, + 0x0004003d,0x00000006,0x0000007e,0x0000007d,0x000500b1,0x0000001a,0x0000007f,0x0000007c, + 0x0000007e,0x000400fa,0x0000007f,0x00000078,0x00000079,0x000200f8,0x00000078,0x0004003d, + 0x00000006,0x00000084,0x00000029,0x0004003d,0x00000006,0x00000085,0x00000076,0x00050080, + 0x00000006,0x00000086,0x00000084,0x00000085,0x00060041,0x00000047,0x00000088,0x00000083, + 0x00000025,0x00000086,0x0003003e,0x00000088,0x00000087,0x000200f9,0x0000007a,0x000200f8, + 0x0000007a,0x0004003d,0x00000006,0x00000089,0x00000076,0x00050080,0x00000006,0x0000008a, + 0x00000089,0x00000016,0x0003003e,0x00000076,0x0000008a,0x000200f9,0x00000077,0x000200f8, + 0x00000079,0x0004003d,0x00000006,0x0000008b,0x0000001f,0x0003003e,0x0000002e,0x0000008b, + 0x0003003e,0x0000008c,0x00000025,0x000200f9,0x0000008d,0x000200f8,0x0000008d,0x000400f6, + 0x0000008f,0x00000090,0x00000000,0x000200f9,0x00000091,0x000200f8,0x00000091,0x0004003d, + 0x00000006,0x00000092,0x0000008c,0x00050041,0x00000017,0x00000093,0x00000015,0x00000021, + 0x0004003d,0x00000006,0x00000094,0x00000093,0x000500b1,0x0000001a,0x00000095,0x00000092, + 0x00000094,0x000400fa,0x00000095,0x0000008e,0x0000008f,0x000200f8,0x0000008e,0x0003003e, + 0x00000096,0x00000025,0x000200f9,0x00000097,0x000200f8,0x00000097,0x000400f6,0x00000099, + 0x0000009a,0x00000000,0x000200f9,0x0000009b,0x000200f8,0x0000009b,0x0004003d,0x00000006, + 0x0000009c,0x00000096,0x00050041,0x00000017,0x0000009d,0x00000015,0x00000025,0x0004003d, + 0x00000006,0x0000009e,0x0000009d,0x000500b1,0x0000001a,0x0000009f,0x0000009c,0x0000009e, + 0x000400fa,0x0000009f,0x00000098,0x00000099,0x000200f8,0x00000098,0x0004003d,0x00000006, + 0x000000a2,0x0000002e,0x00060041,0x00000047,0x000000a3,0x00000045,0x00000025,0x000000a2, + 0x0004003d,0x0000003a,0x000000a4,0x000000a3,0x0004003d,0x00000006,0x000000a5,0x00000029, + 0x0004003d,0x00000006,0x000000a6,0x00000096,0x00050080,0x00000006,0x000000a7,0x000000a5, + 0x000000a6,0x00060041,0x00000047,0x000000a8,0x0000003e,0x00000025,0x000000a7,0x0004003d, + 0x0000003a,0x000000a9,0x000000a8,0x00050083,0x0000003a,0x000000aa,0x000000a4,0x000000a9, + 0x0006000c,0x0000003a,0x000000ab,0x00000001,0x0000001b,0x000000aa,0x0003003e,0x000000a1, + 0x000000ab,0x0004003d,0x00000006,0x000000b0,0x0000002e,0x0004003d,0x0000003a,0x000000b1, + 0x000000a1,0x00060041,0x00000047,0x000000b2,0x000000af,0x00000025,0x000000b0,0x0003003e, + 0x000000b2,0x000000b1,0x0004003d,0x00000006,0x000000b3,0x00000029,0x0004003d,0x00000006, + 0x000000b4,0x00000096,0x00050080,0x00000006,0x000000b5,0x000000b3,0x000000b4,0x0004003d, + 0x0000003a,0x000000b6,0x000000a1,0x00060041,0x00000047,0x000000b7,0x00000083,0x00000025, + 0x000000b5,0x0004003d,0x0000003a,0x000000b8,0x000000b7,0x00050081,0x0000003a,0x000000b9, + 0x000000b8,0x000000b6,0x00060041,0x00000047,0x000000ba,0x00000083,0x00000025,0x000000b5, + 0x0003003e,0x000000ba,0x000000b9,0x0004003d,0x00000006,0x000000bb,0x0000002e,0x00050080, + 0x00000006,0x000000bc,0x000000bb,0x00000016,0x0003003e,0x0000002e,0x000000bc,0x000200f9, + 0x0000009a,0x000200f8,0x0000009a,0x0004003d,0x00000006,0x000000bd,0x00000096,0x00050080, + 0x00000006,0x000000be,0x000000bd,0x00000016,0x0003003e,0x00000096,0x000000be,0x000200f9, + 0x00000097,0x000200f8,0x00000099,0x000200f9,0x00000090,0x000200f8,0x00000090,0x0004003d, + 0x00000006,0x000000bf,0x0000008c,0x00050080,0x00000006,0x000000c0,0x000000bf,0x00000016, + 0x0003003e,0x0000008c,0x000000c0,0x000200f9,0x0000008d,0x000200f8,0x0000008f,0x0004003d, + 0x00000006,0x000000c1,0x0000001f,0x0003003e,0x0000002e,0x000000c1,0x0003003e,0x000000c2, + 0x00000025,0x000200f9,0x000000c3,0x000200f8,0x000000c3,0x000400f6,0x000000c5,0x000000c6, + 0x00000000,0x000200f9,0x000000c7,0x000200f8,0x000000c7,0x0004003d,0x00000006,0x000000c8, + 0x000000c2,0x00050041,0x00000017,0x000000c9,0x00000015,0x00000021,0x0004003d,0x00000006, + 0x000000ca,0x000000c9,0x000500b1,0x0000001a,0x000000cb,0x000000c8,0x000000ca,0x000400fa, + 0x000000cb,0x000000c4,0x000000c5,0x000200f8,0x000000c4,0x0003003e,0x000000cc,0x00000025, + 0x000200f9,0x000000cd,0x000200f8,0x000000cd,0x000400f6,0x000000cf,0x000000d0,0x00000000, + 0x000200f9,0x000000d1,0x000200f8,0x000000d1,0x0004003d,0x00000006,0x000000d2,0x000000cc, + 0x00050041,0x00000017,0x000000d3,0x00000015,0x00000025,0x0004003d,0x00000006,0x000000d4, + 0x000000d3,0x000500b1,0x0000001a,0x000000d5,0x000000d2,0x000000d4,0x000400fa,0x000000d5, + 0x000000ce,0x000000cf,0x000200f8,0x000000ce,0x0004003d,0x00000006,0x000000d7,0x0000002e, + 0x00060041,0x00000047,0x000000d8,0x000000af,0x00000025,0x000000d7,0x0004003d,0x0000003a, + 0x000000d9,0x000000d8,0x0004003d,0x00000006,0x000000da,0x00000029,0x0004003d,0x00000006, + 0x000000db,0x000000cc,0x00050080,0x00000006,0x000000dc,0x000000da,0x000000db,0x00060041, + 0x00000047,0x000000dd,0x00000083,0x00000025,0x000000dc,0x0004003d,0x0000003a,0x000000de, + 0x000000dd,0x00050088,0x0000003a,0x000000df,0x000000d9,0x000000de,0x0003003e,0x000000d6, + 0x000000df,0x0004003d,0x00000006,0x000000e0,0x0000002e,0x0004003d,0x0000003a,0x000000e1, + 0x000000d6,0x00060041,0x00000047,0x000000e2,0x000000af,0x00000025,0x000000e0,0x0003003e, + 0x000000e2,0x000000e1,0x0004003d,0x00000006,0x000000e3,0x0000002e,0x00050080,0x00000006, + 0x000000e4,0x000000e3,0x00000016,0x0003003e,0x0000002e,0x000000e4,0x000200f9,0x000000d0, + 0x000200f8,0x000000d0,0x0004003d,0x00000006,0x000000e5,0x000000cc,0x00050080,0x00000006, + 0x000000e6,0x000000e5,0x00000016,0x0003003e,0x000000cc,0x000000e6,0x000200f9,0x000000cd, + 0x000200f8,0x000000cf,0x000200f9,0x000000c6,0x000200f8,0x000000c6,0x0004003d,0x00000006, + 0x000000e7,0x000000c2,0x00050080,0x00000006,0x000000e8,0x000000e7,0x00000016,0x0003003e, + 0x000000c2,0x000000e8,0x000200f9,0x000000c3,0x000200f8,0x000000c5,0x000100fd,0x00010038 +}; + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/shader/spirv_generator.py b/modules/dnn/src/vkcom/shader/spirv_generator.py new file mode 100644 index 0000000000..0f9dd6e451 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/spirv_generator.py @@ -0,0 +1,88 @@ +# Iterate all GLSL shaders (with suffix '.comp') in current directory. +# +# Use glslangValidator to compile them to SPIR-V shaders and write them +# into .cpp files as unsigned int array. +# +# Also generate a header file 'spv_shader.hpp' to extern declare these shaders. + +import re +import os +import sys + +dir = "./" +license_decl = \ +'// This file is part of OpenCV project.\n'\ +'// It is subject to the license terms in the LICENSE file found in the top-level directory\n'\ +'// of this distribution and at http://opencv.org/license.html.\n'\ +'//\n'\ +'// Copyright (C) 2018, Intel Corporation, all rights reserved.\n'\ +'// Third party copyrights are property of their respective owners.\n\n' +precomp = '#include \"../../precomp.hpp\"\n' +ns_head = '\nnamespace cv { namespace dnn { namespace vkcom {\n\n' +ns_tail = '\n}}} // namespace cv::dnn::vkcom\n' + +headfile = open('spv_shader.hpp', 'w') +headfile.write(license_decl) +headfile.write('#ifndef OPENCV_DNN_SPV_SHADER_HPP\n') +headfile.write('#define OPENCV_DNN_SPV_SHADER_HPP\n\n') +headfile.write(ns_head) + +cmd_remove = '' +null_out = '' +if sys.platform.find('win32') != -1: + cmd_remove = 'del' + null_out = ' >>nul 2>nul' +elif sys.platform.find('linux') != -1: + cmd_remove = 'rm' + null_out = ' > /dev/null 2>&1' + +list = os.listdir(dir) +for i in range(0, len(list)): + if (os.path.splitext(list[i])[-1] != '.comp'): + continue + prefix = os.path.splitext(list[i])[0]; + path = os.path.join(dir, list[i]) + + + bin_file = prefix + '.tmp' + cmd = ' glslangValidator -V ' + path + ' -S comp -o ' + bin_file + print('compiling') + if os.system(cmd) != 0: + continue; + size = os.path.getsize(bin_file) + + spv_txt_file = prefix + '.spv' + cmd = 'glslangValidator -V ' + path + ' -S comp -o ' + spv_txt_file + ' -x' + null_out + os.system(cmd) + + infile_name = spv_txt_file + outfile_name = prefix + '_spv.cpp' + array_name = prefix + '_spv' + infile = open(infile_name, 'r') + outfile = open(outfile_name, 'w') + + outfile.write(license_decl) + outfile.write(precomp) + outfile.write(ns_head) + # xxx.spv ==> xxx_spv.cpp + fmt = 'extern const unsigned int %s[%d] = {\n' % (array_name, size/4) + outfile.write(fmt) + for eachLine in infile: + if(re.match(r'^.*\/\/', eachLine)): + continue + newline = ' ' + eachLine.replace('\t','') + outfile.write(newline) + infile.close() + outfile.write("};\n") + outfile.write(ns_tail) + + # write a line into header file + fmt = 'extern const unsigned int %s[%d];\n' % (array_name, size/4) + headfile.write(fmt) + + os.system(cmd_remove + ' ' + bin_file) + os.system(cmd_remove + ' ' + spv_txt_file) + +headfile.write(ns_tail) +headfile.write('\n#endif /* OPENCV_DNN_SPV_SHADER_HPP */\n') +headfile.close(); diff --git a/modules/dnn/src/vkcom/shader/spv_shader.hpp b/modules/dnn/src/vkcom/shader/spv_shader.hpp new file mode 100644 index 0000000000..cdc96ce6e2 --- /dev/null +++ b/modules/dnn/src/vkcom/shader/spv_shader.hpp @@ -0,0 +1,27 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_SPV_SHADER_HPP +#define OPENCV_DNN_SPV_SHADER_HPP + + +namespace cv { namespace dnn { namespace vkcom { + +extern const unsigned int dw_conv_spv[1655]; +extern const unsigned int permute_spv[765]; +extern const unsigned int lrn_spv[1845]; +extern const unsigned int concat_spv[541]; +extern const unsigned int avg_pool_spv[1538]; +extern const unsigned int softmax_spv[1440]; +extern const unsigned int prior_box_spv[1480]; +extern const unsigned int max_pool_spv[1449]; +extern const unsigned int relu_spv[502]; +extern const unsigned int conv_spv[1859]; + +}}} // namespace cv::dnn::vkcom + +#endif /* OPENCV_DNN_SPV_SHADER_HPP */ diff --git a/modules/dnn/src/vkcom/src/buffer.cpp b/modules/dnn/src/vkcom/src/buffer.cpp new file mode 100644 index 0000000000..48083b55cc --- /dev/null +++ b/modules/dnn/src/vkcom/src/buffer.cpp @@ -0,0 +1,85 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/buffer.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +static uint32_t findMemoryType(uint32_t memoryTypeBits, VkMemoryPropertyFlags properties) +{ + VkPhysicalDeviceMemoryProperties memoryProperties; + + vkGetPhysicalDeviceMemoryProperties(getPhysicalDevice(), &memoryProperties); + + for (uint32_t i = 0; i < memoryProperties.memoryTypeCount; ++i) { + if ((memoryTypeBits & (1 << i)) && + ((memoryProperties.memoryTypes[i].propertyFlags & properties) == properties)) + return i; + } + return -1; +} + +bool Buffer::init(size_t size_in_bytes, const char* data) +{ + if (buffer_ != VK_NULL_HANDLE) + { + printf("Warn: Buffer object already inited\n"); + return false; + } + + VkBufferCreateInfo bufferCreateInfo = {}; + bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + bufferCreateInfo.size = size_in_bytes; + bufferCreateInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + VK_CHECK_RESULT(vkCreateBuffer(device_, &bufferCreateInfo, NULL, &buffer_)); + + VkMemoryRequirements memoryRequirements; + vkGetBufferMemoryRequirements(device_, buffer_, &memoryRequirements); + + VkMemoryAllocateInfo allocateInfo = {}; + allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocateInfo.allocationSize = memoryRequirements.size; + allocateInfo.memoryTypeIndex = findMemoryType(memoryRequirements.memoryTypeBits, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); + VK_CHECK_RESULT(vkAllocateMemory(device_, &allocateInfo, NULL, &memory_)); + + if (data) + { + char* dst; + VK_CHECK_RESULT(vkMapMemory(device_, memory_, 0, size_in_bytes, 0, (void **)&dst)); + memcpy(dst, data, size_in_bytes); + vkUnmapMemory(device_, memory_); + } + + VK_CHECK_RESULT(vkBindBufferMemory(device_, buffer_, memory_, 0)); + return true; +} + +Buffer::Buffer(VkDevice& device, size_t size_in_bytes, const char* data) +{ + device_ = device; + buffer_ = VK_NULL_HANDLE; + memory_ = VK_NULL_HANDLE; + init(size_in_bytes, data); +} + +Buffer::~Buffer() +{ + vkFreeMemory(device_, memory_, NULL); + vkDestroyBuffer(device_, buffer_, NULL); +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/common.hpp b/modules/dnn/src/vkcom/src/common.hpp new file mode 100644 index 0000000000..5465a1a83a --- /dev/null +++ b/modules/dnn/src/vkcom/src/common.hpp @@ -0,0 +1,81 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_COMMON_HPP +#define OPENCV_DNN_VKCOM_COMMON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef HAVE_VULKAN +#include +#endif +#include "opencv2/core/utils/logger.hpp" +#include "../vulkan/vk_functions.hpp" +#include "../include/vkcom.hpp" +#include "../shader/spv_shader.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +enum ShapeIdx +{ + kShapeIdxBatch = 0, + kShapeIdxChannel, + kShapeIdxHeight, + kShapeIdxWidth, +}; + +#define VK_CHECK_RESULT(f) \ +{ \ + if (f != VK_SUCCESS) \ + { \ + CV_LOG_WARNING(NULL, "Vulkan check failed"); \ + } \ +} + +#define VKCOM_CHECK_BOOL_RET_VAL(val, ret) \ +{ \ + bool res = (val); \ + if (!res) \ + { \ + CV_LOG_WARNING(NULL, "Check bool failed"); \ + return ret; \ + } \ +} + +#define VKCOM_CHECK_POINTER_RET_VOID(p) \ +{ \ + if (NULL == (p)) \ + { \ + CV_LOG_WARNING(NULL, "Check pointer failed"); \ + return; \ + } \ +} + +#define VKCOM_CHECK_POINTER_RET_VAL(p, val) \ +{ \ + if (NULL == (p)) \ + { \ + CV_LOG_WARNING(NULL, "Check pointer failed"); \ + return (val); \ + } \ +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_COMMON_HPP diff --git a/modules/dnn/src/vkcom/src/context.hpp b/modules/dnn/src/vkcom/src/context.hpp new file mode 100644 index 0000000000..f5505ce11e --- /dev/null +++ b/modules/dnn/src/vkcom/src/context.hpp @@ -0,0 +1,29 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_CONTEXT_HPP +#define OPENCV_DNN_VKCOM_CONTEXT_HPP +#include "common.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +struct Context +{ + VkDevice device; + VkQueue queue; + VkCommandPool cmd_pool; + std::map shader_modules; + int ref; +}; + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_CONTEXT_HPP diff --git a/modules/dnn/src/vkcom/src/internal.cpp b/modules/dnn/src/vkcom/src/internal.cpp new file mode 100644 index 0000000000..bdf8f9823d --- /dev/null +++ b/modules/dnn/src/vkcom/src/internal.cpp @@ -0,0 +1,153 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +std::vector compile(const std::string& name, + shaderc_shader_kind kind, + const std::string& data) +{ + std::vector result; +#ifdef USE_SHADERC + shaderc::Compiler compiler; + shaderc::CompileOptions options; + + // Like -DMY_DEFINE=1 + //options.AddMacroDefinition("MY_DEFINE", "1"); + options.SetGenerateDebugInfo(); + options.SetTargetEnvironment(shaderc_target_env_vulkan, shaderc_env_version_vulkan_1_1); + shaderc::SpvCompilationResult module = compiler.CompileGlslToSpv( + data.c_str(), data.size(), kind, name.c_str(), options); + + if (module.GetCompilationStatus() != + shaderc_compilation_status_success) { + std::cerr << module.GetErrorMessage(); + } + + //std::vector result(module.cbegin(), module.cend()); + result.assign(module.cbegin(), module.cend()); + return result; +#else + assert(0); + return result; +#endif +} + +void bindTensor(VkDevice& device, Tensor& tensor, int binding, VkDescriptorSet descriptor_set) +{ + VkDescriptorBufferInfo desc_buffer_info = {}; + desc_buffer_info.buffer = tensor.getBuffer()->getVkBuffer(); + desc_buffer_info.offset = 0; + desc_buffer_info.range = tensor.size(); + + VkWriteDescriptorSet write_descriptor_set = {}; + write_descriptor_set.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + write_descriptor_set.dstSet = descriptor_set; + write_descriptor_set.dstBinding = binding; + write_descriptor_set.descriptorCount = 1; + write_descriptor_set.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + write_descriptor_set.pBufferInfo = &desc_buffer_info; + + vkUpdateDescriptorSets(device, 1, &write_descriptor_set, 0, NULL); +} + +void computeConvOutputShapeAndPadding(const PaddingMode& padding_mode, + int& padding_top, int& padding_left, + const int& in_h, const int& in_w, + const int& filter_h, const int& filter_w, + const int& dilation_h, const int& dilation_w, + const int& stride_h, const int& stride_w, + int& out_h, int& out_w) +{ + if (padding_mode == kPaddingModeValid) + { + padding_top = 0; + padding_left = 0; + out_h = ceil((in_h - (filter_h - 1) * dilation_h) / stride_h); + out_w = ceil((in_w - (filter_w - 1) * dilation_w) / stride_w); + } + else if (padding_mode == kPaddingModeSame) + { + padding_top = ((filter_h - 1) * dilation_h + 1) / 2; + padding_left = ((filter_w - 1) * dilation_w + 1) / 2; + out_h = ceil(in_h / stride_h); + out_w = ceil(in_w / stride_w); + } + else if (padding_mode == kPaddingModeCaffe) + { + const int filter_h_actual = dilation_h * (filter_h - 1) + 1; + const int filter_w_actual = dilation_w * (filter_w - 1) + 1; + out_h = (in_h + 2 * padding_top - filter_h_actual) / stride_h + 1; + out_w = (in_w + 2 * padding_left - filter_w_actual) / stride_w + 1; + } + else + { + CV_Error(Error::StsError, format("Invalid padding mode:%d", padding_mode)); + } +} + +void computePoolOutputShape(const PaddingMode& padding_mode, + const int& padding_top, const int& padding_left, + const int& in_h, const int& in_w, + const int& filter_h, const int& filter_w, + const int& stride_h, const int& stride_w, + int& out_h, int& out_w) +{ + if (padding_mode == kPaddingModeValid) + { + assert(padding_top == 0); + assert(padding_left == 0); + out_h = ceil((in_h - (filter_h - 1)) / stride_h); + out_w = ceil((in_h - (filter_w - 1)) / stride_w); + } + else if (padding_mode == kPaddingModeSame) + { + const int padding_top_ = filter_h / 2; + const int padding_left_ = filter_w / 2; + CV_Assert(padding_top == padding_top_); + CV_Assert(padding_left == padding_left_); + out_h = ceil(in_h / stride_h); + out_w = ceil(in_h / stride_w); + } + else if (padding_mode == kPaddingModeCaffe) + { + int out_h_ = static_cast(ceil(static_cast( + in_h + 2 * padding_top - filter_h) / stride_h)) + 1; + int out_w_ = static_cast(ceil(static_cast( + in_h + 2 * padding_left - filter_w) / stride_w)) + 1; + + if (padding_top || padding_left) + { + // If we have padding, ensure that the last pooling starts strictly + // inside the image (instead of at the padding); otherwise clip the last. + if ((out_h_ - 1) * stride_h >= in_h + padding_top) { + --out_h_; + } + if ((out_w - 1) * stride_h >= in_h + padding_left) { + --out_w; + } + assert((out_h_ - 1) * stride_h < in_h + padding_top); + assert((out_w_ - 1) * stride_w < in_h + padding_left); + } + out_h = out_h_; + out_w = out_w_; + } + else + { + CV_Error(Error::StsError, format("Invalid padding mode:%d", padding_mode)); + } +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/internal.hpp b/modules/dnn/src/vkcom/src/internal.hpp new file mode 100644 index 0000000000..a2e4955a33 --- /dev/null +++ b/modules/dnn/src/vkcom/src/internal.hpp @@ -0,0 +1,91 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_INTERNAL_HPP +#define OPENCV_DNN_VKCOM_INTERNAL_HPP + +#include +#include "../include/vkcom.hpp" +#include "context.hpp" + +#ifdef USE_SHADERC +#include "shaderc/shaderc.hpp" +#else +typedef int shaderc_shader_kind; +#define shaderc_compute_shader 0 +#endif + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +Context* getContext(); +VkPhysicalDevice getPhysicalDevice(); +std::vector compile(const std::string& name, + shaderc_shader_kind kind, + const std::string& data); +void bindTensor(VkDevice& device, Tensor& tensor, int binding, VkDescriptorSet descriptor_set); +void computeConvOutputShapeAndPadding(const PaddingMode& padding_mode, + int& padding_top, int& padding_left, + const int& in_h, const int& in_w, + const int& filter_h, const int& filter_w, + const int& dilation_h, const int& dilation_w, + const int& stride_h, const int& stride_w, + int& out_h, int& out_w); +void computePoolOutputShape(const PaddingMode& padding_mode, + const int& padding_top, const int& padding_left, + const int& in_h, const int& in_w, + const int& filter_h, const int& filter_w, + const int& stride_h, const int& stride_w, + int& out_h, int& out_w); + +inline bool checkFormat(Format fmt) +{ + return (fmt > -1 && fmt < kFormatNum) ? true : false; +} + +inline size_t elementSize(Format fmt) +{ + if (fmt == kFormatFp32 || fmt == kFormatInt32) + { + return 4; + } + else if (fmt >= 0 && fmt < kFormatNum) + { + CV_LOG_WARNING(NULL, format("Unsupported format %d", fmt)); + } + else + { + CV_Error(Error::StsError, format("Invalid format %d", fmt)); + } + return 0; +} + +inline int shapeCount(const Shape& shape, int start = -1, int end = -1) +{ + if (start == -1) start = 0; + if (end == -1) end = (int)shape.size(); + + if (shape.empty()) + return 0; + + int elems = 1; + assert(start <= (int)shape.size() && + end <= (int)shape.size() && + start <= end); + for(int i = start; i < end; i++) + { + elems *= shape[i]; + } + return elems; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom + +#endif // OPENCV_DNN_VKCOM_INTERNAL_HPP diff --git a/modules/dnn/src/vkcom/src/op_base.cpp b/modules/dnn/src/vkcom/src/op_base.cpp new file mode 100644 index 0000000000..6c7fa94d5e --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_base.cpp @@ -0,0 +1,186 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_base.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +OpBase::OpBase() +{ + ctx_ = getContext(); + device_ = ctx_->device; + pipeline_ = VK_NULL_HANDLE; + cmd_buffer_ = VK_NULL_HANDLE; + descriptor_pool_ = VK_NULL_HANDLE; + descriptor_set_ = VK_NULL_HANDLE; + descriptor_set_layout_ = VK_NULL_HANDLE; + pipeline_layout_ = VK_NULL_HANDLE; + module_ = VK_NULL_HANDLE; +} + +OpBase::~OpBase() +{ + vkDestroyShaderModule(device_, module_, NULL); + vkDestroyDescriptorPool(device_, descriptor_pool_, NULL); + vkDestroyDescriptorSetLayout(device_, descriptor_set_layout_, NULL); + vkDestroyPipeline(device_, pipeline_, NULL); + vkDestroyPipelineLayout(device_, pipeline_layout_, NULL); +} + +void OpBase::initVulkanThing(int buffer_num) +{ + createDescriptorSetLayout(buffer_num); + createDescriptorSet(buffer_num); + createCommandBuffer(); +} + +void OpBase::createDescriptorSetLayout(int buffer_num) +{ + VkDescriptorSetLayoutBinding bindings[buffer_num] = {}; + for (int i = 0; i < buffer_num; i++) + { + bindings[i].binding = i; + bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + bindings[i].descriptorCount = 1; + bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + } + VkDescriptorSetLayoutCreateInfo info = {}; + info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + info.bindingCount = buffer_num; + info.pBindings = bindings; + VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device_, &info, NULL, &descriptor_set_layout_)); +} + +void OpBase::createDescriptorSet(int buffer_num) +{ + VkDescriptorPoolSize pool_size = {}; + pool_size.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + pool_size.descriptorCount = buffer_num; + + VkDescriptorPoolCreateInfo info = {}; + info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + info.maxSets = 1; + info.poolSizeCount = 1; + info.pPoolSizes = &pool_size; + VK_CHECK_RESULT(vkCreateDescriptorPool(device_, &info, NULL, &descriptor_pool_)); + + VkDescriptorSetAllocateInfo allocate_info = {}; + allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + allocate_info.descriptorPool = descriptor_pool_; + allocate_info.descriptorSetCount = 1; + allocate_info.pSetLayouts = &descriptor_set_layout_; + VK_CHECK_RESULT(vkAllocateDescriptorSets(device_, &allocate_info, &descriptor_set_)); +} + +void OpBase::createShaderModule(const uint32_t* spv, size_t sz, const std::string& source) +{ + VkShaderModuleCreateInfo create_info = {}; + create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + if (spv) + { + create_info.pCode = spv; + create_info.codeSize = sz; + } + else + { + // online compilation + std::vector code; + code = compile("shader", shaderc_compute_shader, source); + create_info.pCode = code.data(); + create_info.codeSize = sizeof(uint32_t) * code.size(); + } + VK_CHECK_RESULT(vkCreateShaderModule(device_, &create_info, NULL, &module_)); +} + +void OpBase::createPipeline(size_t push_constants_size) +{ + // create pipeline + VkPipelineShaderStageCreateInfo stage_create_info = {}; + stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + stage_create_info.stage = VK_SHADER_STAGE_COMPUTE_BIT; + stage_create_info.module = module_; + stage_create_info.pName = "main"; + VkPushConstantRange push_constant_ranges[1] = {}; + push_constant_ranges[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + push_constant_ranges[0].offset = 0; + push_constant_ranges[0].size = push_constants_size; + + VkPipelineLayoutCreateInfo pipeline_layout_create_info = {}; + pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + if (push_constants_size != 0) + { + pipeline_layout_create_info.pushConstantRangeCount = 1; + pipeline_layout_create_info.pPushConstantRanges = push_constant_ranges; + } + pipeline_layout_create_info.setLayoutCount = 1; + pipeline_layout_create_info.pSetLayouts = &descriptor_set_layout_; + VK_CHECK_RESULT(vkCreatePipelineLayout(device_, &pipeline_layout_create_info, + NULL, &pipeline_layout_)); + + VkComputePipelineCreateInfo pipeline_create_info = {}; + pipeline_create_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + pipeline_create_info.stage = stage_create_info; + pipeline_create_info.layout = pipeline_layout_; + VK_CHECK_RESULT(vkCreateComputePipelines(device_, VK_NULL_HANDLE, + 1, &pipeline_create_info, + NULL, &pipeline_)); +} + +void OpBase::createCommandBuffer() +{ + VkCommandBufferAllocateInfo info = {}; + info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + info.commandPool = ctx_->cmd_pool; + info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + info.commandBufferCount = 1; + VK_CHECK_RESULT(vkAllocateCommandBuffers(device_, &info, &cmd_buffer_)); +} + +void OpBase::recordCommandBuffer(void* push_constants, size_t push_constants_size) +{ + VkCommandBufferBeginInfo beginInfo = {}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + VK_CHECK_RESULT(vkBeginCommandBuffer(cmd_buffer_, &beginInfo)); + if (push_constants) + vkCmdPushConstants(cmd_buffer_, pipeline_layout_, + VK_SHADER_STAGE_COMPUTE_BIT, 0, + push_constants_size, push_constants); + vkCmdBindPipeline(cmd_buffer_, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_); + vkCmdBindDescriptorSets(cmd_buffer_, VK_PIPELINE_BIND_POINT_COMPUTE, + pipeline_layout_, 0, 1, &descriptor_set_, 0, NULL); + vkCmdDispatch(cmd_buffer_, group_x_, group_y_, group_z_); + + VK_CHECK_RESULT(vkEndCommandBuffer(cmd_buffer_)); +} + +void OpBase::runCommandBuffer() +{ + VkSubmitInfo submit_info = {}; + submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.commandBufferCount = 1; + submit_info.pCommandBuffers = &cmd_buffer_; + + VkFence fence; + VkFenceCreateInfo fence_create_info_ = {}; + fence_create_info_.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fence_create_info_.flags = 0; + + VK_CHECK_RESULT(vkCreateFence(device_, &fence_create_info_, NULL, &fence)); + VK_CHECK_RESULT(vkQueueSubmit(ctx_->queue, 1, &submit_info, fence)); + VK_CHECK_RESULT(vkWaitForFences(device_, 1, &fence, VK_TRUE, 100000000000)); + vkDestroyFence(device_, fence, NULL); +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_concat.cpp b/modules/dnn/src/vkcom/src/op_concat.cpp new file mode 100644 index 0000000000..fbc6a098eb --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_concat.cpp @@ -0,0 +1,138 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_concat.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 256 + +struct ConcatParam { + int out_concat_axis; + int accumulated_concat_axis; + int concat_size; + int total_concat_size; + int thread_num; +}; + +OpConcat::OpConcat(const int axis) +{ + init(axis); + type_ = "Concat"; +} + +bool OpConcat::init(const int axis) +{ + axis_ = axis; +#define BUFFER_NUM 2 + OpBase::initVulkanThing(BUFFER_NUM); + return true; +} + +void OpConcat::reshapeOutTensor(std::vector& in, Tensor& out) +{ + int sum_axis = 0; + + for (int i = 0; i < in.size(); ++i) + { + sum_axis += in[i]->dimSize(axis_); + } + + Shape shape = in[0]->getShape(); + shape[axis_] = sum_axis; + out.reshape(NULL, shape); +} + +bool OpConcat::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + return forward(ins, outs[0]); +} + +bool OpConcat::forward(std::vector& ins, Tensor& out) +{ + int input_num = ins.size(); + Tensor& first_tensor = ins[0]; + int sum_axis = first_tensor.dimSize(axis_); + int dim_num = first_tensor.dimNum(); + for (int i = 1; i < input_num; ++i) + { + Tensor& tensor = ins[i]; + assert(tensor.dimNum() == dim_num); + for (int d = 0; d < dim_num; ++d) + { + if (d == axis_) + { + sum_axis += tensor.dimSize(axis_);; + } + else + { + assert(first_tensor.dimSize(d) == tensor.dimSize(d)); + } + } + } + + assert(out.dimSize(axis_) == sum_axis); + for (int d = 0; d < dim_num; ++d) + { + if (d != axis_) + { + assert(out.dimSize(d) == first_tensor.dimSize(d)); + } + } + out_concat_axis_ = sum_axis; + concat_size_ = out.count(axis_ + 1); + + if (pipeline_ == VK_NULL_HANDLE) + { + config_.local_size_x = LOCAL_SZ_X; + config_.block_height = 1; + config_.block_width = 1; + config_.block_depth = 1; + createShaderModule(concat_spv, sizeof(concat_spv)); + createPipeline(sizeof(ConcatParam)); + } + + accumulated_concat_axis_ = 0; + for (int i = 0; i < input_num; i++) + { + bindTensor(device_, ins[i], 0, descriptor_set_); + bindTensor(device_, out, 1, descriptor_set_); + total_concat_size_ = ins[i].count(axis_); + thread_num_ = ins[i].count(); + computeGroupCount(); + ConcatParam param = {out_concat_axis_, + accumulated_concat_axis_, + concat_size_, + total_concat_size_, + thread_num_}; + recordCommandBuffer((void *)¶m, sizeof(ConcatParam)); + runCommandBuffer(); + accumulated_concat_axis_ += ins[i].dimSize(axis_); + } + + return true; +} + +bool OpConcat::computeGroupCount() +{ + group_x_ = alignSize(thread_num_, config_.local_size_x) / config_.local_size_x; + group_y_ = 1; + group_z_ = 1; + + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_conv.cpp b/modules/dnn/src/vkcom/src/op_conv.cpp new file mode 100644 index 0000000000..7a15e925ea --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_conv.cpp @@ -0,0 +1,190 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_conv.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 256 + +struct ShaderParam { + int in_h; + int in_w; + int out_h; + int out_w; + int stride_h; + int stride_w; + int pad_h; + int pad_w; + int filter_h; + int filter_w; + int dilation_h; + int dilation_w; + int channels; + int batch; + int has_bias; + int M; + int K; + int N; +}; + +OpConv::OpConv(const int out_channel, const bool has_bias, + const int* filter_size, const int* pad, + const int* stride, const int* dilation, + const int activation, const int group, + const int padding_mode) +{ + init(out_channel, has_bias, filter_size, pad, + stride, dilation, activation, group, padding_mode); + type_ = "Conv"; +} + +void OpConv::reshapeOutTensor(Tensor& in, Tensor& out) +{ + Shape in_shape = in.getShape(); + batch_ = in_shape[kShapeIdxBatch]; + in_height_ = in_shape[kShapeIdxHeight]; + in_width_ = in_shape[kShapeIdxWidth]; + computeConvOutputShapeAndPadding(padding_mode_, padding_top_, padding_left_, + in_height_, in_width_, + filter_height_, filter_width_, + dilation_height_, dilation_width_, + stride_height_, stride_width_, + out_height_, out_width_); + Shape shape = {batch_, out_channel_, out_height_, out_width_}; + out.reshape(NULL, shape); +} + +bool OpConv::init(const int out_channel, const bool has_bias, + const int* filter_size, const int* pad, + const int* stride, const int* dilation, + const int activation, const int group, + const int padding_mode) +{ + out_channel_ = out_channel; + filter_height_ = filter_size[0]; + filter_width_ = filter_size[1]; + padding_top_ = pad[0]; + padding_left_ = pad[1]; + stride_height_ = stride[0]; + stride_width_ = stride[1]; + dilation_height_ = dilation[0]; + dilation_width_ = dilation[1]; + padding_mode_ = (PaddingMode)padding_mode; + has_bias_ = has_bias ? 1 : 0; + activation_ = activation; + group_ = group; + + #define BUFFER_NUM 4 + OpBase::initVulkanThing(BUFFER_NUM); + return true; +} + +bool OpConv::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + std::vector shape = {1}; + Tensor bias(0, shape); + + if (has_bias_) + { + assert(blobs.size() == 2); + bias = blobs[1]; + } + + return forward(ins[0], blobs[0], bias, outs[0]); +} + +bool OpConv::forward(Tensor& in, Tensor& filter_weights, Tensor& bias, Tensor& out) +{ + Shape in_shape = in.getShape(); + Shape out_shape = out.getShape(); + batch_ = in_shape[kShapeIdxBatch]; + in_height_ = in_shape[kShapeIdxHeight]; + in_width_ = in_shape[kShapeIdxWidth]; + in_channel_= in_shape[kShapeIdxChannel]; + out_height_ = out_shape[kShapeIdxHeight]; + out_width_ = out_shape[kShapeIdxWidth]; + + dwconv_ = (out_channel_ == in_channel_ && in_channel_ == group_); + if (dwconv_ == false) + assert(group_ == 1); // TODO: support group > 1 + + if (pipeline_ == VK_NULL_HANDLE) + { + config_.local_size_x = LOCAL_SZ_X; + config_.local_size_y = 1; + config_.local_size_z = 1; + config_.block_height = 1; + config_.block_width = 1; + config_.block_depth = 1; + config_.shader_type = kConvShaderTypeBasic; + + if (dwconv_) + createShaderModule(dw_conv_spv, sizeof(dw_conv_spv)); + else + createShaderModule(conv_spv, sizeof(conv_spv)); + createPipeline(sizeof(ShaderParam)); + computeGroupCount(); + } + + bindTensor(device_, in, 0, descriptor_set_); + bindTensor(device_, bias, 1, descriptor_set_); + bindTensor(device_, filter_weights, 2, descriptor_set_); + bindTensor(device_, out, 3, descriptor_set_); + + int M = out_height_ * out_width_; + int K = filter_height_ * filter_width_ * in_channel_; + int N = out_channel_; + ShaderParam param = {in_height_, in_width_, + out_height_, out_width_, + stride_height_, stride_width_, + padding_top_, padding_left_, + filter_height_, filter_width_, + dilation_height_, dilation_width_, + in_channel_, batch_, has_bias_, + M, K, N}; + + recordCommandBuffer((void *)¶m, sizeof(ShaderParam)); + runCommandBuffer(); + return true; +} + +bool OpConv::computeGroupCount() +{ + if (dwconv_) + { + group_x_ = alignSize(out_width_, config_.local_size_x) / config_.local_size_x; + group_y_ = alignSize(out_height_, config_.local_size_y) / config_.local_size_y; + group_z_ = alignSize(in_channel_, config_.local_size_z) / config_.local_size_z; + return true; + } + + int M = out_height_ * out_width_; + int N = out_channel_; + + if (config_.shader_type == kConvShaderTypeBasic) + { + group_x_ = alignSize(M, config_.local_size_x) / config_.local_size_x; + group_y_ = alignSize(N, config_.local_size_y) / config_.local_size_y; + group_z_ = alignSize(batch_, config_.local_size_z) / config_.local_size_z; + } + else + CV_Assert(0); + + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_lrn.cpp b/modules/dnn/src/vkcom/src/op_lrn.cpp new file mode 100644 index 0000000000..8a9f1a3344 --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_lrn.cpp @@ -0,0 +1,115 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_lrn.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 256 +#define LOCAL_SZ_Y 1 +#define LOCAL_SZ_Z 1 + +struct LRNParam { + int thread_num; + int channels; + int height; + int width; + int filter_len; + int radius; + float alpha; + float bias; + float negative_beta; +}; + +OpLRN::OpLRN(const int radius, const float bias, + const float alpha, const float beta, + const bool norm_by_size) +{ + init(radius, bias, alpha, beta, norm_by_size); + type_ = "LRN"; +} + +void OpLRN::reshapeOutTensor(Tensor& in, Tensor& out) +{ + Shape shape = in.getShape(); + out.reshape(NULL, shape); +} + +bool OpLRN::init(const int radius, const float bias, + const float alpha, const float beta, + const bool norm_by_size) +{ + radius_ = radius; + filter_len_ = 2 * radius_ + 1; + bias_ = bias; + alpha_ = alpha; + beta_ = beta; + norm_by_size_ = norm_by_size; + OpBase::initVulkanThing(2); + return true; +} + +bool OpLRN::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + return forward(ins[0], outs[0]); +} + +bool OpLRN::forward(Tensor& in, Tensor& out) +{ + Shape in_shape = in.getShape(); + batch_ = in_shape[kShapeIdxBatch]; + height_ = in_shape[kShapeIdxHeight]; + width_ = in_shape[kShapeIdxWidth]; + channels_= in_shape[kShapeIdxChannel]; + thread_num_ = batch_ * height_ * width_; + + if (pipeline_ == VK_NULL_HANDLE) + { + config_.local_size_x = LOCAL_SZ_X; + config_.local_size_y = LOCAL_SZ_Y; + config_.local_size_z = LOCAL_SZ_Z; + config_.block_height = 1; + config_.block_width = 1; + config_.block_depth = 1; + config_.shader_type = kLRNShaderTypeBasic; + createShaderModule(lrn_spv, sizeof(lrn_spv)); + createPipeline(sizeof(LRNParam)); + computeGroupCount(); + } + + bindTensor(device_, in, 0, descriptor_set_); + bindTensor(device_, out,1, descriptor_set_); + + LRNParam param = {batch_ * height_ * width_, + channels_, height_, width_, + filter_len_, radius_, + alpha_ / (norm_by_size_ ? filter_len_ : 1), + bias_, -1 * beta_}; + recordCommandBuffer((void *)¶m, sizeof(LRNParam)); + runCommandBuffer(); + return true; +} + +bool OpLRN::computeGroupCount() +{ + group_x_ = alignSize(thread_num_, config_.local_size_x) / config_.local_size_x; + group_y_ = 1; + group_z_ = 1; + + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_permute.cpp b/modules/dnn/src/vkcom/src/op_permute.cpp new file mode 100644 index 0000000000..8f6c3913cb --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_permute.cpp @@ -0,0 +1,163 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_permute.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +struct PermuteParam { + int global_size; + int num_axes; + int nthreads; +}; + +static bool needForPermutation(std::vector& order) +{ + for (int i = 0; i < order.size(); ++i) + { + if (order[i] != i) + return true; + } + return false; +} + +OpPermute::OpPermute(std::vector& order) +{ + order_.assign(order.begin(), order.end()); + dims_ = order.size(); + need_permute_ = needForPermutation(order_); + type_ = "Permute"; + if (need_permute_) + OpBase::initVulkanThing(5); +} + +void OpPermute::reshapeOutTensor(std::vector& ins, std::vector& outs) +{ + assert(!ins.empty()); + assert(ins.size() == outs.size()); + + if (need_permute_) + { + assert(dims_ == ins[0]->dimNum()); + + Shape shape_before = ins[0]->getShape(); + Shape shape_after; + for (size_t i = 0; i < dims_; i++) + { + shape_after.push_back(shape_before[order_[i]]); + } + + for (size_t i = 0; i < ins.size(); i++) + { + assert(ins[i]->dimNum() == 4); + assert(ins[i]->dimSize(2) == shape_before[2] && ins[i]->dimSize(3) == shape_before[3]); + assert(ins[i]->count() == shapeCount(shape_after)); + outs[i].reshape(NULL, shape_after); + } + } + else + { + for(int i = 0; i < ins.size(); i++) + { + Shape in_shape = ins[i]->getShape(); + outs[i].reshape(NULL, in_shape); + } + } +} + +void OpPermute::prepareStrides(const Shape &shape_before, const Shape &shape_after) +{ + assert(shape_before.size() == dims_); + assert(shape_after.size() == dims_); + + old_stride_.resize(dims_); + new_stride_.resize(dims_); + + old_stride_[dims_ - 1] = 1; + new_stride_[dims_ - 1] = 1; + + for(int i = dims_ - 2; i >= 0; i--) + { + old_stride_[i] = old_stride_[i + 1] * shape_before[i + 1]; + new_stride_[i] = new_stride_[i + 1] * shape_after[i + 1]; + } + + Shape shape(1, old_stride_.size()); + tensor_old_stride_.reshape((const char*)old_stride_.data(), shape, kFormatInt32); + tensor_new_stride_.reshape((const char*)new_stride_.data(), shape, kFormatInt32); +} + +bool OpPermute::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + return forward(ins, outs); +} + +bool OpPermute::forward(std::vector& ins, std::vector& outs) +{ + int num_ins = ins.size(); + in_shape_ = ins[0].getShape(); + out_shape_ = outs[0].getShape(); + if (!need_permute_) + { + for (int i = 0; i < num_ins; i++) + { + assert(outs[i].count() == ins[i].count()); + if (outs[i].getBuffer() != ins[i].getBuffer()) + ins[i].copyTo(outs[i]); + } + return true; + } + + if (pipeline_ == VK_NULL_HANDLE) + { + createShaderModule(permute_spv, sizeof(permute_spv)); + createPipeline(sizeof(PermuteParam)); + } + + prepareStrides(ins[0].getShape(), outs[0].getShape()); + std::vectorshape(1, order_.size()); + tensor_order_.reshape((const char*)order_.data(), shape, kFormatInt32); + bindTensor(device_, tensor_order_, 1, descriptor_set_); + bindTensor(device_, tensor_old_stride_, 2, descriptor_set_); + bindTensor(device_, tensor_new_stride_, 3, descriptor_set_); + + nthreads_ = ins[0].count(); +#define LOCAL_SZ_X 256 + global_size_ = alignSize(nthreads_, LOCAL_SZ_X); + computeGroupCount(); + + PermuteParam param = {global_size_, dims_, nthreads_}; + for (int i = 0; i < num_ins; i++) + { + bindTensor(device_, ins[i], 0, descriptor_set_); + bindTensor(device_, outs[i], 4, descriptor_set_); + recordCommandBuffer((void *)¶m, sizeof(PermuteParam)); + runCommandBuffer(); + } + + return true; +} + +bool OpPermute::computeGroupCount() +{ + group_x_ = global_size_ / LOCAL_SZ_X; + group_y_ = 1; + group_z_ = 1; + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_pool.cpp b/modules/dnn/src/vkcom/src/op_pool.cpp new file mode 100644 index 0000000000..71cd1019c5 --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_pool.cpp @@ -0,0 +1,160 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_pool.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 256 +#define LOCAL_SZ_Y 1 +#define LOCAL_SZ_Z 1 + +struct PoolParam { + int channels; + int in_height; + int in_width; + int out_height; + int out_width; + int padding_top; + int padding_left; + int filter_h; + int filter_w; + int stride_h; + int stride_w; + int total; + int mask_or_padded_area; +}; + +OpPool::OpPool(const int* filter_size, const int* pad, const int* stride, + const int padding_mode, const PoolType type, + const bool avg_pool_padded_area) +{ + init(filter_size, pad, stride, padding_mode, type, avg_pool_padded_area); + type_ = "Pool"; +} + +bool OpPool::init(const int* filter_size, const int* pad, const int* stride, + const int padding_mode, const PoolType type, bool avg_pool_padded_area) +{ + VKCOM_CHECK_BOOL_RET_VAL(padding_mode >= 0 && padding_mode < kPaddingModeNum, false); + VKCOM_CHECK_POINTER_RET_VAL(filter_size, false); + VKCOM_CHECK_POINTER_RET_VAL(pad, false); + VKCOM_CHECK_POINTER_RET_VAL(stride, false); + + filter_height_ = filter_size[0]; + filter_width_ = filter_size[1]; + padding_top_ = pad[0]; + padding_left_ = pad[1]; + padding_mode_ = (PaddingMode)padding_mode; + stride_height_ = stride[0]; + stride_width_ = stride[1]; + pool_type_ = type; + avg_pool_padded_area_ = avg_pool_padded_area ? 1 : 0; + + if (pool_type_ == kPoolTypeAvg) + OpBase::initVulkanThing(2); + else if (pool_type_ == kPoolTypeMax) + OpBase::initVulkanThing(3); + else + assert(0); + return true; +} + +void OpPool::reshapeOutTensor(Tensor& in, Tensor& out) +{ + Shape in_shape = in.getShape(); + batch_ = in_shape[kShapeIdxBatch]; + channels_ = in_shape[kShapeIdxChannel]; + in_height_ = in_shape[kShapeIdxHeight]; + in_width_ = in_shape[kShapeIdxWidth]; + computePoolOutputShape(padding_mode_, padding_top_, padding_left_, + in_height_, in_width_, + filter_height_, filter_width_, + stride_height_, stride_width_, + out_height_, out_width_); + Shape out_shape = {batch_, channels_, out_height_, out_width_}; + out.reshape(NULL, out_shape); +} + +bool OpPool::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + for (size_t ii = 0; ii < ins.size(); ii++) + { + Tensor& inpMat = ins[ii]; + int out_index = (pool_type_ == kPoolTypeMax) ? 2 : 1; + Tensor& outMat = outs[out_index * ii]; + Tensor maskMat = (pool_type_ == kPoolTypeMax) ? outs[2 * ii + 1] : Tensor(); + if (!forward(inpMat, outMat, maskMat)) + return false; + } + return true; +} + +bool OpPool::forward(Tensor& in, Tensor& out, Tensor& mask) +{ + Shape in_shape = in.getShape(); + Shape out_shape = out.getShape(); + batch_ = in_shape[kShapeIdxBatch]; + channels_ = in_shape[kShapeIdxChannel]; + in_height_ = in_shape[kShapeIdxHeight]; + in_width_ = in_shape[kShapeIdxWidth]; + out_height_ = out_shape[kShapeIdxHeight]; + out_width_ = out_shape[kShapeIdxWidth]; + need_mask_ = mask.isEmpty() ? 0 : 1; + + if (pipeline_ == VK_NULL_HANDLE) + { + config_.local_size_x = LOCAL_SZ_X; + config_.local_size_y = LOCAL_SZ_Y; + config_.local_size_z = LOCAL_SZ_Z; + config_.block_height = 1; + config_.block_width = 1; + config_.block_depth = 1; + if (pool_type_ == kPoolTypeAvg) + createShaderModule(avg_pool_spv, sizeof(avg_pool_spv)); + else + createShaderModule(max_pool_spv, sizeof(max_pool_spv)); + createPipeline(sizeof(PoolParam)); + computeGroupCount(); + } + + bindTensor(device_, in, 0, descriptor_set_); + bindTensor(device_, out, 1, descriptor_set_); + if (need_mask_) + bindTensor(device_, mask, 2, descriptor_set_); + PoolParam param = {channels_, + in_height_, in_width_, + out_height_, out_width_, + padding_top_, padding_left_, + filter_height_, filter_width_, + stride_height_, stride_width_, out.count(), + pool_type_ == kPoolTypeAvg ? avg_pool_padded_area_ : need_mask_}; + recordCommandBuffer((void *)¶m, sizeof(PoolParam)); + runCommandBuffer(); + return true; +} + +bool OpPool::computeGroupCount() +{ +#define GLOBAL_SIZE (128 * 128) + group_x_ = alignSize(GLOBAL_SIZE, config_.local_size_x) / config_.local_size_x; + group_y_ = 1; + group_z_ = 1; + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_prior_box.cpp b/modules/dnn/src/vkcom/src/op_prior_box.cpp new file mode 100644 index 0000000000..e07e97b8ba --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_prior_box.cpp @@ -0,0 +1,151 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_prior_box.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 256 +struct PriorBoxParam { + int global_size; + int nthreads; + float step_x; + float step_y; + int offsets_x_size; + int width_size; + int layer_w; + int image_h; + int image_w; + int clip; + int variance_off; +}; + +OpPriorBox::OpPriorBox(float step_x, + float step_y, + bool clip, + int num_priors, + std::vector& variance, + std::vector& offsets_x, + std::vector& offsets_y, + std::vector& box_widths, + std::vector& box_heights) +{ + step_x_ = step_x; + step_y_ = step_y; + clip_ = clip; + num_priors_ = num_priors; + variance_ = variance; + offsets_x_ = offsets_x; + offsets_y_ = offsets_y; + box_widths_ = box_widths; + box_heights_ = box_heights; + type_ = "PriorBox"; +#define BUFFER_NUM 6 + OpBase::initVulkanThing(BUFFER_NUM); +} + +void OpPriorBox::reshapeOutTensor(std::vector& ins, Tensor& out) +{ + assert(!ins.empty()); + + Shape in_shape = ins[0]->getShape(); + int layer_h = in_shape[kShapeIdxHeight]; + int layer_w = in_shape[kShapeIdxWidth]; + int out_num = 1; + int out_channel = 2; + Shape out_shape = {out_num, out_channel, layer_h * layer_w * num_priors_ * 4}; + out.reshape(NULL, out_shape); +} + +bool OpPriorBox::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + return forward(ins, outs[0]); +} + +bool OpPriorBox::forward(std::vector& ins, Tensor& out) +{ + assert(ins.size() == 2); + Shape in_shape = ins[0].getShape(); + Shape img_shape = ins[1].getShape(); + + in_h_ = in_shape[kShapeIdxHeight]; + in_w_ = in_shape[kShapeIdxWidth]; + img_h_ = img_shape[kShapeIdxHeight]; + img_w_ = img_shape[kShapeIdxWidth]; + out_channel_ = out.dimSize(1); + out_channel_size_ = out.dimSize(2); + nthreads_ = in_h_ * in_w_; + global_size_ = alignSize(nthreads_, LOCAL_SZ_X); + + if (pipeline_ == VK_NULL_HANDLE) + { + createShaderModule(prior_box_spv, sizeof(prior_box_spv)); + createPipeline(sizeof(PriorBoxParam)); + computeGroupCount(); + } + + std::vectorshape; + shape.push_back(offsets_x_.size()); + tensor_offsets_x_.reshape((const char*)offsets_x_.data(), shape); + tensor_offsets_y_.reshape((const char*)offsets_y_.data(), shape); + + shape[0] = box_widths_.size(); + tensor_widths_.reshape((const char*)box_widths_.data(), shape); + tensor_heights_.reshape((const char*)box_heights_.data(), shape); + + float variance[4] = {variance_[0], variance_[0], variance_[0], variance_[0]}; + if (variance_.size() > 1) + { + assert(variance_.size() == 4); + for (int i = 1; i < variance_.size(); i++) + variance[i] = variance_[i]; + } + shape[0] = 4; + tensor_variance_.reshape((const char*)variance, shape); + + bindTensor(device_, tensor_offsets_x_, 0, descriptor_set_); + bindTensor(device_, tensor_offsets_y_, 1, descriptor_set_); + bindTensor(device_, tensor_widths_, 2, descriptor_set_); + bindTensor(device_, tensor_heights_, 3, descriptor_set_); + bindTensor(device_, tensor_variance_, 4, descriptor_set_); + bindTensor(device_, out, 5, descriptor_set_); + + PriorBoxParam param = {global_size_, + nthreads_, + step_x_, + step_y_, + (int)offsets_x_.size(), + (int)box_widths_.size(), + in_w_, + img_h_, + img_w_, + clip_ ? 1 : 0, + out_channel_size_ / 4}; + recordCommandBuffer((void *)¶m, sizeof(PriorBoxParam)); + runCommandBuffer(); + return true; +} + +bool OpPriorBox::computeGroupCount() +{ + group_x_ = global_size_ / LOCAL_SZ_X; + group_y_ = 1; + group_z_ = 1; + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_relu.cpp b/modules/dnn/src/vkcom/src/op_relu.cpp new file mode 100644 index 0000000000..15c3ce5424 --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_relu.cpp @@ -0,0 +1,74 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_relu.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 32 + +struct ReLUParam { + int total; + float slope; +}; + +OpReLU::OpReLU(const float slope) : slope_(slope) +{ + OpBase::initVulkanThing(2); + type_ = "ReLU"; +} + +void OpReLU::reshapeOutTensor(Tensor& in, Tensor& out) +{ + Shape shape = in.getShape(); + out.reshape(NULL, shape); +} + +bool OpReLU::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + return forward(ins[0], outs[0]); +} + +bool OpReLU::forward(Tensor& in, Tensor& out) +{ + if (pipeline_ == VK_NULL_HANDLE) + { + total_ = in.count(); +#define maxComputeWorkGroupCount 65535 + computeGroupCount(); + createShaderModule(relu_spv, sizeof(relu_spv)); + createPipeline(sizeof(ReLUParam)); + } + + bindTensor(device_, in, 0, descriptor_set_); + bindTensor(device_, out, 1, descriptor_set_); + ReLUParam param = { total_, slope_ }; + recordCommandBuffer((void *)¶m, sizeof(ReLUParam)); + runCommandBuffer(); + return true; +} + +bool OpReLU::computeGroupCount() +{ + group_x_ = alignSize(total_, LOCAL_SZ_X) / LOCAL_SZ_X; + if (group_x_ > maxComputeWorkGroupCount) + group_x_ = maxComputeWorkGroupCount; + group_y_ = 1; + group_z_ = 1; + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/op_softmax.cpp b/modules/dnn/src/vkcom/src/op_softmax.cpp new file mode 100644 index 0000000000..f0b20f8a64 --- /dev/null +++ b/modules/dnn/src/vkcom/src/op_softmax.cpp @@ -0,0 +1,110 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_softmax.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +#define LOCAL_SZ_X 256 +#define LOCAL_SZ_Y 1 +#define LOCAL_SZ_Z 1 + +struct SoftmaxParam { + int channel_size; + int outer_size; + int channels; +}; + +OpSoftmax::OpSoftmax(const int axis, const bool log_softmax) +{ + init(axis, log_softmax); + type_ = "Softmax"; +} + +OpSoftmax::~OpSoftmax() +{ + if (max_tensor_) + delete max_tensor_; + if (sum_tensor_) + delete sum_tensor_; +} + +void OpSoftmax::reshapeOutTensor(Tensor& in, Tensor& out) +{ + Shape shape = in.getShape(); + out.reshape(NULL, shape); +} + +bool OpSoftmax::init(const int axis, const bool log_softmax) +{ + axis_ = axis; + log_softmax_ = log_softmax; + max_tensor_ = NULL; + sum_tensor_ = NULL; + OpBase::initVulkanThing(4); + return true; +} + +bool OpSoftmax::forward(std::vector& ins, + std::vector& blobs, + std::vector& outs) +{ + return forward(ins[0], outs[0]); +} + +bool OpSoftmax::forward(Tensor& in, Tensor& out) +{ + channels_ = in.dimSize(axis_); + channel_size_ = in.count(axis_+1); + outer_size_ = in.count(0, axis_); + + if (pipeline_ == VK_NULL_HANDLE) + { + config_.local_size_x = LOCAL_SZ_X; + config_.local_size_y = LOCAL_SZ_Y; + config_.local_size_z = LOCAL_SZ_Z; + config_.block_height = 1; + config_.block_width = 1; + config_.block_depth = 1; + createShaderModule(softmax_spv, sizeof(softmax_spv)); + createPipeline(sizeof(SoftmaxParam)); + computeGroupCount(); + } + + if (max_tensor_ == NULL || sum_tensor_ == NULL) + { + std::vector shape = {outer_size_, channel_size_}; + max_tensor_ = new Tensor(NULL, shape); + sum_tensor_ = new Tensor(NULL, shape); + } + bindTensor(device_, in, 0, descriptor_set_); + bindTensor(device_, *max_tensor_, 1, descriptor_set_); + bindTensor(device_, *sum_tensor_, 2, descriptor_set_); + bindTensor(device_, out, 3, descriptor_set_); + SoftmaxParam param = {channel_size_, outer_size_, channels_}; + recordCommandBuffer((void *)¶m, sizeof(SoftmaxParam)); + runCommandBuffer(); + return true; +} + +bool OpSoftmax::computeGroupCount() +{ + group_x_ = alignSize(outer_size_, config_.local_size_x) / config_.local_size_x; + group_y_ = 1; + group_z_ = 1; + + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/tensor.cpp b/modules/dnn/src/vkcom/src/tensor.cpp new file mode 100644 index 0000000000..eb5723e8ea --- /dev/null +++ b/modules/dnn/src/vkcom/src/tensor.cpp @@ -0,0 +1,131 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +Tensor::Tensor(Format fmt) : size_in_byte_(0), format_(fmt) +{ + Context *ctx = getContext(); + device_ = ctx->device; +} + +Tensor::Tensor(const char* data, std::vector& shape, Format fmt) + : size_in_byte_(0), format_(fmt) +{ + Context *ctx = getContext(); + device_ = ctx->device; + reshape(data, shape); +} + +void* Tensor::map() +{ + void *p; + + VK_CHECK_RESULT(vkMapMemory(device_, buffer_->getVkMemory(), + 0, size_in_byte_, 0, (void **)&p)); + + return p; +} + +void Tensor::unMap() +{ + vkUnmapMemory(device_, buffer_->getVkMemory()); +} + +Shape Tensor::getShape() const +{ + return shape_; +} + +int Tensor::count(const int start_axis, const int end_axis) const +{ + return shapeCount(shape_, start_axis, end_axis); +} + +int Tensor::dimSize(const int axis) const +{ + CV_Assert(axis >= 0); + CV_Assert(axis < shape_.size()); + + return shape_[axis]; +} + +int Tensor::dimNum() const +{ + return shape_.size(); +} + +Tensor Tensor::reshape(const char* data, const std::vector& shape, bool alloc, Format fmt) +{ + if (device_ == VK_NULL_HANDLE) + { + CV_Error(Error::StsError, "device is NULL"); + return *this; + } + + CV_Assert(shape.size() > 0 && shape.size() <= 6); + + if (shape_ != shape) shape_ = shape; + if (checkFormat(fmt) && fmt != format_) format_ = fmt; + + size_t new_size = shapeCount(shape_) * elementSize(format_); + if (alloc || new_size > size_in_byte_) + alloc = true; + size_in_byte_ = new_size; + + if (alloc) + { + buffer_.reset(new Buffer(device_, size_in_byte_, data)); + } + else if (data) + { + void* p = map(); + memcpy(p, data, size_in_byte_); + unMap(); + } + + return *this; +} + +void Tensor::setTo(float val) +{ + if (device_ == VK_NULL_HANDLE) + { + CV_Error(Error::StsError, "device is NULL"); + return; + } + + CV_Assert(format_ == kFormatFp32); + + float* p = (float *)map(); + int cnt = count(); + for (int i = 0; i < cnt; i++) + *p++ = val; + unMap(); +} + +int Tensor::getFormat() const +{ + return format_; +} + +void Tensor::copyTo(Tensor& dst) +{ + void* p = map(); + dst.reshape((const char*)p, shape_, format_); + unMap(); +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/src/vkcom.cpp b/modules/dnn/src/vkcom/src/vkcom.cpp new file mode 100644 index 0000000000..16a4e3ab65 --- /dev/null +++ b/modules/dnn/src/vkcom/src/vkcom.cpp @@ -0,0 +1,403 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#include "common.hpp" +#include "internal.hpp" +#include "../include/op_conv.hpp" +#include "../include/op_pool.hpp" +#include "../include/op_lrn.hpp" +#include "../include/op_concat.hpp" +#include "../include/op_softmax.hpp" +#include "../vulkan/vk_loader.hpp" + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN + +static bool enableValidationLayers = false; +static VkInstance kInstance; +static VkPhysicalDevice kPhysicalDevice; +static VkDebugReportCallbackEXT kDebugReportCallback; +static uint32_t kQueueFamilyIndex; +std::vector kEnabledLayers; +typedef std::map IdToContextMap; +IdToContextMap kThreadResources; +static std::map> kShaders; +static int init_count = 0; +static bool init(); +static void release(); +static uint32_t getComputeQueueFamilyIndex(); +static bool checkExtensionAvailability(const char *extension_name, + const std::vector + &available_extensions); +static VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallbackFn( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +static void setContext(Context* ctx) +{ + cv::AutoLock lock(getInitializationMutex()); + std::thread::id tid = std::this_thread::get_id(); + if (kThreadResources.find(tid) != kThreadResources.end()) + { + return; + } + kThreadResources.insert(std::pair(tid, ctx)); +} + +Context* getContext() +{ + Context* ctx = NULL; + + cv::AutoLock lock(getInitializationMutex()); + std::thread::id tid = std::this_thread::get_id(); + IdToContextMap::iterator it = kThreadResources.find(tid); + if (it != kThreadResources.end()) + { + ctx = it->second; + } + return ctx; +} + +static void removeContext() +{ + cv::AutoLock lock(getInitializationMutex()); + std::thread::id tid = std::this_thread::get_id(); + IdToContextMap::iterator it = kThreadResources.find(tid); + if (it == kThreadResources.end()) + { + return; + } + kThreadResources.erase(it); +} + +bool initPerThread() +{ + VkDevice device; + VkQueue queue; + VkCommandPool cmd_pool; + + VKCOM_CHECK_BOOL_RET_VAL(init(), false); + Context* ctx = getContext(); + if (ctx) + { + ctx->ref++; + return true; + } + + // create device, queue, command pool + VkDeviceQueueCreateInfo queueCreateInfo = {}; + queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queueCreateInfo.queueFamilyIndex = kQueueFamilyIndex; + queueCreateInfo.queueCount = 1; // create one queue in this family. We don't need more. + float queuePriorities = 1.0; // we only have one queue, so this is not that imporant. + queueCreateInfo.pQueuePriorities = &queuePriorities; + + VkDeviceCreateInfo deviceCreateInfo = {}; + + // Specify any desired device features here. We do not need any for this application, though. + VkPhysicalDeviceFeatures deviceFeatures = {}; + + deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + deviceCreateInfo.enabledLayerCount = kEnabledLayers.size(); + deviceCreateInfo.ppEnabledLayerNames = kEnabledLayers.data(); + deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo; + deviceCreateInfo.queueCreateInfoCount = 1; + deviceCreateInfo.pEnabledFeatures = &deviceFeatures; + + VK_CHECK_RESULT(vkCreateDevice(kPhysicalDevice, &deviceCreateInfo, NULL, &device)); + + // Get a handle to the only member of the queue family. + vkGetDeviceQueue(device, kQueueFamilyIndex, 0, &queue); + + // create command pool + VkCommandPoolCreateInfo commandPoolCreateInfo = {}; + commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + // the queue family of this command pool. All command buffers allocated from this command pool, + // must be submitted to queues of this family ONLY. + commandPoolCreateInfo.queueFamilyIndex = kQueueFamilyIndex; + VK_CHECK_RESULT(vkCreateCommandPool(device, &commandPoolCreateInfo, NULL, &cmd_pool)); + + ctx = new Context(); + ctx->device = device; + ctx->queue = queue; + ctx->cmd_pool = cmd_pool; + ctx->ref = 1; + setContext(ctx); + return true; +} + +void deinitPerThread() +{ + Context* ctx = getContext(); + if (ctx == NULL) + { + release(); + return; + } + + if (ctx->ref > 1) + { + ctx->ref--; + } + else if (ctx->ref == 1) + { + for(auto &kv: ctx->shader_modules) + { + vkDestroyShaderModule(ctx->device, kv.second, NULL); + } + ctx->shader_modules.clear(); + vkDestroyCommandPool(ctx->device, ctx->cmd_pool, NULL); + vkDestroyDevice(ctx->device, NULL); + removeContext(); + delete ctx; + } + else + CV_Assert(0); + release(); +} + +static bool init() +{ + cv::AutoLock lock(getInitializationMutex()); + + if (init_count == 0) + { + if(!loadVulkanLibrary()) + { + return false; + } + else if (!loadVulkanEntry()) + { + return false; + } + else if (!loadVulkanGlobalFunctions()) + { + return false; + } + + // create VkInstance, VkPhysicalDevice + std::vector enabledExtensions; + if (enableValidationLayers) + { + uint32_t layerCount; + vkEnumerateInstanceLayerProperties(&layerCount, NULL); + + std::vector layerProperties(layerCount); + vkEnumerateInstanceLayerProperties(&layerCount, layerProperties.data()); + + bool foundLayer = false; + for (VkLayerProperties prop : layerProperties) + { + if (strcmp("VK_LAYER_LUNARG_standard_validation", prop.layerName) == 0) + { + foundLayer = true; + break; + } + } + + if (!foundLayer) + { + throw std::runtime_error("Layer VK_LAYER_LUNARG_standard_validation not supported\n"); + } + kEnabledLayers.push_back("VK_LAYER_LUNARG_standard_validation"); + + uint32_t extensionCount; + + vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, NULL); + std::vector extensionProperties(extensionCount); + vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensionProperties.data()); + + bool foundExtension = false; + for (VkExtensionProperties prop : extensionProperties) + { + if (strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, prop.extensionName) == 0) + { + foundExtension = true; + break; + } + } + + if (!foundExtension) { + throw std::runtime_error("Extension VK_EXT_DEBUG_REPORT_EXTENSION_NAME not supported\n"); + } + enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME); + } + + VkApplicationInfo applicationInfo = {}; + applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + applicationInfo.pApplicationName = "VkCom Library"; + applicationInfo.applicationVersion = 0; + applicationInfo.pEngineName = "vkcom"; + applicationInfo.engineVersion = 0; + applicationInfo.apiVersion = VK_API_VERSION_1_0;; + + VkInstanceCreateInfo createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + createInfo.flags = 0; + createInfo.pApplicationInfo = &applicationInfo; + + // Give our desired layers and extensions to vulkan. + createInfo.enabledLayerCount = kEnabledLayers.size(); + createInfo.ppEnabledLayerNames = kEnabledLayers.data(); + createInfo.enabledExtensionCount = enabledExtensions.size(); + createInfo.ppEnabledExtensionNames = enabledExtensions.data(); + + VK_CHECK_RESULT(vkCreateInstance(&createInfo, NULL, &kInstance)); + + if (!loadVulkanFunctions(kInstance)) + { + return false; + } + + if (enableValidationLayers && vkCreateDebugReportCallbackEXT) + { + VkDebugReportCallbackCreateInfoEXT createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; + createInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | + VK_DEBUG_REPORT_WARNING_BIT_EXT | + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; + createInfo.pfnCallback = &debugReportCallbackFn; + + // Create and register callback. + VK_CHECK_RESULT(vkCreateDebugReportCallbackEXT(kInstance, &createInfo, + NULL, &kDebugReportCallback)); + } + + // find physical device + uint32_t deviceCount; + vkEnumeratePhysicalDevices(kInstance, &deviceCount, NULL); + if (deviceCount == 0) + { + throw std::runtime_error("could not find a device with vulkan support"); + } + + std::vector devices(deviceCount); + vkEnumeratePhysicalDevices(kInstance, &deviceCount, devices.data()); + + for (VkPhysicalDevice device : devices) + { + if (true) + { + kPhysicalDevice = device; + break; + } + } + + kQueueFamilyIndex = getComputeQueueFamilyIndex(); + } + + init_count++; + return true; +} + +static void release() +{ + cv::AutoLock lock(getInitializationMutex()); + if (init_count == 0) + { + return; + } + + init_count--; + if (init_count == 0) + { + if (enableValidationLayers) { + auto func = (PFN_vkDestroyDebugReportCallbackEXT) + vkGetInstanceProcAddr(kInstance, "vkDestroyDebugReportCallbackEXT"); + if (func == nullptr) { + throw std::runtime_error("Could not load vkDestroyDebugReportCallbackEXT"); + } + func(kInstance, kDebugReportCallback, NULL); + } + kShaders.clear(); + vkDestroyInstance(kInstance, NULL); + } + + return; +} + +// Returns the index of a queue family that supports compute operations. +static uint32_t getComputeQueueFamilyIndex() +{ + uint32_t queueFamilyCount; + + vkGetPhysicalDeviceQueueFamilyProperties(kPhysicalDevice, &queueFamilyCount, NULL); + + std::vector queueFamilies(queueFamilyCount); + vkGetPhysicalDeviceQueueFamilyProperties(kPhysicalDevice, + &queueFamilyCount, + queueFamilies.data()); + + uint32_t i = 0; + for (; i < queueFamilies.size(); ++i) + { + VkQueueFamilyProperties props = queueFamilies[i]; + + if (props.queueCount > 0 && (props.queueFlags & VK_QUEUE_COMPUTE_BIT)) + { + break; + } + } + + if (i == queueFamilies.size()) + { + throw std::runtime_error("could not find a queue family that supports operations"); + } + + return i; +} + +bool checkExtensionAvailability(const char *extension_name, + const std::vector &available_extensions) +{ + for( size_t i = 0; i < available_extensions.size(); ++i ) + { + if( strcmp( available_extensions[i].extensionName, extension_name ) == 0 ) + { + return true; + } + } + return false; +} + +VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallbackFn( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData) +{ + std::cout << "Debug Report: " << pLayerPrefix << ":" << pMessage << std::endl; + return VK_FALSE; +} + +// internally used functions +VkPhysicalDevice getPhysicalDevice() +{ + return kPhysicalDevice; +} + +bool isAvailable() +{ + return getContext() != NULL; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/vulkan/function_list.inl b/modules/dnn/src/vkcom/vulkan/function_list.inl new file mode 100644 index 0000000000..074644e44a --- /dev/null +++ b/modules/dnn/src/vkcom/vulkan/function_list.inl @@ -0,0 +1,301 @@ +#ifndef VK_ENTRY +#define VK_ENTRY(func) +#endif + +#ifndef VK_GLOBAL_LEVEL_FUNC +#define VK_GLOBAL_LEVEL_FUNC(func) +#endif + +#ifndef VK_GLOBAL_LEVEL_FUNC_MANDATORY +#define VK_GLOBAL_LEVEL_FUNC_MANDATORY(func) +#endif + +#ifndef VK_FUNC +#define VK_FUNC(func) +#endif + +#ifndef VK_FUNC_MANDATORY +#define VK_FUNC_MANDATORY(func) +#endif + +VK_ENTRY(vkGetInstanceProcAddr) +VK_GLOBAL_LEVEL_FUNC(vkEnumerateInstanceVersion) +VK_GLOBAL_LEVEL_FUNC_MANDATORY(vkEnumerateInstanceExtensionProperties) +VK_GLOBAL_LEVEL_FUNC_MANDATORY(vkEnumerateInstanceLayerProperties) +VK_GLOBAL_LEVEL_FUNC_MANDATORY(vkCreateInstance) +VK_FUNC_MANDATORY(vkDestroyInstance) +VK_FUNC_MANDATORY(vkEnumeratePhysicalDevices) +VK_FUNC_MANDATORY(vkGetPhysicalDeviceQueueFamilyProperties) +VK_FUNC(vkGetPhysicalDeviceFeatures) +VK_FUNC(vkGetPhysicalDeviceFormatProperties) +VK_FUNC(vkGetPhysicalDeviceImageFormatProperties) +VK_FUNC(vkGetPhysicalDeviceProperties) +VK_FUNC(vkGetPhysicalDeviceMemoryProperties) +VK_FUNC(vkGetDeviceProcAddr) +VK_FUNC(vkCreateDevice) +VK_FUNC(vkDestroyDevice) +VK_FUNC(vkEnumerateDeviceExtensionProperties) +VK_FUNC(vkEnumerateDeviceLayerProperties) +VK_FUNC(vkGetDeviceQueue) +VK_FUNC(vkQueueSubmit) +VK_FUNC(vkQueueWaitIdle) +VK_FUNC(vkDeviceWaitIdle) +VK_FUNC(vkAllocateMemory) +VK_FUNC(vkFreeMemory) +VK_FUNC(vkMapMemory) +VK_FUNC(vkUnmapMemory) +VK_FUNC(vkFlushMappedMemoryRanges) +VK_FUNC(vkInvalidateMappedMemoryRanges) +VK_FUNC(vkGetDeviceMemoryCommitment) +VK_FUNC(vkBindBufferMemory) +VK_FUNC(vkBindImageMemory) +VK_FUNC(vkGetBufferMemoryRequirements) +VK_FUNC(vkGetImageMemoryRequirements) +VK_FUNC(vkGetImageSparseMemoryRequirements) +VK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties) +VK_FUNC(vkQueueBindSparse) +VK_FUNC(vkCreateFence) +VK_FUNC(vkDestroyFence) +VK_FUNC(vkResetFences) +VK_FUNC(vkGetFenceStatus) +VK_FUNC(vkWaitForFences) +VK_FUNC(vkCreateSemaphore) +VK_FUNC(vkDestroySemaphore) +VK_FUNC(vkCreateEvent) +VK_FUNC(vkDestroyEvent) +VK_FUNC(vkGetEventStatus) +VK_FUNC(vkSetEvent) +VK_FUNC(vkResetEvent) +VK_FUNC(vkCreateQueryPool) +VK_FUNC(vkDestroyQueryPool) +VK_FUNC(vkGetQueryPoolResults) +VK_FUNC(vkCreateBuffer) +VK_FUNC(vkDestroyBuffer) +VK_FUNC(vkCreateBufferView) +VK_FUNC(vkDestroyBufferView) +VK_FUNC(vkCreateImage) +VK_FUNC(vkDestroyImage) +VK_FUNC(vkGetImageSubresourceLayout) +VK_FUNC(vkCreateImageView) +VK_FUNC(vkDestroyImageView) +VK_FUNC(vkCreateShaderModule) +VK_FUNC(vkDestroyShaderModule) +VK_FUNC(vkCreatePipelineCache) +VK_FUNC(vkDestroyPipelineCache) +VK_FUNC(vkGetPipelineCacheData) +VK_FUNC(vkMergePipelineCaches) +VK_FUNC(vkCreateGraphicsPipelines) +VK_FUNC(vkCreateComputePipelines) +VK_FUNC(vkDestroyPipeline) +VK_FUNC(vkCreatePipelineLayout) +VK_FUNC(vkDestroyPipelineLayout) +VK_FUNC(vkCreateSampler) +VK_FUNC(vkDestroySampler) +VK_FUNC(vkCreateDescriptorSetLayout) +VK_FUNC(vkDestroyDescriptorSetLayout) +VK_FUNC(vkCreateDescriptorPool) +VK_FUNC(vkDestroyDescriptorPool) +VK_FUNC(vkResetDescriptorPool) +VK_FUNC(vkAllocateDescriptorSets) +VK_FUNC(vkFreeDescriptorSets) +VK_FUNC(vkUpdateDescriptorSets) +VK_FUNC(vkCreateFramebuffer) +VK_FUNC(vkDestroyFramebuffer) +VK_FUNC(vkCreateRenderPass) +VK_FUNC(vkDestroyRenderPass) +VK_FUNC(vkGetRenderAreaGranularity) +VK_FUNC(vkCreateCommandPool) +VK_FUNC(vkDestroyCommandPool) +VK_FUNC(vkResetCommandPool) +VK_FUNC(vkAllocateCommandBuffers) +VK_FUNC(vkFreeCommandBuffers) +VK_FUNC(vkBeginCommandBuffer) +VK_FUNC(vkEndCommandBuffer) +VK_FUNC(vkResetCommandBuffer) +VK_FUNC(vkCmdBindPipeline) +VK_FUNC(vkCmdSetViewport) +VK_FUNC(vkCmdSetScissor) +VK_FUNC(vkCmdSetLineWidth) +VK_FUNC(vkCmdSetDepthBias) +VK_FUNC(vkCmdSetBlendConstants) +VK_FUNC(vkCmdSetDepthBounds) +VK_FUNC(vkCmdSetStencilCompareMask) +VK_FUNC(vkCmdSetStencilWriteMask) +VK_FUNC(vkCmdSetStencilReference) +VK_FUNC(vkCmdBindDescriptorSets) +VK_FUNC(vkCmdBindIndexBuffer) +VK_FUNC(vkCmdBindVertexBuffers) +VK_FUNC(vkCmdDraw) +VK_FUNC(vkCmdDrawIndexed) +VK_FUNC(vkCmdDrawIndirect) +VK_FUNC(vkCmdDrawIndexedIndirect) +VK_FUNC(vkCmdDispatch) +VK_FUNC(vkCmdDispatchIndirect) +VK_FUNC(vkCmdCopyBuffer) +VK_FUNC(vkCmdCopyImage) +VK_FUNC(vkCmdBlitImage) +VK_FUNC(vkCmdCopyBufferToImage) +VK_FUNC(vkCmdCopyImageToBuffer) +VK_FUNC(vkCmdUpdateBuffer) +VK_FUNC(vkCmdFillBuffer) +VK_FUNC(vkCmdClearColorImage) +VK_FUNC(vkCmdClearDepthStencilImage) +VK_FUNC(vkCmdClearAttachments) +VK_FUNC(vkCmdResolveImage) +VK_FUNC(vkCmdSetEvent) +VK_FUNC(vkCmdResetEvent) +VK_FUNC(vkCmdWaitEvents) +VK_FUNC(vkCmdPipelineBarrier) +VK_FUNC(vkCmdBeginQuery) +VK_FUNC(vkCmdEndQuery) +VK_FUNC(vkCmdResetQueryPool) +VK_FUNC(vkCmdWriteTimestamp) +VK_FUNC(vkCmdCopyQueryPoolResults) +VK_FUNC(vkCmdPushConstants) +VK_FUNC(vkCmdBeginRenderPass) +VK_FUNC(vkCmdNextSubpass) +VK_FUNC(vkCmdEndRenderPass) +VK_FUNC(vkCmdExecuteCommands) +VK_FUNC(vkBindBufferMemory2) +VK_FUNC(vkBindImageMemory2) +VK_FUNC(vkGetDeviceGroupPeerMemoryFeatures) +VK_FUNC(vkCmdSetDeviceMask) +VK_FUNC(vkCmdDispatchBase) +VK_FUNC(vkEnumeratePhysicalDeviceGroups) +VK_FUNC(vkGetImageMemoryRequirements2) +VK_FUNC(vkGetBufferMemoryRequirements2) +VK_FUNC(vkGetImageSparseMemoryRequirements2) +VK_FUNC(vkGetPhysicalDeviceFeatures2) +VK_FUNC(vkGetPhysicalDeviceProperties2) +VK_FUNC(vkGetPhysicalDeviceFormatProperties2) +VK_FUNC(vkGetPhysicalDeviceImageFormatProperties2) +VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties2) +VK_FUNC(vkGetPhysicalDeviceMemoryProperties2) +VK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties2) +VK_FUNC(vkTrimCommandPool) +VK_FUNC(vkGetDeviceQueue2) +VK_FUNC(vkCreateSamplerYcbcrConversion) +VK_FUNC(vkDestroySamplerYcbcrConversion) +VK_FUNC(vkCreateDescriptorUpdateTemplate) +VK_FUNC(vkDestroyDescriptorUpdateTemplate) +VK_FUNC(vkUpdateDescriptorSetWithTemplate) +VK_FUNC(vkGetPhysicalDeviceExternalBufferProperties) +VK_FUNC(vkGetPhysicalDeviceExternalFenceProperties) +VK_FUNC(vkGetPhysicalDeviceExternalSemaphoreProperties) +VK_FUNC(vkGetDescriptorSetLayoutSupport) +VK_FUNC(vkDestroySurfaceKHR) +VK_FUNC(vkGetPhysicalDeviceSurfaceSupportKHR) +VK_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) +VK_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR) +VK_FUNC(vkGetPhysicalDeviceSurfacePresentModesKHR) +VK_FUNC(vkCreateSwapchainKHR) +VK_FUNC(vkDestroySwapchainKHR) +VK_FUNC(vkGetSwapchainImagesKHR) +VK_FUNC(vkAcquireNextImageKHR) +VK_FUNC(vkQueuePresentKHR) +VK_FUNC(vkGetDeviceGroupPresentCapabilitiesKHR) +VK_FUNC(vkGetDeviceGroupSurfacePresentModesKHR) +VK_FUNC(vkGetPhysicalDevicePresentRectanglesKHR) +VK_FUNC(vkAcquireNextImage2KHR) +VK_FUNC(vkGetPhysicalDeviceDisplayPropertiesKHR) +VK_FUNC(vkGetPhysicalDeviceDisplayPlanePropertiesKHR) +VK_FUNC(vkGetDisplayPlaneSupportedDisplaysKHR) +VK_FUNC(vkGetDisplayModePropertiesKHR) +VK_FUNC(vkCreateDisplayModeKHR) +VK_FUNC(vkGetDisplayPlaneCapabilitiesKHR) +VK_FUNC(vkCreateDisplayPlaneSurfaceKHR) +VK_FUNC(vkCreateSharedSwapchainsKHR) +VK_FUNC(vkGetPhysicalDeviceFeatures2KHR) +VK_FUNC(vkGetPhysicalDeviceProperties2KHR) +VK_FUNC(vkGetPhysicalDeviceFormatProperties2KHR) +VK_FUNC(vkGetPhysicalDeviceImageFormatProperties2KHR) +VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties2KHR) +VK_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR) +VK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties2KHR) +VK_FUNC(vkGetDeviceGroupPeerMemoryFeaturesKHR) +VK_FUNC(vkCmdSetDeviceMaskKHR) +VK_FUNC(vkCmdDispatchBaseKHR) +VK_FUNC(vkTrimCommandPoolKHR) +VK_FUNC(vkEnumeratePhysicalDeviceGroupsKHR) +VK_FUNC(vkGetPhysicalDeviceExternalBufferPropertiesKHR) +VK_FUNC(vkGetMemoryFdKHR) +VK_FUNC(vkGetMemoryFdPropertiesKHR) +VK_FUNC(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR) +VK_FUNC(vkImportSemaphoreFdKHR) +VK_FUNC(vkGetSemaphoreFdKHR) +VK_FUNC(vkCmdPushDescriptorSetKHR) +VK_FUNC(vkCmdPushDescriptorSetWithTemplateKHR) +VK_FUNC(vkCreateDescriptorUpdateTemplateKHR) +VK_FUNC(vkDestroyDescriptorUpdateTemplateKHR) +VK_FUNC(vkUpdateDescriptorSetWithTemplateKHR) +VK_FUNC(vkGetSwapchainStatusKHR) +VK_FUNC(vkGetPhysicalDeviceExternalFencePropertiesKHR) +VK_FUNC(vkImportFenceFdKHR) +VK_FUNC(vkGetFenceFdKHR) +VK_FUNC(vkGetPhysicalDeviceSurfaceCapabilities2KHR) +VK_FUNC(vkGetPhysicalDeviceSurfaceFormats2KHR) +VK_FUNC(vkGetImageMemoryRequirements2KHR) +VK_FUNC(vkGetBufferMemoryRequirements2KHR) +VK_FUNC(vkGetImageSparseMemoryRequirements2KHR) +VK_FUNC(vkCreateSamplerYcbcrConversionKHR) +VK_FUNC(vkDestroySamplerYcbcrConversionKHR) +VK_FUNC(vkBindBufferMemory2KHR) +VK_FUNC(vkBindImageMemory2KHR) +VK_FUNC(vkGetDescriptorSetLayoutSupportKHR) +VK_FUNC(vkCreateDebugReportCallbackEXT) +VK_FUNC(vkDestroyDebugReportCallbackEXT) +VK_FUNC(vkDebugReportMessageEXT) +VK_FUNC(vkDebugMarkerSetObjectTagEXT) +VK_FUNC(vkDebugMarkerSetObjectNameEXT) +VK_FUNC(vkCmdDebugMarkerBeginEXT) +VK_FUNC(vkCmdDebugMarkerEndEXT) +VK_FUNC(vkCmdDebugMarkerInsertEXT) +VK_FUNC(vkCmdDrawIndirectCountAMD) +VK_FUNC(vkCmdDrawIndexedIndirectCountAMD) +VK_FUNC(vkGetShaderInfoAMD) +VK_FUNC(vkGetPhysicalDeviceExternalImageFormatPropertiesNV) +VK_FUNC(vkCmdProcessCommandsNVX) +VK_FUNC(vkCmdReserveSpaceForCommandsNVX) +VK_FUNC(vkCreateIndirectCommandsLayoutNVX) +VK_FUNC(vkDestroyIndirectCommandsLayoutNVX) +VK_FUNC(vkCreateObjectTableNVX) +VK_FUNC(vkDestroyObjectTableNVX) +VK_FUNC(vkRegisterObjectsNVX) +VK_FUNC(vkUnregisterObjectsNVX) +VK_FUNC(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX) +VK_FUNC(vkCmdSetViewportWScalingNV) +VK_FUNC(vkReleaseDisplayEXT) +VK_FUNC(vkGetPhysicalDeviceSurfaceCapabilities2EXT) +VK_FUNC(vkDisplayPowerControlEXT) +VK_FUNC(vkRegisterDeviceEventEXT) +VK_FUNC(vkRegisterDisplayEventEXT) +VK_FUNC(vkGetSwapchainCounterEXT) +VK_FUNC(vkGetRefreshCycleDurationGOOGLE) +VK_FUNC(vkGetPastPresentationTimingGOOGLE) +VK_FUNC(vkCmdSetDiscardRectangleEXT) +VK_FUNC(vkSetHdrMetadataEXT) +VK_FUNC(vkSetDebugUtilsObjectNameEXT) +VK_FUNC(vkSetDebugUtilsObjectTagEXT) +VK_FUNC(vkQueueBeginDebugUtilsLabelEXT) +VK_FUNC(vkQueueEndDebugUtilsLabelEXT) +VK_FUNC(vkQueueInsertDebugUtilsLabelEXT) +VK_FUNC(vkCmdBeginDebugUtilsLabelEXT) +VK_FUNC(vkCmdEndDebugUtilsLabelEXT) +VK_FUNC(vkCmdInsertDebugUtilsLabelEXT) +VK_FUNC(vkCreateDebugUtilsMessengerEXT) +VK_FUNC(vkDestroyDebugUtilsMessengerEXT) +VK_FUNC(vkSubmitDebugUtilsMessageEXT) +VK_FUNC(vkCmdSetSampleLocationsEXT) +VK_FUNC(vkGetPhysicalDeviceMultisamplePropertiesEXT) +VK_FUNC(vkCreateValidationCacheEXT) +VK_FUNC(vkDestroyValidationCacheEXT) +VK_FUNC(vkMergeValidationCachesEXT) +VK_FUNC(vkGetValidationCacheDataEXT) +VK_FUNC(vkGetMemoryHostPointerPropertiesEXT) +VK_FUNC(vkCmdWriteBufferMarkerAMD) + +#undef VK_ENTRY +#undef VK_GLOBAL_LEVEL_FUNC +#undef VK_GLOBAL_LEVEL_FUNC_MANDATORY +#undef VK_FUNC +#undef VK_FUNC_MANDATORY diff --git a/modules/dnn/src/vkcom/vulkan/vk_functions.cpp b/modules/dnn/src/vkcom/vulkan/vk_functions.cpp new file mode 100644 index 0000000000..d43090ee1f --- /dev/null +++ b/modules/dnn/src/vkcom/vulkan/vk_functions.cpp @@ -0,0 +1,23 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#ifdef HAVE_VULKAN +#include + +#define VK_ENTRY(func) PFN_##func func = nullptr; +#define VK_GLOBAL_LEVEL_FUNC(func) PFN_##func func = nullptr; +#define VK_GLOBAL_LEVEL_FUNC_MANDATORY(func) PFN_##func func = nullptr; +#define VK_FUNC(func) PFN_##func func = nullptr; +#define VK_FUNC_MANDATORY(func) PFN_##func func = nullptr; + +namespace cv { namespace dnn { namespace vkcom { + +#include "function_list.inl" + +}}} // namespace cv::dnn::vkcom +#endif // HAVE_VULKAN diff --git a/modules/dnn/src/vkcom/vulkan/vk_functions.hpp b/modules/dnn/src/vkcom/vulkan/vk_functions.hpp new file mode 100644 index 0000000000..02e3bd69ac --- /dev/null +++ b/modules/dnn/src/vkcom/vulkan/vk_functions.hpp @@ -0,0 +1,28 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_VULKAN_VK_FUNCTONS_HPP +#define OPENCV_DNN_VKCOM_VULKAN_VK_FUNCTONS_HPP + +#include "../../precomp.hpp" +#ifdef HAVE_VULKAN +#include + +#define VK_ENTRY(func) extern PFN_##func func; +#define VK_GLOBAL_LEVEL_FUNC(func) extern PFN_##func func; +#define VK_GLOBAL_LEVEL_FUNC_MANDATORY(func) extern PFN_##func func; +#define VK_FUNC(func) extern PFN_##func func; +#define VK_FUNC_MANDATORY(func) extern PFN_##func func; + +namespace cv { namespace dnn { namespace vkcom { + +#include "function_list.inl" + +}}} // namespace cv::dnn::vkcom +#endif // HAVE_VULKAN + +#endif // OPENCV_DNN_VKCOM_VULKAN_VK_FUNCTONS_HPP diff --git a/modules/dnn/src/vkcom/vulkan/vk_loader.cpp b/modules/dnn/src/vkcom/vulkan/vk_loader.cpp new file mode 100644 index 0000000000..da7f865adb --- /dev/null +++ b/modules/dnn/src/vkcom/vulkan/vk_loader.cpp @@ -0,0 +1,124 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../../precomp.hpp" +#ifdef HAVE_VULKAN +#include +#endif +#include "vk_functions.hpp" + +#if defined(_WIN32) +#include +typedef HMODULE VulkanHandle; +#define DEFAULT_VK_LIBRARY_PATH "vulkan-1.dll" +#define LOAD_VK_LIBRARY(path) LoadLibrary(path) +#define FREE_VK_LIBRARY(handle) FreeLibrary(handle) +#define GET_VK_ENTRY_POINT(handle) \ + (PFN_vkGetInstanceProcAddr)GetProcAddress(handle, "vkGetInstanceProcAddr"); +#endif // _WIN32 + +#if defined(__linux__) +#include +#include +typedef void* VulkanHandle; +#define DEFAULT_VK_LIBRARY_PATH "libvulkan.so.1" +#define LOAD_VK_LIBRARY(path) dlopen(path, RTLD_LAZY | RTLD_GLOBAL) +#define FREE_VK_LIBRARY(handle) dlclose(handle) +#define GET_VK_ENTRY_POINT(handle) \ + (PFN_vkGetInstanceProcAddr)dlsym(handle, "vkGetInstanceProcAddr"); +#endif // __linux__ + +#ifndef DEFAULT_VK_LIBRARY_PATH +#define DEFAULT_VK_LIBRARY_PATH "" +#define LOAD_VK_LIBRARY(path) nullptr +#define FREE_VK_LIBRARY(handle) +#define GET_VK_ENTRY_POINT(handle) nullptr +#endif + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN +static VulkanHandle handle = nullptr; + +bool loadVulkanFunctions(VkInstance& instance) +{ +#define VK_FUNC(fun) \ + fun = (PFN_##fun)vkGetInstanceProcAddr(instance, #fun); + +#define VK_FUNC_MANDATORY(fun) \ + VK_FUNC(fun) \ + if(!fun) \ + { \ + fprintf(stderr, "Could not load Vulkan function: %s !\n", #fun); \ + return false; \ + } + +#include "function_list.inl" + return true; +} + +bool loadVulkanGlobalFunctions() +{ +#define VK_GLOBAL_LEVEL_FUNC(fun) \ + fun = (PFN_##fun)vkGetInstanceProcAddr(nullptr, #fun); + +#define VK_GLOBAL_LEVEL_FUNC_MANDATORY(fun) \ + VK_GLOBAL_LEVEL_FUNC(fun) \ + if(!fun) \ + { \ + fprintf(stderr, "Could not load global Vulkan function: %s !\n", #fun); \ + return false; \ + } + +#include "function_list.inl" + return true; +} + +bool loadVulkanEntry() +{ + if (handle == nullptr) + return false; + + vkGetInstanceProcAddr = GET_VK_ENTRY_POINT(handle); + if (!vkGetInstanceProcAddr) + { + fprintf(stderr, "Could not load Vulkan entry function: vkGetInstanceProcAddr!\n"); + return false; + } + + return true; +} + +bool loadVulkanLibrary() +{ + if (handle != nullptr) + return true; + + const char* path; + const char* envPath = getenv("OPENCV_VULKAN_RUNTIME"); + if (envPath) + { + path = envPath; + } + else + { + path = DEFAULT_VK_LIBRARY_PATH; + } + + handle = LOAD_VK_LIBRARY(path); + if( handle == nullptr ) + { + fprintf(stderr, "Could not load Vulkan library: %s!\n", path); + return false; + } + + return true; +} + +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom diff --git a/modules/dnn/src/vkcom/vulkan/vk_loader.hpp b/modules/dnn/src/vkcom/vulkan/vk_loader.hpp new file mode 100644 index 0000000000..aa8e98bcd9 --- /dev/null +++ b/modules/dnn/src/vkcom/vulkan/vk_loader.hpp @@ -0,0 +1,21 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#ifndef OPENCV_DNN_VKCOM_VULKAN_VK_LOADER_HPP +#define OPENCV_DNN_VKCOM_VULKAN_VK_LOADER_HPP + +namespace cv { namespace dnn { namespace vkcom { + +#ifdef HAVE_VULKAN +bool loadVulkanLibrary(); +bool loadVulkanEntry(); +bool loadVulkanGlobalFunctions(); +bool loadVulkanFunctions(VkInstance& instance); +#endif // HAVE_VULKAN + +}}} // namespace cv::dnn::vkcom +#endif // OPENCV_DNN_VKCOM_VULKAN_VK_LOADER_HPP diff --git a/modules/dnn/test/test_backends.cpp b/modules/dnn/test/test_backends.cpp index a42cc4c174..919f5779e7 100644 --- a/modules/dnn/test/test_backends.cpp +++ b/modules/dnn/test/test_backends.cpp @@ -285,6 +285,6 @@ TEST_P(DNNTestNetwork, FastNeuralStyle_eccv16) processNet("dnn/fast_neural_style_eccv16_starry_night.t7", "", inp, "", "", l1, lInf); } -INSTANTIATE_TEST_CASE_P(/*nothing*/, DNNTestNetwork, dnnBackendsAndTargets(true, true, false)); +INSTANTIATE_TEST_CASE_P(/*nothing*/, DNNTestNetwork, dnnBackendsAndTargets(true, true, false, true)); }} // namespace diff --git a/modules/dnn/test/test_common.hpp b/modules/dnn/test/test_common.hpp index de43a727dd..69ade1a50e 100644 --- a/modules/dnn/test/test_common.hpp +++ b/modules/dnn/test/test_common.hpp @@ -55,6 +55,7 @@ static inline void PrintTo(const cv::dnn::Backend& v, std::ostream* os) case DNN_BACKEND_HALIDE: *os << "HALIDE"; return; case DNN_BACKEND_INFERENCE_ENGINE: *os << "DLIE"; return; case DNN_BACKEND_OPENCV: *os << "OCV"; return; + case DNN_BACKEND_VKCOM: *os << "VKCOM"; return; } // don't use "default:" to emit compiler warnings *os << "DNN_BACKEND_UNKNOWN(" << v << ")"; } @@ -66,6 +67,7 @@ static inline void PrintTo(const cv::dnn::Target& v, std::ostream* os) case DNN_TARGET_OPENCL: *os << "OCL"; return; case DNN_TARGET_OPENCL_FP16: *os << "OCL_FP16"; return; case DNN_TARGET_MYRIAD: *os << "MYRIAD"; return; + case DNN_TARGET_VULKAN: *os << "VULKAN"; return; } // don't use "default:" to emit compiler warnings *os << "DNN_TARGET_UNKNOWN(" << v << ")"; } @@ -238,7 +240,8 @@ using namespace cv::dnn; static testing::internal::ParamGenerator > dnnBackendsAndTargets( bool withInferenceEngine = true, bool withHalide = false, - bool withCpuOCV = true + bool withCpuOCV = true, + bool withVkCom = true ) { std::vector > targets; @@ -275,6 +278,10 @@ static testing::internal::ParamGenerator > dnnBackendsAnd targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL)); targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL_FP16)); } +#endif +#ifdef HAVE_VULKAN + if (withVkCom) + targets.push_back(make_tuple(DNN_BACKEND_VKCOM, DNN_TARGET_VULKAN)); #endif if (targets.empty()) // validate at least CPU mode targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_CPU)); diff --git a/modules/dnn/test/test_misc.cpp b/modules/dnn/test/test_misc.cpp index acf8dae427..07f97ed4ef 100644 --- a/modules/dnn/test/test_misc.cpp +++ b/modules/dnn/test/test_misc.cpp @@ -161,6 +161,8 @@ TEST_P(setInput, normalization) throw SkipTestException("Myriad is not available/disabled in OpenCV"); if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16 && dtype != CV_32F) throw SkipTestException(""); + if (backend == DNN_BACKEND_VKCOM && dtype != CV_32F) + throw SkipTestException(""); Mat inp(5, 5, CV_8UC3); randu(inp, 0, 255);